@remnic/core 9.69.9 → 9.69.11

package/dist/{chunk-Y3WMJAZ3.js → chunk-QRDSXR3V.js}

@@ -1,6 +1,6 @@
 import {
   rebuildMemoryProjection
-} from "./chunk-E5WTGEWX.js";
+} from "./chunk-BEXFNGQ3.js";
 
 // src/convergence-refresh.ts
 async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, getStorage, searchEnabled) {
@@ -32,4 +32,4 @@ async function refreshConvergedNamespaces(namespaces, namespaceSearchRouter, get
 export {
   refreshConvergedNamespaces
 };
-//# sourceMappingURL=chunk-Y3WMJAZ3.js.map
+//# sourceMappingURL=chunk-QRDSXR3V.js.map

package/dist/{chunk-NDE7CH6C.js → chunk-QUVWFZOU.js}

@@ -1,6 +1,6 @@
 import {
   resolveCorpusNamespaceRoots
-} from "./chunk-NAZROP6I.js";
+} from "./chunk-XMIAU4CO.js";
 import {
   capabilityAllowsNamespace
 } from "./chunk-MZWSOLMT.js";
@@ -200,4 +200,4 @@ async function readAggregateExtractionWatermark(options) {
 export {
   readAggregateExtractionWatermark
 };
-//# sourceMappingURL=chunk-NDE7CH6C.js.map
+//# sourceMappingURL=chunk-QUVWFZOU.js.map

package/dist/{chunk-M5GBTETG.js → chunk-R7FXPG4T.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-3QWF54M4.js";
+} from "./chunk-5P2KNFJZ.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-M5GBTETG.js.map
+//# sourceMappingURL=chunk-R7FXPG4T.js.map

package/dist/chunk-RF2SMMPP.js

@@ -0,0 +1,37 @@
+// src/deep-recall-renderer.ts
+function renderDeepRecallResult(result) {
+  if (!result.ok) {
+    return [`# Deep recall`, ``, `- error: ${result.error ?? "unknown"}`, ``].join("\n");
+  }
+  const lines = ["# Deep recall", ""];
+  if (result.entries.length === 0) {
+    lines.push("No memories retrieved.", "");
+  } else {
+    lines.push("## Memories", "");
+    for (const [index, entry] of result.entries.entries()) {
+      const via = entry.viaAnchor ? ` via anchor "${entry.viaAnchor}"` : "";
+      lines.push(
+        `${index + 1}. **${entry.memoryId}** (score ${entry.score.toFixed(3)}, origin ${entry.origin}${via})`
+      );
+      lines.push(`   ${entry.content.replace(/\s+/g, " ").trim().slice(0, 400)}`);
+    }
+    lines.push("");
+  }
+  lines.push("## Trace", "");
+  if (result.trace.length === 0) {
+    lines.push("(empty)");
+  } else {
+    for (const step of result.trace) {
+      lines.push(
+        `- step ${step.step}: ${step.action} \u2014 ${step.detail} (workingSet=${step.workingSetSize}, frontier=${step.frontierSize}, ${step.durationMs}ms)`
+      );
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+export {
+  renderDeepRecallResult
+};
+//# sourceMappingURL=chunk-RF2SMMPP.js.map

package/dist/chunk-RF2SMMPP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deep-recall-renderer.ts"],"sourcesContent":["/**\n * Shared markdown renderer for deep recall (issue #2332).\n *\n * Rule 22 (AGENTS.md): never fork formatting — CLI text output, MCP text\n * output, and any later surface all render through this one module.\n * Deterministic: entries in result order, trace in step order.\n */\n\nimport type { DeepRecallResult } from \"./deep-recall.js\";\n\nexport function renderDeepRecallResult(result: DeepRecallResult): string {\n  if (!result.ok) {\n    return [`# Deep recall`, ``, `- error: ${result.error ?? \"unknown\"}`, ``].join(\"\\n\");\n  }\n  const lines: string[] = [\"# Deep recall\", \"\"];\n  if (result.entries.length === 0) {\n    lines.push(\"No memories retrieved.\", \"\");\n  } else {\n    lines.push(\"## Memories\", \"\");\n    for (const [index, entry] of result.entries.entries()) {\n      const via = entry.viaAnchor ? ` via anchor \"${entry.viaAnchor}\"` : \"\";\n      lines.push(\n        `${index + 1}. **${entry.memoryId}** (score ${entry.score.toFixed(3)}, origin ${entry.origin}${via})`,\n      );\n      lines.push(`   ${entry.content.replace(/\\s+/g, \" \").trim().slice(0, 400)}`);\n    }\n    lines.push(\"\");\n  }\n  lines.push(\"## Trace\", \"\");\n  if (result.trace.length === 0) {\n    lines.push(\"(empty)\");\n  } else {\n    for (const step of result.trace) {\n      lines.push(\n        `- step ${step.step}: ${step.action} — ${step.detail} (workingSet=${step.workingSetSize}, frontier=${step.frontierSize}, ${step.durationMs}ms)`,\n      );\n    }\n  }\n  lines.push(\"\");\n  return lines.join(\"\\n\");\n}\n"],"mappings":";AAUO,SAAS,uBAAuB,QAAkC;AACvE,MAAI,CAAC,OAAO,IAAI;AACd,WAAO,CAAC,iBAAiB,IAAI,YAAY,OAAO,SAAS,SAAS,IAAI,EAAE,EAAE,KAAK,IAAI;AAAA,EACrF;AACA,QAAM,QAAkB,CAAC,iBAAiB,EAAE;AAC5C,MAAI,OAAO,QAAQ,WAAW,GAAG;AAC/B,UAAM,KAAK,0BAA0B,EAAE;AAAA,EACzC,OAAO;AACL,UAAM,KAAK,eAAe,EAAE;AAC5B,eAAW,CAAC,OAAO,KAAK,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACrD,YAAM,MAAM,MAAM,YAAY,gBAAgB,MAAM,SAAS,MAAM;AACnE,YAAM;AAAA,QACJ,GAAG,QAAQ,CAAC,OAAO,MAAM,QAAQ,aAAa,MAAM,MAAM,QAAQ,CAAC,CAAC,YAAY,MAAM,MAAM,GAAG,GAAG;AAAA,MACpG;AACA,YAAM,KAAK,MAAM,MAAM,QAAQ,QAAQ,QAAQ,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,EAAE;AAAA,IAC5E;AACA,UAAM,KAAK,EAAE;AAAA,EACf;AACA,QAAM,KAAK,YAAY,EAAE;AACzB,MAAI,OAAO,MAAM,WAAW,GAAG;AAC7B,UAAM,KAAK,SAAS;AAAA,EACtB,OAAO;AACL,eAAW,QAAQ,OAAO,OAAO;AAC/B,YAAM;AAAA,QACJ,UAAU,KAAK,IAAI,KAAK,KAAK,MAAM,WAAM,KAAK,MAAM,gBAAgB,KAAK,cAAc,cAAc,KAAK,YAAY,KAAK,KAAK,UAAU;AAAA,MAC5I;AAAA,IACF;AAAA,EACF;AACA,QAAM,KAAK,EAAE;AACb,SAAO,MAAM,KAAK,IAAI;AACxB;","names":[]}

package/dist/{chunk-X66BHMAU.js → chunk-RJ57OOCD.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-EEOUMG3J.js";
 import {
   iterateOfflineSyncSnapshotFileRecords
-} from "./chunk-JCUG7AXZ.js";
+} from "./chunk-XJJYSX6F.js";
 
 // src/access-offline-manifest.ts
 import * as nodePath from "path";
@@ -49,4 +49,4 @@ async function createOfflineSyncManifestStream(orchestrator, namespace, userExcl
 export {
   createOfflineSyncManifestStream
 };
-//# sourceMappingURL=chunk-X66BHMAU.js.map
+//# sourceMappingURL=chunk-RJ57OOCD.js.map

package/dist/chunk-S5G2LAL7.js

@@ -0,0 +1,354 @@
+import {
+  rankDeepRecallFrontier
+} from "./chunk-HRATODNO.js";
+import {
+  validateRefineRewrite
+} from "./chunk-WTWQA7BB.js";
+import {
+  selectExpandNodeIds
+} from "./chunk-VZIAVM72.js";
+import {
+  extractJsonCandidates,
+  stripCodeFences
+} from "./chunk-RGMVMVMF.js";
+import {
+  compareDeterministicStrings
+} from "./chunk-G73MCJKL.js";
+
+// src/deep-recall.ts
+import { z } from "zod";
+var PolicyActionSchema = z.object({
+  action: z.enum(["REFINE", "EXPAND", "STOP"]),
+  refinedQuery: z.string().optional().nullable(),
+  expandNodeIds: z.array(z.string()).optional().nullable(),
+  reason: z.string()
+});
+var MAX_SOURCE_MEMORY_IDS_PER_NODE = 5;
+var EXPAND_SCORE_INHERITANCE = 0.8;
+var STATE_WORKING_SET_ENTRIES = 12;
+var STATE_ENTRY_SNIPPET_CHARS = 200;
+var DeepRecallDeadlineExceeded = class extends Error {
+  constructor() {
+    super("deep recall total timeout reached");
+  }
+};
+async function withDeadline(work, deadlineMs, now) {
+  if (!Number.isFinite(deadlineMs)) return await work;
+  const remaining = deadlineMs - now();
+  if (remaining <= 0) throw new DeepRecallDeadlineExceeded();
+  const expiry = Promise.withResolvers();
+  const timer = setTimeout(() => expiry.reject(new DeepRecallDeadlineExceeded()), remaining);
+  try {
+    return await Promise.race([work, expiry.promise]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parsePolicyOutput(raw) {
+  if (raw === null) return null;
+  const candidates = [stripCodeFences(raw), ...extractJsonCandidates(raw)];
+  for (const candidate of candidates) {
+    if (candidate.trim().length === 0) continue;
+    try {
+      const parsed = PolicyActionSchema.safeParse(JSON.parse(candidate));
+      if (parsed.success) return parsed.data;
+    } catch {
+    }
+  }
+  return null;
+}
+function mergeIntoWorkingSet(workingSet, hits, origin, contentFor) {
+  for (const hit of hits) {
+    if (typeof hit.memoryId !== "string" || hit.memoryId.length === 0) continue;
+    if (typeof hit.score !== "number" || !Number.isFinite(hit.score)) continue;
+    const existing = workingSet.get(hit.memoryId);
+    if (existing && existing.score >= hit.score) continue;
+    workingSet.set(hit.memoryId, {
+      memoryId: hit.memoryId,
+      content: contentFor(hit.memoryId),
+      score: hit.score,
+      origin: existing ? existing.origin : origin,
+      ...existing?.viaAnchor ? { viaAnchor: existing.viaAnchor } : {}
+    });
+  }
+}
+function buildFrontierIndex(graph) {
+  const memoryIdToNodeIds = /* @__PURE__ */ new Map();
+  const nodeIdToNode = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    nodeIdToNode.set(node.nodeId, node);
+    for (const memoryId of node.sourceMemoryIds ?? []) {
+      const list = memoryIdToNodeIds.get(memoryId) ?? [];
+      list.push(node.nodeId);
+      memoryIdToNodeIds.set(memoryId, list);
+    }
+  }
+  const nodeIdToAnchorIds = /* @__PURE__ */ new Map();
+  const anchorIdToAnchor = /* @__PURE__ */ new Map();
+  for (const anchor of graph.anchors) {
+    anchorIdToAnchor.set(anchor.anchorId, anchor);
+    for (const nodeRef of anchor.nodeRefs) {
+      const list = nodeIdToAnchorIds.get(nodeRef) ?? [];
+      list.push(anchor.anchorId);
+      nodeIdToAnchorIds.set(nodeRef, list);
+    }
+  }
+  return { memoryIdToNodeIds, nodeIdToNode, nodeIdToAnchorIds, anchorIdToAnchor };
+}
+function nodeAddsNothing(node, workingSet) {
+  return (node.sourceMemoryIds ?? []).slice(0, MAX_SOURCE_MEMORY_IDS_PER_NODE).every((memoryId) => workingSet.has(memoryId));
+}
+function refreshFrontier(workingSet, graph, expandedNodeIds) {
+  const index = graph.index;
+  const byNodeId = /* @__PURE__ */ new Map();
+  for (const [memoryId, entry] of workingSet) {
+    for (const nodeId of index.memoryIdToNodeIds.get(memoryId) ?? []) {
+      for (const anchorId of index.nodeIdToAnchorIds.get(nodeId) ?? []) {
+        const anchor = index.anchorIdToAnchor.get(anchorId);
+        if (!anchor) continue;
+        for (const otherNodeRef of anchor.nodeRefs) {
+          if (otherNodeRef === nodeId) continue;
+          if (expandedNodeIds.has(otherNodeRef)) continue;
+          const otherNode = index.nodeIdToNode.get(otherNodeRef);
+          if (!otherNode || nodeAddsNothing(otherNode, workingSet)) continue;
+          const current = byNodeId.get(otherNodeRef);
+          if (current === void 0 || entry.score > current.parentScore) {
+            byNodeId.set(otherNodeRef, {
+              nodeId: otherNodeRef,
+              sharedAnchorCount: (current?.sharedAnchorCount ?? 0) + 1,
+              parentMemoryId: memoryId,
+              parentScore: entry.score,
+              anchorValue: anchor.anchorValue
+            });
+          } else {
+            current.sharedAnchorCount += 1;
+          }
+        }
+      }
+    }
+  }
+  const ranked = rankDeepRecallFrontier([...byNodeId.values()]);
+  return ranked.flatMap((rankedCandidate) => {
+    const candidate = byNodeId.get(rankedCandidate.nodeId);
+    const node = index.nodeIdToNode.get(rankedCandidate.nodeId);
+    if (!candidate || !node) return [];
+    return [
+      {
+        nodeId: candidate.nodeId,
+        title: node.title,
+        reason: `shares anchor "${candidate.anchorValue}" with ${candidate.parentMemoryId}`,
+        sharedAnchorCount: rankedCandidate.sharedAnchorCount,
+        parentMemoryId: candidate.parentMemoryId,
+        parentScore: candidate.parentScore,
+        anchorValue: candidate.anchorValue
+      }
+    ];
+  });
+}
+function renderStatePrompt(input) {
+  const lines = [
+    "You are guiding a multi-hop memory retrieval loop. Pick exactly one action.",
+    "REFINE when the retrieved memories look misaligned with the question (return a rewritten query).",
+    "EXPAND to follow named frontier nodes that plausibly hold the answer (return their nodeIds).",
+    "STOP when the working set is sufficient to answer.",
+    "",
+    `QUESTION: ${input.query}`,
+    `STEPS REMAINING: ${input.stepsRemaining}`,
+    "",
+    "WORKING SET (retrieved memories):"
+  ];
+  const entries = [...input.workingSet.values()].sort((a, b) => b.score - a.score || compareDeterministicStrings(a.memoryId, b.memoryId)).slice(0, STATE_WORKING_SET_ENTRIES);
+  if (entries.length === 0) lines.push("(empty)");
+  for (const entry of entries) {
+    const snippet = entry.content.slice(0, STATE_ENTRY_SNIPPET_CHARS).replace(/\s+/g, " ");
+    lines.push(`- ${entry.memoryId} (score=${entry.score.toFixed(3)}, origin=${entry.origin}): ${snippet}`);
+  }
+  lines.push("", "FRONTIER (anchor-linked candidates not yet retrieved):");
+  if (input.frontier.length === 0) lines.push("(empty)");
+  for (const item of input.frontier) {
+    lines.push(`- ${item.nodeId}: ${item.title} \u2014 ${item.reason}`);
+  }
+  lines.push(
+    "",
+    'Respond with JSON only: {"action":"REFINE","refinedQuery":"...","reason":"..."}',
+    'or {"action":"EXPAND","expandNodeIds":["..."],"reason":"..."}',
+    'or {"action":"STOP","reason":"..."}'
+  );
+  return lines.join("\n");
+}
+function finalRank(entries) {
+  return [...entries].sort(
+    (a, b) => b.score - a.score || compareDeterministicStrings(a.memoryId, b.memoryId)
+  );
+}
+async function runBudgetedDeepRecall(deps, query) {
+  const cfg = deps.config;
+  const now = deps.nowMs ?? Date.now;
+  const startedMs = now();
+  const deadlineMs = cfg.totalTimeoutMs > 0 ? startedMs + cfg.totalTimeoutMs : Number.POSITIVE_INFINITY;
+  const trace = [];
+  const contentCache = /* @__PURE__ */ new Map();
+  const contentFor = (memoryId) => contentCache.get(memoryId) ?? "";
+  const workingSet = /* @__PURE__ */ new Map();
+  let graph = { index: buildFrontierIndex({ nodes: [], anchors: [] }) };
+  const expandedNodeIds = /* @__PURE__ */ new Set();
+  const hydrateOrDrop = async (memoryId) => {
+    const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);
+    if (!memory || !memory.active) {
+      workingSet.delete(memoryId);
+      contentCache.delete(memoryId);
+      return;
+    }
+    contentCache.set(memoryId, memory.content);
+    const entry = workingSet.get(memoryId);
+    if (entry) entry.content = memory.content;
+  };
+  let exhaustedDetail = null;
+  try {
+    const seedHits = await withDeadline(deps.searchSeed(query, cfg.maxResults), deadlineMs, now);
+    mergeIntoWorkingSet(workingSet, seedHits, "seed", contentFor);
+  } catch (err) {
+    if (!(err instanceof DeepRecallDeadlineExceeded)) {
+      return { ok: false, error: "backend_unavailable", entries: [], trace: [] };
+    }
+    exhaustedDetail = "total timeout reached during seed search";
+  }
+  if (exhaustedDetail === null) {
+    try {
+      graph = { index: buildFrontierIndex(await withDeadline(deps.loadGraph(), deadlineMs, now)) };
+      for (const memoryId of [...workingSet.keys()]) {
+        await hydrateOrDrop(memoryId);
+      }
+    } catch (err) {
+      if (!(err instanceof DeepRecallDeadlineExceeded)) throw err;
+      exhaustedDetail = "total timeout reached loading the graph or hydrating seeds";
+    }
+  }
+  let frontier = refreshFrontier(workingSet, graph, expandedNodeIds);
+  let currentQuery = query;
+  let refinesUsed = 0;
+  const pushStep = (step2, action, detail, stepStartMs) => {
+    trace.push({
+      step: step2,
+      action,
+      detail,
+      workingSetSize: workingSet.size,
+      frontierSize: frontier.length,
+      durationMs: Math.max(0, now() - stepStartMs)
+    });
+  };
+  if (exhaustedDetail !== null) {
+    pushStep(0, "BUDGET_EXHAUSTED", exhaustedDetail, startedMs);
+  } else if (cfg.maxSteps <= 0) {
+    pushStep(0, "STOP", "policy loop disabled (maxSteps=0)", startedMs);
+  }
+  let step = 0;
+  try {
+    while (exhaustedDetail === null && cfg.maxSteps > 0 && step < cfg.maxSteps) {
+      const stepStartMs = now();
+      if (now() >= deadlineMs) {
+        pushStep(step, "BUDGET_EXHAUSTED", "total timeout reached before policy call", stepStartMs);
+        break;
+      }
+      const stepBudgetMs = cfg.stepTimeoutMs > 0 ? cfg.stepTimeoutMs : Number.POSITIVE_INFINITY;
+      const effectiveBudgetMs = Math.min(stepBudgetMs, deadlineMs - now());
+      const timeoutMs = Number.isFinite(effectiveBudgetMs) ? Math.max(1, effectiveBudgetMs) : 0;
+      const raw = await withDeadline(
+        deps.callPolicy(
+          renderStatePrompt({ query: currentQuery, workingSet, frontier, stepsRemaining: cfg.maxSteps - step }),
+          timeoutMs
+        ),
+        deadlineMs,
+        now
+      );
+      const parsed = parsePolicyOutput(raw);
+      if (parsed === null) {
+        pushStep(step, "STOP", "invalid_policy_output", stepStartMs);
+        break;
+      }
+      if (parsed.action === "STOP") {
+        pushStep(step, "STOP", parsed.reason || "policy stop", stepStartMs);
+        break;
+      }
+      if (parsed.action === "REFINE") {
+        const rewrite = validateRefineRewrite({
+          currentQuery,
+          refinedQuery: parsed.refinedQuery ?? null,
+          refinesUsed
+        });
+        if (!rewrite.ok) {
+          pushStep(step, "STOP", rewrite.reason, stepStartMs);
+          break;
+        }
+        currentQuery = rewrite.refinedQuery;
+        refinesUsed += 1;
+        try {
+          const refinedHits = await withDeadline(deps.searchSeed(currentQuery, cfg.maxResults), deadlineMs, now);
+          mergeIntoWorkingSet(workingSet, refinedHits, "refine", contentFor);
+          for (const hit of refinedHits) {
+            if (workingSet.has(hit.memoryId) && !contentCache.has(hit.memoryId)) {
+              await hydrateOrDrop(hit.memoryId);
+            }
+          }
+        } catch (err) {
+          if (err instanceof DeepRecallDeadlineExceeded) throw err;
+        }
+        frontier = refreshFrontier(workingSet, graph, expandedNodeIds);
+        pushStep(step, "REFINE", currentQuery, stepStartMs);
+        step += 1;
+        continue;
+      }
+      const selection = cfg.maxExpandPerStep <= 0 ? { ok: true, nodeIds: [], truncated: false } : selectExpandNodeIds({
+        frontierIds: frontier.map((item) => item.nodeId),
+        requestedIds: parsed.expandNodeIds ?? [],
+        maxExpandPerStep: cfg.maxExpandPerStep
+      });
+      if (!selection.ok) {
+        pushStep(step, "STOP", "invalid_policy_output", stepStartMs);
+        break;
+      }
+      const chosen = new Map(frontier.map((item) => [item.nodeId, item]));
+      for (const nodeId of selection.nodeIds) {
+        const item = chosen.get(nodeId);
+        const node = graph.index.nodeIdToNode.get(nodeId);
+        if (!item || !node) continue;
+        for (const memoryId of (node.sourceMemoryIds ?? []).slice(0, MAX_SOURCE_MEMORY_IDS_PER_NODE)) {
+          if (workingSet.has(memoryId)) continue;
+          const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);
+          if (!memory || !memory.active) continue;
+          workingSet.set(memoryId, {
+            memoryId,
+            content: memory.content,
+            score: item.parentScore * EXPAND_SCORE_INHERITANCE,
+            origin: "expand",
+            viaAnchor: item.anchorValue
+          });
+          contentCache.set(memoryId, memory.content);
+        }
+        expandedNodeIds.add(nodeId);
+      }
+      frontier = refreshFrontier(workingSet, graph, expandedNodeIds);
+      pushStep(step, "EXPAND", selection.nodeIds.join(", "), stepStartMs);
+      step += 1;
+    }
+  } catch (err) {
+    if (!(err instanceof DeepRecallDeadlineExceeded)) throw err;
+    pushStep(step, "BUDGET_EXHAUSTED", "total timeout reached mid-step", startedMs);
+  }
+  if (cfg.maxSteps > 0 && step >= cfg.maxSteps && trace[trace.length - 1]?.action !== "STOP") {
+    pushStep(step, "BUDGET_EXHAUSTED", "maxSteps policy calls reached", startedMs);
+    const marker = trace[trace.length - 1];
+    if (marker) marker.durationMs = Math.max(0, now() - startedMs);
+  }
+  const entries = finalRank([...workingSet.values()]).map((entry) => ({ ...entry }));
+  return {
+    ok: true,
+    entries: cfg.maxResults > 0 ? entries.slice(0, cfg.maxResults) : [],
+    trace
+  };
+}
+
+export {
+  runBudgetedDeepRecall
+};
+//# sourceMappingURL=chunk-S5G2LAL7.js.map

package/dist/chunk-S5G2LAL7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/deep-recall.ts"],"sourcesContent":["/**\n * Budgeted deep-recall loop (issue #2332, harmonic series P4).\n *\n * REFINE / EXPAND / STOP retrieval over the abstraction-node + cue-anchor\n * graph built by issue #2329, blended with QMD search. This is the deep\n * surface ONLY — never wired into `before_prompt_build` or any recall\n * section (that latency disqualifies the hot path; see the issue).\n *\n * The loop is dependency-injected: seeding, graph loading, memory loading,\n * and the policy LLM call arrive as `DeepRecallDeps`, so the loop is\n * deterministic under a scripted fake policy (tests) and thin when the\n * access service wires real deps. Pure decision helpers are reused from\n * the `recall-deep-*` primitives — never re-implemented here.\n */\n\nimport { z } from \"zod\";\nimport type { AbstractionNode } from \"./abstraction-nodes.js\";\nimport type { CueAnchor } from \"./cue-anchors.js\";\nimport { compareDeterministicStrings } from \"./deterministic-order.js\";\nimport { extractJsonCandidates, stripCodeFences } from \"./json-extract.js\";\nimport { rankDeepRecallFrontier } from \"./recall-deep-frontier.js\";\nimport { selectExpandNodeIds } from \"./recall-deep-expand-select.js\";\nimport { validateRefineRewrite } from \"./recall-deep-rewrite.js\";\nimport type { DeepRecallConfig } from \"./deep-recall-config.js\";\n\nexport type { DeepRecallConfig } from \"./deep-recall-config.js\";\n\nexport interface DeepRecallEntry {\n  memoryId: string;\n  /** Trimmed to 500 chars for state rendering; full content only in final output. */\n  content: string;\n  /** Seed similarity, or expansion inheritance (parent score * 0.8). */\n  score: number;\n  origin: \"seed\" | \"refine\" | \"expand\";\n  /** anchorValue that linked the entry, when origin === \"expand\". */\n  viaAnchor?: string;\n}\n\nexport interface DeepRecallFrontierItem {\n  nodeId: string;\n  title: string;\n  /** e.g. `shares anchor \"<anchorValue>\" with <memoryId>`. */\n  reason: string;\n  sharedAnchorCount: number;\n  /** Working-set memory the anchor was shared with; drives expansion scoring. */\n  parentMemoryId: string;\n  parentScore: number;\n  anchorValue: string;\n}\n\nexport interface DeepRecallTraceStep {\n  step: number;\n  action: \"REFINE\" | \"EXPAND\" | \"STOP\" | \"BUDGET_EXHAUSTED\";\n  /** Rewritten query, chosen nodeIds, or stop reason. */\n  detail: string;\n  workingSetSize: number;\n  frontierSize: number;\n  durationMs: number;\n}\n\nexport interface DeepRecallResult {\n  /** false only for backend failure — NEVER conflated with empty (§22). */\n  ok: boolean;\n  error?: \"backend_unavailable\" | \"timeout\" | \"disabled\";\n  entries: DeepRecallEntry[];\n  trace: DeepRecallTraceStep[];\n}\n\nexport interface DeepRecallGraphSnapshot {\n  nodes: AbstractionNode[];\n  anchors: CueAnchor[];\n}\n\nexport interface DeepRecallSeedHit {\n  memoryId: string;\n  score: number;\n}\n\nexport type DeepRecallSeedResult =\n  | { ok: true; results: DeepRecallSeedHit[] }\n  | { ok: false; error: \"backend_unavailable\" };\n\nexport interface DeepRecallMemoryView {\n  memoryId: string;\n  content: string;\n  active: boolean;\n}\n\nexport interface DeepRecallDeps {\n  config: DeepRecallConfig;\n  /** QMD (or equivalent) seed search. A thrown error means backend failure. */\n  searchSeed(query: string, limit: number): Promise<DeepRecallSeedHit[]>;\n  /** Nodes + anchors, loaded once per invocation. */\n  loadGraph(): Promise<DeepRecallGraphSnapshot>;\n  /** Namespace-scoped memory-by-id read; null when absent from the caller's namespace (§30). */\n  loadMemory(memoryId: string): Promise<DeepRecallMemoryView | null>;\n  /** Raw policy LLM output (JSON text); null when the call failed. */\n  callPolicy(statePrompt: string, timeoutMs: number): Promise<string | null>;\n  nowMs?(): number;\n}\n\nconst PolicyActionSchema = z.object({\n  action: z.enum([\"REFINE\", \"EXPAND\", \"STOP\"]),\n  refinedQuery: z.string().optional().nullable(),\n  expandNodeIds: z.array(z.string()).optional().nullable(),\n  reason: z.string(),\n});\n\ntype PolicyAction = z.infer<typeof PolicyActionSchema>;\n\nconst MAX_SOURCE_MEMORY_IDS_PER_NODE = 5;\nconst EXPAND_SCORE_INHERITANCE = 0.8;\nconst STATE_WORKING_SET_ENTRIES = 12;\nconst STATE_ENTRY_SNIPPET_CHARS = 200;\n\n/** Thrown when the shared whole-invocation deadline expires mid-await. */\nclass DeepRecallDeadlineExceeded extends Error {\n  constructor() {\n    super(\"deep recall total timeout reached\");\n  }\n}\n\n/**\n * Race one dependency call against the SHARED whole-invocation deadline.\n *\n * `deadlineMs` is an absolute instant computed once per invocation, so every\n * await subtracts elapsed time instead of restarting the budget, and a stalled\n * seed search, graph load, or memory read can no longer outlive the documented\n * `totalTimeoutMs` just because the deadline is only *checked* between steps.\n * An infinite deadline (`totalTimeoutMs: 0`, a documented disable value) passes\n * the work through untouched — no timer, no wrapper.\n */\nasync function withDeadline<T>(work: Promise<T>, deadlineMs: number, now: () => number): Promise<T> {\n  if (!Number.isFinite(deadlineMs)) return await work;\n  const remaining = deadlineMs - now();\n  if (remaining <= 0) throw new DeepRecallDeadlineExceeded();\n  // The timer stays REFERENCED: it is the only thing keeping the loop alive\n  // when the awaited dependency never settles, which is precisely the case the\n  // deadline exists for. It is always cleared in the `finally`.\n  const expiry = Promise.withResolvers<never>();\n  const timer = setTimeout(() => expiry.reject(new DeepRecallDeadlineExceeded()), remaining);\n  try {\n    return await Promise.race([work, expiry.promise]);\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\nfunction parsePolicyOutput(raw: string | null): PolicyAction | null {\n  if (raw === null) return null;\n  const candidates = [stripCodeFences(raw), ...extractJsonCandidates(raw)];\n  for (const candidate of candidates) {\n    if (candidate.trim().length === 0) continue;\n    try {\n      const parsed = PolicyActionSchema.safeParse(JSON.parse(candidate));\n      if (parsed.success) return parsed.data;\n    } catch {\n      // try the next candidate\n    }\n  }\n  return null;\n}\n\ninterface WorkingEntry extends DeepRecallEntry {\n  content: string;\n}\n\nfunction mergeIntoWorkingSet(\n  workingSet: Map<string, WorkingEntry>,\n  hits: readonly DeepRecallSeedHit[],\n  origin: \"seed\" | \"refine\",\n  contentFor: (memoryId: string) => string\n): void {\n  for (const hit of hits) {\n    if (typeof hit.memoryId !== \"string\" || hit.memoryId.length === 0) continue;\n    if (typeof hit.score !== \"number\" || !Number.isFinite(hit.score)) continue;\n    const existing = workingSet.get(hit.memoryId);\n    // Duplicates keep the higher score and the earlier origin (§13: one\n    // content form, one merge rule, everywhere).\n    if (existing && existing.score >= hit.score) continue;\n    workingSet.set(hit.memoryId, {\n      memoryId: hit.memoryId,\n      content: contentFor(hit.memoryId),\n      score: hit.score,\n      origin: existing ? existing.origin : origin,\n      ...(existing?.viaAnchor ? { viaAnchor: existing.viaAnchor } : {}),\n    });\n  }\n}\n\ninterface FrontierIndex {\n  memoryIdToNodeIds: Map<string, string[]>;\n  nodeIdToNode: Map<string, AbstractionNode>;\n  nodeIdToAnchorIds: Map<string, string[]>;\n  anchorIdToAnchor: Map<string, CueAnchor>;\n}\n\nfunction buildFrontierIndex(graph: DeepRecallGraphSnapshot): FrontierIndex {\n  const memoryIdToNodeIds = new Map<string, string[]>();\n  const nodeIdToNode = new Map<string, AbstractionNode>();\n  for (const node of graph.nodes) {\n    nodeIdToNode.set(node.nodeId, node);\n    for (const memoryId of node.sourceMemoryIds ?? []) {\n      const list = memoryIdToNodeIds.get(memoryId) ?? [];\n      list.push(node.nodeId);\n      memoryIdToNodeIds.set(memoryId, list);\n    }\n  }\n  const nodeIdToAnchorIds = new Map<string, string[]>();\n  const anchorIdToAnchor = new Map<string, CueAnchor>();\n  for (const anchor of graph.anchors) {\n    anchorIdToAnchor.set(anchor.anchorId, anchor);\n    for (const nodeRef of anchor.nodeRefs) {\n      const list = nodeIdToAnchorIds.get(nodeRef) ?? [];\n      list.push(anchor.anchorId);\n      nodeIdToAnchorIds.set(nodeRef, list);\n    }\n  }\n  return { memoryIdToNodeIds, nodeIdToNode, nodeIdToAnchorIds, anchorIdToAnchor };\n}\n\n/**\n * A candidate node adds nothing when every source memory the EXPAND path would\n * load is already in the working set (or when it has none): offering it as an\n * unretrieved candidate lets the policy burn steps re-expanding a node that can\n * only re-add what is already present.\n */\nfunction nodeAddsNothing(node: AbstractionNode, workingSet: ReadonlyMap<string, WorkingEntry>): boolean {\n  return (node.sourceMemoryIds ?? [])\n    .slice(0, MAX_SOURCE_MEMORY_IDS_PER_NODE)\n    .every((memoryId) => workingSet.has(memoryId));\n}\n\n/**\n * Frontier refresh (after every working-set change): for each working-set\n * memory, anchors whose nodeRefs include a node listing that memory make\n * every OTHER referenced node a frontier candidate. Ranked by the shared\n * pure helper (shared-anchor count desc, nodeId asc — total comparator).\n *\n * Nodes in `expandedNodeIds` are dropped: a node EXPAND already followed is\n * not an unretrieved candidate, even when some of its source memories never\n * entered the working set (an inactive or foreign read is skipped), so\n * re-offering it would let the policy spend every remaining step adding\n * nothing.\n */\nfunction refreshFrontier(\n  workingSet: ReadonlyMap<string, WorkingEntry>,\n  graph: FrontierGraph,\n  expandedNodeIds: ReadonlySet<string>\n): DeepRecallFrontierItem[] {\n  const index = graph.index;\n  interface Candidate {\n    nodeId: string;\n    sharedAnchorCount: number;\n    parentMemoryId: string;\n    parentScore: number;\n    anchorValue: string;\n  }\n  const byNodeId = new Map<string, Candidate>();\n  for (const [memoryId, entry] of workingSet) {\n    for (const nodeId of index.memoryIdToNodeIds.get(memoryId) ?? []) {\n      for (const anchorId of index.nodeIdToAnchorIds.get(nodeId) ?? []) {\n        const anchor = index.anchorIdToAnchor.get(anchorId);\n        if (!anchor) continue;\n        for (const otherNodeRef of anchor.nodeRefs) {\n          if (otherNodeRef === nodeId) continue;\n          if (expandedNodeIds.has(otherNodeRef)) continue;\n          const otherNode = index.nodeIdToNode.get(otherNodeRef);\n          if (!otherNode || nodeAddsNothing(otherNode, workingSet)) continue;\n          const current = byNodeId.get(otherNodeRef);\n          if (current === undefined || entry.score > current.parentScore) {\n            byNodeId.set(otherNodeRef, {\n              nodeId: otherNodeRef,\n              sharedAnchorCount: (current?.sharedAnchorCount ?? 0) + 1,\n              parentMemoryId: memoryId,\n              parentScore: entry.score,\n              anchorValue: anchor.anchorValue,\n            });\n          } else {\n            current.sharedAnchorCount += 1;\n          }\n        }\n      }\n    }\n  }\n  const ranked = rankDeepRecallFrontier([...byNodeId.values()]);\n  return ranked.flatMap((rankedCandidate) => {\n    const candidate = byNodeId.get(rankedCandidate.nodeId);\n    const node = index.nodeIdToNode.get(rankedCandidate.nodeId);\n    if (!candidate || !node) return [];\n    return [\n      {\n        nodeId: candidate.nodeId,\n        title: node.title,\n        reason: `shares anchor \"${candidate.anchorValue}\" with ${candidate.parentMemoryId}`,\n        sharedAnchorCount: rankedCandidate.sharedAnchorCount,\n        parentMemoryId: candidate.parentMemoryId,\n        parentScore: candidate.parentScore,\n        anchorValue: candidate.anchorValue,\n      },\n    ];\n  });\n}\n\ninterface FrontierGraph {\n  index: FrontierIndex;\n}\n\n\nfunction renderStatePrompt(input: {\n  query: string;\n  workingSet: ReadonlyMap<string, WorkingEntry>;\n  frontier: readonly DeepRecallFrontierItem[];\n  stepsRemaining: number;\n}): string {\n  const lines: string[] = [\n    \"You are guiding a multi-hop memory retrieval loop. Pick exactly one action.\",\n    \"REFINE when the retrieved memories look misaligned with the question (return a rewritten query).\",\n    \"EXPAND to follow named frontier nodes that plausibly hold the answer (return their nodeIds).\",\n    \"STOP when the working set is sufficient to answer.\",\n    \"\",\n    `QUESTION: ${input.query}`,\n    `STEPS REMAINING: ${input.stepsRemaining}`,\n    \"\",\n    \"WORKING SET (retrieved memories):\",\n  ];\n  const entries = [...input.workingSet.values()]\n    .sort((a, b) => b.score - a.score || compareDeterministicStrings(a.memoryId, b.memoryId))\n    .slice(0, STATE_WORKING_SET_ENTRIES);\n  if (entries.length === 0) lines.push(\"(empty)\");\n  for (const entry of entries) {\n    const snippet = entry.content.slice(0, STATE_ENTRY_SNIPPET_CHARS).replace(/\\s+/g, \" \");\n    lines.push(`- ${entry.memoryId} (score=${entry.score.toFixed(3)}, origin=${entry.origin}): ${snippet}`);\n  }\n  lines.push(\"\", \"FRONTIER (anchor-linked candidates not yet retrieved):\");\n  if (input.frontier.length === 0) lines.push(\"(empty)\");\n  for (const item of input.frontier) {\n    lines.push(`- ${item.nodeId}: ${item.title} — ${item.reason}`);\n  }\n  lines.push(\n    \"\",\n    'Respond with JSON only: {\"action\":\"REFINE\",\"refinedQuery\":\"...\",\"reason\":\"...\"}',\n    'or {\"action\":\"EXPAND\",\"expandNodeIds\":[\"...\"],\"reason\":\"...\"}',\n    'or {\"action\":\"STOP\",\"reason\":\"...\"}',\n  );\n  return lines.join(\"\\n\");\n}\n\nfunction finalRank(entries: readonly DeepRecallEntry[]): DeepRecallEntry[] {\n  return [...entries].sort(\n    (a, b) => b.score - a.score || compareDeterministicStrings(a.memoryId, b.memoryId)\n  );\n}\n\n/**\n * The budgeted loop. Seed (QMD + graph) -> policy steps -> ranked, capped\n * output. Only a SEED backend failure returns `ok: false`; timeout and\n * budget exhaustion mid-loop return the partial working set with\n * `ok: true` and a BUDGET_EXHAUSTED trace tail.\n */\nexport async function runBudgetedDeepRecall(deps: DeepRecallDeps, query: string): Promise<DeepRecallResult> {\n  const cfg = deps.config;\n  const now = deps.nowMs ?? Date.now;\n  const startedMs = now();\n  const deadlineMs = cfg.totalTimeoutMs > 0 ? startedMs + cfg.totalTimeoutMs : Number.POSITIVE_INFINITY;\n\n  const trace: DeepRecallTraceStep[] = [];\n  const contentCache = new Map<string, string>();\n  const contentFor = (memoryId: string): string => contentCache.get(memoryId) ?? \"\";\n  const workingSet = new Map<string, WorkingEntry>();\n  let graph: FrontierGraph = { index: buildFrontierIndex({ nodes: [], anchors: [] }) };\n  // Nodes already followed by EXPAND leave the frontier for good.\n  const expandedNodeIds = new Set<string>();\n  /**\n   * Hydrate one working-set entry from `loadMemory`, DROPPING it when the read\n   * is missing or reports a non-active memory: QMD can still index a memory\n   * whose governance status moved out of the active set, and hydrating it\n   * would surface content the active-set check excluded.\n   */\n  const hydrateOrDrop = async (memoryId: string): Promise<void> => {\n    const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);\n    if (!memory || !memory.active) {\n      workingSet.delete(memoryId);\n      contentCache.delete(memoryId);\n      return;\n    }\n    contentCache.set(memoryId, memory.content);\n    const entry = workingSet.get(memoryId);\n    if (entry) entry.content = memory.content;\n  };\n  // Pre-policy work (seed search, graph load, seed hydration) is bounded by the\n  // SAME deadline as the policy calls; exhausting it here yields the partial\n  // working set rather than blocking the later check from ever running.\n  let exhaustedDetail: string | null = null;\n  try {\n    const seedHits = await withDeadline(deps.searchSeed(query, cfg.maxResults), deadlineMs, now);\n    mergeIntoWorkingSet(workingSet, seedHits, \"seed\", contentFor);\n  } catch (err) {\n    if (!(err instanceof DeepRecallDeadlineExceeded)) {\n      // Seed backend failure is the only ok:false path (§22: an empty index\n      // proceeds; a thrown search does not).\n      return { ok: false, error: \"backend_unavailable\", entries: [], trace: [] };\n    }\n    exhaustedDetail = \"total timeout reached during seed search\";\n  }\n  if (exhaustedDetail === null) {\n    try {\n      graph = { index: buildFrontierIndex(await withDeadline(deps.loadGraph(), deadlineMs, now)) };\n      // Seed hydration also enforces the active set: a stale or non-active\n      // QMD hit leaves the working set instead of being hydrated in place.\n      for (const memoryId of [...workingSet.keys()]) {\n        await hydrateOrDrop(memoryId);\n      }\n    } catch (err) {\n      if (!(err instanceof DeepRecallDeadlineExceeded)) throw err;\n      exhaustedDetail = \"total timeout reached loading the graph or hydrating seeds\";\n    }\n  }\n\n  let frontier = refreshFrontier(workingSet, graph, expandedNodeIds);\n  let currentQuery = query;\n  let refinesUsed = 0;\n\n  const pushStep = (step: number, action: DeepRecallTraceStep[\"action\"], detail: string, stepStartMs: number): void => {\n    trace.push({\n      step,\n      action,\n      detail,\n      workingSetSize: workingSet.size,\n      frontierSize: frontier.length,\n      durationMs: Math.max(0, now() - stepStartMs),\n    });\n  };\n\n  if (exhaustedDetail !== null) {\n    // Pre-policy work already spent the whole-invocation budget: report the\n    // partial working set (ok:true, §22) instead of starting a policy call\n    // that cannot finish inside the deadline.\n    pushStep(0, \"BUDGET_EXHAUSTED\", exhaustedDetail, startedMs);\n  } else if (cfg.maxSteps <= 0) {\n    // `maxSteps: 0` is a documented disable value (§33): seed-only retrieval,\n    // with no policy call at all. The zero check dominates the step threshold\n    // instead of relying on the loop condition falling through.\n    pushStep(0, \"STOP\", \"policy loop disabled (maxSteps=0)\", startedMs);\n  }\n  let step = 0;\n  try {\n    while (exhaustedDetail === null && cfg.maxSteps > 0 && step < cfg.maxSteps) {\n      const stepStartMs = now();\n      if (now() >= deadlineMs) {\n        pushStep(step, \"BUDGET_EXHAUSTED\", \"total timeout reached before policy call\", stepStartMs);\n        break;\n      }\n      // Two independent axes bound the policy call: its own per-step timeout and\n      // whatever is left of the shared deadline. `stepTimeoutMs: 0` disables only\n      // its own axis (§33) — a finite total budget still applies, so the call can\n      // never outlive `totalTimeoutMs`. `timeoutMs: 0` reaches the policy only\n      // when BOTH axes are disabled.\n      const stepBudgetMs = cfg.stepTimeoutMs > 0 ? cfg.stepTimeoutMs : Number.POSITIVE_INFINITY;\n      const effectiveBudgetMs = Math.min(stepBudgetMs, deadlineMs - now());\n      const timeoutMs = Number.isFinite(effectiveBudgetMs) ? Math.max(1, effectiveBudgetMs) : 0;\n      const raw = await withDeadline(\n        deps.callPolicy(\n          renderStatePrompt({ query: currentQuery, workingSet, frontier, stepsRemaining: cfg.maxSteps - step }),\n          timeoutMs\n        ),\n        deadlineMs,\n        now\n      );\n      const parsed = parsePolicyOutput(raw);\n      if (parsed === null) {\n        pushStep(step, \"STOP\", \"invalid_policy_output\", stepStartMs);\n        break;\n      }\n      if (parsed.action === \"STOP\") {\n        pushStep(step, \"STOP\", parsed.reason || \"policy stop\", stepStartMs);\n        break;\n      }\n      if (parsed.action === \"REFINE\") {\n        const rewrite = validateRefineRewrite({\n          currentQuery,\n          refinedQuery: parsed.refinedQuery ?? null,\n          refinesUsed,\n        });\n        if (!rewrite.ok) {\n          pushStep(step, \"STOP\", rewrite.reason, stepStartMs);\n          break;\n        }\n        currentQuery = rewrite.refinedQuery;\n        refinesUsed += 1;\n        try {\n          const refinedHits = await withDeadline(deps.searchSeed(currentQuery, cfg.maxResults), deadlineMs, now);\n          mergeIntoWorkingSet(workingSet, refinedHits, \"refine\", contentFor);\n          for (const hit of refinedHits) {\n            if (workingSet.has(hit.memoryId) && !contentCache.has(hit.memoryId)) {\n              await hydrateOrDrop(hit.memoryId);\n            }\n          }\n        } catch (err) {\n          // Re-search failure mid-loop is partial, not fatal (§22): the loop\n          // keeps what it has and the policy decides the next move. Deadline\n          // expiry is NOT a partial failure — it ends the invocation.\n          if (err instanceof DeepRecallDeadlineExceeded) throw err;\n        }\n        frontier = refreshFrontier(workingSet, graph, expandedNodeIds);\n        pushStep(step, \"REFINE\", currentQuery, stepStartMs);\n        step += 1;\n        continue;\n      }\n      // EXPAND. A configured ceiling of 0 is a documented no-op limit (§33):\n      // the action is honored but selects nothing.\n      const selection =\n        cfg.maxExpandPerStep <= 0\n          ? { ok: true as const, nodeIds: [] as string[], truncated: false }\n          : selectExpandNodeIds({\n              frontierIds: frontier.map((item) => item.nodeId),\n              requestedIds: parsed.expandNodeIds ?? [],\n              maxExpandPerStep: cfg.maxExpandPerStep,\n            });\n      if (!selection.ok) {\n        pushStep(step, \"STOP\", \"invalid_policy_output\", stepStartMs);\n        break;\n      }\n      const chosen = new Map(frontier.map((item) => [item.nodeId, item]));\n      for (const nodeId of selection.nodeIds) {\n        const item = chosen.get(nodeId);\n        const node = graph.index.nodeIdToNode.get(nodeId);\n        if (!item || !node) continue;\n        for (const memoryId of (node.sourceMemoryIds ?? []).slice(0, MAX_SOURCE_MEMORY_IDS_PER_NODE)) {\n          if (workingSet.has(memoryId)) continue;\n          const memory = await withDeadline(deps.loadMemory(memoryId), deadlineMs, now);\n          // Only active memories enter the working set (§41); a null read\n          // (foreign namespace, §30) skips the same way.\n          if (!memory || !memory.active) continue;\n          workingSet.set(memoryId, {\n            memoryId,\n            content: memory.content,\n            score: item.parentScore * EXPAND_SCORE_INHERITANCE,\n            origin: \"expand\",\n            viaAnchor: item.anchorValue,\n          });\n          contentCache.set(memoryId, memory.content);\n        }\n        expandedNodeIds.add(nodeId);\n      }\n      frontier = refreshFrontier(workingSet, graph, expandedNodeIds);\n      pushStep(step, \"EXPAND\", selection.nodeIds.join(\", \"), stepStartMs);\n      step += 1;\n    }\n  } catch (err) {\n    if (!(err instanceof DeepRecallDeadlineExceeded)) throw err;\n    // A dependency call inside a step outran the shared deadline: the per-step\n    // timeout is not the wall clock, so record exhaustion and keep the partial\n    // working set. durationMs spans the whole invocation.\n    pushStep(step, \"BUDGET_EXHAUSTED\", \"total timeout reached mid-step\", startedMs);\n  }\n\n  if (cfg.maxSteps > 0 && step >= cfg.maxSteps && trace[trace.length - 1]?.action !== \"STOP\") {\n    pushStep(step, \"BUDGET_EXHAUSTED\", \"maxSteps policy calls reached\", startedMs);\n    // durationMs for the exhaustion marker is the whole invocation so far.\n    const marker = trace[trace.length - 1];\n    if (marker) marker.durationMs = Math.max(0, now() - startedMs);\n  }\n\n  // Final output carries full content; the 200-char trim is state rendering only.\n  const entries = finalRank([...workingSet.values()]).map((entry) => ({ ...entry }));\n  return {\n    ok: true,\n    entries: cfg.maxResults > 0 ? entries.slice(0, cfg.maxResults) : [],\n    trace,\n  };\n}\n"],"mappings":"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","names":["step"]}

package/dist/{chunk-VOPOPTZ7.js → chunk-TRLCMLX7.js}

@@ -2,7 +2,7 @@ import {
   WHO_KNOWS_DEFAULT_LIMIT,
   WHO_KNOWS_MAX_LIMIT,
   validateWhoKnowsInput
-} from "./chunk-6C57JBJ3.js";
+} from "./chunk-LUDXSSTW.js";
 
 // src/who-knows-cli.ts
 function extractWhoKnowsRawArgs(rest) {
@@ -74,4 +74,4 @@ export {
   renderWhoKnowsText,
   renderWhoKnows
 };
-//# sourceMappingURL=chunk-VOPOPTZ7.js.map
+//# sourceMappingURL=chunk-TRLCMLX7.js.map

package/dist/{chunk-KZMFU7YL.js → chunk-V3HUBF7T.js}

@@ -1,7 +1,7 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-3QWF54M4.js";
+} from "./chunk-5P2KNFJZ.js";
 import {
   SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
 } from "./chunk-EEOUMG3J.js";
@@ -343,4 +343,4 @@ export {
   parseSupportPassportModelJob,
   SupportPassportModelBridge
 };
-//# sourceMappingURL=chunk-KZMFU7YL.js.map
+//# sourceMappingURL=chunk-V3HUBF7T.js.map

package/dist/{chunk-KLL5SPER.js → chunk-VHAKBUBD.js}

@@ -3,7 +3,7 @@ import {
   getOperation,
   operationRequiresAuthorizedNamespace,
   operationUsesPrincipalNamespace
-} from "./chunk-3QWF54M4.js";
+} from "./chunk-5P2KNFJZ.js";
 import {
   assertOperationAuthorizationAllowed
 } from "./chunk-MZWSOLMT.js";
