@remnic/core 9.69.56 → 9.69.58

package/dist/chunk-DXODYQ7J.js

@@ -0,0 +1,319 @@
+import {
+  ACTIVE_STATUSES
+} from "./chunk-42DJ235G.js";
+
+// src/recall-why.ts
+var RECALL_WHY_STAGES = Object.freeze(["retrieval", "policy-filter", "rerank", "cap", "format"]);
+var RECALL_WHY_DROP_REASONS = Object.freeze([
+  "backend-unavailable",
+  "planner-mode",
+  "namespace-scope",
+  "path-excluded",
+  "status-filter",
+  "not-a-candidate",
+  "score-floor",
+  "cap-eviction"
+]);
+var RecallWhyInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RecallWhyInputError";
+  }
+};
+var REMEDIATION = {
+  "backend-unavailable": "The search backend did not answer. Check that the index daemon is running and reachable; this is an outage, not an empty result.",
+  "planner-mode": "The planner classified this prompt as not needing recall. Pass an explicit recall mode, or rephrase the prompt so it reads as a memory request.",
+  "namespace-scope": "The memory lives outside the namespaces this recall reads. Query its namespace explicitly, or grant the caller read access to it.",
+  "path-excluded": "The path is served by a dedicated surface and is excluded from generic recall by design. Read it through that surface instead.",
+  "status-filter": "Only active memories are injected. Reactivate the memory, or read it through an explicit search or archive surface.",
+  "not-a-candidate": "The memory exists on disk but retrieval never saw it \u2014 the search index is stale for this path. Reindex, then retry.",
+  "score-floor": "The candidate scored below the relevance floor. Use wording closer to the stored memory, or widen the retrieval budget.",
+  "cap-eviction": "The candidate survived filtering but was cut by the final result cap. Raise the recall budget or narrow the query."
+};
+async function explainRecallMiss(query, opts) {
+  if (typeof query !== "string" || query.length === 0 || query.trim().length === 0) {
+    throw new RecallWhyInputError("recallWhy: query is required and must be non-empty");
+  }
+  const expect = opts.expect;
+  if (expect !== void 0 && (typeof expect !== "string" || expect.length === 0 || expect.trim().length === 0)) {
+    throw new RecallWhyInputError("recallWhy: expect must be a non-empty string when supplied");
+  }
+  const deps = opts.deps;
+  const plannerMode = deps.plannerMode(query);
+  const scopedNamespaces = [...deps.scopedNamespaces];
+  const outcome = await deps.runRecall(query, {
+    ...opts.sessionKey !== void 0 ? { sessionKey: opts.sessionKey } : {},
+    ...opts.namespace !== void 0 ? { namespace: opts.namespace } : {},
+    ...opts.abortSignal !== void 0 ? { abortSignal: opts.abortSignal } : {}
+  });
+  if (!outcome.ok) {
+    return {
+      schemaVersion: "1",
+      query,
+      ...opts.namespace !== void 0 ? { namespace: opts.namespace } : {},
+      plannerMode,
+      ok: false,
+      failure: { reason: "backend_unavailable", detail: outcome.detail },
+      recallNamespaces: scopedNamespaces,
+      appliedResultLimit: 0,
+      stages: [
+        {
+          stage: "retrieval",
+          considered: 0,
+          admitted: 0,
+          reason: `backend_unavailable: ${outcome.detail}`,
+          drops: []
+        }
+      ],
+      recalledMemoryIds: [],
+      ...expect !== void 0 ? {
+        expectation: {
+          expect,
+          matched: false,
+          recalled: false,
+          stage: "retrieval",
+          reason: "backend-unavailable",
+          detail: outcome.detail,
+          remediation: REMEDIATION["backend-unavailable"]
+        }
+      } : {}
+    };
+  }
+  const snapshot = outcome.snapshot;
+  const stages = buildStages(snapshot, plannerMode);
+  const recalledMemoryIds = (snapshot?.appliedResults ?? []).map((r) => r.memoryId);
+  const expectation = expect === void 0 ? void 0 : await traceExpectation(expect, snapshot, plannerMode, deps, scopedNamespaces);
+  return {
+    schemaVersion: "1",
+    query,
+    ...snapshot?.namespace !== void 0 ? { namespace: snapshot.namespace } : opts.namespace !== void 0 ? { namespace: opts.namespace } : {},
+    plannerMode,
+    ok: true,
+    recallNamespaces: scopedNamespaces,
+    appliedResultLimit: nonNegativeInt(snapshot?.appliedResultLimit),
+    stages,
+    recalledMemoryIds,
+    ...expectation !== void 0 ? { expectation } : {}
+  };
+}
+var PLANNER_MODE_NOTE = {
+  no_recall: "planner mode no_recall: retrieval never ran",
+  minimal: "planner mode minimal: retrieval headroom is capped"
+};
+function buildStages(snapshot, plannerMode) {
+  if (snapshot === null) {
+    return [
+      {
+        stage: "retrieval",
+        considered: 0,
+        admitted: 0,
+        reason: PLANNER_MODE_NOTE[plannerMode] ?? "no candidates were captured for this query",
+        drops: []
+      }
+    ];
+  }
+  const captured = snapshot.results;
+  const rejected = captured.filter((r) => nonEmpty(r.rejectedBy) !== void 0);
+  const admittedByPolicy = captured.length - rejected.length;
+  const headroom = snapshot.headroomResults;
+  const applied = snapshot.appliedResults;
+  const appliedIds = new Set(applied.map((r) => r.memoryId));
+  const evicted = headroom.filter((r) => !appliedIds.has(r.memoryId));
+  const filterLadder = snapshot.filters.map((f) => `${f.name}: ${f.admitted}/${f.considered}${f.reason ? ` (${f.reason})` : ""}`).join("; ");
+  return [
+    {
+      stage: "retrieval",
+      considered: captured.length,
+      admitted: captured.length,
+      // Both stage paths annotate the retrieval row from the SAME table, so
+      // a planner mode can never be reported on one path and dropped on the
+      // other. Modes with no note omit the key rather than setting it to
+      // undefined, keeping the JSON shape byte-stable.
+      ...PLANNER_MODE_NOTE[plannerMode] !== void 0 ? { reason: PLANNER_MODE_NOTE[plannerMode] } : {},
+      drops: []
+    },
+    {
+      stage: "policy-filter",
+      considered: captured.length,
+      admitted: admittedByPolicy,
+      ...filterLadder.length > 0 ? { reason: filterLadder } : {},
+      drops: sortDrops(
+        rejected.map((r) => ({
+          memoryId: r.memoryId,
+          path: r.path,
+          reason: policyReasonFor(nonEmpty(r.rejectedBy) ?? ""),
+          detail: `rejectedBy=${nonEmpty(r.rejectedBy) ?? "unknown"}`
+        }))
+      )
+    },
+    {
+      stage: "rerank",
+      considered: admittedByPolicy,
+      admitted: headroom.length,
+      drops: []
+    },
+    {
+      stage: "cap",
+      considered: headroom.length,
+      admitted: applied.length,
+      reason: `appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`,
+      drops: sortDrops(
+        evicted.map((r) => ({
+          memoryId: r.memoryId,
+          path: r.path,
+          reason: "cap-eviction",
+          detail: `cut by appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`
+        }))
+      )
+    },
+    {
+      stage: "format",
+      considered: applied.length,
+      admitted: applied.length,
+      reason: `budget used ${nonNegativeInt(snapshot.budget.used)}/${nonNegativeInt(snapshot.budget.chars)} chars`,
+      drops: []
+    }
+  ];
+}
+function policyReasonFor(rejectedBy) {
+  const name = rejectedBy.toLowerCase();
+  if (name.includes("namespace")) return "namespace-scope";
+  if (name.includes("status") || name.includes("superseded") || name.includes("quarantine")) {
+    return "status-filter";
+  }
+  if (name.includes("path") || name.includes("artifact") || name.includes("excluded")) {
+    return "path-excluded";
+  }
+  if (name.includes("score") || name.includes("floor") || name.includes("threshold")) {
+    return "score-floor";
+  }
+  return "not-a-candidate";
+}
+async function traceExpectation(expect, snapshot, plannerMode, deps, recallNamespaces) {
+  const ref = await deps.findExpected(expect);
+  if (ref === null) {
+    return {
+      expect,
+      matched: false,
+      recalled: false,
+      stage: "retrieval",
+      reason: "not-a-candidate",
+      detail: "no stored memory matches this id or substring",
+      remediation: "Nothing on disk matches. Check the id or substring; the memory may never have been written."
+    };
+  }
+  const base = { expect, matched: true, memoryId: ref.memoryId, path: ref.path };
+  if (snapshot !== null) {
+    if (snapshot.appliedResults.some((r) => matchesRef(r, ref))) {
+      return { ...base, recalled: true };
+    }
+    const rejectedRow = snapshot.results.find((r) => matchesRef(r, ref) && nonEmpty(r.rejectedBy) !== void 0);
+    if (rejectedRow !== void 0) {
+      const rejectedBy = nonEmpty(rejectedRow.rejectedBy) ?? "unknown";
+      const reason = policyReasonFor(rejectedBy);
+      return {
+        ...base,
+        recalled: false,
+        stage: "policy-filter",
+        reason,
+        detail: `rejectedBy=${rejectedBy}`,
+        remediation: REMEDIATION[reason]
+      };
+    }
+    if (snapshot.headroomResults.some((r) => matchesRef(r, ref)) || snapshot.results.some((r) => matchesRef(r, ref))) {
+      return {
+        ...base,
+        recalled: false,
+        stage: "cap",
+        reason: "cap-eviction",
+        detail: `survived filtering but was cut by appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`,
+        remediation: REMEDIATION["cap-eviction"]
+      };
+    }
+  }
+  if (plannerMode === "no_recall") {
+    return {
+      ...base,
+      recalled: false,
+      stage: "retrieval",
+      reason: "planner-mode",
+      detail: "plannerMode=no_recall: retrieval never ran for this query",
+      remediation: REMEDIATION["planner-mode"]
+    };
+  }
+  if (deps.namespacesEnabled && !recallNamespaces.includes(ref.namespace)) {
+    return {
+      ...base,
+      recalled: false,
+      stage: "policy-filter",
+      reason: "namespace-scope",
+      detail: `namespace=${ref.namespace} is outside the recall scope [${recallNamespaces.join(", ")}]`,
+      remediation: REMEDIATION["namespace-scope"]
+    };
+  }
+  if (deps.isExcludedPath(ref.path)) {
+    return {
+      ...base,
+      recalled: false,
+      stage: "policy-filter",
+      reason: "path-excluded",
+      detail: `path=${ref.path} is excluded from generic recall`,
+      remediation: REMEDIATION["path-excluded"]
+    };
+  }
+  if (!ACTIVE_STATUSES.has(ref.status)) {
+    return {
+      ...base,
+      recalled: false,
+      stage: "policy-filter",
+      reason: "status-filter",
+      detail: `status=${ref.status}`,
+      remediation: REMEDIATION["status-filter"]
+    };
+  }
+  if (plannerMode === "minimal") {
+    return {
+      ...base,
+      recalled: false,
+      stage: "retrieval",
+      reason: "planner-mode",
+      detail: "plannerMode=minimal: retrieval headroom is capped for this query",
+      remediation: REMEDIATION["planner-mode"]
+    };
+  }
+  return {
+    ...base,
+    recalled: false,
+    stage: "retrieval",
+    reason: "not-a-candidate",
+    detail: "the memory passes every policy filter but retrieval never returned it",
+    remediation: REMEDIATION["not-a-candidate"]
+  };
+}
+function matchesRef(result, ref) {
+  return result.memoryId === ref.memoryId || result.path === ref.path;
+}
+function nonEmpty(value) {
+  if (typeof value !== "string") return void 0;
+  return value.length > 0 ? value : void 0;
+}
+function nonNegativeInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  const floored = Math.floor(value);
+  return floored > 0 ? floored : 0;
+}
+function sortDrops(drops) {
+  return [...drops].sort((a, b) => {
+    if (a.memoryId !== b.memoryId) return a.memoryId < b.memoryId ? -1 : 1;
+    if (a.path !== b.path) return a.path < b.path ? -1 : 1;
+    return 0;
+  });
+}
+
+export {
+  RECALL_WHY_STAGES,
+  RECALL_WHY_DROP_REASONS,
+  RecallWhyInputError,
+  explainRecallMiss
+};
+//# sourceMappingURL=chunk-DXODYQ7J.js.map

