@remnic/core 9.69.50 → 9.69.52

package/dist/chunk-DH536WT2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-explain-renderer.ts","../src/recall-xray-renderer.ts"],"sourcesContent":["/**\n * Renderers for RecallTierExplain (issue #518).\n *\n * Pure functions that format a `LastRecallSnapshot` and its\n * optional `tierExplain` field for human text and machine JSON\n * consumption.  CLI / HTTP / MCP surfaces consume these — they do\n * not format explain output themselves, so rendering is tested in\n * one place.\n */\n\nimport type { LastRecallSnapshot } from \"./recall-state.js\";\nimport type { RecallTierExplain } from \"./types.js\";\nimport { isRetrievalTier } from \"./retrieval-tiers.js\";\nimport type {\n  RecallXraySnapshot,\n  RecallFilterTrace,\n  RecallXrayResult,\n} from \"./recall-xray.js\";\nimport { renderXrayMarkdown } from \"./recall-xray-renderer.js\";\n\nfunction sanitizeString(v: unknown): string | null {\n  return typeof v === \"string\" && v.length > 0 ? v : null;\n}\n\nfunction sanitizeFiniteNumber(v: unknown): number | null {\n  return typeof v === \"number\" && Number.isFinite(v) ? v : null;\n}\n\n/**\n * `text` and `json` are the original formats (backwards-compatible\n * since issue #518).  `markdown` was added in issue #570 PR 7 and\n * delegates to the shared X-ray renderer so the three observability\n * surfaces stay in lock-step (CLAUDE.md rule 22).\n */\nexport type RecallExplainFormat = \"text\" | \"json\" | \"markdown\";\n\nexport interface RecallExplainJsonPayload {\n  hasExplain: boolean;\n  snapshotFound: boolean;\n  sessionKey: string | null;\n  recordedAt: string | null;\n  namespace: string | null;\n  memoryIds: string[];\n  source: string | null;\n  sourcesUsed: string[] | null;\n  latencyMs: number | null;\n  tierExplain: RecallTierExplain | null;\n}\n\nfunction normalizeTierExplain(value: unknown): RecallTierExplain | null {\n  if (!value || typeof value !== \"object\" || Array.isArray(value)) return null;\n  const raw = value as Record<string, unknown>;\n  const filteredBy = Array.isArray(raw.filteredBy)\n    ? raw.filteredBy.filter((x): x is string => typeof x === \"string\")\n    : [];\n  const sourceAnchors = Array.isArray(raw.sourceAnchors)\n    ? raw.sourceAnchors\n        .filter(\n          (a): a is { path: string; lineRange?: unknown } =>\n            !!a && typeof a === \"object\" && typeof (a as { path?: unknown }).path === \"string\",\n        )\n        .map((a) => {\n          const lr = (a as { lineRange?: unknown }).lineRange;\n          const lineRange =\n            Array.isArray(lr) &&\n            lr.length === 2 &&\n            Number.isFinite(lr[0]) &&\n            Number.isFinite(lr[1])\n              ? ([lr[0] as number, lr[1] as number] as [number, number])\n              : undefined;\n          return lineRange\n            ? { path: (a as { path: string }).path, lineRange }\n            : { path: (a as { path: string }).path };\n        })\n    : undefined;\n  return {\n    tier: isRetrievalTier(raw.tier) ? raw.tier : \"hybrid\",\n    tierReason: typeof raw.tierReason === \"string\" ? raw.tierReason : \"\",\n    filteredBy,\n    candidatesConsidered: sanitizeFiniteNumber(raw.candidatesConsidered) ?? 0,\n    latencyMs: sanitizeFiniteNumber(raw.latencyMs) ?? 0,\n    ...(sourceAnchors !== undefined ? { sourceAnchors } : {}),\n  };\n}\n\nexport function toRecallExplainJson(\n  snapshot: LastRecallSnapshot | null,\n): RecallExplainJsonPayload {\n  if (!snapshot) {\n    return {\n      hasExplain: false,\n      snapshotFound: false,\n      sessionKey: null,\n      recordedAt: null,\n      namespace: null,\n      memoryIds: [],\n      source: null,\n      sourcesUsed: null,\n      latencyMs: null,\n      tierExplain: null,\n    };\n  }\n  const normalizedExplain = normalizeTierExplain(snapshot.tierExplain);\n  return {\n    hasExplain: normalizedExplain !== null,\n    snapshotFound: true,\n    sessionKey: sanitizeString(snapshot.sessionKey),\n    recordedAt: sanitizeString(snapshot.recordedAt),\n    namespace: sanitizeString(snapshot.namespace),\n    memoryIds: Array.isArray(snapshot.memoryIds)\n      ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n      : [],\n    source: sanitizeString(snapshot.source),\n    sourcesUsed: Array.isArray(snapshot.sourcesUsed)\n      ? snapshot.sourcesUsed.filter((x): x is string => typeof x === \"string\")\n      : null,\n    latencyMs: sanitizeFiniteNumber(snapshot.latencyMs),\n    tierExplain: normalizedExplain,\n  };\n}\n\n/**\n * Render the shared \"--- tier explain ---\" text block used by both the\n * recall-explain surface and the Recall X-ray surface.  Callers provide\n * the normalized `RecallTierExplain` (or `null` for the\n * not-populated/disabled case) so the block stays character-for-character\n * identical across surfaces (CLAUDE.md rule 22).  The returned strings do\n * NOT include leading blank lines or headers — callers own that framing.\n */\nexport function renderTierExplainTextLines(\n  tierExplain: RecallTierExplain | null,\n): string[] {\n  const lines: string[] = [];\n  if (!tierExplain) {\n    lines.push(\n      \"(not populated — direct-answer tier disabled or did not fire)\",\n    );\n    return lines;\n  }\n  lines.push(`tier: ${tierExplain.tier}`);\n  lines.push(`reason: ${tierExplain.tierReason}`);\n  lines.push(`candidates-considered: ${tierExplain.candidatesConsidered}`);\n  lines.push(`latency-ms: ${tierExplain.latencyMs}`);\n  if (tierExplain.filteredBy.length > 0) {\n    lines.push(`filtered-by: ${tierExplain.filteredBy.join(\", \")}`);\n  } else {\n    lines.push(\"filtered-by: (none)\");\n  }\n  if (tierExplain.sourceAnchors && tierExplain.sourceAnchors.length > 0) {\n    lines.push(\"source-anchors:\");\n    for (const anchor of tierExplain.sourceAnchors) {\n      const range = anchor.lineRange\n        ? `:${anchor.lineRange[0]}-${anchor.lineRange[1]}`\n        : \"\";\n      lines.push(`  - ${anchor.path}${range}`);\n    }\n  }\n  return lines;\n}\n\nexport function toRecallExplainText(\n  snapshot: LastRecallSnapshot | null,\n): string {\n  const lines: string[] = [\"=== Recall Explain ===\"];\n\n  if (!snapshot) {\n    lines.push(\"No recall snapshot recorded yet.\");\n    return lines.join(\"\\n\");\n  }\n\n  const sessionKey = sanitizeString(snapshot.sessionKey);\n  const recordedAt = sanitizeString(snapshot.recordedAt);\n  const namespace = sanitizeString(snapshot.namespace);\n  const source = sanitizeString(snapshot.source);\n  lines.push(`session: ${sessionKey ?? \"(unknown)\"}`);\n  lines.push(`recorded: ${recordedAt ?? \"(unknown)\"}`);\n  if (namespace) lines.push(`namespace: ${namespace}`);\n  if (source) lines.push(`source: ${source}`);\n  const sourcesUsed = Array.isArray(snapshot.sourcesUsed)\n    ? snapshot.sourcesUsed.filter((x): x is string => typeof x === \"string\")\n    : [];\n  if (sourcesUsed.length > 0) {\n    lines.push(`sources-used: ${sourcesUsed.join(\", \")}`);\n  }\n  const latencyMs = sanitizeFiniteNumber(snapshot.latencyMs);\n  if (latencyMs !== null) {\n    lines.push(`latency-ms: ${latencyMs}`);\n  }\n  const memoryIds = Array.isArray(snapshot.memoryIds)\n    ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n    : [];\n  if (memoryIds.length > 0) {\n    lines.push(`memories: ${memoryIds.join(\", \")}`);\n  }\n\n  const ex = normalizeTierExplain(snapshot.tierExplain);\n  if (!ex) {\n    lines.push(\"\");\n    lines.push(\n      \"tier-explain: (not populated — direct-answer tier disabled or did not fire)\",\n    );\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- tier explain ---\");\n  for (const line of renderTierExplainTextLines(ex)) {\n    lines.push(line);\n  }\n  return lines.join(\"\\n\");\n}\n\n/**\n * Adapter: convert a `LastRecallSnapshot` into a best-effort\n * `RecallXraySnapshot` so the markdown renderer can produce a\n * consistent, richly-formatted document for callers that have asked\n * for `markdown` format.  The LastRecallSnapshot and the X-ray\n * snapshot share session/namespace/memoryIds; additional X-ray-only\n * fields (filters, score decomposition, graph path, audit id) are\n * left empty because the legacy snapshot doesn't carry them.  The\n * renderer handles missing fields gracefully.\n */\n/**\n * Strip backticks, pipes, and newlines from a host-provided value so it\n * cannot escape its enclosing markdown code span, break the surrounding\n * table row, or inject extra rows when it lands in\n * `renderXrayMarkdown`.  Applied at the adapter boundary because\n * `LastRecallSnapshot` is hydrated from on-disk JSON without schema\n * validation (codex P2 review on #605).\n *\n * Accepts `unknown` so non-string truthy values (numbers, objects,\n * booleans, arrays) coming from a corrupted snapshot are coerced to\n * the empty string rather than crashing on `.replace(...)`.  Callers\n * should treat an empty return as \"drop this field.\"\n */\nfunction sanitizeForMarkdownInline(value: unknown): string {\n  if (typeof value !== \"string\") return \"\";\n  return value.replace(/[`|\\r\\n]/g, \" \").trim();\n}\n\n/**\n * Map the legacy `LastRecallSnapshot.source` field to the\n * `RecallXrayServedBy` union used by the unified x-ray renderer.\n * Mirrors the `mapRecallSourceToXrayServedBy` helper inside\n * `orchestrator.ts` (which is private).  Keep the two in sync when a\n * new source lands — unknown values collapse to `\"hybrid\"` to preserve\n * backwards compatibility with older on-disk snapshots.\n */\nfunction mapLegacySourceToServedBy(\n  source: unknown,\n): \"hybrid\" | \"recent-scan\" {\n  if (source === \"recent_scan\") return \"recent-scan\";\n  return \"hybrid\";\n}\n\nexport function toRecallXraySnapshotFromLegacy(\n  snapshot: LastRecallSnapshot | null,\n): RecallXraySnapshot | null {\n  if (!snapshot) return null;\n  const capturedAt = (() => {\n    if (typeof snapshot.recordedAt !== \"string\") return 0;\n    const ms = Date.parse(snapshot.recordedAt);\n    return Number.isFinite(ms) && ms >= 0 ? ms : 0;\n  })();\n  const memoryIds = Array.isArray(snapshot.memoryIds)\n    ? snapshot.memoryIds.filter((x): x is string => typeof x === \"string\")\n    : [];\n  // Codex P2 + Cursor Medium on #605: every converted result used to\n  // be stamped with `servedBy: \"hybrid\"`, misattributing legacy\n  // snapshots that came from `recent_scan` (or any future source).\n  // Propagate the recorded `source` so markdown `recall-explain`\n  // output matches the `served-by=` string the native x-ray capture\n  // would emit for the same recall.\n  const servedBy = mapLegacySourceToServedBy(snapshot.source);\n  const results: RecallXrayResult[] = memoryIds.map((memoryId) => ({\n    memoryId,\n    path: \"\",\n    servedBy,\n    scoreDecomposition: { final: 0 },\n    admittedBy: [],\n  }));\n  const filters: RecallFilterTrace[] = [];\n  return {\n    schemaVersion: \"1\",\n    // `LastRecallSnapshot` does not preserve the original query text;\n    // synthesize a placeholder so the renderer has a non-empty\n    // string to print.  `queryHash` + `queryLen` stay in the JSON\n    // payload via `toRecallExplainJson` for callers that need them.\n    query:\n      snapshot.queryHash\n        ? `(legacy explain; queryHash=${snapshot.queryHash})`\n        : \"(legacy explain)\",\n    // `snapshotId` is synthesized here; `sessionKey` is already\n    // sanitized before it reaches the ID because we re-use the\n    // sanitized string below.\n    snapshotId: `legacy-${sanitizeForMarkdownInline(snapshot.sessionKey ?? \"unknown\") || \"unknown\"}-${capturedAt}`,\n    capturedAt,\n    // Run the raw on-disk value through the same normalizer the text\n    // and JSON paths use so the markdown adapter cannot render\n    // unvalidated tier-explain payloads (cursor / codex review on\n    // #605).  A malformed tierExplain is dropped to null, matching the\n    // behavior of the non-markdown surfaces.\n    tierExplain: normalizeTierExplain(snapshot.tierExplain) ?? null,\n    results,\n    appliedResultLimit: 0,\n    appliedResults: [],\n    headroomResults: [],\n    filters,\n    budget: { chars: 0, used: 0 },\n    // Sanitize legacy session metadata at the adapter boundary so a\n    // malformed on-disk value (containing backticks, pipes, or\n    // newlines) cannot break the enclosing markdown table when\n    // `renderXrayMarkdown` prints it in a raw code-span cell (codex P2\n    // review on #605).\n    ...(snapshot.sessionKey\n      ? (() => {\n          const clean = sanitizeForMarkdownInline(snapshot.sessionKey);\n          return clean ? { sessionKey: clean } : {};\n        })()\n      : {}),\n    ...(snapshot.namespace\n      ? (() => {\n          const clean = sanitizeForMarkdownInline(snapshot.namespace);\n          return clean ? { namespace: clean } : {};\n        })()\n      : {}),\n  };\n}\n\nexport function renderRecallExplain(\n  snapshot: LastRecallSnapshot | null,\n  format: RecallExplainFormat,\n): string {\n  if (format === \"json\") {\n    return JSON.stringify(toRecallExplainJson(snapshot), null, 2);\n  }\n  if (format === \"markdown\") {\n    // Delegate to the shared X-ray renderer so CLI / HTTP / MCP\n    // markdown output all share one implementation (CLAUDE.md rule\n    // 22).  The JSON and text paths remain byte-for-byte\n    // backwards-compatible with pre-#570 behavior.\n    return renderXrayMarkdown(toRecallXraySnapshotFromLegacy(snapshot));\n  }\n  return toRecallExplainText(snapshot);\n}\n\nexport function parseRecallExplainFormat(value: unknown): RecallExplainFormat {\n  if (value === undefined || value === null) return \"text\";\n  if (typeof value !== \"string\") {\n    throw new Error(\n      `--format expects \"text\", \"json\", or \"markdown\", got ${typeof value}`,\n    );\n  }\n  const v = value.trim().toLowerCase();\n  if (v === \"text\" || v === \"json\" || v === \"markdown\") return v;\n  throw new Error(\n    `--format expects \"text\", \"json\", or \"markdown\", got ${JSON.stringify(value)}`,\n  );\n}\n","/**\n * Unified Recall X-ray renderer (issue #570, PR 2).\n *\n * Pure functions that format a `RecallXraySnapshot` for human text,\n * GitHub-flavored markdown, and machine JSON consumption.  CLI / HTTP\n * / MCP surfaces all call into this module — they do NOT format X-ray\n * output themselves, so rendering is tested in one place (CLAUDE.md\n * rule 22).\n *\n * Scope for PR 2 (this slice):\n *   - Pure rendering.  No IO, no transport, no capture.\n *   - `renderXray(snapshot, format)` with format ∈\n *     `{\"json\", \"text\", \"markdown\"}`.\n *   - `parseXrayFormat(value)` — input validator that rejects unknown\n *     formats with a listed-options error (CLAUDE.md rule 51).\n *   - Golden-file-style tests in `recall-xray-renderer.test.ts`.\n */\n\nimport type {\n  RecallFilterTrace,\n  RecallXrayResult,\n  RecallXraySnapshot,\n  RecallXrayServedBy,\n} from \"./recall-xray.js\";\nimport { summarizeDisclosureTokens } from \"./recall-xray.js\";\nimport { renderTierExplainTextLines } from \"./recall-explain-renderer.js\";\nimport { summarizeRetrievedMemoryProvenance } from \"./memory-provenance.js\";\n\nexport type RecallXrayFormat = \"json\" | \"text\" | \"markdown\";\n\nexport const RECALL_XRAY_FORMATS: readonly RecallXrayFormat[] = [\n  \"json\",\n  \"text\",\n  \"markdown\",\n] as const;\n\n/**\n * Validate and coerce a user-provided `--format` / `format` argument to\n * `RecallXrayFormat`.  Unknown values throw an error listing valid\n * options (CLAUDE.md rule 51).  `undefined`/`null` defaults to `\"text\"`.\n */\nexport function parseXrayFormat(value: unknown): RecallXrayFormat {\n  if (value === undefined || value === null) return \"text\";\n  if (typeof value !== \"string\") {\n    throw new Error(\n      `--format expects one of ${RECALL_XRAY_FORMATS.join(\", \")}; got ${typeof value}`,\n    );\n  }\n  const v = value.trim().toLowerCase();\n  if (v === \"json\" || v === \"text\" || v === \"markdown\") return v;\n  throw new Error(\n    `--format expects one of ${RECALL_XRAY_FORMATS.join(\", \")}; got ${JSON.stringify(value)}`,\n  );\n}\n\n/**\n * Top-level dispatcher.  CLI / HTTP / MCP callers should always route\n * through this function so the three formats stay in lock-step.\n */\nexport function renderXray(\n  snapshot: RecallXraySnapshot | null,\n  format: RecallXrayFormat,\n): string {\n  if (format === \"json\") return renderXrayJson(snapshot);\n  if (format === \"markdown\") return renderXrayMarkdown(snapshot);\n  return renderXrayText(snapshot);\n}\n\n// ─── JSON ─────────────────────────────────────────────────────────────────\n\n/**\n * Deterministic JSON encoding of an X-ray snapshot.  Returns a stable\n * v1 envelope when the snapshot is absent so consumers can pattern-match\n * on `snapshotFound` rather than distinguishing `null` vs `{}`.\n */\nexport function renderXrayJson(snapshot: RecallXraySnapshot | null): string {\n  if (!snapshot) {\n    return JSON.stringify(\n      { schemaVersion: \"1\", snapshotFound: false },\n      null,\n      2,\n    );\n  }\n  // `snapshotFound` is injected *before* the rest so downstream JSON\n  // consumers see it near the top of the document.\n  return JSON.stringify(\n    { snapshotFound: true, ...snapshot },\n    null,\n    2,\n  );\n}\n\n// ─── Text ─────────────────────────────────────────────────────────────────\n\nexport function renderXrayText(snapshot: RecallXraySnapshot | null): string {\n  const lines: string[] = [\"=== Recall X-ray ===\"];\n  if (!snapshot) {\n    lines.push(\"No X-ray snapshot captured.\");\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(`query: ${snapshot.query}`);\n  lines.push(`snapshot-id: ${snapshot.snapshotId}`);\n  lines.push(`captured-at: ${formatCapturedAt(snapshot.capturedAt)}`);\n  if (snapshot.sessionKey) lines.push(`session: ${snapshot.sessionKey}`);\n  if (snapshot.namespace) lines.push(`namespace: ${snapshot.namespace}`);\n  if (snapshot.traceId) lines.push(`trace-id: ${snapshot.traceId}`);\n  lines.push(\n    `budget: ${snapshot.budget.used} / ${snapshot.budget.chars} chars`,\n  );\n\n  lines.push(\"\");\n  lines.push(\"--- filters ---\");\n  if (snapshot.filters.length === 0) {\n    lines.push(\"(no filter traces recorded)\");\n  } else {\n    for (const f of snapshot.filters) {\n      lines.push(renderFilterTextLine(f));\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- results ---\");\n  if (snapshot.results.length === 0) {\n    lines.push(\"(no results admitted)\");\n  } else {\n    snapshot.results.forEach((result, idx) => {\n      for (const line of renderResultTextLines(result, idx + 1)) {\n        lines.push(line);\n      }\n    });\n  }\n\n  lines.push(\"\");\n  lines.push(\"--- tier explain ---\");\n  for (const line of renderTierExplainTextLines(snapshot.tierExplain ?? null)) {\n    lines.push(line);\n  }\n\n  return lines.join(\"\\n\");\n}\n\nfunction renderFilterTextLine(f: RecallFilterTrace): string {\n  const base = `- ${f.name}: ${f.admitted}/${f.considered} admitted`;\n  return f.reason ? `${base} (${f.reason})` : base;\n}\n\nfunction renderResultTextLines(\n  result: RecallXrayResult,\n  rank: number,\n): string[] {\n  const lines: string[] = [];\n  lines.push(`[${rank}] ${result.memoryId} — ${servedByLabel(result.servedBy)}`);\n  if (result.path) lines.push(`    path: ${result.path}`);\n  if (result.stateView) lines.push(`    state-view: ${result.stateView}`);\n  lines.push(`    score: ${renderScoreDecomposition(result)}`);\n  if (result.provenance) {\n    lines.push(\n      `    provenance: ${summarizeRetrievedMemoryProvenance(result.provenance)}`,\n    );\n    lines.push(`    retrieval-reason: ${result.provenance.retrievalReason}`);\n    if (result.provenance.userContextScopes.length > 0) {\n      lines.push(\n        `    context-scopes: ${result.provenance.userContextScopes.join(\", \")}`,\n      );\n    }\n    if (\n      result.provenance.safety !== \"safe\" ||\n      result.provenance.safetyReasons.length > 0\n    ) {\n      const reasonSuffix =\n        result.provenance.safetyReasons.length > 0\n          ? ` (${result.provenance.safetyReasons.join(\", \")})`\n          : \"\";\n      lines.push(`    safety: ${result.provenance.safety}${reasonSuffix}`);\n    }\n  }\n  if (result.sourceSpan) {\n    const q = truncateForXray(result.sourceSpan.quote, 120);\n    lines.push(\n      `    source: \"${q}\" (observed ${result.sourceSpan.observedAt}) [${result.sourceSpan.provenance}]`,\n    );\n  }\n  if (result.admittedBy.length > 0) {\n    lines.push(`    admitted-by: ${result.admittedBy.join(\", \")}`);\n  }\n  if (result.rejectedBy) {\n    lines.push(`    rejected-by: ${result.rejectedBy}`);\n  }\n  if (result.graphPath && result.graphPath.length > 0) {\n    lines.push(`    graph-path: ${result.graphPath.join(\" -> \")}`);\n    // Issue #681 PR 3/3 — surface per-edge confidence inline so\n    // operators can attribute floor-pruning / PageRank ranking\n    // decisions to specific edges. Skipped when no confidences were\n    // recorded (legacy snapshot or single-node path).\n    if (\n      result.graphEdgeConfidences &&\n      result.graphEdgeConfidences.length > 0\n    ) {\n      lines.push(\n        `    edge-confidences: ${result.graphEdgeConfidences\n          .map((c) => c.toFixed(2))\n          .join(\", \")}`,\n      );\n    }\n  }\n  if (result.pathPenaltyApplied !== undefined) {\n    lines.push(`    path-penalty: ${result.pathPenaltyApplied ? \"yes\" : \"no\"}`);\n  }\n  if (result.pathNodeIds && result.pathNodeIds.length > 0) {\n    lines.push(`    path-node-ids: ${result.pathNodeIds.join(\" -> \")}`);\n  }\n  if (result.auditEntryId) {\n    lines.push(`    audit-entry: ${result.auditEntryId}`);\n  }\n  return lines;\n}\n\n// ─── Markdown ─────────────────────────────────────────────────────────────\n\nexport function renderXrayMarkdown(\n  snapshot: RecallXraySnapshot | null,\n): string {\n  const lines: string[] = [\"# Recall X-ray\"];\n  if (!snapshot) {\n    lines.push(\"\");\n    lines.push(\"_No X-ray snapshot captured._\");\n    return lines.join(\"\\n\");\n  }\n\n  lines.push(\"\");\n  lines.push(`**Query:** ${mdInlineCode(snapshot.query)}`);\n  lines.push(\"\");\n  lines.push(\"| Field | Value |\");\n  lines.push(\"| --- | --- |\");\n  lines.push(`| Snapshot ID | \\`${snapshot.snapshotId}\\` |`);\n  lines.push(`| Captured at | ${formatCapturedAt(snapshot.capturedAt)} |`);\n  if (snapshot.sessionKey) {\n    lines.push(`| Session | \\`${snapshot.sessionKey}\\` |`);\n  }\n  if (snapshot.namespace) {\n    lines.push(`| Namespace | \\`${snapshot.namespace}\\` |`);\n  }\n  if (snapshot.traceId) {\n    lines.push(`| Trace ID | \\`${snapshot.traceId}\\` |`);\n  }\n  lines.push(\n    `| Budget | ${snapshot.budget.used} / ${snapshot.budget.chars} chars |`,\n  );\n\n  lines.push(\"\");\n  lines.push(\"## Filters\");\n  if (snapshot.filters.length === 0) {\n    lines.push(\"\");\n    lines.push(\"_No filter traces recorded._\");\n  } else {\n    lines.push(\"\");\n    lines.push(\"| Filter | Considered | Admitted | Reason |\");\n    lines.push(\"| --- | ---: | ---: | --- |\");\n    for (const f of snapshot.filters) {\n      const reason = f.reason ? mdEscape(f.reason) : \"\";\n      lines.push(`| ${mdEscape(f.name)} | ${f.considered} | ${f.admitted} | ${reason} |`);\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"## Results\");\n  if (snapshot.results.length === 0) {\n    lines.push(\"\");\n    lines.push(\"_No results admitted._\");\n  } else {\n    snapshot.results.forEach((result, idx) => {\n      for (const line of renderResultMarkdownLines(result, idx + 1)) {\n        lines.push(line);\n      }\n    });\n\n    // Per-disclosure token-spend summary (issue #677 PR 3/4).  Only\n    // emitted when at least one result carries a disclosure level so\n    // we don't pollute the snapshot for callers who haven't wired the\n    // depth knob through.  Counts and tokens default to 0 for buckets\n    // with no contributions.\n    const summary = summarizeDisclosureTokens(snapshot.results);\n    const hasAnyDisclosure =\n      summary.chunk.count + summary.section.count + summary.raw.count > 0;\n    if (hasAnyDisclosure) {\n      lines.push(\"\");\n      lines.push(\"### Token spend by disclosure\");\n      lines.push(\"\");\n      lines.push(\"| Disclosure | Results | Estimated tokens |\");\n      lines.push(\"| --- | ---: | ---: |\");\n      lines.push(\n        `| chunk | ${summary.chunk.count} | ${summary.chunk.estimatedTokens} |`,\n      );\n      lines.push(\n        `| section | ${summary.section.count} | ${summary.section.estimatedTokens} |`,\n      );\n      lines.push(\n        `| raw | ${summary.raw.count} | ${summary.raw.estimatedTokens} |`,\n      );\n      if (summary.unspecified.count > 0) {\n        lines.push(\n          `| _(unspecified)_ | ${summary.unspecified.count} | ${summary.unspecified.estimatedTokens} |`,\n        );\n      }\n    }\n  }\n\n  lines.push(\"\");\n  lines.push(\"## Tier Explain\");\n  if (!snapshot.tierExplain) {\n    lines.push(\"\");\n    lines.push(\n      \"_Not populated — direct-answer tier disabled or did not fire._\",\n    );\n  } else {\n    const te = snapshot.tierExplain;\n    lines.push(\"\");\n    lines.push(\"| Field | Value |\");\n    lines.push(\"| --- | --- |\");\n    lines.push(`| Tier | \\`${te.tier}\\` |`);\n    lines.push(`| Reason | ${mdEscape(te.tierReason)} |`);\n    lines.push(`| Candidates considered | ${te.candidatesConsidered} |`);\n    lines.push(`| Latency (ms) | ${te.latencyMs} |`);\n    lines.push(\n      `| Filtered by | ${\n        te.filteredBy.length > 0\n          ? te.filteredBy.map(mdInlineCode).join(\", \")\n          : \"_(none)_\"\n      } |`,\n    );\n    if (te.sourceAnchors && te.sourceAnchors.length > 0) {\n      lines.push(\"\");\n      lines.push(\"**Source anchors:**\");\n      for (const anchor of te.sourceAnchors) {\n        const range = anchor.lineRange\n          ? `:${anchor.lineRange[0]}-${anchor.lineRange[1]}`\n          : \"\";\n        lines.push(`- \\`${anchor.path}${range}\\``);\n      }\n    }\n  }\n\n  return lines.join(\"\\n\");\n}\n\nfunction renderResultMarkdownLines(\n  result: RecallXrayResult,\n  rank: number,\n): string[] {\n  const lines: string[] = [];\n  lines.push(\"\");\n  lines.push(\n    `### ${rank}. \\`${result.memoryId}\\` — ${servedByLabel(result.servedBy)}`,\n  );\n  if (result.path) {\n    lines.push(\"\");\n    lines.push(`- **Path:** \\`${result.path}\\``);\n  } else {\n    lines.push(\"\");\n  }\n  lines.push(`- **Score:** ${renderScoreDecomposition(result)}`);\n  if (result.provenance) {\n    lines.push(\n      `- **Provenance:** ${mdEscape(summarizeRetrievedMemoryProvenance(result.provenance))}`,\n    );\n    lines.push(\n      `- **Retrieval reason:** ${mdInlineCode(result.provenance.retrievalReason)}`,\n    );\n    if (result.provenance.userContextScopes.length > 0) {\n      lines.push(\n        `- **Context scopes:** ${result.provenance.userContextScopes\n          .map(mdInlineCode)\n          .join(\", \")}`,\n      );\n    }\n    if (\n      result.provenance.safety !== \"safe\" ||\n      result.provenance.safetyReasons.length > 0\n    ) {\n      const reasonSuffix =\n        result.provenance.safetyReasons.length > 0\n          ? ` (${result.provenance.safetyReasons.map(mdInlineCode).join(\", \")})`\n          : \"\";\n      lines.push(\n        `- **Safety:** ${mdInlineCode(result.provenance.safety)}${reasonSuffix}`,\n      );\n    }\n  }\n  if (result.sourceSpan) {\n    const q = truncateForXray(result.sourceSpan.quote, 120);\n    lines.push(\n      `- **Source:** \"${mdEscape(q)}\" (${mdInlineCode(result.sourceSpan.observedAt)}) \\u2014 ${result.sourceSpan.provenance}`,\n    );\n  }\n  if (result.admittedBy.length > 0) {\n    lines.push(\n      `- **Admitted by:** ${result.admittedBy.map(mdInlineCode).join(\", \")}`,\n    );\n  }\n  if (result.stateView) {\n    lines.push(`- **State view:** ${mdInlineCode(result.stateView)}`);\n  }\n  if (result.rejectedBy) {\n    lines.push(`- **Rejected by:** ${mdInlineCode(result.rejectedBy)}`);\n  }\n  if (result.graphPath && result.graphPath.length > 0) {\n    lines.push(\n      `- **Graph path:** ${result.graphPath\n        .map(mdInlineCode)\n        .join(\" → \")}`,\n    );\n    // Issue #681 PR 3/3 — render per-edge confidences as a parallel\n    // markdown line so operators can correlate them with the path\n    // arrows above. Skipped when no confidences were recorded.\n    if (\n      result.graphEdgeConfidences &&\n      result.graphEdgeConfidences.length > 0\n    ) {\n      lines.push(\n        `- **Edge confidences:** ${result.graphEdgeConfidences\n          .map((c) => mdInlineCode(c.toFixed(2)))\n          .join(\", \")}`,\n      );\n    }\n  }\n  if (result.pathPenaltyApplied !== undefined) {\n    lines.push(\n      `- **Path penalty applied:** ${mdInlineCode(result.pathPenaltyApplied ? \"yes\" : \"no\")}`,\n    );\n  }\n  if (result.pathNodeIds && result.pathNodeIds.length > 0) {\n    lines.push(\n      `- **Path node ids:** ${result.pathNodeIds.map(mdInlineCode).join(\" → \")}`,\n    );\n  }\n  if (result.auditEntryId) {\n    lines.push(`- **Audit entry:** \\`${result.auditEntryId}\\``);\n  }\n  if (result.disclosure !== undefined) {\n    const tokenLine =\n      typeof result.estimatedTokens === \"number\"\n        ? ` (~${result.estimatedTokens} tokens)`\n        : \"\";\n    lines.push(`- **Disclosure:** \\`${result.disclosure}\\`${tokenLine}`);\n  } else if (typeof result.estimatedTokens === \"number\") {\n    // Disclosure unspecified but tokens recorded — still surface the\n    // budget so the operator can attribute spend.\n    lines.push(`- **Estimated tokens:** ${result.estimatedTokens}`);\n  }\n  return lines;\n}\n\n// ─── Shared helpers ───────────────────────────────────────────────────────\n\nfunction servedByLabel(servedBy: RecallXrayServedBy): string {\n  return `served-by=${servedBy}`;\n}\n\nfunction renderScoreDecomposition(result: RecallXrayResult): string {\n  const parts: string[] = [`final=${formatScore(result.scoreDecomposition.final)}`];\n  const s = result.scoreDecomposition;\n  if (s.vector !== undefined) parts.push(`vector=${formatScore(s.vector)}`);\n  if (s.bm25 !== undefined) parts.push(`bm25=${formatScore(s.bm25)}`);\n  if (s.importance !== undefined) {\n    parts.push(`importance=${formatScore(s.importance)}`);\n  }\n  if (s.mmrPenalty !== undefined) {\n    parts.push(`mmr_penalty=${formatScore(s.mmrPenalty)}`);\n  }\n  if (s.tierPrior !== undefined) {\n    parts.push(`tier_prior=${formatScore(s.tierPrior)}`);\n  }\n  if (s.reinforcementBoost !== undefined && s.reinforcementBoost > 0) {\n    parts.push(`reinforcement_boost=${formatScore(s.reinforcementBoost)}`);\n  }\n  return parts.join(\" \");\n}\n\nfunction formatScore(value: number): string {\n  // Deterministic 4-decimal formatting keeps golden files stable\n  // without printing spurious trailing zeros via toString().\n  if (!Number.isFinite(value)) return \"0.0000\";\n  return value.toFixed(4);\n}\n\nfunction formatCapturedAt(ts: number): string {\n  if (!Number.isFinite(ts) || ts < 0) return \"(unknown)\";\n  // `new Date(n).toISOString()` throws a RangeError for finite numbers\n  // outside the valid Date range (roughly |n| > 8.64e15).  That case\n  // can surface when snapshots are corrupted or captured with a\n  // custom clock, so coerce it to the same \"(unknown)\" fallback\n  // rather than crashing the renderer.\n  try {\n    return new Date(ts).toISOString();\n  } catch {\n    return \"(unknown)\";\n  }\n}\n\nfunction mdEscape(value: string): string {\n  // Pipe is the only character that breaks GFM table rendering; escape\n  // backslash first so we do not re-escape the escape character.\n  return value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\\|/g, \"\\\\|\");\n}\n\n/**\n * Truncate a quote for X-ray display (issue #1575 PR 3). Collapses internal\n * whitespace runs (including newlines/carriage returns) to single spaces so\n * a multi-line source excerpt cannot split what is meant to be a single X-ray\n * row, then caps at `maxChars` on a word boundary with an ellipsis marker.\n * The JSON \\`sourceSpan.quote\\` stays verbatim — this is display-only.\n */\nfunction truncateForXray(text: string, maxChars: number): string {\n  const collapsed = text.replace(/\\s+/g, \" \").trim();\n  if (collapsed.length <= maxChars) return collapsed;\n  const slice = collapsed.slice(0, maxChars);\n  const lastSpace = slice.lastIndexOf(\" \");\n  const cut = lastSpace > Math.floor(maxChars * 0.5) ? slice.slice(0, lastSpace) : slice;\n  return `${cut}\\u2026`;\n}\n\nfunction mdInlineCode(value: string): string {\n  if (value.length === 0) return \"``\";\n  // Use exactly enough backticks to unambiguously wrap content that\n  // itself contains backticks (GFM rule).\n  const longestRun = /`+/g;\n  let maxLen = 0;\n  for (const match of value.matchAll(longestRun)) {\n    if (match[0].length > maxLen) maxLen = match[0].length;\n  }\n  const fence = \"`\".repeat(maxLen + 1);\n  const pad = value.startsWith(\"`\") || value.endsWith(\"`\") ? \" \" : \"\";\n  return `${fence}${pad}${value}${pad}${fence}`;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ECLY4NZA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-xray.ts"],"sourcesContent":["/**\n * Recall X-ray snapshot schema (issue #570, PR 1).\n *\n * The X-ray surface is the unified, per-result attribution document that\n * merges the tier that served each memory, its score decomposition, any\n * graph path, an audit entry id, and the exact filter/eligibility ladder\n * that either admitted or rejected each candidate.  This file defines the\n * schema and an in-memory builder + builder-state helper.\n *\n * Scope for PR 1 (this slice):\n *   - Types only + pure builder functions (no IO, no rendering).\n *   - Orchestrator plumbing captures a snapshot when the caller passes\n *     `xrayCapture: true`.  No behavior change when the flag is absent.\n *   - NO new public surfaces here — CLI/HTTP/MCP land in later slices.\n *\n * The shared renderer lands in PR 2 at `recall-xray-renderer.ts`.  Do not\n * fork formatting logic into other surfaces; extend the renderer.\n */\n\nimport { randomUUID } from \"node:crypto\";\n\nimport { normalizeRetrievedMemoryProvenance, type RetrievedMemoryProvenance } from \"./memory-provenance.js\";\nimport { estimateTokenCount } from \"./token-estimate.js\";\nimport type { RecallDisclosure, RecallTierExplain } from \"./types.js\";\nimport type { StateLabel } from \"./recall-state-view.js\";\nimport { isRecallDisclosure } from \"./types.js\";\n\n/**\n * Estimate token cost of a payload for X-ray disclosure accounting.\n */\nexport function estimateRecallTokens(text: string | null | undefined): number {\n  if (typeof text !== \"string\" || text.length === 0) return 0;\n  return estimateTokenCount(text);\n}\n\n/**\n * Aggregated per-disclosure token spend summary, computed by the\n * renderer from a snapshot's results.  Non-negative integers.\n */\nexport interface RecallXrayDisclosureSummary {\n  chunk: { count: number; estimatedTokens: number };\n  section: { count: number; estimatedTokens: number };\n  raw: { count: number; estimatedTokens: number };\n  /** Number of results without a recorded disclosure level. */\n  unspecified: { count: number; estimatedTokens: number };\n}\n\n/**\n * Which retrieval source produced a given result.  This is the X-ray\n * tier ladder called out in issue #570 and is *distinct* from the\n * `RetrievalTier` enum (which describes issue #518's tier-explain\n * block).  Keeping the sets separate lets the two observability\n * surfaces evolve without conflating their vocabularies:\n *\n *   - `RetrievalTier`     — direct-answer eligibility ladder.\n *   - `RecallXrayServedBy` — which source materialized each result.\n */\nexport type RecallXrayServedBy =\n  | \"direct-answer\"\n  | \"hybrid\"\n  | \"graph\"\n  | \"recent-scan\"\n  | \"procedural\"\n  | \"review-context\"\n  | \"lcm-file-parts\"\n  | \"lcm-tool-parts\";\n\nexport const RECALL_XRAY_SERVED_BY_VALUES: readonly RecallXrayServedBy[] = [\n  \"direct-answer\",\n  \"hybrid\",\n  \"graph\",\n  \"recent-scan\",\n  \"procedural\",\n  \"review-context\",\n  \"lcm-file-parts\",\n  \"lcm-tool-parts\",\n] as const;\n\nexport function isRecallXrayServedBy(\n  value: unknown,\n): value is RecallXrayServedBy {\n  return (\n    typeof value === \"string\" &&\n    (RECALL_XRAY_SERVED_BY_VALUES as readonly string[]).includes(value)\n  );\n}\n\n/**\n * Score decomposition for a single X-ray result.\n *\n * All fields are optional because different tiers populate different\n * terms: `hybrid` reports vector + bm25 + mmr penalty, `direct-answer`\n * reports importance + tier prior, etc.  The only guaranteed field is\n * `final`, which is the post-combination score used for ordering.\n */\nexport interface RecallXrayScoreDecomposition {\n  vector?: number;\n  bm25?: number;\n  importance?: number;\n  mmrPenalty?: number;\n  tierPrior?: number;\n  /** Additive boost from `reinforcement_count` frontmatter (issue #687 PR 3/4). */\n  reinforcementBoost?: number;\n  final: number;\n}\n\n/**\n * Per-result breakdown inside an X-ray snapshot.\n */\nexport interface RecallXrayResult {\n  memoryId: string;\n  path: string;\n  servedBy: RecallXrayServedBy;\n  scoreDecomposition: RecallXrayScoreDecomposition;\n  graphPath?: string[];\n  /**\n   * Issue #681 PR 3/3 — per-edge confidence values aligned with\n   * `graphPath`. When present, `graphEdgeConfidences[i]` is the\n   * confidence of the edge between `graphPath[i]` and `graphPath[i+1]`,\n   * so the array length is one less than `graphPath`. Legacy edges\n   * without a recorded confidence render as `1.0`. Operators use this\n   * to attribute floor-pruning and PageRank ranking decisions back to\n   * specific edges. The renderer drops the line when the array is\n   * empty or absent so legacy snapshots round-trip cleanly.\n   */\n  graphEdgeConfidences?: number[];\n  /** Graph activation node ids recorded for path-scoring provenance. */\n  pathNodeIds?: string[];\n  /** True when a graph path penalty was applied. */\n  pathPenaltyApplied?: boolean;\n  auditEntryId?: string;\n  /** Human-readable list of filters the candidate *passed*. */\n  admittedBy: string[];\n  /**\n   * First filter that *would have* rejected the candidate, or undefined\n   * when the candidate was admitted without a rejection trace.  When\n   * present, `admittedBy` may still contain filters the candidate passed\n   * before the rejecting gate; consumers should render both.\n   */\n  rejectedBy?: string;\n  /**\n   * Disclosure depth used to render this result's payload (issue #677\n   * PR 3/4).  Mirrors the per-result disclosure already exposed in the\n   * recall response so X-ray consumers can attribute token spend to\n   * the depth that produced it.\n   */\n  disclosure?: RecallDisclosure;\n  /**\n   * Estimated token cost of the rendered payload at the chosen\n   * disclosure depth.  Non-negative integer.  Computed by callers via\n   * `estimateRecallTokens(text)`; the renderer aggregates these into\n   * a per-disclosure summary so operators can see where their budget\n   * went.\n   */\n  estimatedTokens?: number;\n  /**\n   * Free-form tags from the memory's YAML frontmatter (issue #689 PR 3/3).\n   * Populated by the X-ray capture path when the caller passes a `tags`\n   * filter so per-result tags are available alongside the filter trace\n   * in `snapshot.filters`.  Also populated without a filter when the\n   * orchestrator decorates results via `xrayCapture: true` so all X-ray\n   * consumers can inspect memory labels without a separate storage read.\n   * Absent (not `[]`) when the frontmatter has no tags or the memory\n   * could not be read.\n   */\n  tags?: string[];\n  /**\n   * Per-result memory provenance and safety context. Populated by recall\n   * capture when the memory frontmatter was already loaded by retrieval.\n   */\n  provenance?: RetrievedMemoryProvenance;\n  /**\n   * Claim-level provenance span (issue #1575 PR 3). The first source excerpt\n   * backing this memory, surfaced so X-ray consumers can see the literal\n   * utterance each fact derives from alongside retrieval provenance. Absent\n   * when the memory carries no source spans (legacy or `provenance: \"none\"`).\n   */\n  sourceSpan?: {\n    /** Verbatim quote excerpt (capped at write time by `provenance.maxQuoteChars`). */\n    quote: string;\n    /** ISO timestamp of the source turn. */\n    observedAt: string;\n    /** Coarse strength tag from the frontmatter. */\n    provenance: \"verified\" | \"unverified\" | \"none\";\n  };\n  /**\n   * Issue #1577 — per-result trust score, band, and components from the\n   * unified TrustScore recall stage. Present when `trustScoreEnabled` is on.\n   * Quarantined items appear here with `quarantined: true` and a reason so\n   * exclusion never looks like \"no result\" (rule 34).\n   */\n  trust?: {\n    score: number;\n    band: \"high\" | \"medium\" | \"low\" | \"quarantine\";\n    components: Record<string, { value: number; weight: number }>;\n    multiplier: number;\n    quarantined: boolean;\n    quarantineReason?: string;\n  };\n  /**\n   * #1952 — recall state-view label for this result (`current`,\n   * `historical`, or `transition`). Present only when state views were\n   * active for the recall AND the result was annotated at the inject\n   * seam; absent otherwise, so legacy snapshots round-trip unchanged.\n   */\n  stateView?: StateLabel;\n}\n\n/**\n * Trace entry for a filter the orchestrator evaluated during recall.\n * Captures the name of the filter, how many candidates it saw, and how\n * many it let through.  Used by X-ray consumers to render the filter\n * ladder above the per-result breakdown.\n */\nexport interface RecallFilterTrace {\n  name: string;\n  considered: number;\n  admitted: number;\n  /** Optional human-readable reason for any rejections. */\n  reason?: string;\n}\n\n/**\n * Peer-profile injection annotation (issue #679 completion).\n *\n * When `peerProfileRecallEnabled` is true and a peer is registered for\n * the session, the orchestrator injects a `## Peer Profile` section into\n * the recall context. This annotation records which peer was injected and\n * how many profile fields were included so operators can correlate\n * retrieval quality with peer-context enrichment.\n *\n * `null` means no peer profile was injected (peer not registered, feature\n * disabled, or peer has no profile fields).\n */\nexport interface RecallXrayPeerProfileInjection {\n  /** The peer id whose profile was injected. */\n  peerId: string;\n  /**\n   * Number of profile fields included after the `peerProfileRecallMaxFields`\n   * cap was applied.  Zero means the profile existed but had no fields.\n   */\n  fieldsInjected: number;\n}\n\n/**\n * The unified X-ray snapshot.  CLI, HTTP, and MCP surfaces all render\n * this same shape through the shared renderer (CLAUDE.md rule 22).\n */\nexport interface RecallXraySnapshot {\n  /** Stable v1 tag so downstream consumers can version-gate their parsers. */\n  schemaVersion: \"1\";\n  query: string;\n  /** UUID minted per capture; unique across snapshots within a process. */\n  snapshotId: string;\n  /** Epoch milliseconds the snapshot was captured. */\n  capturedAt: number;\n  /**\n   * Tier-explain block from issue #518, carried verbatim when present.\n   * `null` means direct-answer tier did not run (disabled, or another\n   * tier served the query).\n   */\n  tierExplain: RecallTierExplain | null;\n  results: RecallXrayResult[];\n  appliedResultLimit: number;\n  appliedResults: RecallXrayResult[];\n  headroomResults: RecallXrayResult[];\n  filters: RecallFilterTrace[];\n  /**\n   * Character budget accounting for the final assembled recall payload.\n   * `used` is the rendered-context length; `chars` is the cap.  Both are\n   * non-negative integers in `[0, 2**31)`.\n   */\n  budget: { chars: number; used: number };\n  /** Optional session-scope fields carried for downstream filtering. */\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /**\n   * Peer-profile injection metadata (issue #679 completion).\n   * Non-null when `peerProfileRecallEnabled` is true and a peer profile\n   * was successfully injected into this recall's context. `null` (or\n   * absent) means no peer profile was injected.\n   */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n}\n\n// ─── Builder ──────────────────────────────────────────────────────────────\n\nexport interface BuildXraySnapshotInput {\n  query: string;\n  tierExplain?: RecallTierExplain | null;\n  results?: RecallXrayResult[];\n  appliedResultLimit?: number;\n  appliedResults?: RecallXrayResult[];\n  headroomResults?: RecallXrayResult[];\n  filters?: RecallFilterTrace[];\n  budget?: { chars?: number; used?: number };\n  sessionKey?: string;\n  namespace?: string;\n  traceId?: string;\n  /** Peer-profile injection metadata (issue #679 completion). */\n  peerProfileInjection?: RecallXrayPeerProfileInjection | null;\n  /** Optional injected timestamp for deterministic tests. */\n  now?: () => number;\n  /** Optional injected id generator for deterministic tests. */\n  snapshotIdGenerator?: () => string;\n}\n\n/**\n * Build a `RecallXraySnapshot` from explicit input fields.  Pure\n * function; safe to call from anywhere.  All array/object inputs are\n * shallow-copied so caller mutation after build cannot tear the\n * returned snapshot.\n */\nexport function buildXraySnapshot(\n  input: BuildXraySnapshotInput,\n): RecallXraySnapshot {\n  const now = input.now ?? Date.now;\n  const snapshotIdGenerator = input.snapshotIdGenerator ?? randomUUID;\n\n  const results = Array.isArray(input.results)\n    ? input.results.map(cloneResult)\n    : [];\n  const appliedResults = Array.isArray(input.appliedResults)\n    ? input.appliedResults.map(cloneResult)\n    : [];\n  const headroomResults = Array.isArray(input.headroomResults)\n    ? input.headroomResults.map(cloneResult)\n    : [];\n  const filters = Array.isArray(input.filters)\n    ? input.filters.map(cloneFilter)\n    : [];\n\n  const budgetChars = nonNegativeInt(input.budget?.chars);\n  const budgetUsed = nonNegativeInt(input.budget?.used);\n\n  const tierExplain =\n    input.tierExplain && typeof input.tierExplain === \"object\"\n      ? cloneTierExplain(input.tierExplain)\n      : null;\n\n  // Peer-profile injection annotation (issue #679 completion).\n  // Deep-copy via structuredClone so the caller can't mutate the snapshot\n  // after build. Accept null explicitly (no injection) or a valid object.\n  let peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n  if (input.peerProfileInjection && typeof input.peerProfileInjection === \"object\") {\n    const raw = input.peerProfileInjection;\n    const peerId = nonEmptyString(raw.peerId);\n    if (peerId !== undefined) {\n      peerProfileInjection = {\n        peerId,\n        fieldsInjected: nonNegativeInt(raw.fieldsInjected),\n      };\n    }\n  } else if (input.peerProfileInjection === null) {\n    peerProfileInjection = null;\n  }\n\n  const out: RecallXraySnapshot = {\n    schemaVersion: \"1\",\n    query: typeof input.query === \"string\" ? input.query : \"\",\n    snapshotId: snapshotIdGenerator(),\n    capturedAt: now(),\n    tierExplain,\n    results,\n    appliedResultLimit: nonNegativeInt(input.appliedResultLimit),\n    appliedResults,\n    headroomResults,\n    filters,\n    budget: { chars: budgetChars, used: budgetUsed },\n    sessionKey: nonEmptyString(input.sessionKey),\n    namespace: nonEmptyString(input.namespace),\n    traceId: nonEmptyString(input.traceId),\n  };\n  if (peerProfileInjection !== undefined) {\n    out.peerProfileInjection = peerProfileInjection;\n  }\n  return out;\n}\n\n/**\n * Mutable builder used by the orchestrator to accumulate X-ray fields\n * as recall progresses.  Call `build()` to get the finalized\n * immutable-ish snapshot.  All inputs are validated at insert time so\n * a malformed entry cannot poison the snapshot later.\n */\nexport class RecallXrayBuilder {\n  private readonly query: string;\n  private readonly sessionKey: string | undefined;\n  private namespace: string | undefined;\n  private traceId: string | undefined;\n  private tierExplain: RecallTierExplain | null = null;\n  private readonly results: RecallXrayResult[] = [];\n  private readonly filters: RecallFilterTrace[] = [];\n  private budgetChars = 0;\n  private budgetUsed = 0;\n  private peerProfileInjection: RecallXrayPeerProfileInjection | null | undefined;\n\n  constructor(opts: {\n    query: string;\n    sessionKey?: string;\n    namespace?: string;\n    traceId?: string;\n  }) {\n    this.query = typeof opts.query === \"string\" ? opts.query : \"\";\n    this.sessionKey = nonEmptyString(opts.sessionKey);\n    this.namespace = nonEmptyString(opts.namespace);\n    this.traceId = nonEmptyString(opts.traceId);\n  }\n\n  setNamespace(namespace: string | undefined): void {\n    this.namespace = nonEmptyString(namespace);\n  }\n\n  setTraceId(traceId: string | undefined): void {\n    this.traceId = nonEmptyString(traceId);\n  }\n\n  setTierExplain(tierExplain: RecallTierExplain | null | undefined): void {\n    this.tierExplain =\n      tierExplain && typeof tierExplain === \"object\"\n        ? cloneTierExplain(tierExplain)\n        : null;\n  }\n\n  setBudget(budget: { chars?: number; used?: number }): void {\n    this.budgetChars = nonNegativeInt(budget.chars);\n    this.budgetUsed = nonNegativeInt(budget.used);\n  }\n\n  /**\n   * Record peer-profile injection metadata for this recall snapshot\n   * (issue #679 completion). Pass `null` to explicitly record that no\n   * injection happened (feature enabled but no peer / no profile fields).\n   */\n  setPeerProfileInjection(\n    injection: RecallXrayPeerProfileInjection | null,\n  ): void {\n    this.peerProfileInjection = injection;\n  }\n\n  recordResult(result: RecallXrayResult): void {\n    this.results.push(cloneResult(result));\n  }\n\n  recordFilter(filter: RecallFilterTrace): void {\n    this.filters.push(cloneFilter(filter));\n  }\n\n  build(opts: {\n    now?: () => number;\n    snapshotIdGenerator?: () => string;\n  } = {}): RecallXraySnapshot {\n    return buildXraySnapshot({\n      query: this.query,\n      tierExplain: this.tierExplain,\n      results: this.results,\n      filters: this.filters,\n      budget: { chars: this.budgetChars, used: this.budgetUsed },\n      sessionKey: this.sessionKey,\n      namespace: this.namespace,\n      traceId: this.traceId,\n      peerProfileInjection: this.peerProfileInjection,\n      now: opts.now,\n      snapshotIdGenerator: opts.snapshotIdGenerator,\n    });\n  }\n}\n\n// ─── Internals ────────────────────────────────────────────────────────────\n\nfunction cloneResult(result: RecallXrayResult): RecallXrayResult {\n  if (!result || typeof result !== \"object\") {\n    throw new TypeError(\"RecallXrayResult must be an object\");\n  }\n  if (!isRecallXrayServedBy(result.servedBy)) {\n    throw new TypeError(\n      `RecallXrayResult.servedBy must be one of ${RECALL_XRAY_SERVED_BY_VALUES.join(\n        \", \",\n      )}; got ${JSON.stringify(result.servedBy)}`,\n    );\n  }\n  const memoryId = typeof result.memoryId === \"string\" ? result.memoryId : \"\";\n  const path = typeof result.path === \"string\" ? result.path : \"\";\n  const admittedBy = Array.isArray(result.admittedBy)\n    ? result.admittedBy.filter((x): x is string => typeof x === \"string\")\n    : [];\n  const graphPath = Array.isArray(result.graphPath)\n    ? result.graphPath.filter((x): x is string => typeof x === \"string\")\n    : undefined;\n  // Issue #681 PR 3/3 — per-edge confidences alongside graph path.\n  // Each entry is clamped into [0, 1]; the array is rejected wholesale\n  // when alignment cannot be verified so downstream surfaces can rely\n  // on `graphEdgeConfidences[i]` describing the edge between\n  // `graphPath[i]` and `graphPath[i+1]`.\n  //\n  // Cursor review (#735): the input array length MUST match\n  // `graphPath.length - 1` *before* any per-element filtering. The\n  // earlier implementation skipped non-finite entries via `continue`\n  // and then length-checked the cleaned array — that would silently\n  // shift surviving values to earlier positions. Example: input\n  // `[0.5, NaN, 0.7]` for a 3-edge path would collapse to\n  // `[0.5, 0.7]`, length-check would pass against `expected = 2`, and\n  // the renderer would mis-attribute `0.7` to edge B→C when it really\n  // came from edge C→D. Reject on either size mismatch or any\n  // non-finite entry so misalignment is impossible.\n  let graphEdgeConfidences: number[] | undefined;\n  if (Array.isArray(result.graphEdgeConfidences) && graphPath && graphPath.length > 1) {\n    const expected = graphPath.length - 1;\n    const raw = result.graphEdgeConfidences;\n    if (raw.length === expected) {\n      const cleaned: number[] = [];\n      let allFinite = true;\n      for (const value of raw) {\n        if (typeof value !== \"number\" || !Number.isFinite(value)) {\n          allFinite = false;\n          break;\n        }\n        cleaned.push(Math.min(1, Math.max(0, value)));\n      }\n      if (allFinite) {\n        graphEdgeConfidences = cleaned;\n      }\n    }\n  }\n  const pathNodeIds = Array.isArray(result.pathNodeIds)\n    ? result.pathNodeIds.filter((x): x is string => typeof x === \"string\")\n    : undefined;\n  const pathPenaltyApplied =\n    typeof result.pathPenaltyApplied === \"boolean\"\n      ? result.pathPenaltyApplied\n      : undefined;\n  const stateView =\n    result.stateView === \"current\" || result.stateView === \"historical\" || result.stateView === \"transition\"\n      ? result.stateView\n      : undefined;\n  const auditEntryId = nonEmptyString(result.auditEntryId);\n  const rejectedBy = nonEmptyString(result.rejectedBy);\n  const scoreDecomposition = cloneScoreDecomposition(result.scoreDecomposition);\n  const out: RecallXrayResult = {\n    memoryId,\n    path,\n    servedBy: result.servedBy,\n    scoreDecomposition,\n    admittedBy,\n  };\n  if (graphPath !== undefined) out.graphPath = graphPath;\n  if (graphEdgeConfidences !== undefined) {\n    out.graphEdgeConfidences = graphEdgeConfidences;\n  }\n  if (pathNodeIds !== undefined) out.pathNodeIds = pathNodeIds;\n  if (pathPenaltyApplied !== undefined) out.pathPenaltyApplied = pathPenaltyApplied;\n  if (stateView !== undefined) out.stateView = stateView;\n  if (auditEntryId !== undefined) out.auditEntryId = auditEntryId;\n  if (rejectedBy !== undefined) out.rejectedBy = rejectedBy;\n  // Disclosure + token telemetry (issue #677 PR 3/4).  Only attach when\n  // present and well-formed; unknown disclosure values are dropped so a\n  // bad caller can't poison downstream renderers.  Uses the shared\n  // `isRecallDisclosure` guard so adding a fourth disclosure level\n  // requires touching only `types.ts`.\n  if (isRecallDisclosure(result.disclosure)) {\n    out.disclosure = result.disclosure;\n  }\n  if (\n    typeof result.estimatedTokens === \"number\" &&\n    Number.isFinite(result.estimatedTokens) &&\n    result.estimatedTokens >= 0\n  ) {\n    out.estimatedTokens = Math.floor(result.estimatedTokens);\n  }\n  // Tags from frontmatter (issue #689 PR 3/3).  Normalize identically to\n  // the recall-surface path: trim and drop empty strings so consumers can\n  // compare tags directly without a secondary normalization step.\n  if (Array.isArray(result.tags)) {\n    const cleanedTags = result.tags\n      .filter((t): t is string => typeof t === \"string\")\n      .map((t) => t.trim())\n      .filter((t) => t.length > 0);\n    if (cleanedTags.length > 0) {\n      out.tags = cleanedTags;\n    }\n  }\n  const provenance = normalizeRetrievedMemoryProvenance(result.provenance);\n  if (provenance !== undefined) {\n    out.provenance = provenance;\n  }\n  // Claim-level provenance span (#1575 PR 3). Deep-copy the three scalar\n  // fields so the snapshot returned by getLastXraySnapshot is independent\n  // of the caller's object (matches the structuredClone contract).\n  const ss = result.sourceSpan;\n  if (\n    ss &&\n    typeof ss.quote === \"string\" &&\n    typeof ss.observedAt === \"string\" &&\n    (ss.provenance === \"verified\" ||\n      ss.provenance === \"unverified\" ||\n      ss.provenance === \"none\")\n  ) {\n    out.sourceSpan = {\n      quote: ss.quote,\n      observedAt: ss.observedAt,\n      provenance: ss.provenance,\n    };\n  }\n  // Issue #1577 — preserve the trust projection through the clone so\n  // getLastXraySnapshot surfaces trust score/band/quarantine reason (review\n  // Oqg_o: cloneResult was silently dropping the field). Deep-copy the scalar +\n  // record fields so the snapshot is independent of the caller's object,\n  // matching the structuredClone contract used for every other field above.\n  if (result.trust) {\n    const t = result.trust;\n    const components: Record<string, { value: number; weight: number }> = {};\n    for (const [k, v] of Object.entries(t.components)) {\n      components[k] = { value: v.value, weight: v.weight };\n    }\n    out.trust = {\n      score: t.score,\n      band: t.band,\n      components,\n      multiplier: t.multiplier,\n      quarantined: t.quarantined,\n      ...(t.quarantineReason ? { quarantineReason: t.quarantineReason } : {}),\n    };\n  }\n  return out;\n}\n\n/**\n * Summarize per-disclosure token spend across an X-ray snapshot's\n * results.  Pure helper — used by the markdown renderer to print a\n * \"per-disclosure token spend\" line and exposed for tests / surfaces.\n */\nexport function summarizeDisclosureTokens(\n  results: ReadonlyArray<Pick<RecallXrayResult, \"disclosure\" | \"estimatedTokens\">>,\n): RecallXrayDisclosureSummary {\n  const summary: RecallXrayDisclosureSummary = {\n    chunk: { count: 0, estimatedTokens: 0 },\n    section: { count: 0, estimatedTokens: 0 },\n    raw: { count: 0, estimatedTokens: 0 },\n    unspecified: { count: 0, estimatedTokens: 0 },\n  };\n  for (const result of results) {\n    const tokens =\n      typeof result.estimatedTokens === \"number\" &&\n      Number.isFinite(result.estimatedTokens) &&\n      result.estimatedTokens >= 0\n        ? Math.floor(result.estimatedTokens)\n        : 0;\n    const bucket = isRecallDisclosure(result.disclosure)\n      ? result.disclosure\n      : \"unspecified\";\n    summary[bucket].count += 1;\n    summary[bucket].estimatedTokens += tokens;\n  }\n  return summary;\n}\n\nfunction cloneFilter(filter: RecallFilterTrace): RecallFilterTrace {\n  if (!filter || typeof filter !== \"object\") {\n    throw new TypeError(\"RecallFilterTrace must be an object\");\n  }\n  const out: RecallFilterTrace = {\n    name: typeof filter.name === \"string\" ? filter.name : \"\",\n    considered: nonNegativeInt(filter.considered),\n    admitted: nonNegativeInt(filter.admitted),\n  };\n  const reason = nonEmptyString(filter.reason);\n  if (reason !== undefined) out.reason = reason;\n  return out;\n}\n\nfunction cloneScoreDecomposition(\n  value: RecallXrayScoreDecomposition | undefined,\n): RecallXrayScoreDecomposition {\n  if (!value || typeof value !== \"object\") {\n    return { final: 0 };\n  }\n  const out: RecallXrayScoreDecomposition = {\n    final: finiteNumber(value.final) ?? 0,\n  };\n  const vector = finiteNumber(value.vector);\n  if (vector !== undefined) out.vector = vector;\n  const bm25 = finiteNumber(value.bm25);\n  if (bm25 !== undefined) out.bm25 = bm25;\n  const importance = finiteNumber(value.importance);\n  if (importance !== undefined) out.importance = importance;\n  const mmrPenalty = finiteNumber(value.mmrPenalty);\n  if (mmrPenalty !== undefined) out.mmrPenalty = mmrPenalty;\n  const tierPrior = finiteNumber(value.tierPrior);\n  if (tierPrior !== undefined) out.tierPrior = tierPrior;\n  const reinforcementBoost = finiteNumber(value.reinforcementBoost);\n  if (reinforcementBoost !== undefined && reinforcementBoost > 0) {\n    out.reinforcementBoost = reinforcementBoost;\n  }\n  return out;\n}\n\nfunction cloneTierExplain(tierExplain: RecallTierExplain): RecallTierExplain {\n  // Use structuredClone so future RecallTierExplain additions do not\n  // silently share references through hand-enumerated fields.  The\n  // payload is JSON-shaped.\n  return structuredClone(tierExplain);\n}\n\nfunction nonNegativeInt(value: unknown): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 0;\n  if (value <= 0) return 0;\n  return Math.floor(value);\n}\n\nfunction finiteNumber(value: unknown): number | undefined {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return undefined;\n  return value;\n}\n\nfunction nonEmptyString(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const trimmed = value.trim();\n  if (trimmed.length === 0) return undefined;\n  return trimmed;\n}\n"],"mappings":"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","names":[]}