@remnic/core 9.69.38 → 9.69.40

package/dist/chunk-NETQXOPY.js

@@ -0,0 +1,221 @@
+import {
+  coerceBooleanLike
+} from "./chunk-PQVCH2AE.js";
+
+// src/recall-state-view.ts
+var DEFAULT_RECALL_STATE_VIEWS = false;
+var CHANGE_WORDS = ["switch", "switches", "switched", "switching", "change", "changes", "changed", "changing"];
+var CHANGE_PHRASE_RE = /\bwhen\s+did\b|\bused\s+to\b/;
+var CHANGE_WORD_RE = new RegExp(`\\b(?:${CHANGE_WORDS.join("|")})\\b`);
+var EVENT_POINTER_RE = /\b(?:before|after)\s+(?:the|a|an|this|that|these|those)\b/;
+function parseRecallStateViews(raw) {
+  return coerceBooleanLike(raw, "recallStateViews") === true;
+}
+function isChangeOrientedQuery(query) {
+  const lower = query.toLowerCase();
+  return CHANGE_PHRASE_RE.test(lower) || CHANGE_WORD_RE.test(lower) || EVENT_POINTER_RE.test(lower);
+}
+function shouldWidenSuperseded(successorId, candidateIds) {
+  return typeof successorId === "string" && successorId.length > 0 && candidateIds.has(successorId);
+}
+function formatSupersededPrefix(date, successorId) {
+  return `[superseded ${date} by ${successorId}]`;
+}
+function resultStateViewId(result) {
+  return result.id ?? result.docid ?? "";
+}
+function stateViewKey(namespace, id) {
+  return `${typeof namespace === "string" ? namespace : ""}\0${id}`;
+}
+function resultStateViewKey(result) {
+  const id = resultStateViewId(result);
+  return id ? stateViewKey(result.namespace, id) : "";
+}
+function stateViewIdFromKey(key) {
+  const sep = key.indexOf("\0");
+  return sep === -1 ? key : key.slice(sep + 1);
+}
+function buildSuccessorMap(results, chains) {
+  const byPred = /* @__PURE__ */ new Map();
+  const link = (predKey, succKey, overwrite) => {
+    if (!predKey || !succKey) return;
+    if (overwrite || !byPred.has(predKey)) byPred.set(predKey, succKey);
+  };
+  for (const chain of chains) {
+    if (chain.predecessorId && chain.successorId) {
+      link(
+        stateViewKey(chain.namespace, chain.predecessorId),
+        stateViewKey(chain.namespace, chain.successorId),
+        false
+      );
+    }
+  }
+  for (const result of results) {
+    const key = resultStateViewKey(result);
+    if (key && result.supersedes) {
+      link(stateViewKey(result.namespace, result.supersedes), key, false);
+    }
+  }
+  for (const result of results) {
+    const key = resultStateViewKey(result);
+    if (key && result.supersededBy) {
+      link(key, stateViewKey(result.namespace, result.supersededBy), true);
+    }
+  }
+  return byPred;
+}
+function successorLinkOf(result, byPred) {
+  const key = resultStateViewKey(result);
+  return {
+    superseded: result.status === "superseded" || Boolean(result.supersededBy) || byPred.has(key),
+    successorKey: result.supersededBy ? stateViewKey(result.namespace, result.supersededBy) : byPred.get(key)
+  };
+}
+function labelFor(key, result, byPred, admittedIds, asOfMs) {
+  const { successorKey } = successorLinkOf(result, byPred);
+  const isPred = shouldWidenSuperseded(successorKey, admittedIds);
+  let isSucc = false;
+  for (const [predId, succId] of byPred) {
+    if (succId === key && admittedIds.has(predId)) {
+      isSucc = true;
+      break;
+    }
+  }
+  if (isPred && isSucc) return "transition";
+  if (isPred) return "historical";
+  if (isSucc) return "current";
+  if (result.status === "superseded") {
+    return asOfMs === null ? "historical" : snapshotStateLabel(result, asOfMs);
+  }
+  return "current";
+}
+function snapshotStateLabel(result, asOfMs) {
+  const invalidAtMs = Date.parse(result.invalidAt ?? "");
+  const boundaryMs = Number.isFinite(invalidAtMs) ? invalidAtMs : Date.parse(result.supersededAt ?? "");
+  return Number.isFinite(boundaryMs) && boundaryMs <= asOfMs ? "historical" : "current";
+}
+function annotateStateView(results, query, chains, options = {}) {
+  const enabled = options.enabled === true;
+  if (!enabled || options.changeIntent !== true && !isChangeOrientedQuery(query)) return results;
+  const asOfMs = typeof options.asOfMs === "number" && Number.isFinite(options.asOfMs) ? options.asOfMs : null;
+  const byPred = buildSuccessorMap(results, chains);
+  const candidateIds = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    const key = resultStateViewKey(result);
+    if (key) candidateIds.add(key);
+  }
+  let admitted;
+  if (asOfMs !== null) {
+    admitted = results.slice();
+  } else {
+    admitted = [];
+    for (const result of results) {
+      const { superseded, successorKey } = successorLinkOf(result, byPred);
+      if (!superseded || shouldWidenSuperseded(successorKey, candidateIds)) {
+        admitted.push(result);
+      }
+    }
+    let admittedIds2 = new Set(admitted.map(resultStateViewKey).filter(Boolean));
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (let i = admitted.length - 1; i >= 0; i -= 1) {
+        const row = admitted[i];
+        const { superseded, successorKey } = successorLinkOf(row, byPred);
+        if (superseded && !shouldWidenSuperseded(successorKey, admittedIds2)) {
+          admitted.splice(i, 1);
+          changed = true;
+        }
+      }
+      if (changed) admittedIds2 = new Set(admitted.map(resultStateViewKey).filter(Boolean));
+    }
+  }
+  const admittedIds = new Set(admitted.map(resultStateViewKey).filter(Boolean));
+  return admitted.map((result) => {
+    const key = resultStateViewKey(result);
+    const { successorKey } = successorLinkOf(result, byPred);
+    const stateLabel = labelFor(key, result, byPred, admittedIds, asOfMs);
+    if (result.supersededBy || !successorKey) return { ...result, stateLabel };
+    return { ...result, stateLabel, supersededBy: stateViewIdFromKey(successorKey) };
+  });
+}
+function reconcileStateViewPairs(results) {
+  const byPred = buildSuccessorMap(results, []);
+  let kept = results.slice();
+  for (let changed = true; changed; ) {
+    changed = false;
+    const keptKeys = new Set(kept.map(resultStateViewKey).filter(Boolean));
+    const next = [];
+    for (const row of kept) {
+      const { superseded, successorKey } = successorLinkOf(row, byPred);
+      if (superseded && !shouldWidenSuperseded(successorKey, keptKeys)) {
+        changed = true;
+        continue;
+      }
+      next.push(row);
+    }
+    if (changed) kept = next;
+  }
+  return kept;
+}
+function capStateViewPackets(ordered, limit) {
+  const safeLimit = typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;
+  if (safeLimit === 0) return [];
+  if (ordered.length === 0) return [];
+  const byPred = buildSuccessorMap(ordered, []);
+  const parent = /* @__PURE__ */ new Map();
+  const root = (key) => {
+    let current = key;
+    for (; ; ) {
+      const up = parent.get(current);
+      if (up === void 0 || up === current) {
+        parent.set(current, current);
+        return current;
+      }
+      current = up;
+    }
+  };
+  const union = (a, b) => {
+    const ra = root(a);
+    const rb = root(b);
+    if (ra !== rb) parent.set(ra, rb);
+  };
+  const keys = [];
+  const keyToIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < ordered.length; i += 1) {
+    const key = resultStateViewKey(ordered[i]) || `#idx${i}`;
+    keys.push(key);
+    if (!parent.has(key)) parent.set(key, key);
+    const first = keyToIndex.get(key);
+    if (first !== void 0) union(keys[first], key);
+    else keyToIndex.set(key, i);
+  }
+  for (const [predKey, succKey] of byPred) {
+    const predIdx = keyToIndex.get(predKey);
+    const succIdx = keyToIndex.get(succKey);
+    if (predIdx !== void 0 && succIdx !== void 0) union(keys[predIdx], keys[succIdx]);
+  }
+  const selectedRoots = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ordered.length && selectedRoots.size < safeLimit; i += 1) {
+    selectedRoots.add(root(keys[i]));
+  }
+  const selected = [];
+  for (let i = 0; i < ordered.length; i += 1) {
+    if (selectedRoots.has(root(keys[i]))) selected.push(ordered[i]);
+  }
+  return selected;
+}
+
+export {
+  DEFAULT_RECALL_STATE_VIEWS,
+  parseRecallStateViews,
+  isChangeOrientedQuery,
+  shouldWidenSuperseded,
+  formatSupersededPrefix,
+  resultStateViewId,
+  stateViewKey,
+  resultStateViewKey,
+  annotateStateView,
+  reconcileStateViewPairs,
+  capStateViewPackets
+};
+//# sourceMappingURL=chunk-NETQXOPY.js.map