package/dist/chunk-DXODYQ7J.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-why.ts"],"sourcesContent":["/**\n * Recall-miss diagnosis (issue #3033).\n *\n * `remnic xray` explains the attribution of results that WERE returned.\n * Nothing explained an absence, so an operator who expected a memory back\n * could not tell their own configuration from a product defect. This module\n * answers the other question: given a query, which pipeline stage dropped\n * the memory I expected?\n *\n * Host-agnostic and strictly READ-ONLY: it persists nothing, indexes\n * nothing, and never mutates recall behaviour. It is deliberately NOT gated\n * by `recallDirectAnswerEnabled` (which gates the xray tier-explain block) —\n * a diagnostic that only works once the feature you are diagnosing is\n * already enabled is useless.\n *\n * Reuse, never fork (AGENTS.md rule 22 / issue decision 3). The pipeline is\n * not re-implemented here. Every stage decision comes from one of exactly\n * two places:\n *\n *   1. The `RecallXraySnapshot` the REAL recall published — its\n *      `results` / `headroomResults` / `appliedResults` / `filters` /\n *      `appliedResultLimit` fields already record what each stage saw and\n *      admitted. That snapshot IS the existing stage recorder.\n *   2. The same shared predicates the pipeline itself calls, injected\n *      through {@link RecallWhyDeps} so a caller cannot accidentally supply\n *      a divergent copy: `planRecallMode`, `isGenericRecallExcludedPath`,\n *      `ACTIVE_STATUSES`, and the shared namespace resolver.\n *\n * Stage order follows the recall contract in AGENTS.md\n * (\"Retrieval/Intent/Cache Guardrails\" #1): candidate retrieval headroom ->\n * policy filters -> rerank/boost -> cap -> format. A memory is reported\n * against the EARLIEST stage that dropped it.\n *\n * Empty is not failed (Review Prevention Checklist #22): a search-backend\n * outage returns `{ ok: false, failure: { reason: \"backend_unavailable\" } }`\n * and never \"0 candidates\".\n */\n\nimport { ACTIVE_STATUSES } from \"./contradiction/contradiction-scan.js\";\nimport type { RecallXrayResult, RecallXraySnapshot } from \"./recall-xray.js\";\nimport type { MemoryStatus, RecallPlanMode } from \"./types.js\";\n\n/**\n * Pipeline stages, in contract order. Frozen `as const` WITHOUT a\n * `readonly RecallWhyStage[]` annotation so the derived union below stays\n * narrow (Review Prevention Checklist #47).\n */\nexport const RECALL_WHY_STAGES = Object.freeze([\"retrieval\", \"policy-filter\", \"rerank\", \"cap\", \"format\"] as const);\n\nexport type RecallWhyStage = (typeof RECALL_WHY_STAGES)[number];\n\n// Pins the narrow union: an unused @ts-expect-error is itself a compile\n// error, so widening RECALL_WHY_STAGES to string[] fails the build.\n// @ts-expect-error \"bogus\" is not a RecallWhyStage\nconst _stageUnionIsNarrow: RecallWhyStage = \"bogus\";\nvoid _stageUnionIsNarrow;\n\n/** Why a candidate was dropped. */\nexport const RECALL_WHY_DROP_REASONS = Object.freeze([\n  \"backend-unavailable\",\n  \"planner-mode\",\n  \"namespace-scope\",\n  \"path-excluded\",\n  \"status-filter\",\n  \"not-a-candidate\",\n  \"score-floor\",\n  \"cap-eviction\",\n] as const);\n\nexport type RecallWhyDropReason = (typeof RECALL_WHY_DROP_REASONS)[number];\n\n// @ts-expect-error \"bogus\" is not a RecallWhyDropReason\nconst _reasonUnionIsNarrow: RecallWhyDropReason = \"bogus\";\nvoid _reasonUnionIsNarrow;\n\n/** A single dropped candidate, attributed to the stage that dropped it. */\nexport interface RecallWhyDrop {\n  memoryId: string;\n  path: string;\n  reason: RecallWhyDropReason;\n  /** Human-readable specifics, e.g. `status=superseded`. */\n  detail: string;\n}\n\n/** What one pipeline stage saw and admitted. */\nexport interface RecallWhyStageRecord {\n  stage: RecallWhyStage;\n  /** Candidates entering the stage. Non-negative integer. */\n  considered: number;\n  /** Candidates leaving the stage. Non-negative integer. */\n  admitted: number;\n  /** Filter-ladder detail carried verbatim from the snapshot, when present. */\n  reason?: string;\n  drops: RecallWhyDrop[];\n}\n\n/** Verdict for the `--expect <memory-id|substring>` trace. */\nexport interface RecallWhyExpectation {\n  /** The id or substring the caller asked about, exactly as supplied. */\n  expect: string;\n  /** True when a stored memory matched `expect`. */\n  matched: boolean;\n  memoryId?: string;\n  path?: string;\n  /** True when the memory survived to the injected set. */\n  recalled: boolean;\n  /** Stage that dropped it. Absent when `recalled` is true. */\n  stage?: RecallWhyStage;\n  reason?: RecallWhyDropReason;\n  detail?: string;\n  /** One-line operator remediation. Absent when `recalled` is true. */\n  remediation?: string;\n}\n\n/** The diagnosis. Rendered identically by CLI, HTTP, and MCP. */\nexport interface RecallWhyReport {\n  /** Stable v1 tag so downstream parsers can version-gate. */\n  schemaVersion: \"1\";\n  query: string;\n  namespace?: string;\n  plannerMode: RecallPlanMode;\n  /**\n   * False ONLY when the diagnosis itself could not run because the search\n   * backend was unavailable. An honest empty pipeline is `ok: true`.\n   */\n  ok: boolean;\n  failure?: { reason: \"backend_unavailable\"; detail: string };\n  recallNamespaces: string[];\n  /** Final user-facing cap the recall applied. Non-negative integer. */\n  appliedResultLimit: number;\n  stages: RecallWhyStageRecord[];\n  /** Memory ids that survived every stage. */\n  recalledMemoryIds: string[];\n  expectation?: RecallWhyExpectation;\n}\n\n/**\n * Outcome of replaying the real recall. `ok: false` is reserved for a\n * search backend that could not answer — never for an honest empty\n * result (Review Prevention Checklist #22).\n */\nexport type RecallWhyRecallOutcome =\n  | { ok: true; snapshot: RecallXraySnapshot | null }\n  | { ok: false; reason: \"backend_unavailable\"; detail: string };\n\n/** The stored memory a caller's `--expect` resolved to. */\nexport interface RecallWhyMemoryRef {\n  memoryId: string;\n  path: string;\n  status: MemoryStatus;\n  namespace: string;\n}\n\n/**\n * Injected pipeline access. Every member is either the real recall or a\n * predicate the real pipeline itself calls — never a reimplementation.\n */\nexport interface RecallWhyDeps {\n  /** Runs the REAL recall with X-ray capture and reports backend faults. */\n  runRecall(\n    query: string,\n    options: { sessionKey?: string; namespace?: string; abortSignal?: AbortSignal }\n  ): Promise<RecallWhyRecallOutcome>;\n  /** `planRecallMode` from `intent.ts` — the planner the pipeline uses. */\n  plannerMode(query: string): RecallPlanMode;\n  /**\n   * Namespaces this caller reads, resolved through the SAME shared\n   * resolver the recall path uses (rule 30). Used when the recall did\n   * not record its own scope.\n   */\n  scopedNamespaces: readonly string[];\n  namespacesEnabled: boolean;\n  /** `isGenericRecallExcludedPath` bound to the live config. */\n  isExcludedPath(path: string): boolean;\n  /** Read-only lookup by exact memory id, else by id/path substring. */\n  findExpected(expect: string): Promise<RecallWhyMemoryRef | null>;\n}\n\nexport interface RecallWhyOptions {\n  deps: RecallWhyDeps;\n  /** Memory id or substring to trace through every stage. */\n  expect?: string;\n  sessionKey?: string;\n  namespace?: string;\n  abortSignal?: AbortSignal;\n}\n\n/** Thrown for caller-input faults so surfaces can map them to a 400. */\nexport class RecallWhyInputError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"RecallWhyInputError\";\n  }\n}\n\nconst REMEDIATION: Record<RecallWhyDropReason, string> = {\n  \"backend-unavailable\":\n    \"The search backend did not answer. Check that the index daemon is running and reachable; this is an outage, not an empty result.\",\n  \"planner-mode\":\n    \"The planner classified this prompt as not needing recall. Pass an explicit recall mode, or rephrase the prompt so it reads as a memory request.\",\n  \"namespace-scope\":\n    \"The memory lives outside the namespaces this recall reads. Query its namespace explicitly, or grant the caller read access to it.\",\n  \"path-excluded\":\n    \"The path is served by a dedicated surface and is excluded from generic recall by design. Read it through that surface instead.\",\n  \"status-filter\":\n    \"Only active memories are injected. Reactivate the memory, or read it through an explicit search or archive surface.\",\n  \"not-a-candidate\":\n    \"The memory exists on disk but retrieval never saw it — the search index is stale for this path. Reindex, then retry.\",\n  \"score-floor\":\n    \"The candidate scored below the relevance floor. Use wording closer to the stored memory, or widen the retrieval budget.\",\n  \"cap-eviction\":\n    \"The candidate survived filtering but was cut by the final result cap. Raise the recall budget or narrow the query.\",\n};\n\n/**\n * Diagnose why a query did not surface an expected memory.\n *\n * Runs the real recall once, then attributes the outcome to stages. When\n * `expect` is supplied, traces that one memory and names the exact stage\n * that dropped it plus a remediation hint.\n */\nexport async function explainRecallMiss(query: string, opts: RecallWhyOptions): Promise<RecallWhyReport> {\n  // Validate the EXACT value — never normalize first (checklist #45). A\n  // whitespace-only query is a caller fault, not an empty query.\n  if (typeof query !== \"string\" || query.length === 0 || query.trim().length === 0) {\n    throw new RecallWhyInputError(\"recallWhy: query is required and must be non-empty\");\n  }\n  const expect = opts.expect;\n  if (expect !== undefined && (typeof expect !== \"string\" || expect.length === 0 || expect.trim().length === 0)) {\n    throw new RecallWhyInputError(\"recallWhy: expect must be a non-empty string when supplied\");\n  }\n  const deps = opts.deps;\n  const plannerMode = deps.plannerMode(query);\n  const scopedNamespaces = [...deps.scopedNamespaces];\n\n  const outcome = await deps.runRecall(query, {\n    ...(opts.sessionKey !== undefined ? { sessionKey: opts.sessionKey } : {}),\n    ...(opts.namespace !== undefined ? { namespace: opts.namespace } : {}),\n    ...(opts.abortSignal !== undefined ? { abortSignal: opts.abortSignal } : {}),\n  });\n\n  if (!outcome.ok) {\n    // Empty != failed. The retrieval stage reports the outage; no stage\n    // downstream of it ran, so none is reported as having seen zero.\n    return {\n      schemaVersion: \"1\",\n      query,\n      ...(opts.namespace !== undefined ? { namespace: opts.namespace } : {}),\n      plannerMode,\n      ok: false,\n      failure: { reason: \"backend_unavailable\", detail: outcome.detail },\n      recallNamespaces: scopedNamespaces,\n      appliedResultLimit: 0,\n      stages: [\n        {\n          stage: \"retrieval\",\n          considered: 0,\n          admitted: 0,\n          reason: `backend_unavailable: ${outcome.detail}`,\n          drops: [],\n        },\n      ],\n      recalledMemoryIds: [],\n      ...(expect !== undefined\n        ? {\n            expectation: {\n              expect,\n              matched: false,\n              recalled: false,\n              stage: \"retrieval\" as const,\n              reason: \"backend-unavailable\" as const,\n              detail: outcome.detail,\n              remediation: REMEDIATION[\"backend-unavailable\"],\n            },\n          }\n        : {}),\n    };\n  }\n\n  const snapshot = outcome.snapshot;\n  const stages = buildStages(snapshot, plannerMode);\n  const recalledMemoryIds = (snapshot?.appliedResults ?? []).map((r) => r.memoryId);\n  const expectation =\n    expect === undefined ? undefined : await traceExpectation(expect, snapshot, plannerMode, deps, scopedNamespaces);\n\n  return {\n    schemaVersion: \"1\",\n    query,\n    ...(snapshot?.namespace !== undefined\n      ? { namespace: snapshot.namespace }\n      : opts.namespace !== undefined\n        ? { namespace: opts.namespace }\n        : {}),\n    plannerMode,\n    ok: true,\n    recallNamespaces: scopedNamespaces,\n    appliedResultLimit: nonNegativeInt(snapshot?.appliedResultLimit),\n    stages,\n    recalledMemoryIds,\n    ...(expectation !== undefined ? { expectation } : {}),\n  };\n}\n\n// ─── Stage attribution ────────────────────────────────────────────────────\n\n/**\n * Retrieval-stage note per planner mode. `full` and `graph_mode` run the\n * ordinary pipeline and carry no note.\n */\nconst PLANNER_MODE_NOTE: Partial<Record<RecallPlanMode, string>> = {\n  no_recall: \"planner mode no_recall: retrieval never ran\",\n  minimal: \"planner mode minimal: retrieval headroom is capped\",\n};\n\nfunction buildStages(snapshot: RecallXraySnapshot | null, plannerMode: RecallPlanMode): RecallWhyStageRecord[] {\n  if (snapshot === null) {\n    // No snapshot published: either the planner short-circuited recall or\n    // retrieval produced nothing to capture. Both are honest zero-candidate\n    // states, distinct from the backend-outage branch above.\n    return [\n      {\n        stage: \"retrieval\",\n        considered: 0,\n        admitted: 0,\n        reason: PLANNER_MODE_NOTE[plannerMode] ?? \"no candidates were captured for this query\",\n        drops: [],\n      },\n    ];\n  }\n\n  const captured = snapshot.results;\n  const rejected = captured.filter((r) => nonEmpty(r.rejectedBy) !== undefined);\n  const admittedByPolicy = captured.length - rejected.length;\n  const headroom = snapshot.headroomResults;\n  const applied = snapshot.appliedResults;\n  const appliedIds = new Set(applied.map((r) => r.memoryId));\n  const evicted = headroom.filter((r) => !appliedIds.has(r.memoryId));\n\n  const filterLadder = snapshot.filters\n    .map((f) => `${f.name}: ${f.admitted}/${f.considered}${f.reason ? ` (${f.reason})` : \"\"}`)\n    .join(\"; \");\n\n  return [\n    {\n      stage: \"retrieval\",\n      considered: captured.length,\n      admitted: captured.length,\n      // Both stage paths annotate the retrieval row from the SAME table, so\n      // a planner mode can never be reported on one path and dropped on the\n      // other. Modes with no note omit the key rather than setting it to\n      // undefined, keeping the JSON shape byte-stable.\n      ...(PLANNER_MODE_NOTE[plannerMode] !== undefined ? { reason: PLANNER_MODE_NOTE[plannerMode] } : {}),\n      drops: [],\n    },\n    {\n      stage: \"policy-filter\",\n      considered: captured.length,\n      admitted: admittedByPolicy,\n      ...(filterLadder.length > 0 ? { reason: filterLadder } : {}),\n      drops: sortDrops(\n        rejected.map((r) => ({\n          memoryId: r.memoryId,\n          path: r.path,\n          reason: policyReasonFor(nonEmpty(r.rejectedBy) ?? \"\"),\n          detail: `rejectedBy=${nonEmpty(r.rejectedBy) ?? \"unknown\"}`,\n        }))\n      ),\n    },\n    {\n      stage: \"rerank\",\n      considered: admittedByPolicy,\n      admitted: headroom.length,\n      drops: [],\n    },\n    {\n      stage: \"cap\",\n      considered: headroom.length,\n      admitted: applied.length,\n      reason: `appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`,\n      drops: sortDrops(\n        evicted.map((r) => ({\n          memoryId: r.memoryId,\n          path: r.path,\n          reason: \"cap-eviction\" as const,\n          detail: `cut by appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`,\n        }))\n      ),\n    },\n    {\n      stage: \"format\",\n      considered: applied.length,\n      admitted: applied.length,\n      reason: `budget used ${nonNegativeInt(snapshot.budget.used)}/${nonNegativeInt(snapshot.budget.chars)} chars`,\n      drops: [],\n    },\n  ];\n}\n\n/**\n * Map a filter name the pipeline recorded in `rejectedBy` onto a drop\n * reason. Unknown filter names stay `score-floor`-free and report as\n * `path-excluded`-free too: they fall back to `not-a-candidate` only when\n * nothing matches, so a new pipeline filter can never be silently\n * mis-attributed to an existing reason.\n */\nfunction policyReasonFor(rejectedBy: string): RecallWhyDropReason {\n  const name = rejectedBy.toLowerCase();\n  if (name.includes(\"namespace\")) return \"namespace-scope\";\n  if (name.includes(\"status\") || name.includes(\"superseded\") || name.includes(\"quarantine\")) {\n    return \"status-filter\";\n  }\n  if (name.includes(\"path\") || name.includes(\"artifact\") || name.includes(\"excluded\")) {\n    return \"path-excluded\";\n  }\n  if (name.includes(\"score\") || name.includes(\"floor\") || name.includes(\"threshold\")) {\n    return \"score-floor\";\n  }\n  return \"not-a-candidate\";\n}\n\n// ─── --expect trace ───────────────────────────────────────────────────────\n\nasync function traceExpectation(\n  expect: string,\n  snapshot: RecallXraySnapshot | null,\n  plannerMode: RecallPlanMode,\n  deps: RecallWhyDeps,\n  /** Effective recall scope: what the pipeline recorded, else the caller's. */\n  recallNamespaces: readonly string[]\n): Promise<RecallWhyExpectation> {\n  const ref = await deps.findExpected(expect);\n  if (ref === null) {\n    return {\n      expect,\n      matched: false,\n      recalled: false,\n      stage: \"retrieval\",\n      reason: \"not-a-candidate\",\n      detail: \"no stored memory matches this id or substring\",\n      remediation: \"Nothing on disk matches. Check the id or substring; the memory may never have been written.\",\n    };\n  }\n\n  const base = { expect, matched: true, memoryId: ref.memoryId, path: ref.path };\n\n  if (snapshot !== null) {\n    // The snapshot is authoritative about what actually happened, so it is\n    // consulted before any predicate is re-evaluated.\n    if (snapshot.appliedResults.some((r) => matchesRef(r, ref))) {\n      return { ...base, recalled: true };\n    }\n    const rejectedRow = snapshot.results.find((r) => matchesRef(r, ref) && nonEmpty(r.rejectedBy) !== undefined);\n    if (rejectedRow !== undefined) {\n      const rejectedBy = nonEmpty(rejectedRow.rejectedBy) ?? \"unknown\";\n      const reason = policyReasonFor(rejectedBy);\n      return {\n        ...base,\n        recalled: false,\n        stage: \"policy-filter\",\n        reason,\n        detail: `rejectedBy=${rejectedBy}`,\n        remediation: REMEDIATION[reason],\n      };\n    }\n    if (snapshot.headroomResults.some((r) => matchesRef(r, ref)) || snapshot.results.some((r) => matchesRef(r, ref))) {\n      return {\n        ...base,\n        recalled: false,\n        stage: \"cap\",\n        reason: \"cap-eviction\",\n        detail: `survived filtering but was cut by appliedResultLimit=${nonNegativeInt(snapshot.appliedResultLimit)}`,\n        remediation: REMEDIATION[\"cap-eviction\"],\n      };\n    }\n  }\n\n  // The memory never reached the capture. Attribute it to the earliest\n  // stage whose own predicate rejects it, in contract order: the planner\n  // gates retrieval, then the policy filters run namespace -> path ->\n  // status (the order `filterRecallCandidates` and the state-view\n  // admission apply them in).\n  if (plannerMode === \"no_recall\") {\n    return {\n      ...base,\n      recalled: false,\n      stage: \"retrieval\",\n      reason: \"planner-mode\",\n      detail: \"plannerMode=no_recall: retrieval never ran for this query\",\n      remediation: REMEDIATION[\"planner-mode\"],\n    };\n  }\n  if (deps.namespacesEnabled && !recallNamespaces.includes(ref.namespace)) {\n    return {\n      ...base,\n      recalled: false,\n      stage: \"policy-filter\",\n      reason: \"namespace-scope\",\n      detail: `namespace=${ref.namespace} is outside the recall scope [${recallNamespaces.join(\", \")}]`,\n      remediation: REMEDIATION[\"namespace-scope\"],\n    };\n  }\n  if (deps.isExcludedPath(ref.path)) {\n    return {\n      ...base,\n      recalled: false,\n      stage: \"policy-filter\",\n      reason: \"path-excluded\",\n      detail: `path=${ref.path} is excluded from generic recall`,\n      remediation: REMEDIATION[\"path-excluded\"],\n    };\n  }\n  if (!ACTIVE_STATUSES.has(ref.status)) {\n    return {\n      ...base,\n      recalled: false,\n      stage: \"policy-filter\",\n      reason: \"status-filter\",\n      detail: `status=${ref.status}`,\n      remediation: REMEDIATION[\"status-filter\"],\n    };\n  }\n  if (plannerMode === \"minimal\") {\n    return {\n      ...base,\n      recalled: false,\n      stage: \"retrieval\",\n      reason: \"planner-mode\",\n      detail: \"plannerMode=minimal: retrieval headroom is capped for this query\",\n      remediation: REMEDIATION[\"planner-mode\"],\n    };\n  }\n  return {\n    ...base,\n    recalled: false,\n    stage: \"retrieval\",\n    reason: \"not-a-candidate\",\n    detail: \"the memory passes every policy filter but retrieval never returned it\",\n    remediation: REMEDIATION[\"not-a-candidate\"],\n  };\n}\n\n// ─── Internals ────────────────────────────────────────────────────────────\n\nfunction matchesRef(result: RecallXrayResult, ref: RecallWhyMemoryRef): boolean {\n  return result.memoryId === ref.memoryId || result.path === ref.path;\n}\n\nfunction nonEmpty(value: string | undefined): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  return value.length > 0 ? value : undefined;\n}\n\nfunction nonNegativeInt(value: unknown): number {\n  // Reject non-finite explicitly rather than letting NaN fall through a\n  // comparison (checklist #45).\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 0;\n  const floored = Math.floor(value);\n  return floored > 0 ? floored : 0;\n}\n\n/** Total comparator: -1 / 0 / 1, and 0 for genuinely equal rows. */\nfunction sortDrops(drops: RecallWhyDrop[]): RecallWhyDrop[] {\n  return [...drops].sort((a, b) => {\n    if (a.memoryId !== b.memoryId) return a.memoryId < b.memoryId ? -1 : 1;\n    if (a.path !== b.path) return a.path < b.path ? -1 : 1;\n    return 0;\n  });\n}\n"],"mappings":"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","names":[]}