nolo-cli 0.213.0 → 0.222.0-alpha.2

package/{chunk-EYLGAEB4.js → chunk-YGMBIXCF.js}

@@ -1,3 +1,131 @@
+// packages/cli/client/cliExitSync.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var scopes = new AsyncLocalStorage();
+var KNOWN_SYNC_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "owner_mismatch",
+  "owner_origin_mismatch",
+  "owner_grant_revoked",
+  "owner_oauth_unavailable",
+  "invalid_grant",
+  "auth_no_token",
+  "token_expired"
+]);
+var SYNC_FAILURE_CODE_RE = /"(?:code|error|reason)"\s*:\s*"([A-Za-z0-9_.:-]{1,48})"/;
+function classifyDialogSyncFailure(error) {
+  if (error instanceof Error && error.name === "AbortError") return "aborted";
+  if (error instanceof Error && error.name === "TimeoutError") return "timeout";
+  const match = error instanceof Error ? /^remote dialog evidence write failed: HTTP (\d{3})\b([\s\S]*)$/.exec(error.message) : null;
+  if (!match) return "transport_or_sync";
+  const candidate = SYNC_FAILURE_CODE_RE.exec(match[2] ?? "")?.[1]?.toLowerCase();
+  const code = candidate && KNOWN_SYNC_FAILURE_CODES.has(candidate) ? candidate : void 0;
+  return code ? `http_${match[1]}(${code})` : `http_${match[1]}`;
+}
+function startOwnedDialogSync(fetchImpl, start) {
+  const scope = scopes.getStore();
+  if (!scope) return start(fetchImpl);
+  if (scope.closed) return Promise.reject(new Error("dialog_sync_scope_closed"));
+  const entry = { watermark: scope.entries.length + 1, httpOkRecords: 0, controller: new AbortController(), state: "pending", done: Promise.resolve() };
+  scope.entries.push(entry);
+  const trackedFetch = async (url, init) => {
+    entry.controller.signal.throwIfAborted();
+    const signal = init?.signal ? AbortSignal.any([init.signal, entry.controller.signal]) : entry.controller.signal;
+    const response = await fetchImpl(url, { ...init, signal });
+    signal.throwIfAborted();
+    if (response.ok && String(url).includes("/api/v1/db/write/")) entry.httpOkRecords++;
+    return response;
+  };
+  entry.done = Promise.resolve().then(() => start(trackedFetch)).then((result) => {
+    if (entry.state === "pending") entry.state = "completed";
+    return result;
+  }, (error) => {
+    if (entry.state === "pending") {
+      entry.state = "failed";
+      entry.failureClass = classifyDialogSyncFailure(error);
+    }
+    throw error;
+  });
+  void entry.done.catch(() => {
+  });
+  return entry.done;
+}
+function drain(scope, unsafeRunner = false) {
+  if (scope.drain) return scope.drain;
+  scope.closed = true;
+  scope.drain = (async () => {
+    const entries = scope.entries.slice();
+    let timer;
+    const abortPending = (classification) => {
+      for (const entry of entries) if (entry.state === "pending") {
+        entry.state = "timeout";
+        entry.failureClass = classification;
+        entry.controller.abort(new Error("dialog_sync_drain_stopped"));
+      }
+    };
+    try {
+      if (unsafeRunner) abortPending("runner_not_stopped");
+      else if (entries.length) await Promise.race([
+        Promise.allSettled(entries.map((entry) => entry.done)),
+        new Promise((resolve) => {
+          timer = setTimeout(() => {
+            abortPending("timeout");
+            resolve();
+          }, scope.timeoutMs);
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    const failed = entries.filter((entry) => entry.state !== "completed");
+    for (const entry of failed) scope.output.write(`[nolo] dialog_sync ${entry.state}: watermark=${entry.watermark} httpOkRecords=${entry.httpOkRecords} class=${entry.failureClass ?? entry.state}; local history retained; remote sync incomplete.
+`);
+    return failed.length === 0;
+  })();
+  return scope.drain;
+}
+function exitCliFromWatchdog(code, exit, stopRunner) {
+  const scope = scopes.getStore();
+  if (!scope) {
+    exit(code);
+    return Promise.resolve();
+  }
+  if (scope.watchdogExit) return scope.watchdogExit;
+  scope.closed = true;
+  scope.watchdogExit = (async () => {
+    let stopped = false;
+    try {
+      stopped = await stopRunner();
+    } catch {
+    }
+    if (!stopped) scope.output.write("[nolo] dialog_sync failed: class=runner_not_stopped; cancelling pending sync before hard exit.\n");
+    const complete = await drain(scope, !stopped);
+    exit(code === 0 || !complete ? 1 : code);
+  })();
+  return scope.watchdogExit;
+}
+async function runCliCommandWithSyncDrain(command, options) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) && (options.timeoutMs ?? 0) > 0 ? options.timeoutMs : 15e3;
+  await scopes.run({ entries: [], closed: false, output: options.output, timeoutMs }, async () => {
+    const scope = scopes.getStore();
+    let code = 70;
+    let commandError;
+    let commandThrew = false;
+    try {
+      code = await command();
+    } catch (error) {
+      commandThrew = true;
+      commandError = error;
+    }
+    if (scope.watchdogExit) {
+      await scope.watchdogExit;
+      if (commandThrew) throw commandError;
+      return;
+    }
+    const complete = await drain(scope);
+    if (commandThrew) throw commandError;
+    options.exit(code === 0 && !complete ? 1 : code);
+  });
+}
+
 // packages/cli/diagnostics/normalizeError.ts
 var MAX_CAUSE_DEPTH = 4;
 var MAX_AGGREGATE_ERRORS = 8;
@@ -774,6 +902,10 @@ function getLogger(component) {
 }
 
 export {
+  classifyDialogSyncFailure,
+  startOwnedDialogSync,
+  exitCliFromWatchdog,
+  runCliCommandWithSyncDrain,
   normalizeError,
   getProcessRingBuffer,
   resolveDefaultLogPath,

package/chunk-YL3EFYL3.js

@@ -0,0 +1,199 @@
+// packages/ai/memory/rank.ts
+var CJK_SEQUENCE_REGEX = /[\u3400-\u4dbf\u4e00-\u9fff]+/g;
+var MEMORY_IDENTIFIER_REGEX = /\b(?:memory|noise)-[a-z0-9][a-z0-9-]*/gi;
+var buildCjkTokens = (text) => {
+  const sequences = text.match(CJK_SEQUENCE_REGEX) ?? [];
+  const tokens = [];
+  for (const sequence of sequences) {
+    if (sequence.length >= 2) {
+      tokens.push(sequence);
+    }
+    for (let index = 0; index < sequence.length - 1; index += 1) {
+      tokens.push(sequence.slice(index, index + 2));
+    }
+  }
+  return tokens;
+};
+var tokenize = (text) => {
+  const normalized = text.toLowerCase();
+  const wordTokens = normalized.split(/[\s,.;:!?()[\]{}"'`，。！？：；、]+/).map((token) => token.trim()).filter((token) => token.length >= 2);
+  return [...wordTokens, ...buildCjkTokens(normalized)];
+};
+var keywordScore = (query, item) => {
+  const queryTokens = new Set(tokenize(query));
+  if (queryTokens.size === 0) return 0;
+  const haystack = /* @__PURE__ */ new Set([
+    ...tokenize(item.content),
+    ...(item.tags ?? []).map((tag) => tag.toLowerCase()),
+    item.patternKey?.toLowerCase() ?? ""
+  ]);
+  let matches = 0;
+  for (const token of queryTokens) {
+    if (haystack.has(token)) matches += 1;
+  }
+  return Math.min(1, matches / Math.max(2, queryTokens.size));
+};
+var identifierScore = (query, item) => {
+  const identifiers = query.match(MEMORY_IDENTIFIER_REGEX) ?? [];
+  if (identifiers.length === 0) return 0;
+  const content = item.content.toLowerCase();
+  const matches = identifiers.filter(
+    (identifier) => content.includes(identifier.toLowerCase())
+  ).length;
+  return matches / identifiers.length;
+};
+var DAY_MS = 864e5;
+var UNRETRIEVED_MEMORY_GRACE_DAYS = 3;
+var MIN_UNRETRIEVED_SCORE_FACTOR = 0.3;
+var UNRETRIEVED_DECAY_HALF_LIFE_DAYS = 7;
+var retrievalFrequencyScore = (item, nowMs) => {
+  const lastRetrievedMs = Date.parse(item.lastActivatedAt || item.createdAt);
+  const ageDays = Math.max(0, (nowMs - lastRetrievedMs) / DAY_MS);
+  const recency = 1 / (1 + ageDays / 7);
+  const frequency = Math.min(1, Math.log1p(item.activationCount ?? 0) / 3);
+  return 0.7 * recency + 0.3 * frequency;
+};
+var unretrievedDecayFactor = (item, nowMs) => {
+  if ((item.activationCount ?? 0) !== 0) return 1;
+  const createdAgeDays = Math.max(0, (nowMs - Date.parse(item.createdAt)) / DAY_MS);
+  if (createdAgeDays <= UNRETRIEVED_MEMORY_GRACE_DAYS) return 1;
+  const overdue = createdAgeDays - UNRETRIEVED_MEMORY_GRACE_DAYS;
+  return Math.max(
+    MIN_UNRETRIEVED_SCORE_FACTOR,
+    1 / (1 + overdue / UNRETRIEVED_DECAY_HALF_LIFE_DAYS)
+  );
+};
+var retrievalScore = (item, nowMs) => retrievalFrequencyScore(item, nowMs) * unretrievedDecayFactor(item, nowMs);
+var creationRecencyScore = (item, nowMs) => {
+  const createdMs = Date.parse(item.createdAt);
+  const ageDays = Math.max(0, (nowMs - createdMs) / 864e5);
+  return 1 / (1 + ageDays / 7);
+};
+var typeFitScore = (item) => {
+  if (item.kind === "episodic") return 0.75;
+  if (item.kind === "semantic") return 0.9;
+  return 0.85;
+};
+var understandingScore = (item) => {
+  if (!item.tags?.includes("understanding-memory")) return 0;
+  if (item.facet === "unfinished") return 1;
+  if (item.facet === "tension") return 0.95;
+  if (item.facet === "preference") return 0.85;
+  if (item.facet === "style") return 0.75;
+  return 0.8;
+};
+var pathScore = (item, context) => {
+  let score = 0;
+  if (context?.currentOwner && item.ownerType === context.currentOwner.ownerType && item.ownerId === context.currentOwner.ownerId) {
+    score += 0.65;
+  }
+  if (context?.currentSubject && item.subjectType === context.currentSubject.subjectType && item.subjectId === context.currentSubject.subjectId) {
+    score += 0.85;
+  }
+  return Math.min(1, score);
+};
+var scoreMemoryItem = (item, query, nowMs = Date.now(), context) => {
+  const queryMatch = keywordScore(query, item);
+  const identifierMatch = identifierScore(query, item);
+  const retrieval = retrievalScore(item, nowMs);
+  const createdRecency = creationRecencyScore(item, nowMs);
+  const importance = item.importance ?? 0;
+  const confidence = item.confidence ?? 0;
+  const typeFit = typeFitScore(item);
+  const understanding = understandingScore(item);
+  const path = pathScore(item, context);
+  return 0.25 * queryMatch + 0.2 * identifierMatch + 0.2 * path + 0.09 * retrieval + // weak retrieval signal, NOT successful-use reinforcement
+  0.16 * createdRecency + 0.06 * importance + 0.03 * confidence + 0.02 * typeFit + 0.01 * understanding;
+};
+var rankMemoryCandidates = (items, query, context) => {
+  const nowMs = Date.now();
+  return [...items].sort((a, b) => {
+    const aExplicit = a.sourceKind === "explicit-user-directive";
+    const bExplicit = b.sourceKind === "explicit-user-directive";
+    if (aExplicit !== bExplicit) return bExplicit ? 1 : -1;
+    if (aExplicit) {
+      return Date.parse(b.createdAt) - Date.parse(a.createdAt);
+    }
+    return scoreMemoryItem(b, query, nowMs, context) - scoreMemoryItem(a, query, nowMs, context);
+  });
+};
+
+// packages/ai/memory/vnext/localRecall.ts
+var MIN_SHARED_TOKENS = 2;
+var MAX_LOCAL_RECALL_STATES = 8;
+var IDF_MIN_CORPUS = 20;
+var RARE_DF_RATIO = 0.05;
+var SAFE_TECHNICAL_SYNONYMS = {
+  pr: ["\u5BA1\u67E5", "\u4EE3\u7801\u5BA1\u67E5", "diff"],
+  diff: ["\u5BA1\u67E5", "\u4EE3\u7801\u5BA1\u67E5"],
+  review: ["\u5BA1\u67E5", "\u4EE3\u7801\u5BA1\u67E5"],
+  deploy: ["\u90E8\u7F72", "\u53D1\u7248"],
+  release: ["\u53D1\u7248", "\u53D1\u5E03"],
+  desktop: ["\u684C\u9762", "\u684C\u9762\u7AEF"]
+};
+var distinctTokens = (text) => new Set(tokenize(text).filter((token) => token.length >= 2));
+var haystackTokens = (state, entity) => distinctTokens(
+  [state.facet, state.text, entity?.name ?? "", ...entity?.aliases ?? []].join(" ")
+);
+var recallMemoryVNextLocal = (input) => {
+  const rawTokens = distinctTokens(input.query);
+  if (rawTokens.size === 0) return [];
+  const queryTokens = new Set(rawTokens);
+  for (const token of rawTokens) {
+    const syns = SAFE_TECHNICAL_SYNONYMS[token.toLowerCase()];
+    if (syns) {
+      for (const syn of syns) {
+        for (const t of distinctTokens(syn)) queryTokens.add(t);
+      }
+    }
+  }
+  const entityById = new Map(input.entities.map((entity) => [entity.id, entity]));
+  const prepared = [];
+  for (const state of input.states) {
+    if (state.retiredAt || !state.text.trim()) continue;
+    prepared.push({
+      state,
+      tokens: haystackTokens(state, entityById.get(state.entityId))
+    });
+  }
+  if (prepared.length === 0) return [];
+  const useIdf = prepared.length >= IDF_MIN_CORPUS;
+  const rareCutoff = prepared.length * RARE_DF_RATIO;
+  const rareTokens = /* @__PURE__ */ new Set();
+  if (useIdf) {
+    for (const token of queryTokens) {
+      let df = 0;
+      for (const item of prepared) if (item.tokens.has(token)) df++;
+      if (df > 0 && df <= rareCutoff) rareTokens.add(token);
+    }
+  }
+  const scored = [];
+  for (const item of prepared) {
+    let sharedTokens = 0;
+    let rareShared = 0;
+    for (const token of queryTokens) {
+      if (!item.tokens.has(token)) continue;
+      sharedTokens++;
+      if (rareTokens.has(token)) rareShared++;
+    }
+    if (sharedTokens < MIN_SHARED_TOKENS) {
+      if (!(useIdf && rareShared >= 1)) continue;
+    }
+    if (useIdf && rareTokens.size > 0 && rareShared === 0) continue;
+    scored.push({
+      state: item.state,
+      sharedTokens,
+      score: useIdf ? rareShared * 10 + sharedTokens : sharedTokens
+    });
+  }
+  return scored.sort((a, b) => b.score - a.score || a.state.id.localeCompare(b.state.id)).slice(0, input.limit ?? MAX_LOCAL_RECALL_STATES).map(({ state, sharedTokens }) => ({ state, sharedTokens }));
+};
+
+export {
+  rankMemoryCandidates,
+  MIN_SHARED_TOKENS,
+  MAX_LOCAL_RECALL_STATES,
+  IDF_MIN_CORPUS,
+  RARE_DF_RATIO,
+  recallMemoryVNextLocal
+};

package/{chunk-MMA3LZ3W.js → chunk-YNIYE47Z.js}

@@ -1,6 +1,6 @@
 import {
   __commonJS
-} from "./chunk-4VNS5WPM.js";
+} from "./chunk-U67V476Y.js";
 
 // node_modules/@babel/runtime/helpers/interopRequireDefault.js
 var require_interopRequireDefault = __commonJS({

package/{chunk-W4S457LU.js → chunk-YU4ZPWVF.js}

@@ -1,19 +1,19 @@
+import {
+  resolveAgentImageInputSupport
+} from "./chunk-OBWT45ZU.js";
 import {
   TOOL_HAD_IMAGES,
   hadToolImages
 } from "./chunk-E2BESSAW.js";
 import {
-  resolveAgentImageInputSupport
-} from "./chunk-YWSEPJ7C.js";
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
 import {
   isRecord
 } from "./chunk-KUG52IAP.js";
 import {
   asOptionalFiniteNumber
 } from "./chunk-WWC7I6TA.js";
-import {
-  asTrimmedString
-} from "./chunk-3EUW3WEO.js";
 import {
   asOptionalTrimmedString
 } from "./chunk-G3SUCT4W.js";
@@ -151,6 +151,41 @@ function resolveAgentRuntimeConfigFromRecord(key, record) {
   };
 }
 
+// packages/ai/context/requestBudget.ts
+function evaluateRequestBudget(input) {
+  const outputReserveTokens = input.output.semantics === "shared-window" ? input.output.finalWireCapTokens : input.output.semantics === "unknown" ? input.output.fallbackReserveTokens : 0;
+  const basis = input.output.semantics === "unknown" ? "heuristic" : input.output.semantics;
+  const costs = [
+    input.messageTokens,
+    input.toolSchemaTokens,
+    input.otherInputTokens ?? 0,
+    input.protocolReserveTokens,
+    outputReserveTokens
+  ];
+  if (!Number.isFinite(input.contextWindow) || input.contextWindow <= 0 || costs.some((value) => !Number.isFinite(value) || value < 0)) {
+    return {
+      estimatedInputTokens: 0,
+      outputReserveTokens: 0,
+      availableInputTokens: 0,
+      fitsEstimate: false,
+      basis,
+      reason: "invalid-budget"
+    };
+  }
+  const estimatedInputTokens = Math.ceil(input.messageTokens) + Math.ceil(input.toolSchemaTokens) + Math.ceil(input.otherInputTokens ?? 0);
+  const reserve = Math.ceil(outputReserveTokens);
+  const availableInputTokens = Math.floor(input.contextWindow) - Math.ceil(input.protocolReserveTokens) - reserve;
+  const fitsEstimate = availableInputTokens >= 0 && estimatedInputTokens <= availableInputTokens;
+  return {
+    estimatedInputTokens,
+    outputReserveTokens: reserve,
+    availableInputTokens,
+    fitsEstimate,
+    basis,
+    reason: fitsEstimate ? "fits" : "over-budget"
+  };
+}
+
 // packages/agent-runtime/desktopRequestSnapshot.ts
 var DESKTOP_AGENT_CONFIG_SNAPSHOT_STRING_FIELDS = [
   "name",
@@ -434,6 +469,7 @@ function assertDesktopAgentRuntimeTurnBodyHasNoRawSecrets(body) {
 }
 
 export {
+  evaluateRequestBudget,
   extractImageUrlsFromMessages,
   hasImageInRuntimeMessages,
   stripImagePartsFromMessages,