package/dist/chunk-NETQXOPY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-state-view.ts"],"sourcesContent":["/**\n * Recall state views (issue #1952).\n *\n * Config key: `recallStateViews` (default false). When false, annotateStateView\n * is identity: same array reference, no `stateLabel`. config.ts is at its\n * fileSizeGrandfather ceiling, so parseConfig wiring waits for a later PR.\n * Call `parseRecallStateViews` at the recall seam when that lands.\n *\n * Change-intent morphology lives here (do not grow intent.ts). A superseded\n * memory is admitted only when its successor is also in the candidate set.\n *\n * #2859 — chain identities are namespace-qualified (`namespace\\0id`): the\n * same id in two namespaces never cross-anchors. The reverse chain derives\n * from the successor's `supersedes` back-pointer when a predecessor lacks\n * `supersededBy`, and asOf snapshot labels use the temporal validity\n * boundary (predecessor `invalidAt` / successor `validAt`), not the\n * `supersededAt` write time.\n */\nimport { coerceBooleanLike } from \"./connectors/coerce.js\";\n\nexport type StateLabel = \"current\" | \"historical\" | \"transition\";\n\nexport interface StateViewChain {\n  predecessorId: string;\n  successorId: string;\n  supersededAt?: string;\n  /** #2859 — namespace scope; a chain link never crosses namespaces. */\n  namespace?: string;\n}\n\nexport interface StateViewResult {\n  id?: string;\n  docid?: string;\n  status?: string;\n  /** #2859 — namespace that owns this row; qualifies every chain identity. */\n  namespace?: string;\n  /** #2859 — back-pointer: id of the row this one replaced. */\n  supersedes?: string;\n  supersededBy?: string;\n  supersededAt?: string;\n  /** #2859 — fact validity start (frontmatter `valid_at`). */\n  validAt?: string;\n  /** #2859 — fact validity end (frontmatter `invalid_at`). */\n  invalidAt?: string;\n  stateLabel?: StateLabel;\n}\n\nexport const DEFAULT_RECALL_STATE_VIEWS = false;\n\nconst CHANGE_WORDS = [\"switch\", \"switches\", \"switched\", \"switching\", \"change\", \"changes\", \"changed\", \"changing\"];\n\n// Phrase matches are token-bounded: \"when Didi\" must not fire the\n// \"when did\" phrase, and \"confused to\" must not fire \"used to\".\nconst CHANGE_PHRASE_RE = /\\bwhen\\s+did\\b|\\bused\\s+to\\b/;\nconst CHANGE_WORD_RE = new RegExp(`\\\\b(?:${CHANGE_WORDS.join(\"|\")})\\\\b`);\n// Bare \"before\"/\"after\" are ordinary sequencing (\"before lunch\",\n// \"after install\"). They carry change intent only when they point at a\n// specific event through a determiner (\"before the move\", \"after the\n// cutover\").\nconst EVENT_POINTER_RE = /\\b(?:before|after)\\s+(?:the|a|an|this|that|these|those)\\b/;\n\nexport function parseRecallStateViews(raw: unknown): boolean {\n  return coerceBooleanLike(raw, \"recallStateViews\") === true;\n}\n\nexport function isChangeOrientedQuery(query: string): boolean {\n  const lower = query.toLowerCase();\n  return CHANGE_PHRASE_RE.test(lower) || CHANGE_WORD_RE.test(lower) || EVENT_POINTER_RE.test(lower);\n}\n\nexport function shouldWidenSuperseded(\n  successorId: string | undefined,\n  candidateIds: ReadonlySet<string>,\n): boolean {\n  return typeof successorId === \"string\" && successorId.length > 0 && candidateIds.has(successorId);\n}\n\nexport function formatSupersededPrefix(date: string, successorId: string): string {\n  return `[superseded ${date} by ${successorId}]`;\n}\n\nexport function resultStateViewId(result: StateViewResult): string {\n  return result.id ?? result.docid ?? \"\";\n}\n\n/**\n * #2859 — namespace-qualified chain identity. Namespace fanout can surface\n * the same id from two namespaces; every successor/admission match runs on\n * `namespace\\0id` keys so a row in one namespace can never anchor (or be\n * anchored by) an identically-named row in another.\n */\nexport function stateViewKey(namespace: string | undefined, id: string): string {\n  return `${typeof namespace === \"string\" ? namespace : \"\"}\\u0000${id}`;\n}\n\nexport function resultStateViewKey(result: StateViewResult): string {\n  const id = resultStateViewId(result);\n  return id ? stateViewKey(result.namespace, id) : \"\";\n}\n\n/** Inverse of {@link stateViewKey}: the id after the namespace separator. */\nfunction stateViewIdFromKey(key: string): string {\n  const sep = key.indexOf(\"\\u0000\");\n  return sep === -1 ? key : key.slice(sep + 1);\n}\n\n/**\n * predecessorKey → successorKey, namespace-qualified. Precedence: explicit\n * chains, then successor rows' `supersedes` back-pointers (#2859 — derives\n * the reverse chain when the predecessor lacks `supersededBy`), then the\n * predecessor's own `supersededBy` (authoritative when present).\n */\nfunction buildSuccessorMap(\n  results: readonly StateViewResult[],\n  chains: readonly StateViewChain[],\n): Map<string, string> {\n  const byPred = new Map<string, string>();\n  const link = (predKey: string, succKey: string, overwrite: boolean): void => {\n    if (!predKey || !succKey) return;\n    if (overwrite || !byPred.has(predKey)) byPred.set(predKey, succKey);\n  };\n  for (const chain of chains) {\n    if (chain.predecessorId && chain.successorId) {\n      link(\n        stateViewKey(chain.namespace, chain.predecessorId),\n        stateViewKey(chain.namespace, chain.successorId),\n        false,\n      );\n    }\n  }\n  for (const result of results) {\n    const key = resultStateViewKey(result);\n    if (key && result.supersedes) {\n      link(stateViewKey(result.namespace, result.supersedes), key, false);\n    }\n  }\n  for (const result of results) {\n    const key = resultStateViewKey(result);\n    if (key && result.supersededBy) {\n      link(key, stateViewKey(result.namespace, result.supersededBy), true);\n    }\n  }\n  return byPred;\n}\n\nfunction successorLinkOf(\n  result: StateViewResult,\n  byPred: ReadonlyMap<string, string>,\n): { superseded: boolean; successorKey: string | undefined } {\n  const key = resultStateViewKey(result);\n  return {\n    superseded:\n      result.status === \"superseded\" ||\n      Boolean(result.supersededBy) ||\n      byPred.has(key),\n    successorKey: result.supersededBy\n      ? stateViewKey(result.namespace, result.supersededBy)\n      : byPred.get(key),\n  };\n}\n\nfunction labelFor(\n  key: string,\n  result: StateViewResult,\n  byPred: Map<string, string>,\n  admittedIds: ReadonlySet<string>,\n  asOfMs: number | null,\n): StateLabel {\n  const { successorKey } = successorLinkOf(result, byPred);\n  const isPred = shouldWidenSuperseded(successorKey, admittedIds);\n  let isSucc = false;\n  for (const [predId, succId] of byPred) {\n    if (succId === key && admittedIds.has(predId)) {\n      isSucc = true;\n      break;\n    }\n  }\n  if (isPred && isSucc) return \"transition\";\n  if (isPred) return \"historical\";\n  if (isSucc) return \"current\";\n  if (result.status === \"superseded\") {\n    // #1952 asOf mode: the successor is legitimately absent under the\n    // historical pin (a linked successor takes the pair branches above).\n    // The row was the live fact at the snapshot when the temporal\n    // validity boundary postdates the pin (\"current\" relative to the\n    // snapshot); already replaced at the pin is \"historical\". #2859: the\n    // boundary is the fact's validity flip — `invalidAt` (the supersession\n    // pipeline sets it to the successor's valid_at) — not the\n    // `supersededAt` write time; legacy rows without a window fall back\n    // to supersededAt.\n    return asOfMs === null ? \"historical\" : snapshotStateLabel(result, asOfMs);\n  }\n  return \"current\";\n}\n\nfunction snapshotStateLabel(result: StateViewResult, asOfMs: number): StateLabel {\n  const invalidAtMs = Date.parse(result.invalidAt ?? \"\");\n  const boundaryMs = Number.isFinite(invalidAtMs)\n    ? invalidAtMs\n    : Date.parse(result.supersededAt ?? \"\");\n  return Number.isFinite(boundaryMs) && boundaryMs <= asOfMs ? \"historical\" : \"current\";\n}\n\nexport function annotateStateView<T extends StateViewResult>(\n  results: T[],\n  query: string,\n  chains: readonly StateViewChain[],\n  options: { enabled?: boolean; asOfMs?: number; changeIntent?: boolean } = {},\n): T[] {\n  const enabled = options.enabled === true;\n  // #2893 — changeIntent:true marks intent as already classified from the\n  // ORIGINAL prompt; `query` may be cron-normalized (intent signal\n  // truncated or stop-worded away) and must not be re-checked then.\n  if (!enabled || (options.changeIntent !== true && !isChangeOrientedQuery(query))) return results;\n  // #1952 asOf mode: under a historical pin the pipeline's isValidAsOf\n  // gate already decided validity at the pinned instant, so a predecessor\n  // must not be discarded merely because its successor is absent under\n  // the same filter. A valid asOf result is never emptied here.\n  const asOfMs =\n    typeof options.asOfMs === \"number\" && Number.isFinite(options.asOfMs)\n      ? options.asOfMs\n      : null;\n\n  const byPred = buildSuccessorMap(results, chains);\n  const candidateIds = new Set<string>();\n  for (const result of results) {\n    const key = resultStateViewKey(result);\n    if (key) candidateIds.add(key);\n  }\n  let admitted: T[];\n  if (asOfMs !== null) {\n    admitted = results.slice();\n  } else {\n    admitted = [];\n    for (const result of results) {\n      const { superseded, successorKey } = successorLinkOf(result, byPred);\n      if (!superseded || shouldWidenSuperseded(successorKey, candidateIds)) {\n        admitted.push(result);\n      }\n    }\n\n    // #1952 contract: superseded never appears without its successor. A\n    // successor can itself be dropped (filtered elsewhere, or transitively\n    // orphaned), so reconcile to a fixpoint instead of trusting the first pass.\n    let admittedIds = new Set(admitted.map(resultStateViewKey).filter(Boolean));\n    for (let changed = true; changed; ) {\n      changed = false;\n      for (let i = admitted.length - 1; i >= 0; i -= 1) {\n        const row = admitted[i]!;\n        const { superseded, successorKey } = successorLinkOf(row, byPred);\n        if (superseded && !shouldWidenSuperseded(successorKey, admittedIds)) {\n          admitted.splice(i, 1);\n          changed = true;\n        }\n      }\n      if (changed) admittedIds = new Set(admitted.map(resultStateViewKey).filter(Boolean));\n    }\n  }\n\n  const admittedIds = new Set(admitted.map(resultStateViewKey).filter(Boolean));\n  return admitted.map((result) => {\n    const key = resultStateViewKey(result);\n    const { successorKey } = successorLinkOf(result, byPred);\n    const stateLabel = labelFor(key, result, byPred, admittedIds, asOfMs);\n    if (result.supersededBy || !successorKey) return { ...result, stateLabel };\n    return { ...result, stateLabel, supersededBy: stateViewIdFromKey(successorKey) };\n  });\n}\n\n/**\n * #2859 — drop superseded rows whose successor is not in the pool BEFORE\n * the user cap/MMR runs, so post-cap orphan removal can never underfill\n * the result set. Reconciles to a fixpoint (a dropped successor orphans\n * its own predecessors). Rows with no successor links pass through in\n * order. ponytail: repeated full-pool passes are O(n²) on one long chain;\n * recall pools stay small, memoize per-key if pools ever grow.\n */\nexport function reconcileStateViewPairs<T extends StateViewResult>(results: readonly T[]): T[] {\n  const byPred = buildSuccessorMap(results, []);\n  let kept = results.slice();\n  for (let changed = true; changed; ) {\n    changed = false;\n    const keptKeys = new Set(kept.map(resultStateViewKey).filter(Boolean));\n    const next: T[] = [];\n    for (const row of kept) {\n      const { superseded, successorKey } = successorLinkOf(row, byPred);\n      if (superseded && !shouldWidenSuperseded(successorKey, keptKeys)) {\n        changed = true;\n        continue;\n      }\n      next.push(row);\n    }\n    if (changed) kept = next;\n  }\n  return kept;\n}\n\n/**\n * #2859 — packet-counting cap. A predecessor/successor chain admitted\n * together is ONE complete evidence packet: it consumes a single slot of\n * the user cap, and the slice never splits a packet at the boundary (no\n * underfill from post-cap orphan removal). Rows keep their incoming\n * (MMR) order; packets are ordered by first appearance. Call\n * reconcileStateViewPairs first so orphans never consume a slot.\n */\nexport function capStateViewPackets<T extends StateViewResult>(\n  ordered: readonly T[],\n  limit: number,\n): T[] {\n  const safeLimit =\n    typeof limit === \"number\" && Number.isFinite(limit) ? Math.max(0, Math.floor(limit)) : 0;\n  if (safeLimit === 0) return [];\n  if (ordered.length === 0) return [];\n\n  const byPred = buildSuccessorMap(ordered, []);\n  // Union-find over row keys; blank-key rows become per-index singletons.\n  const parent = new Map<string, string>();\n  const root = (key: string): string => {\n    let current = key;\n    for (;;) {\n      const up = parent.get(current);\n      if (up === undefined || up === current) {\n        parent.set(current, current);\n        return current;\n      }\n      current = up;\n    }\n  };\n  const union = (a: string, b: string): void => {\n    const ra = root(a);\n    const rb = root(b);\n    if (ra !== rb) parent.set(ra, rb);\n  };\n  const keys: string[] = [];\n  const keyToIndex = new Map<string, number>();\n  for (let i = 0; i < ordered.length; i += 1) {\n    // ponytail: blank-key rows must stay distinct singletons; index-keyed.\n    const key = resultStateViewKey(ordered[i]!) || `#idx${i}`;\n    keys.push(key);\n    if (!parent.has(key)) parent.set(key, key);\n    const first = keyToIndex.get(key);\n    if (first !== undefined) union(keys[first]!, key);\n    else keyToIndex.set(key, i);\n  }\n  for (const [predKey, succKey] of byPred) {\n    const predIdx = keyToIndex.get(predKey);\n    const succIdx = keyToIndex.get(succKey);\n    if (predIdx !== undefined && succIdx !== undefined) union(keys[predIdx]!, keys[succIdx]!);\n  }\n  // Packets ordered by first appearance; admit whole packets until the cap.\n  const selectedRoots = new Set<string>();\n  for (let i = 0; i < ordered.length && selectedRoots.size < safeLimit; i += 1) {\n    selectedRoots.add(root(keys[i]!));\n  }\n  const selected: T[] = [];\n  for (let i = 0; i < ordered.length; i += 1) {\n    if (selectedRoots.has(root(keys[i]!))) selected.push(ordered[i]!);\n  }\n  return selected;\n}\n"],"mappings":"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","names":["admittedIds"]}