@@ -60,4 +60,4 @@ export {
   authorizationProbeNamespaces,
   authorizationProbeRequiresPrincipalNamespace
 };
-//# sourceMappingURL=chunk-KLL5SPER.js.map
+//# sourceMappingURL=chunk-VHAKBUBD.js.map

package/dist/{chunk-WF2WCZCR.js → chunk-VYD63IFH.js}

@@ -17,14 +17,14 @@ import {
 } from "./chunk-4ZWCQJNM.js";
 import {
   normalizeQmdResultPath
-} from "./chunk-YHCBJULX.js";
+} from "./chunk-JGXMA6HL.js";
 import {
   withholdToolScopedFromSharedNamespace
 } from "./chunk-S2V7RUCL.js";
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-XXW32OL7.js";
+} from "./chunk-OYV6RKPM.js";
 import {
   createMemorySnapshot
 } from "./chunk-S2HLHAZ4.js";
@@ -11374,4 +11374,4 @@ export {
   isValidBufferSurpriseEvent,
   StorageManager3 as StorageManager
 };
-//# sourceMappingURL=chunk-WF2WCZCR.js.map
+//# sourceMappingURL=chunk-VYD63IFH.js.map

package/dist/chunk-VZIAVM72.js

@@ -0,0 +1,49 @@
+// src/recall-deep-expand-select.ts
+var DEFAULT_MAX_EXPAND_PER_STEP = 3;
+function selectExpandNodeIds(input) {
+  const max = input.maxExpandPerStep === void 0 ? DEFAULT_MAX_EXPAND_PER_STEP : input.maxExpandPerStep;
+  if (!Number.isInteger(max) || max < 1) {
+    throw new RangeError(
+      `maxExpandPerStep must be an integer >= 1; got ${JSON.stringify(max)}`
+    );
+  }
+  if (!Array.isArray(input.requestedIds)) {
+    return { ok: false, error: "invalid_policy_output", foreignIds: [] };
+  }
+  const frontier = new Set(input.frontierIds);
+  const seen = /* @__PURE__ */ new Set();
+  const foreign = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const entry of input.requestedIds) {
+    if (typeof entry !== "string" || entry.trim().length === 0) {
+      foreign.add(String(entry));
+      continue;
+    }
+    if (!frontier.has(entry)) {
+      foreign.add(entry);
+      continue;
+    }
+    if (seen.has(entry)) continue;
+    seen.add(entry);
+    ordered.push(entry);
+  }
+  if (foreign.size > 0) {
+    return {
+      ok: false,
+      error: "invalid_policy_output",
+      foreignIds: [...foreign].sort()
+    };
+  }
+  const truncated = ordered.length > max;
+  return {
+    ok: true,
+    nodeIds: truncated ? ordered.slice(0, max) : ordered,
+    truncated
+  };
+}
+
+export {
+  DEFAULT_MAX_EXPAND_PER_STEP,
+  selectExpandNodeIds
+};
+//# sourceMappingURL=chunk-VZIAVM72.js.map