package/dist/{chunk-UZZ7SQT3.js → chunk-NVVZPBKI.js}

@@ -3,7 +3,7 @@ import {
   isArtifactMemoryPath,
   isLocationDayPath,
   isMeetingRecordPath
-} from "./chunk-BV4ZKIZH.js";
+} from "./chunk-K75A5XWU.js";
 import {
   OKF_RESERVED_BASENAMES
 } from "./chunk-PCEYGOSL.js";
@@ -208,4 +208,4 @@ export {
   isGenericRecallExcludedPath,
   filterRecallCandidates
 };
-//# sourceMappingURL=chunk-UZZ7SQT3.js.map
+//# sourceMappingURL=chunk-NVVZPBKI.js.map

package/dist/{chunk-BLDBT6HZ.js → chunk-PJRKLB4Z.js}

@@ -26,14 +26,30 @@ function classifyFallbackParseFailure(reason) {
     case "no_models":
       return "auth_config";
     case "http_error":
+    case "timeout":
       return "provider_retryable";
     case "empty":
+    case "schema_rejection":
       return "parse_empty";
   }
 }
+function formatExtractionParseFailureLog(input) {
+  const modelUsed = typeof input.attemptedModel === "string" && input.attemptedModel.length > 0 ? input.attemptedModel : "unknown";
+  const errorClass = typeof input.errorClass === "string" && input.errorClass.length > 0 ? input.errorClass : "none";
+  const httpStatus = typeof input.httpStatus === "number" && Number.isFinite(input.httpStatus) ? String(input.httpStatus) : "none";
+  return [
+    "extraction fallback returned no parsed output",
+    `failureReason=${input.failureReason}`,
+    `modelUsed=${modelUsed}`,
+    `errorClass=${errorClass}`,
+    `httpStatus=${httpStatus}`,
+    `traceId=${input.traceId}`
+  ].join(" ");
+}
 
 export {
   classifyExtractionThrownError,
-  classifyFallbackParseFailure
+  classifyFallbackParseFailure,
+  formatExtractionParseFailureLog
 };
-//# sourceMappingURL=chunk-BLDBT6HZ.js.map
+//# sourceMappingURL=chunk-PJRKLB4Z.js.map

package/dist/chunk-PJRKLB4Z.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-error-classification.ts"],"sourcesContent":["import type { ExtractionFailureClass } from \"./types.js\";\nimport { isTransientHttpError } from \"./connectors/live/transient-errors.js\";\n\n/**\n * Read a numeric HTTP status off a thrown error without re-implementing the\n * shared transient classifier. Uses `in`/typeof narrowing (no inline casts).\n */\nfunction httpStatusFromError(err: unknown): number | undefined {\n  if (!err || typeof err !== \"object\") return undefined;\n  if (\"status\" in err && typeof err.status === \"number\" && Number.isFinite(err.status)) return err.status;\n  if (\"statusCode\" in err && typeof err.statusCode === \"number\" && Number.isFinite(err.statusCode)) {\n    return err.statusCode;\n  }\n  return undefined;\n}\n\n/**\n * Map a thrown extraction error to a coarse failure class for the retry/breaker\n * layer. 401/403 → `auth_config` (misconfigured provider, open the breaker);\n * transient (429/5xx/network, per the shared `isTransientHttpError`) → back off;\n * anything else defaults to `provider_retryable` (fail-open toward retry, but\n * capped by the per-fingerprint attempt budget). Never throws.\n */\nexport function classifyExtractionThrownError(err: unknown): ExtractionFailureClass {\n  try {\n    const status = httpStatusFromError(err);\n    if (status === 401 || status === 403) return \"auth_config\";\n    if (isTransientHttpError(err)) return \"provider_retryable\";\n    return \"provider_retryable\";\n  } catch {\n    return \"provider_retryable\";\n  }\n}\n\n/**\n * Map the gateway fallback's discriminated parse-failure reason to a coarse\n * extraction failure class. \"no models configured\" is an auth/config problem;\n * an HTTP/transport failure backs off; an unparseable-but-present response is a\n * genuine empty-parse.\n */\nexport function classifyFallbackParseFailure(\n  reason: \"no_models\" | \"empty\" | \"http_error\" | \"schema_rejection\" | \"timeout\",\n): ExtractionFailureClass {\n  switch (reason) {\n    case \"no_models\":\n      return \"auth_config\";\n    case \"http_error\":\n    case \"timeout\":\n      return \"provider_retryable\";\n    case \"empty\":\n    case \"schema_rejection\":\n      return \"parse_empty\";\n  }\n}\n\n/**\n * Operator-visible extraction parse-failure line. Keeps the historical\n * greppable prefix and appends the fields that used to live only at debug.\n */\nexport function formatExtractionParseFailureLog(input: {\n  failureReason: string;\n  attemptedModel?: string;\n  httpStatus?: number;\n  errorClass?: string;\n  traceId: string;\n}): string {\n  const modelUsed =\n    typeof input.attemptedModel === \"string\" && input.attemptedModel.length > 0\n      ? input.attemptedModel\n      : \"unknown\";\n  const errorClass =\n    typeof input.errorClass === \"string\" && input.errorClass.length > 0\n      ? input.errorClass\n      : \"none\";\n  const httpStatus =\n    typeof input.httpStatus === \"number\" && Number.isFinite(input.httpStatus)\n      ? String(input.httpStatus)\n      : \"none\";\n  return [\n    \"extraction fallback returned no parsed output\",\n    `failureReason=${input.failureReason}`,\n    `modelUsed=${modelUsed}`,\n    `errorClass=${errorClass}`,\n    `httpStatus=${httpStatus}`,\n    `traceId=${input.traceId}`,\n  ].join(\" \");\n}\n"],"mappings":";;;;;AAOA,SAAS,oBAAoB,KAAkC;AAC7D,MAAI,CAAC,OAAO,OAAO,QAAQ,SAAU,QAAO;AAC5C,MAAI,YAAY,OAAO,OAAO,IAAI,WAAW,YAAY,OAAO,SAAS,IAAI,MAAM,EAAG,QAAO,IAAI;AACjG,MAAI,gBAAgB,OAAO,OAAO,IAAI,eAAe,YAAY,OAAO,SAAS,IAAI,UAAU,GAAG;AAChG,WAAO,IAAI;AAAA,EACb;AACA,SAAO;AACT;AASO,SAAS,8BAA8B,KAAsC;AAClF,MAAI;AACF,UAAM,SAAS,oBAAoB,GAAG;AACtC,QAAI,WAAW,OAAO,WAAW,IAAK,QAAO;AAC7C,QAAI,qBAAqB,GAAG,EAAG,QAAO;AACtC,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,SAAS,6BACd,QACwB;AACxB,UAAQ,QAAQ;AAAA,IACd,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,EACX;AACF;AAMO,SAAS,gCAAgC,OAMrC;AACT,QAAM,YACJ,OAAO,MAAM,mBAAmB,YAAY,MAAM,eAAe,SAAS,IACtE,MAAM,iBACN;AACN,QAAM,aACJ,OAAO,MAAM,eAAe,YAAY,MAAM,WAAW,SAAS,IAC9D,MAAM,aACN;AACN,QAAM,aACJ,OAAO,MAAM,eAAe,YAAY,OAAO,SAAS,MAAM,UAAU,IACpE,OAAO,MAAM,UAAU,IACvB;AACN,SAAO;AAAA,IACL;AAAA,IACA,iBAAiB,MAAM,aAAa;AAAA,IACpC,aAAa,SAAS;AAAA,IACtB,cAAc,UAAU;AAAA,IACxB,cAAc,UAAU;AAAA,IACxB,WAAW,MAAM,OAAO;AAAA,EAC1B,EAAE,KAAK,GAAG;AACZ;","names":[]}

package/dist/{chunk-TTSJ7WUC.js → chunk-PKUJNICO.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-7S53BPTU.js";
+} from "./chunk-MVG3KXON.js";
 import {
   OKF_PROFILE_TYPE,
   okfTypeForMemory
@@ -272,4 +272,4 @@ export {
   exportOkfBundle,
   firstHeading
 };
-//# sourceMappingURL=chunk-TTSJ7WUC.js.map
+//# sourceMappingURL=chunk-PKUJNICO.js.map

package/dist/{chunk-QMWKENNK.js → chunk-Q4AUIFUA.js}

@@ -1,3 +1,6 @@
+import {
+  ClaudeCodeAdapter
+} from "./chunk-J64TK33U.js";
 import {
   CodexAdapter
 } from "./chunk-RSUYKGGZ.js";
@@ -7,9 +10,6 @@ import {
 import {
   ReplitAdapter
 } from "./chunk-TMSXWOBZ.js";
-import {
-  ClaudeCodeAdapter
-} from "./chunk-J64TK33U.js";
 import {
   headerValue
 } from "./chunk-7RXCMVFQ.js";
@@ -108,4 +108,4 @@ export {
   OpenCodeAdapter,
   AdapterRegistry
 };
-//# sourceMappingURL=chunk-QMWKENNK.js.map
+//# sourceMappingURL=chunk-Q4AUIFUA.js.map

package/dist/{chunk-G43PMSME.js → chunk-QE6YVNP5.js}

@@ -1,9 +1,9 @@
-import {
-  runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-SCXURCVT.js";
 import {
   normalizeDreamsStatusWindowHours
 } from "./chunk-EQWEIIKQ.js";
+import {
+  runGraphEdgeDecayMaintenanceAcrossNamespaces
+} from "./chunk-SCXURCVT.js";
 import {
   executeResolution,
   isValidResolutionVerb,
@@ -29,10 +29,10 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-62QIQEUC.js";
+} from "./chunk-SFHLQPBF.js";
 import {
   validateBriefingFormat
-} from "./chunk-TUKGXQ5T.js";
+} from "./chunk-VQYWKCDR.js";
 import {
   enforceNamespaceAllowList,
   tokenCapabilityStore
@@ -45,7 +45,7 @@ import {
   recallRequestSchema,
   retainedCategoryAlias,
   suggestionSubmitRequestSchema
-} from "./chunk-P4ZAEYKG.js";
+} from "./chunk-ZX3AYNNV.js";
 import {
   projectTagProjectId
 } from "./chunk-3Q3N35W7.js";
@@ -560,4 +560,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-G43PMSME.js.map
+//# sourceMappingURL=chunk-QE6YVNP5.js.map

package/dist/{chunk-WKDFJXW5.js → chunk-QM2SPLKQ.js}

@@ -155,4 +155,4 @@ export {
   probeFetch,
   SingleFlightProbe
 };
-//# sourceMappingURL=chunk-WKDFJXW5.js.map
+//# sourceMappingURL=chunk-QM2SPLKQ.js.map

package/dist/chunk-QM2SPLKQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/local-llm-helpers.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport type { LocalLlmRequestPriority } from \"./local-llm.js\";\n\nexport interface LocalLlmChatCompletionOptions {\n  temperature?: number;\n  maxTokens?: number;\n  responseFormat?: { type: string };\n  timeoutMs?: number;\n  operation?: string;\n  forceDisableThinking?: boolean;\n  disableThinking?: boolean;\n  priority?: LocalLlmRequestPriority;\n  signal?: AbortSignal;\n  redactProviderErrors?: boolean;\n  /** Per-request model; defaults to config.localLlmModel. */\n  model?: string;\n  /**\n   * Optional out-box for the terminal failure cause (issue #2891): on a\n   * failed request the client records the last provider error here so\n   * callers can classify it (e.g. HTTP 429 → rate-limited) in memory\n   * instead of seeing only null. Never logged.\n   */\n  failureDiag?: { lastError?: unknown };\n}\n\nexport interface LocalLlmChatCompletionResult {\n  content: string;\n  usage?: { promptTokens: number; completionTokens: number; totalTokens: number };\n}\nexport function isAbortError(err: unknown): boolean {\n  if (!err || typeof err !== \"object\") return false;\n  const maybe = err as { name?: string; message?: string };\n  return (\n    maybe.name === \"AbortError\" ||\n    maybe.message === \"This operation was aborted\" ||\n    maybe.message === \"The operation was aborted\"\n  );\n}\n\nexport function waitForRetryBackoff(backoffMs: number, signal?: AbortSignal): Promise<boolean> {\n  return new Promise((resolve) => {\n    let settled = false;\n    let timer: NodeJS.Timeout | undefined;\n    const onAbort = (): void => {\n      if (settled) return;\n      settled = true;\n      if (timer) clearTimeout(timer);\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve(false);\n    };\n    const onTimer = (): void => {\n      if (settled) return;\n      settled = true;\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve(true);\n    };\n    timer = setTimeout(onTimer, backoffMs);\n    if (signal) {\n      if (signal.aborted) onAbort();\n      else signal.addEventListener(\"abort\", onAbort, { once: true });\n    }\n  });\n}\n\nexport function normalizeBackendTripReason(reason: string): string {\n  const cleaned = reason.replace(/\\s+/g, \" \").replace(/^[-:–—\\s]+/, \"\").trim();\n  if (!cleaned) return \"unknown local backend failure\";\n  return cleaned.length > 160 ? `${cleaned.slice(0, 157)}...` : cleaned;\n}\n\nexport function extractNonRecoverableBackendReason(reason: string): string | null {\n  const match = reason.match(\n    /Failed to load model|Library not loaded|different Team IDs|code signature|llm_engine_mlx_amphibian/i,\n  );\n  return match?.[0] ?? null;\n}\n\nexport function extractNonRecoverableBackendReasonFromErrorText(errorText: string): string | null {\n  const directReason = extractNonRecoverableBackendReason(errorText);\n  if (directReason) return directReason;\n  try {\n    const parsed = JSON.parse(errorText) as { error?: { message?: string } };\n    return extractNonRecoverableBackendReason(parsed?.error?.message ?? \"\");\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Flatten a fetch rejection into one line, including the `cause` undici hides\n * the real reason behind (`fetch failed` alone says nothing).\n */\nexport function describeFetchFailure(err: unknown): string {\n  const name = err instanceof Error ? err.name : \"\";\n  const message = err instanceof Error ? err.message : String(err);\n  const cause: unknown = err instanceof Error ? (err as Error & { cause?: unknown }).cause : undefined;\n  const causeText = cause instanceof Error\n    ? ` (cause: ${cause.name}: ${cause.message}${\n      typeof (cause as Error & { code?: unknown }).code === \"string\"\n        ? ` [${String((cause as Error & { code?: unknown }).code)}]`\n        : \"\"\n    })`\n    : cause === undefined\n      ? \"\"\n      : ` (cause: ${String(cause)})`;\n  return `${name ? `${name}: ` : \"\"}${message}${causeText}`;\n}\n\n/**\n * What to record when every availability probe failed.\n *\n * A probe that TIMED OUT is not evidence the backend is down: the budget is a\n * fixed 2s and a busy event loop can burn it before the socket is scheduled,\n * so the backend looks dead while it answers other callers in single-digit ms.\n * Caching that verdict took extraction offline for a whole health-check\n * interval at a time (issue #2210), so a timeout leaves availability UNKNOWN —\n * this call fails, the next one re-probes instead of reading a stale false.\n *\n * A backend that ANSWERED and said no is a real verdict and stays cached, or\n * the daemon re-probes a known-bad endpoint on every request.\n */\nexport function resolveUnavailableVerdict(args: {\n  baseUrl: string;\n  sawAbortedProbe: boolean;\n  wasAvailable: boolean | null;\n}): { cacheVerdict: boolean; warning: string | null } {\n  if (args.sawAbortedProbe) {\n    return {\n      cacheVerdict: false,\n      warning:\n        `local LLM availability probe timed out at ${args.baseUrl} (event loop busy?); treating availability as ` +\n        \"unknown and re-probing on the next request rather than marking the backend down\",\n    };\n  }\n  return {\n    cacheVerdict: true,\n    // Surfaced at warn, not debug: extraction stops silently when this flips,\n    // and the daemon emits no debug at all unless configured for it.\n    warning: args.wasAvailable !== false ? `local LLM became unavailable at ${args.baseUrl}` : null,\n  };\n}\n\nexport interface ProbeFetchResult {\n  ok: boolean;\n  data: unknown;\n  status: number | null;\n  /** The probe hit its own budget rather than getting an answer. */\n  aborted?: boolean;\n}\n\n/**\n * One health-probe request.\n *\n * Every failure is logged with its cause: a transport error and a 404 both\n * returned `ok: false` with nothing recorded, so an unreachable backend was\n * indistinguishable from a wrong path and an availability failure had no\n * diagnosable reason at all (§22, issue #2210).\n */\nexport async function probeFetch(\n  url: string,\n  options: { timeoutMs: number; headers: Record<string, string>; signal?: AbortSignal },\n): Promise<ProbeFetchResult> {\n  const controller = new AbortController();\n  const requestSignal = options.signal\n    ? AbortSignal.any([options.signal, controller.signal])\n    : controller.signal;\n  const timeout = setTimeout(() => controller.abort(), options.timeoutMs);\n  try {\n    const response = await fetch(url, { signal: requestSignal, headers: options.headers });\n    clearTimeout(timeout);\n    if (!response.ok) {\n      log.debug(`local LLM probe: ${url} returned HTTP ${response.status}`);\n      return { ok: false, data: null, status: response.status };\n    }\n    const contentType = response.headers.get(\"content-type\");\n    const data = contentType?.includes(\"application/json\") ? await response.json() : await response.text();\n    return { ok: true, data, status: response.status };\n  } catch (err) {\n    clearTimeout(timeout);\n    const aborted = isAbortError(err);\n    log.debug(\n      `local LLM probe: ${url} ${aborted ? `timed out after ${options.timeoutMs}ms` : \"failed\"}: ${describeFetchFailure(err)}`,\n    );\n    return { ok: false, data: null, status: null, aborted };\n  }\n}\n\ninterface PendingProbe {\n  promise: Promise<boolean>;\n  controller: AbortController;\n  /** Callers still awaiting this sequence; at zero the sequence is aborted. */\n  waiters: number;\n}\n\n/**\n * Collapses concurrent probe sequences onto one in-flight run.\n *\n * A timed-out availability probe deliberately caches nothing (issue #2210),\n * which removed the false verdict that used to absorb concurrent callers:\n * every queued request would then run its own full probe sequence, on a host\n * already slow enough to blow the probe budget.\n *\n * Cancellation is refcounted rather than shared: one caller walking away must\n * not abort a sequence the others are still waiting on, so the underlying task\n * is aborted only once every waiter has gone.\n */\nexport class SingleFlightProbe {\n  private pending: PendingProbe | null = null;\n\n  run(task: (signal: AbortSignal) => Promise<boolean>, signal?: AbortSignal): Promise<boolean> {\n    let active = this.pending;\n    if (!active) {\n      const controller = new AbortController();\n      const created: PendingProbe = { promise: Promise.resolve(false), controller, waiters: 0 };\n      created.promise = task(controller.signal).finally(() => {\n        if (this.pending === created) this.pending = null;\n      });\n      this.pending = created;\n      active = created;\n    }\n    const entry = active;\n    entry.waiters += 1;\n    let released = false;\n    const release = () => {\n      if (released) return;\n      released = true;\n      entry.waiters -= 1;\n      if (entry.waiters > 0) return;\n      // Detach BEFORE aborting. `pending` would otherwise still point at this\n      // doomed entry until the task's own `finally` runs a microtask later, and\n      // a caller arriving in that window would join an aborted sequence and\n      // read its `false` as a verdict.\n      if (this.pending === entry) this.pending = null;\n      entry.controller.abort();\n    };\n    if (!signal) return entry.promise.finally(release);\n    return new Promise<boolean>((resolve, reject) => {\n      const onAbort = () => {\n        release();\n        resolve(false);\n      };\n      signal.addEventListener(\"abort\", onAbort, { once: true });\n      entry.promise.then(\n        (value) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          release();\n          resolve(value);\n        },\n        (err: unknown) => {\n          signal.removeEventListener(\"abort\", onAbort);\n          release();\n          reject(err instanceof Error ? err : new Error(String(err)));\n        },\n      );\n    });\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-GT4ZHOKT.js → chunk-QPVNK2VE.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-7S53BPTU.js";
+} from "./chunk-MVG3KXON.js";
 import {
   composeMemoryEnvelope
 } from "./chunk-GDYU6VF4.js";
@@ -546,4 +546,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-GT4ZHOKT.js.map
+//# sourceMappingURL=chunk-QPVNK2VE.js.map

package/dist/{chunk-K5DA5TRG.js → chunk-QS5Q5RBV.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   compareEntityTimestamps
-} from "./chunk-7S53BPTU.js";
+} from "./chunk-MVG3KXON.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -918,4 +918,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-K5DA5TRG.js.map
+//# sourceMappingURL=chunk-QS5Q5RBV.js.map

package/dist/{chunk-BX4EOMKT.js → chunk-RDLPFM7I.js}

@@ -1,6 +1,6 @@
 import {
   parseEntityFile
-} from "./chunk-7S53BPTU.js";
+} from "./chunk-MVG3KXON.js";
 import {
   inferMemoryStatus
 } from "./chunk-7RJUVTVF.js";
@@ -253,4 +253,4 @@ export {
   WHO_KNOWS_MCP_TOOLS,
   handleWhoKnowsHttpQuery
 };
-//# sourceMappingURL=chunk-BX4EOMKT.js.map
+//# sourceMappingURL=chunk-RDLPFM7I.js.map

package/dist/{chunk-EY5JAWZC.js → chunk-RJQAP333.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-62QIQEUC.js";
+} from "./chunk-SFHLQPBF.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-EY5JAWZC.js.map
+//# sourceMappingURL=chunk-RJQAP333.js.map

package/dist/{chunk-5AERZWJD.js → chunk-RLU2Y5GV.js}

@@ -1,15 +1,15 @@
 import {
   applyRecallStateViews
-} from "./chunk-BRZWWUCJ.js";
+} from "./chunk-DFVSJFHK.js";
 import {
   isGenericRecallExcludedPath
-} from "./chunk-UZZ7SQT3.js";
+} from "./chunk-NVVZPBKI.js";
 import {
   shouldFilterSupersededFromRecall
 } from "./chunk-5WITETWU.js";
 import {
   isChangeOrientedQuery
-} from "./chunk-255PC37A.js";
+} from "./chunk-NETQXOPY.js";
 
 // src/recall-state-view-admission.ts
 function resolveRecallStateViewActive(options, config, query) {
@@ -69,4 +69,4 @@ export {
   filterRecentScanMemoriesForStateView,
   indexStateViewAnnotatedResults
 };
-//# sourceMappingURL=chunk-5AERZWJD.js.map
+//# sourceMappingURL=chunk-RLU2Y5GV.js.map

package/dist/chunk-RLU2Y5GV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-state-view-admission.ts"],"sourcesContent":["/**\n * Recall-internal state-view admission (issue #1952).\n *\n * Flag resolution, recent-scan successor-anchor admission, and the X-ray\n * inject-seam annotation live here so recall-internal.ts stays under its\n * ratchet ceiling. Callers keep one-line sites.\n */\n\nimport { isGenericRecallExcludedPath, type GenericRecallPathPolicy } from \"./orchestration/generic-recall-paths.js\";\nimport { isChangeOrientedQuery, type StateViewResult } from \"./recall-state-view.js\";\nimport { applyRecallStateViews } from \"./recall-state-view-wire.js\";\nimport { shouldFilterSupersededFromRecall } from \"./temporal-supersession.js\";\nimport type { MemoryFile } from \"./types.js\";\n\n/**\n * Config flag OR per-call override, gated on change intent; computed once\n * for all branches.\n *\n * #2893: `query` MUST be the ORIGINAL prompt, not the cron-normalized\n * retrievalQuery — buildRecallQueryPolicy truncates standard prompts at\n * maxChars and strips stop-words (\"when\", \"before\", \"after\") from\n * instruction-heavy ones, either of which can erase the change-intent\n * signal before retrieval. Only the resulting boolean flows downstream;\n * retrieval itself keeps using the normalized query.\n */\nexport function resolveRecallStateViewActive(\n  options: { stateView?: boolean },\n  config: { recallStateViews?: boolean },\n  query: string,\n): boolean {\n  return (options.stateView === true || config.recallStateViews === true) && isChangeOrientedQuery(query);\n}\n\n/**\n * Superseded-status filtering delegates to shouldFilterSupersededFromRecall\n * so recent-scan and the QMD safety filter share semantics (kill switch,\n * audit mode, PR #402).\n *\n * #1952: an active state view admits a superseded memory whose successor\n * ALSO survives this admission filter — a successor excluded by status or\n * path can never anchor (mirrors the filterSearchResultsByRecallSafety\n * fixpoint). Anchors grow through admitted chain links, so iterate to a\n * fixpoint.\n *\n * PR #713: when `as_of` is active, pass superseded candidates through here\n * — boostSearchResults's `[valid_at, invalid_at)` evaluation is the\n * authoritative historical gate. Other non-active statuses stay excluded.\n */\nexport function filterRecentScanMemoriesForStateView(\n  memories: readonly MemoryFile[],\n  config: GenericRecallPathPolicy,\n  supersessionOptions: { enabled: boolean; includeInRecall: boolean },\n  stateViewActive: boolean,\n  asOfMs: number | undefined,\n): MemoryFile[] {\n  const asOfActive = typeof asOfMs === \"number\" && Number.isFinite(asOfMs);\n  let stateViewAdmittedIds: Set<string> | null = null;\n  if (stateViewActive && !asOfActive) {\n    stateViewAdmittedIds = new Set(\n      memories\n        .filter(\n          (m) =>\n            !isGenericRecallExcludedPath(m.path, config) &&\n            m.frontmatter.status !== \"superseded\" &&\n            !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions),\n        )\n        .map((m) => m.frontmatter.id)\n        .filter((id): id is string => typeof id === \"string\" && id.length > 0),\n    );\n    for (let progress = true; progress; ) {\n      progress = false;\n      for (const m of memories) {\n        const id = m.frontmatter.id;\n        if (typeof id !== \"string\" || id.length === 0) continue;\n        if (stateViewAdmittedIds.has(id)) continue;\n        if (isGenericRecallExcludedPath(m.path, config)) continue;\n        if (m.frontmatter.status !== \"superseded\") continue;\n        if (!shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions)) continue;\n        if (stateViewAdmittedIds.has(m.frontmatter.supersededBy ?? \"\")) {\n          stateViewAdmittedIds.add(id);\n          progress = true;\n        }\n      }\n    }\n  }\n  return memories.filter((m) => {\n    if (isGenericRecallExcludedPath(m.path, config)) return false;\n    const status = m.frontmatter.status;\n    if (!status || status === \"active\") return true;\n    if (status === \"superseded\") {\n      if (asOfActive) return true;\n      const id = m.frontmatter.id;\n      if (\n        stateViewAdmittedIds !== null &&\n        typeof id === \"string\" &&\n        stateViewAdmittedIds.has(id)\n      ) {\n        return true;\n      }\n      // Include superseded memory only if the canonical gate says\n      // NOT to filter it (kill switch off or audit mode on).\n      return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);\n    }\n    // Other non-active statuses (archived, retired, etc.) are\n    // excluded from the recent-scan path by default.\n    return false;\n  });\n}\n\n/** Label the captured X-ray branch through the same inject-seam annotator. */\nexport function indexStateViewAnnotatedResults<T extends StateViewResult & { path: string; namespace?: string }>(\n  results: T[],\n  query: string,\n  config: unknown,\n  stateViewActive?: boolean,\n  asOfMs?: number,\n): Map<string, T> {\n  return new Map(\n    applyRecallStateViews(results, query, config, stateViewActive, asOfMs).map((xr) => [\n      `${xr.namespace ?? \"\"}\\0${xr.path}`,\n      xr,\n    ]),\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAyBO,SAAS,6BACd,SACA,QACA,OACS;AACT,UAAQ,QAAQ,cAAc,QAAQ,OAAO,qBAAqB,SAAS,sBAAsB,KAAK;AACxG;AAiBO,SAAS,qCACd,UACA,QACA,qBACA,iBACA,QACc;AACd,QAAM,aAAa,OAAO,WAAW,YAAY,OAAO,SAAS,MAAM;AACvE,MAAI,uBAA2C;AAC/C,MAAI,mBAAmB,CAAC,YAAY;AAClC,2BAAuB,IAAI;AAAA,MACzB,SACG;AAAA,QACC,CAAC,MACC,CAAC,4BAA4B,EAAE,MAAM,MAAM,KAC3C,EAAE,YAAY,WAAW,gBACzB,CAAC,iCAAiC,EAAE,aAAa,mBAAmB;AAAA,MACxE,EACC,IAAI,CAAC,MAAM,EAAE,YAAY,EAAE,EAC3B,OAAO,CAAC,OAAqB,OAAO,OAAO,YAAY,GAAG,SAAS,CAAC;AAAA,IACzE;AACA,aAAS,WAAW,MAAM,YAAY;AACpC,iBAAW;AACX,iBAAW,KAAK,UAAU;AACxB,cAAM,KAAK,EAAE,YAAY;AACzB,YAAI,OAAO,OAAO,YAAY,GAAG,WAAW,EAAG;AAC/C,YAAI,qBAAqB,IAAI,EAAE,EAAG;AAClC,YAAI,4BAA4B,EAAE,MAAM,MAAM,EAAG;AACjD,YAAI,EAAE,YAAY,WAAW,aAAc;AAC3C,YAAI,CAAC,iCAAiC,EAAE,aAAa,mBAAmB,EAAG;AAC3E,YAAI,qBAAqB,IAAI,EAAE,YAAY,gBAAgB,EAAE,GAAG;AAC9D,+BAAqB,IAAI,EAAE;AAC3B,qBAAW;AAAA,QACb;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO,SAAS,OAAO,CAAC,MAAM;AAC5B,QAAI,4BAA4B,EAAE,MAAM,MAAM,EAAG,QAAO;AACxD,UAAM,SAAS,EAAE,YAAY;AAC7B,QAAI,CAAC,UAAU,WAAW,SAAU,QAAO;AAC3C,QAAI,WAAW,cAAc;AAC3B,UAAI,WAAY,QAAO;AACvB,YAAM,KAAK,EAAE,YAAY;AACzB,UACE,yBAAyB,QACzB,OAAO,OAAO,YACd,qBAAqB,IAAI,EAAE,GAC3B;AACA,eAAO;AAAA,MACT;AAGA,aAAO,CAAC,iCAAiC,EAAE,aAAa,mBAAmB;AAAA,IAC7E;AAGA,WAAO;AAAA,EACT,CAAC;AACH;AAGO,SAAS,+BACd,SACA,OACA,QACA,iBACA,QACgB;AAChB,SAAO,IAAI;AAAA,IACT,sBAAsB,SAAS,OAAO,QAAQ,iBAAiB,MAAM,EAAE,IAAI,CAAC,OAAO;AAAA,MACjF,GAAG,GAAG,aAAa,EAAE,KAAK,GAAG,IAAI;AAAA,MACjC;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/{chunk-2OGTN37H.js → chunk-ROEFLU37.js}

@@ -34,10 +34,10 @@ import {
 } from "./chunk-QVSRE355.js";
 import {
   getOperation
-} from "./chunk-62QIQEUC.js";
+} from "./chunk-SFHLQPBF.js";
 import {
   WHO_KNOWS_MCP_TOOLS
-} from "./chunk-BX4EOMKT.js";
+} from "./chunk-RDLPFM7I.js";
 import {
   PROMOTION_CANDIDATES_MCP_TOOLS
 } from "./chunk-VYCOJKSX.js";
@@ -52,7 +52,7 @@ import {
 } from "./chunk-MZWSOLMT.js";
 import {
   validateRequest
-} from "./chunk-P4ZAEYKG.js";
+} from "./chunk-ZX3AYNNV.js";
 import {
   readEnvVar
 } from "./chunk-P2QRMMVQ.js";
@@ -4051,4 +4051,4 @@ export {
   MCP_MIGRATED_OPERATIONS,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-2OGTN37H.js.map
+//# sourceMappingURL=chunk-ROEFLU37.js.map