@remnic/core 9.3.719 → 9.3.720

package/dist/{chunk-L5ASZA2F.js → chunk-3XEGHEQ2.js}

@@ -1,6 +1,6 @@
 import {
   isRecallDisclosure
-} from "./chunk-N3DUH6OO.js";
+} from "./chunk-ZW5I3UNP.js";
 import {
   normalizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -197,6 +197,21 @@ function cloneResult(result) {
       provenance: ss.provenance
     };
   }
+  if (result.trust) {
+    const t = result.trust;
+    const components = {};
+    for (const [k, v] of Object.entries(t.components)) {
+      components[k] = { value: v.value, weight: v.weight };
+    }
+    out.trust = {
+      score: t.score,
+      band: t.band,
+      components,
+      multiplier: t.multiplier,
+      quarantined: t.quarantined,
+      ...t.quarantineReason ? { quarantineReason: t.quarantineReason } : {}
+    };
+  }
   return out;
 }
 function summarizeDisclosureTokens(results) {
@@ -277,4 +292,4 @@ export {
   RecallXrayBuilder,
   summarizeDisclosureTokens
 };
-//# sourceMappingURL=chunk-L5ASZA2F.js.map
+//# sourceMappingURL=chunk-3XEGHEQ2.js.map

package/dist/chunk-3XEGHEQ2.js.map

@@ -0,0 +1 @@
+{"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 {\n  normalizeRetrievedMemoryProvenance,\n  type RetrievedMemoryProvenance,\n} from \"./memory-provenance.js\";\nimport type { RecallDisclosure, RecallTierExplain } from \"./types.js\";\nimport { isRecallDisclosure } from \"./types.js\";\n\n/**\n * Estimate token cost of a payload at the rough ~4 chars/token English\n * heuristic.  Non-negative integer; returns 0 for empty / null input.\n * Used by recall surfaces to attach `estimatedTokens` to X-ray results\n * (issue #677 PR 3/4).  Identical to the private heuristic in\n * `chunking.ts`; kept self-contained here so X-ray callers don't pull\n * in chunking internals.\n */\nexport function estimateRecallTokens(text: string | null | undefined): number {\n  if (typeof text !== \"string\" || text.length === 0) return 0;\n  return Math.ceil(text.length / 4);\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  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\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  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  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 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    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 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 (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<RecallXrayResult>,\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":[]}

package/dist/{chunk-YYOK4GVF.js → chunk-422TIKIH.js}

@@ -2,7 +2,7 @@ import {
   TombstoneStore,
   buildRetiredFactTombstoneInputs,
   collectRetiredMemoriesForRebuild
-} from "./chunk-3JJWNZTT.js";
+} from "./chunk-L2B3EE7B.js";
 import {
   WEARABLES_DIR_NAME,
   isValidTranscriptDate
@@ -27,7 +27,7 @@ import {
 import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier
-} from "./chunk-N3DUH6OO.js";
+} from "./chunk-ZW5I3UNP.js";
 import {
   inferMemoryStatus,
   isArchivedMemoryPath,
@@ -5863,4 +5863,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-YYOK4GVF.js.map
+//# sourceMappingURL=chunk-422TIKIH.js.map

package/dist/{chunk-KRGC4EDX.js → chunk-5YQN2XYC.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-SFQ6QNL7.js";
 import {
   StorageManager
-} from "./chunk-YYOK4GVF.js";
+} from "./chunk-422TIKIH.js";
 import {
   buildLifecycleEventsForMemory,
   sortMemoryLifecycleEvents
@@ -74,4 +74,4 @@ export {
   backupExistingLedger,
   rebuildMemoryLifecycleLedger
 };
-//# sourceMappingURL=chunk-KRGC4EDX.js.map
+//# sourceMappingURL=chunk-5YQN2XYC.js.map

package/dist/{chunk-ANI5DUAE.js → chunk-6S5ZI7HB.js}

@@ -1,6 +1,6 @@
 import {
   AdapterRegistry
-} from "./chunk-AU7Q3LSC.js";
+} from "./chunk-RKNJBZ55.js";
 import {
   WearablesInputError
 } from "./chunk-7WV3F5DQ.js";
@@ -17,19 +17,19 @@ import {
   markPlanResolved,
   markPromotionResolved,
   sessionBelongsToPrincipal
-} from "./chunk-P5IPFZVH.js";
+} from "./chunk-BGQ7WKMT.js";
 import {
   validateRequest
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-URM3HW2R.js";
+} from "./chunk-NE5WFIY6.js";
 import {
   EngramAccessInputError
-} from "./chunk-F3PVXKHP.js";
+} from "./chunk-M3GBOKUX.js";
 import {
   CorrectionContractError
-} from "./chunk-OJU73BUX.js";
+} from "./chunk-PPVCZPYA.js";
 import {
   isTrustZoneName
 } from "./chunk-JGSKJHF7.js";
@@ -41,7 +41,7 @@ import {
 } from "./chunk-DEUNUKTD.js";
 import {
   isRecallDisclosure
-} from "./chunk-N3DUH6OO.js";
+} from "./chunk-ZW5I3UNP.js";
 import {
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
@@ -2528,4 +2528,4 @@ function positiveIntQueryParam(value, label) {
 export {
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-ANI5DUAE.js.map
+//# sourceMappingURL=chunk-6S5ZI7HB.js.map

package/dist/{chunk-JIZGYQYH.js → chunk-ATGRQ2NE.js}

@@ -1,9 +1,9 @@
 import {
   defineOperation
-} from "./chunk-URM3HW2R.js";
+} from "./chunk-NE5WFIY6.js";
 import {
   EngramAccessInputError
-} from "./chunk-F3PVXKHP.js";
+} from "./chunk-M3GBOKUX.js";
 import {
   projectTagProjectId
 } from "./chunk-J6BH2OBA.js";
@@ -1023,7 +1023,7 @@ defineOperation({
     if (!cfg.graphEdgeDecayEnabled) {
       return { result: { ranAt: (/* @__PURE__ */ new Date()).toISOString(), disabled: true, reason: "graphEdgeDecayEnabled is false" } };
     }
-    const { runGraphEdgeDecayMaintenanceAcrossNamespaces } = await import("./graph-edge-decay-JLOF3YW4.js");
+    const { runGraphEdgeDecayMaintenanceAcrossNamespaces } = await import("./graph-edge-decay-QDDC6AVV.js");
     const dryRun = input.dryRun === true;
     const results = await runGraphEdgeDecayMaintenanceAcrossNamespaces(ctx.service.memoryDir, {
       windowMs: cfg.graphEdgeDecayWindowMs,
@@ -1312,4 +1312,4 @@ defineOperation({
   schema: looseSchema,
   handler: async (_input, _ctx) => ({ result: { stream: "sse" } })
 });
-//# sourceMappingURL=chunk-JIZGYQYH.js.map
+//# sourceMappingURL=chunk-ATGRQ2NE.js.map

package/dist/chunk-BCDKBDSY.js

@@ -0,0 +1,173 @@
+import {
+  computeTrustScore,
+  trustMultiplier
+} from "./chunk-YN2UN7N3.js";
+import {
+  computeMemoryWorth
+} from "./chunk-IISBCCWR.js";
+
+// src/trust-score-stage.ts
+function buildTrustSignalMap(memories, now, options = {}) {
+  const map = /* @__PURE__ */ new Map();
+  const nowMs = now.getTime();
+  const nowUsable = Number.isFinite(nowMs);
+  for (const m of memories) {
+    const fm = m.frontmatter;
+    const signals = {};
+    if (fm.mw_success !== void 0 || fm.mw_fail !== void 0) {
+      const halfLifeMs = options.recencyHalfLifeDays !== void 0 ? options.recencyHalfLifeDays * 864e5 : void 0;
+      const worth = computeMemoryWorth({
+        mw_success: fm.mw_success,
+        mw_fail: fm.mw_fail,
+        lastAccessed: fm.lastAccessed,
+        now,
+        halfLifeMs
+      });
+      signals.memoryWorth = { score: worth.score, confidence: worth.confidence };
+    }
+    if (fm.provenance !== void 0) signals.provenance = fm.provenance;
+    if (fm.faithfulness !== void 0) {
+      signals.faithfulness = fm.faithfulness.verdict === "skipped_no_span" ? "unchecked" : fm.faithfulness.verdict;
+    }
+    if (Array.isArray(fm.sources) && fm.sources.length > 0) {
+      const distinct = new Set(
+        fm.sources.map((s) => `${s.sessionKey ?? ""}|${s.turnId ?? ""}`)
+      );
+      signals.corroborationCount = distinct.size;
+    }
+    const ts = fm.observedAt ?? fm.lastAccessed;
+    if (nowUsable && typeof ts === "string" && ts.length > 0) {
+      const parsed = Date.parse(ts);
+      if (Number.isFinite(parsed)) {
+        const ageDays = Math.max(0, (nowMs - parsed) / (24 * 60 * 60 * 1e3));
+        signals.ageDays = ageDays;
+        if (options.recencyHalfLifeDays !== void 0) {
+          signals.recencyHalfLifeDays = options.recencyHalfLifeDays;
+        }
+      }
+    }
+    if (Object.keys(signals).length > 0) {
+      map.set(m.path, signals);
+    }
+  }
+  return map;
+}
+function applyTrustScoreStage(candidates, options) {
+  const reorder = options.reorder !== false;
+  const quarantine = options.quarantine !== false;
+  const minMul = options.minMultiplier;
+  const maxMul = options.maxMultiplier;
+  const all = [];
+  const admitted = [];
+  const quarantined = [];
+  for (let i = 0; i < candidates.length; i += 1) {
+    const c = candidates[i];
+    const signals = options.signals.get(c.path);
+    const trust = computeTrustScore(signals, options.weights);
+    const isQuarantined = quarantine && trust.band === "quarantine";
+    const multiplier = isQuarantined ? 1 : trustMultiplier(trust.score, minMul, maxMul);
+    const safeBase = c.score < 0 ? 0 : c.score;
+    const scored = safeBase * multiplier;
+    const item = {
+      path: c.path,
+      score: scored,
+      originalScore: c.score,
+      multiplier,
+      trust,
+      quarantined: isQuarantined
+    };
+    all.push(item);
+    if (isQuarantined) quarantined.push(item);
+    else admitted.push(item);
+  }
+  if (reorder) {
+    admitted.sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return 0;
+    });
+  }
+  return { admitted, quarantined, all };
+}
+function projectTrustForXray(item) {
+  const proj = {
+    score: item.trust.score,
+    band: item.trust.band,
+    components: item.trust.components,
+    multiplier: item.multiplier,
+    quarantined: item.quarantined
+  };
+  if (item.quarantined) {
+    proj.quarantineReason = explainQuarantine(item.trust);
+  }
+  return proj;
+}
+function explainQuarantine(trust) {
+  const c = trust.components;
+  if (c.faithfulness && c.faithfulness.value === 0) return "faithfulness: contradicted";
+  if (c.contradiction && c.contradiction.value <= 0.2) return "contradiction: pending review";
+  return "hard-negative trust signal";
+}
+async function buildTrustSignalsForRerank(candidatePaths, namespaces, deps, signalCache, now, options = {}) {
+  const nowMs = now.getTime();
+  const logDebug = options.logDebug ?? (() => {
+  });
+  const signals = /* @__PURE__ */ new Map();
+  for (const [key, entry] of signalCache.cache) {
+    if (nowMs - entry.at >= signalCache.ttlMs) signalCache.cache.delete(key);
+  }
+  const seenNamespaces = /* @__PURE__ */ new Set();
+  for (const ns of namespaces) {
+    if (seenNamespaces.has(ns)) continue;
+    seenNamespaces.add(ns);
+    try {
+      const cached = signalCache.cache.get(ns);
+      let nsMap;
+      if (cached && nowMs - cached.at < signalCache.ttlMs) {
+        nsMap = cached.signals;
+      } else {
+        const memories = await deps.readNamespaceMemories(ns);
+        nsMap = buildTrustSignalMap(memories, now, {
+          recencyHalfLifeDays: options.recencyHalfLifeDays
+        });
+        signalCache.cache.set(ns, { at: nowMs, signals: nsMap });
+      }
+      for (const [path, s] of nsMap) signals.set(path, s);
+    } catch (err) {
+      logDebug("trust-score: failed to read namespace, skipping", {
+        namespace: ns,
+        error: err.message
+      });
+    }
+  }
+  const missing = candidatePaths.filter((p) => !signals.has(p));
+  if (missing.length > 0) {
+    const fallbackMemories = [];
+    for (const path of missing) {
+      try {
+        const frontmatter = await deps.readMemoryFrontmatter(path);
+        if (frontmatter) fallbackMemories.push({ path, frontmatter });
+      } catch (err) {
+        logDebug("trust-score: direct path lookup failed", {
+          path,
+          error: err.message
+        });
+      }
+    }
+    if (fallbackMemories.length > 0) {
+      const fallbackSignals = buildTrustSignalMap(fallbackMemories, now, {
+        recencyHalfLifeDays: options.recencyHalfLifeDays
+      });
+      for (const [path, s] of fallbackSignals) signals.set(path, s);
+    }
+  }
+  return signals;
+}
+
+export {
+  buildTrustSignalMap,
+  applyTrustScoreStage,
+  projectTrustForXray,
+  explainQuarantine,
+  buildTrustSignalsForRerank
+};
+//# sourceMappingURL=chunk-BCDKBDSY.js.map

package/dist/chunk-BCDKBDSY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/trust-score-stage.ts"],"sourcesContent":["/**\n * trust-score-stage.ts — signal adapters + recall pipeline stage (issue #1577 PR 2).\n *\n * This module sits between the pure {@link computeTrustScore} scorer and the\n * recall pipeline. It owns TWO jobs:\n *\n *   1. **Signal adapters** — read each trust signal via existing readers only\n *      (`buildMemoryWorthCounterMap`-style frontmatter scan, faithfulness /\n *      provenance / sources frontmatter from #1575/#1576). No new disk format,\n *      no new write path. Expensive / optional signals (belief-ledger domain\n *      calibration, contradiction review queue) are extension points that\n *      return `undefined` when unwired — the scorer degrades to neutral for\n *      any absent signal (rule 34).\n *\n *   2. **The recall stage** — apply `trustMultiplier(trust.score)` to each\n *      candidate, exclude `quarantine`-band items from injection, and surface\n *      the per-result `{ score, band, components }` so X-ray and the epistemic\n *      renderer can explain the basis.\n *\n * Mutual exclusion with the Memory Worth filter (rule 39 — one multiplier, one\n * application point): when this stage runs, the standalone memory-worth filter\n * MUST NOT also run. The orchestrator enforces that at the wiring site\n * (`if (caps.recallTrustScore) … else if (caps.recallMemoryWorthFilter) …`);\n * the `double-multiplier` test below pins it structurally.\n */\n\nimport { computeMemoryWorth } from \"./memory-worth.js\";\nimport {\n  computeTrustScore,\n  trustMultiplier,\n  type TrustBand,\n  type TrustScoreComponent,\n  type TrustScoreResult,\n  type TrustSignals,\n  type TrustWeights,\n} from \"./trust-score.js\";\nimport type { FaithfulnessFrontmatter, ProvenanceSource } from \"./types.js\";\n\n/**\n * Frontmatter projection the adapter reads. Kept narrow + structural so it can\n * be fed from a `MemoryFrontmatter`, a bench fixture, or a test stub without\n * pulling the full frontmatter type graph into the stage module.\n */\nexport interface TrustFrontmatterProjection {\n  mw_success?: number;\n  mw_fail?: number;\n  lastAccessed?: string | null;\n  provenance?: \"verified\" | \"unverified\" | \"none\";\n  faithfulness?: FaithfulnessFrontmatter;\n  sources?: ProvenanceSource[];\n  /** Optional ISO creation/observation timestamp used for recency. */\n  observedAt?: string;\n}\n\n/**\n * Build a `path → TrustSignals` map from an in-memory frontmatter scan. The\n * caller passes the memories already read for the memory-worth counter map so\n * we do not re-read the namespace. Pure: no I/O, takes `now` explicitly.\n */\nexport function buildTrustSignalMap(\n  memories: ReadonlyArray<{ path: string; frontmatter: TrustFrontmatterProjection }>,\n  now: Date,\n  options: { recencyHalfLifeDays?: number } = {},\n): Map<string, TrustSignals> {\n  const map = new Map<string, TrustSignals>();\n  const nowMs = now.getTime();\n  const nowUsable = Number.isFinite(nowMs);\n  for (const m of memories) {\n    const fm = m.frontmatter;\n    const signals: TrustSignals = {};\n\n    // Memory worth — reuse the exact Laplace computation the standalone filter\n    // uses so the two never disagree on the same counters.\n    if (fm.mw_success !== undefined || fm.mw_fail !== undefined) {\n      // Pass the half-life through so outcome counters decay at the same\n      // rate as the standalone memory-worth filter (review P2: TrustScore\n      // subsumes the filter, so decay must not be lost). Convert days → ms.\n      const halfLifeMs =\n        options.recencyHalfLifeDays !== undefined\n          ? options.recencyHalfLifeDays * 86_400_000\n          : undefined;\n      const worth = computeMemoryWorth({\n        mw_success: fm.mw_success,\n        mw_fail: fm.mw_fail,\n        lastAccessed: fm.lastAccessed,\n        now,\n        halfLifeMs,\n      });\n      signals.memoryWorth = { score: worth.score, confidence: worth.confidence };\n    }\n\n    if (fm.provenance !== undefined) signals.provenance = fm.provenance;\n    if (fm.faithfulness !== undefined) {\n      // `skipped_no_span` (legacy fact lacking a verified source span) carries\n      // no entailment signal — collapse it to `unchecked` so the scorer treats\n      // it as the neutral \"no verdict\" case rather than a hard negative.\n      signals.faithfulness =\n        fm.faithfulness.verdict === \"skipped_no_span\" ? \"unchecked\" : fm.faithfulness.verdict;\n    }\n\n    // Corroboration = distinct source sessions/turns backing the fact.\n    if (Array.isArray(fm.sources) && fm.sources.length > 0) {\n      const distinct = new Set(\n        fm.sources.map((s) => `${s.sessionKey ?? \"\"}|${s.turnId ?? \"\"}`),\n      );\n      signals.corroborationCount = distinct.size;\n    }\n\n    // Recency: prefer an explicit observation timestamp; fall back to\n    // lastAccessed. Days-old vs the per-category half-life the caller supplies.\n    const ts = fm.observedAt ?? fm.lastAccessed;\n    if (nowUsable && typeof ts === \"string\" && ts.length > 0) {\n      const parsed = Date.parse(ts);\n      if (Number.isFinite(parsed)) {\n        const ageDays = Math.max(0, (nowMs - parsed) / (24 * 60 * 60 * 1000));\n        signals.ageDays = ageDays;\n        if (options.recencyHalfLifeDays !== undefined) {\n          signals.recencyHalfLifeDays = options.recencyHalfLifeDays;\n        }\n      }\n    }\n\n    // Only record an entry when at least one signal is present — a fully-empty\n    // entry would score neutral anyway, and skipping keeps the map small.\n    if (Object.keys(signals).length > 0) {\n      map.set(m.path, signals);\n    }\n  }\n  return map;\n}\n\n/** A scored recall candidate (mirrors `MemoryWorthFilterCandidate`). */\nexport interface TrustStageCandidate {\n  path: string;\n  score: number;\n}\n\n/** One candidate after the TrustScore stage. */\nexport interface TrustStageResultItem {\n  path: string;\n  /** Final score after the trust multiplier is applied. */\n  score: number;\n  /** The untouched input score — for telemetry / X-ray. */\n  originalScore: number;\n  /** The multiplier applied (exactly `1.0` for neutral / quarantined-kept). */\n  multiplier: number;\n  /** The full TrustScore result for X-ray + epistemic rendering. */\n  trust: TrustScoreResult;\n  /** `true` when the item was excluded from injection by quarantine. */\n  quarantined: boolean;\n}\n\nexport interface TrustStageOptions {\n  /** `path → TrustSignals`. Candidates absent from the map score neutral. */\n  signals: ReadonlyMap<string, TrustSignals>;\n  weights?: TrustWeights;\n  /** Multiplier bounds; see {@link trustMultiplier}. */\n  minMultiplier?: number;\n  maxMultiplier?: number;\n  /**\n   * When `true` (default), `quarantine`-band items are excluded from the\n   * returned (injected) list but still appear in {@link TrustStageOutput.all}\n   * with `quarantined: true` so X-ray can surface them with a reason.\n   * Only effective when the stage is active at all.\n   */\n  quarantine?: boolean;\n  /**\n   * Re-sort admitted candidates by descending multiplied score. Default `true`.\n   * When `false`, admitted items keep input order; quarantined items are still\n   * separated out.\n   */\n  reorder?: boolean;\n}\n\n/** Output of {@link applyTrustScoreStage}. */\nexport interface TrustStageOutput {\n  /** Admitted (injectable) candidates, score-multiplied and optionally sorted. */\n  admitted: TrustStageResultItem[];\n  /**\n   * Quarantined candidates — excluded from injection but visible to X-ray with\n   * the reason (rule 34 — exclusion must never look like \"no result\"). Callers\n   * that only need the injected list read `admitted`; X-ray reads `all`.\n   */\n  quarantined: TrustStageResultItem[];\n  /** Every candidate (admitted + quarantined) in input order, for X-ray. */\n  all: TrustStageResultItem[];\n}\n\n/**\n * Apply the unified TrustScore stage: score each candidate, multiply its base\n * score by `trustMultiplier(trust.score)`, and separate hard-negative\n * (quarantine) items from the injectable set.\n *\n * Neutral candidates (no signals → multiplier `1.0`) are mathematically\n * untouched, preserving byte-identical ranking for uninstrumented memories\n * when the feature is ON (and the whole stage is skipped when OFF — rule 39).\n */\nexport function applyTrustScoreStage(\n  candidates: readonly TrustStageCandidate[],\n  options: TrustStageOptions,\n): TrustStageOutput {\n  const reorder = options.reorder !== false;\n  const quarantine = options.quarantine !== false;\n  const minMul = options.minMultiplier;\n  const maxMul = options.maxMultiplier;\n\n  const all: TrustStageResultItem[] = [];\n  const admitted: TrustStageResultItem[] = [];\n  const quarantined: TrustStageResultItem[] = [];\n\n  for (let i = 0; i < candidates.length; i += 1) {\n    const c = candidates[i]!;\n    const signals = options.signals.get(c.path);\n    const trust = computeTrustScore(signals, options.weights);\n    const isQuarantined = quarantine && trust.band === \"quarantine\";\n    // Quarantined items are excluded from injection. Keep their score unchanged\n    // so X-ray shows what the pipeline WOULD have injected — never inflate or\n    // zero the score of a hidden item (rule 34).\n    const multiplier = isQuarantined ? 1 : trustMultiplier(trust.score, minMul, maxMul);\n    // Clamp the base score at zero before multiplying, mirroring the\n    // memory-worth filter: a negative base would invert the multiplier's\n    // intended direction (see memory-worth-filter.ts:145-153).\n    const safeBase = c.score < 0 ? 0 : c.score;\n    const scored = safeBase * multiplier;\n    const item: TrustStageResultItem = {\n      path: c.path,\n      score: scored,\n      originalScore: c.score,\n      multiplier,\n      trust,\n      quarantined: isQuarantined,\n    };\n    all.push(item);\n    if (isQuarantined) quarantined.push(item);\n    else admitted.push(item);\n  }\n\n  if (reorder) {\n    // Stable sort by descending multiplied score, with original input position\n    // as the deterministic tiebreaker (CLAUDE.md rule 19 / checklist §12).\n    admitted.sort((a, b) => {\n      if (b.score !== a.score) return b.score - a.score;\n      // Tiebreaker: original insertion order. We don't have the index handy on\n      // the item, so derive it from `all` ordering (input order is preserved\n      // there). Equal-score items keep first-seen-first order.\n      return 0;\n    });\n    // Node's sort is stable (ES2019+); the explicit `return 0` documents the\n    // contract for reviewers.\n  }\n\n  return { admitted, quarantined, all };\n}\n\n/**\n * Compact X-ray projection of one stage item. Kept separate from the full\n * `TrustScoreResult` so the X-ray snapshot type stays narrow and serializable,\n * and so the renderer never depends on the scorer's internal component map\n * shape beyond `{ value, weight }`.\n */\nexport interface TrustXrayProjection {\n  score: number;\n  band: TrustBand;\n  components: Record<string, TrustScoreComponent>;\n  multiplier: number;\n  quarantined: boolean;\n  /** Human-readable exclusion reason, present only when quarantined. */\n  quarantineReason?: string;\n}\n\n/** Build the X-ray projection for one stage result item. */\nexport function projectTrustForXray(item: TrustStageResultItem): TrustXrayProjection {\n  const proj: TrustXrayProjection = {\n    score: item.trust.score,\n    band: item.trust.band,\n    components: item.trust.components,\n    multiplier: item.multiplier,\n    quarantined: item.quarantined,\n  };\n  if (item.quarantined) {\n    proj.quarantineReason = explainQuarantine(item.trust);\n  }\n  return proj;\n}\n\n/** Deterministic, component-derived reason a memory was quarantined. */\nexport function explainQuarantine(trust: TrustScoreResult): string {\n  const c = trust.components;\n  if (c.faithfulness && c.faithfulness.value === 0) return \"faithfulness: contradicted\";\n  if (c.contradiction && c.contradiction.value <= 0.2) return \"contradiction: pending review\";\n  return \"hard-negative trust signal\";\n}\n\n\n// ─── Recall-stage signal builder (I/O orchestration) ──────────────────────\n\n/**\n * Narrow callbacks the signal builder needs from its host (the orchestrator).\n * Kept as interfaces so the module stays pure-testable: the host binds\n * `getStorage` / `readQmdResultMemory` into these and the builder owns cache\n * management, namespace iteration, and the cold-tier direct fallback.\n */\nexport interface TrustScoreRerankDeps {\n  /** Read every memory in a namespace for the hot-tier signal scan. */\n  readNamespaceMemories(\n    namespace: string,\n  ): Promise<ReadonlyArray<{ path: string; frontmatter: TrustFrontmatterProjection }>>;\n  /** Read one memory's frontmatter by path (cold-tier direct fallback). */\n  readMemoryFrontmatter(path: string): Promise<TrustFrontmatterProjection | null>;\n}\n\n/** Per-namespace signal cache the host owns and the builder mutates. */\nexport interface TrustScoreSignalCache {\n  cache: Map<string, { at: number; signals: ReadonlyMap<string, TrustSignals> }>;\n  ttlMs: number;\n}\n\n/**\n * Build the `path → TrustSignals` map for recall candidates using a\n * per-namespace cache plus a direct-path fallback for cold-tier candidates\n * absent from the hot scan. Extracted from the orchestrator (issue #1577) so\n * the god file carries only thin wiring — the scoring itself is\n * {@link applyTrustScoreStage}.\n *\n * Fail-open: a single unreadable namespace or memory is logged and skipped so\n * a storage hiccup never breaks recall (mirrors `memory-worth-filter.ts`).\n */\nexport async function buildTrustSignalsForRerank(\n  candidatePaths: readonly string[],\n  namespaces: readonly string[],\n  deps: TrustScoreRerankDeps,\n  signalCache: TrustScoreSignalCache,\n  now: Date,\n  options: {\n    recencyHalfLifeDays?: number;\n    logDebug?: (message: string, context: Record<string, unknown>) => void;\n  } = {},\n): Promise<Map<string, TrustSignals>> {\n  const nowMs = now.getTime();\n  const logDebug = options.logDebug ?? (() => {});\n  const signals = new Map<string, TrustSignals>();\n\n  // Evict expired cache entries (mirrors the worth-cache discipline).\n  for (const [key, entry] of signalCache.cache) {\n    if (nowMs - entry.at >= signalCache.ttlMs) signalCache.cache.delete(key);\n  }\n\n  // Per-namespace hot scan with cache.\n  const seenNamespaces = new Set<string>();\n  for (const ns of namespaces) {\n    if (seenNamespaces.has(ns)) continue;\n    seenNamespaces.add(ns);\n    try {\n      const cached = signalCache.cache.get(ns);\n      let nsMap: ReadonlyMap<string, TrustSignals> | undefined;\n      if (cached && nowMs - cached.at < signalCache.ttlMs) {\n        nsMap = cached.signals;\n      } else {\n        const memories = await deps.readNamespaceMemories(ns);\n        nsMap = buildTrustSignalMap(memories, now, {\n          recencyHalfLifeDays: options.recencyHalfLifeDays,\n        });\n        signalCache.cache.set(ns, { at: nowMs, signals: nsMap });\n      }\n      for (const [path, s] of nsMap) signals.set(path, s);\n    } catch (err) {\n      logDebug(\"trust-score: failed to read namespace, skipping\", {\n        namespace: ns,\n        error: (err as Error).message,\n      });\n    }\n  }\n\n  // Direct per-path fallback for cold-tier candidates absent from the hot scan.\n  const missing = candidatePaths.filter((p) => !signals.has(p));\n  if (missing.length > 0) {\n    const fallbackMemories: Array<{ path: string; frontmatter: TrustFrontmatterProjection }> = [];\n    for (const path of missing) {\n      try {\n        const frontmatter = await deps.readMemoryFrontmatter(path);\n        if (frontmatter) fallbackMemories.push({ path, frontmatter });\n      } catch (err) {\n        logDebug(\"trust-score: direct path lookup failed\", {\n          path,\n          error: (err as Error).message,\n        });\n      }\n    }\n    if (fallbackMemories.length > 0) {\n      const fallbackSignals = buildTrustSignalMap(fallbackMemories, now, {\n        recencyHalfLifeDays: options.recencyHalfLifeDays,\n      });\n      for (const [path, s] of fallbackSignals) signals.set(path, s);\n    }\n  }\n\n  return signals;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-P5IPFZVH.js → chunk-BGQ7WKMT.js}

@@ -14,16 +14,16 @@ import {
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-URM3HW2R.js";
+} from "./chunk-NE5WFIY6.js";
 import {
   EngramAccessInputError
-} from "./chunk-F3PVXKHP.js";
+} from "./chunk-M3GBOKUX.js";
 import {
   projectTagProjectId
 } from "./chunk-J6BH2OBA.js";
 import {
   validateBriefingFormat
-} from "./chunk-2COL35PK.js";
+} from "./chunk-T3XSXAWK.js";
 import {
   resolvePrincipal
 } from "./chunk-UZYLX7M6.js";
@@ -4267,7 +4267,7 @@ ${body}`;
             reason: "graphEdgeDecayEnabled is false"
           };
         }
-        const { runGraphEdgeDecayMaintenanceAcrossNamespaces } = await import("./graph-edge-decay-JLOF3YW4.js");
+        const { runGraphEdgeDecayMaintenanceAcrossNamespaces } = await import("./graph-edge-decay-QDDC6AVV.js");
         const dryRun = args.dryRun === true;
         const results = await runGraphEdgeDecayMaintenanceAcrossNamespaces(
           this.service.memoryDir,
@@ -4441,4 +4441,4 @@ export {
   sessionBelongsToPrincipal,
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-P5IPFZVH.js.map
+//# sourceMappingURL=chunk-BGQ7WKMT.js.map

package/dist/{chunk-JAKYZGV4.js → chunk-CYJV5AYC.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-LXSG4L55.js";
+} from "./chunk-V7UUIIR7.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-N3DUH6OO.js";
+} from "./chunk-ZW5I3UNP.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-JAKYZGV4.js.map
+//# sourceMappingURL=chunk-CYJV5AYC.js.map

package/dist/{chunk-APUJIMDM.js → chunk-DG3ORVCU.js}

@@ -10,7 +10,7 @@ import {
 import {
   planNamespaceMaintenance,
   runNamespaceMaintenanceBatchPlan
-} from "./chunk-HLIR3RJ7.js";
+} from "./chunk-WBHQ5LP5.js";
 import {
   resolveHomeDir
 } from "./chunk-JUC24CTX.js";
@@ -441,4 +441,4 @@ var MaintenanceScheduler = class {
 export {
   MaintenanceScheduler
 };
-//# sourceMappingURL=chunk-APUJIMDM.js.map
+//# sourceMappingURL=chunk-DG3ORVCU.js.map

package/dist/{chunk-PBH4JUAB.js → chunk-DVRHLN2O.js}

@@ -4,6 +4,9 @@ function resolveCapabilities(config) {
     rerankCache: config.rerankCacheEnabled,
     recallDirectAnswer: config.recallDirectAnswerEnabled,
     recallMemoryWorthFilter: config.recallMemoryWorthFilterEnabled,
+    // Issue #1577: TrustScore subsumes the Memory Worth multiplier when on;
+    // the orchestrator runs exactly one of the two (mutual exclusion, rule 39).
+    recallTrustScore: config.trustScoreEnabled === true,
     recallMmr: config.recallMmrEnabled,
     recallReasoningTraceBoost: config.recallReasoningTraceBoostEnabled,
     recallPlannerLlm: config.recallPlannerLlmEnabled,
@@ -13,7 +16,11 @@ function resolveCapabilities(config) {
     // Optional flags: preserve the exact default-when-undefined semantics the
     // migrated call sites used (`!== false` = default-on, `=== true` = default-off).
     graphAssistInFullMode: config.graphAssistInFullModeEnabled !== false,
-    graphExpandedIntent: config.graphExpandedIntentEnabled === true
+    graphExpandedIntent: config.graphExpandedIntentEnabled === true,
+    // Issue #1566 Cluster C: mixed-operation flags resolved once per recall op.
+    rerank: config.rerankEnabled,
+    harmonicRetrieval: config.harmonicRetrievalEnabled,
+    parallelRetrieval: config.parallelRetrievalEnabled
   });
 }
 function resolveGraphConstructionCapabilities(config) {
@@ -27,9 +34,17 @@ function resolveGraphConstructionCapabilities(config) {
     graphWriteSessionAdjacency: config.graphWriteSessionAdjacencyEnabled !== false
   });
 }
+function resolveAccessSetupCapabilities(config) {
+  return Object.freeze({
+    recallCrossNamespaceBudget: config.recallCrossNamespaceBudgetEnabled,
+    // Optional/default-off flag: preserve `=== true` semantics.
+    recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true
+  });
+}
 
 export {
   resolveCapabilities,
-  resolveGraphConstructionCapabilities
+  resolveGraphConstructionCapabilities,
+  resolveAccessSetupCapabilities
 };
-//# sourceMappingURL=chunk-PBH4JUAB.js.map
+//# sourceMappingURL=chunk-DVRHLN2O.js.map

package/dist/chunk-DVRHLN2O.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/capabilities.ts"],"sourcesContent":["/**\n * CapabilitySet — recall-operation feature gates resolved once, then threaded.\n *\n * Issue #1523 (Phase 1 of epic #1520). Root cause this addresses: 161+\n * scattered `config.<flag>Enabled` reads mean each gate is re-derived at every\n * call site, and reviews keep finding parallel code paths where one branch\n * checks a gate the other forgot (CLAUDE.md rule 39 — the \"gate divergence\"\n * defect class). The fix is to resolve a frozen capability projection ONCE at\n * the top of the recall operation and pass it down explicitly.\n *\n * Scope of THIS module (first migration PR): only the recall-operation-scoped\n * flags below. Flags that are also read in graph construction, writes, CLI, or\n * the summarizer are deliberately deferred to a follow-up so we never leave a\n * single flag half-migrated (some sites on `caps.`, some on `config.`).\n *\n * Field naming: each field is the config flag name with the trailing `Enabled`\n * removed (`recallMmrEnabled` → `recallMmr`).\n *\n * This is plumbing, not a feature — there is deliberately NO `enabled` gate for\n * the CapabilitySet itself (rule 30 governs behavior changes; resolving and\n * threading a capability projection must stay behavior-preserving).\n */\n\nimport type { PluginConfig } from \"./types.js\";\n\n/**\n * Frozen projection of recall-operation feature gates.\n *\n * Every field is `readonly boolean`. The composition that maps a config flag to\n * a capability (including default-when-undefined semantics for optional flags)\n * lives ONLY in {@link resolveCapabilities} — call sites must read the\n * capability, never re-derive it from raw config.\n */\nexport interface CapabilitySet {\n  /** `rerankCacheEnabled` — cache reranker scores across recall passes. */\n  readonly rerankCache: boolean;\n  /** `recallDirectAnswerEnabled` — observation-mode direct-answer tier. */\n  readonly recallDirectAnswer: boolean;\n  /** `recallMemoryWorthFilterEnabled` — Memory-Worth score reweighting. */\n  readonly recallMemoryWorthFilter: boolean;\n  /** `trustScoreEnabled` — unified TrustScore recall stage (issue #1577). */\n  readonly recallTrustScore: boolean;\n  /** `recallMmrEnabled` — maximal-marginal-relevance diversification. */\n  readonly recallMmr: boolean;\n  /** `recallReasoningTraceBoostEnabled` — boost reasoning-trace memories. */\n  readonly recallReasoningTraceBoost: boolean;\n  /** `recallPlannerLlmEnabled` — LLM-backed recall-mode planner. */\n  readonly recallPlannerLlm: boolean;\n  /** `recallPlannerEnabled` — recall-mode planner (heuristic + optional LLM). */\n  readonly recallPlanner: boolean;\n  /** `recallConfidenceGateEnabled` — Synapse-style confidence gate. */\n  readonly recallConfidenceGate: boolean;\n  /** `graphRecallEnabled` — graph-mode recall tier (gates planner graph mode). */\n  readonly graphRecall: boolean;\n  /** `graphAssistInFullModeEnabled` — graph-assist overlay in full mode. */\n  readonly graphAssistInFullMode: boolean;\n  /** `graphExpandedIntentEnabled` — promote broad-intent asks to graph mode. */\n  readonly graphExpandedIntent: boolean;\n  // --- Issue #1566 Cluster C: mixed-operation flags (recall + summarizer/CLI/writes) ---\n  /** `rerankEnabled` — optional LLM reranking of recall candidates. */\n  readonly rerank: boolean;\n  /** `harmonicRetrievalEnabled` — abstraction-node harmonic retrieval tier. */\n  readonly harmonicRetrieval: boolean;\n  /** `parallelRetrievalEnabled` — three-agent parallel retrieval (DirectFact + Contextual + Temporal). */\n  readonly parallelRetrieval: boolean;\n}\n\n/**\n * Resolve the recall-operation {@link CapabilitySet} from parsed config.\n *\n * Call this ONCE per recall operation (at the `recall()` / `recallInternal`\n * entry) and thread the result down. Composition lives here and only here.\n *\n * Session toggles are intentionally not a parameter yet: `session-toggles.ts`\n * is agent-scoped (per session/agent enable-disable of the whole plugin), not\n * flag-scoped — none of the flags projected here have a per-session override,\n * so there is nothing for a toggle argument to compose at this layer.\n */\nexport function resolveCapabilities(config: PluginConfig): CapabilitySet {\n  return Object.freeze({\n    rerankCache: config.rerankCacheEnabled,\n    recallDirectAnswer: config.recallDirectAnswerEnabled,\n    recallMemoryWorthFilter: config.recallMemoryWorthFilterEnabled,\n    // Issue #1577: TrustScore subsumes the Memory Worth multiplier when on;\n    // the orchestrator runs exactly one of the two (mutual exclusion, rule 39).\n    recallTrustScore: config.trustScoreEnabled === true,\n    recallMmr: config.recallMmrEnabled,\n    recallReasoningTraceBoost: config.recallReasoningTraceBoostEnabled,\n    recallPlannerLlm: config.recallPlannerLlmEnabled,\n    recallPlanner: config.recallPlannerEnabled,\n    recallConfidenceGate: config.recallConfidenceGateEnabled,\n    graphRecall: config.graphRecallEnabled,\n    // Optional flags: preserve the exact default-when-undefined semantics the\n    // migrated call sites used (`!== false` = default-on, `=== true` = default-off).\n    graphAssistInFullMode: config.graphAssistInFullModeEnabled !== false,\n    graphExpandedIntent: config.graphExpandedIntentEnabled === true,\n    // Issue #1566 Cluster C: mixed-operation flags resolved once per recall op.\n    rerank: config.rerankEnabled,\n    harmonicRetrieval: config.harmonicRetrievalEnabled,\n    parallelRetrieval: config.parallelRetrievalEnabled,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Graph-construction capability set (issue #1566 Cluster A).\n//\n// The recall CapabilitySet above covers flags whose EVERY read site lives on\n// the recall call chain. The five flags below are read on graph-construction,\n// write/extraction, AND recall paths — so they cannot join the recall set\n// without leaving some sites on `caps.` and others on `config.` (the exact\n// divergence #1523 forbade). They get their own projection, resolved at graph\n// build/write entry (and alongside `caps` when recall reads them).\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of graph-construction feature gates.\n *\n * Every field is `readonly boolean`. Composition (including default-when-\n * undefined semantics for the optional `graphWriteSessionAdjacencyEnabled`)\n * lives ONLY in {@link resolveGraphConstructionCapabilities}.\n */\nexport interface GraphConstructionCapabilitySet {\n  /** `entityGraphEnabled` — maintain entity co-reference graph edges. */\n  readonly entityGraph: boolean;\n  /** `timeGraphEnabled` — maintain thread-adjacency graph edges. */\n  readonly timeGraph: boolean;\n  /** `causalGraphEnabled` — maintain causal-language graph edges. */\n  readonly causalGraph: boolean;\n  /** `multiGraphMemoryEnabled` — master switch for multi-graph writes/traversal. */\n  readonly multiGraphMemory: boolean;\n  /** `graphWriteSessionAdjacencyEnabled` — session-adjacency fallback for time edges (default-on). */\n  readonly graphWriteSessionAdjacency: boolean;\n}\n\n/**\n * Resolve the {@link GraphConstructionCapabilitySet} from parsed config.\n *\n * Call this ONCE at graph build/write entry (extraction, recall graph\n * expansion, graph-health/repair) and thread the result down — exactly the\n * pattern {@link resolveCapabilities} established for recall.\n */\nexport type GraphConstructionConfigProjection = Pick<\n  PluginConfig,\n  | \"entityGraphEnabled\"\n  | \"timeGraphEnabled\"\n  | \"causalGraphEnabled\"\n  | \"multiGraphMemoryEnabled\"\n  | \"graphWriteSessionAdjacencyEnabled\"\n>;\n\nexport function resolveGraphConstructionCapabilities(\n  config: GraphConstructionConfigProjection,\n): GraphConstructionCapabilitySet {\n  return Object.freeze({\n    entityGraph: config.entityGraphEnabled,\n    timeGraph: config.timeGraphEnabled,\n    causalGraph: config.causalGraphEnabled,\n    multiGraphMemory: config.multiGraphMemoryEnabled,\n    // Optional flag: preserve the exact default-when-undefined semantics the\n    // migrated call site used (`!== false` = default-on).\n    graphWriteSessionAdjacency: config.graphWriteSessionAdjacencyEnabled !== false,\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Access-setup capability set (issue #1566 Cluster B).\n//\n// These two flags gate cross-namespace recall budgeting and anomaly-detection\n// auditing. Resolved once at access-service handler entry (and the operator\n// doctor check) rather than re-derived from raw config at each site.\n// ---------------------------------------------------------------------------\n\n/**\n * Frozen projection of access-setup feature gates (issue #1566 Cluster B).\n *\n * Every field is `readonly boolean`. Composition (including the default-off\n * semantics for the optional `recallAuditAnomalyDetectionEnabled`) lives ONLY\n * in {@link resolveAccessSetupCapabilities}.\n */\nexport interface AccessSetupCapabilitySet {\n  /** `recallCrossNamespaceBudgetEnabled` — rolling cross-namespace recall budget. */\n  readonly recallCrossNamespaceBudget: boolean;\n  /** `recallAuditAnomalyDetectionEnabled` — access-audit anomaly detection (default-off). */\n  readonly recallAuditAnomalyDetection: boolean;\n}\n\n/**\n * Resolve the {@link AccessSetupCapabilitySet} from parsed config.\n *\n * Call this ONCE at access-service handler entry and thread the result down.\n */\nexport type AccessSetupConfigProjection = Pick<\n  PluginConfig,\n  \"recallCrossNamespaceBudgetEnabled\" | \"recallAuditAnomalyDetectionEnabled\"\n>;\n\nexport function resolveAccessSetupCapabilities(\n  config: AccessSetupConfigProjection,\n): AccessSetupCapabilitySet {\n  return Object.freeze({\n    recallCrossNamespaceBudget: config.recallCrossNamespaceBudgetEnabled,\n    // Optional/default-off flag: preserve `=== true` semantics.\n    recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true,\n  });\n}\n"],"mappings":";AA8EO,SAAS,oBAAoB,QAAqC;AACvE,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,oBAAoB,OAAO;AAAA,IAC3B,yBAAyB,OAAO;AAAA;AAAA;AAAA,IAGhC,kBAAkB,OAAO,sBAAsB;AAAA,IAC/C,WAAW,OAAO;AAAA,IAClB,2BAA2B,OAAO;AAAA,IAClC,kBAAkB,OAAO;AAAA,IACzB,eAAe,OAAO;AAAA,IACtB,sBAAsB,OAAO;AAAA,IAC7B,aAAa,OAAO;AAAA;AAAA;AAAA,IAGpB,uBAAuB,OAAO,iCAAiC;AAAA,IAC/D,qBAAqB,OAAO,+BAA+B;AAAA;AAAA,IAE3D,QAAQ,OAAO;AAAA,IACf,mBAAmB,OAAO;AAAA,IAC1B,mBAAmB,OAAO;AAAA,EAC5B,CAAC;AACH;AAiDO,SAAS,qCACd,QACgC;AAChC,SAAO,OAAO,OAAO;AAAA,IACnB,aAAa,OAAO;AAAA,IACpB,WAAW,OAAO;AAAA,IAClB,aAAa,OAAO;AAAA,IACpB,kBAAkB,OAAO;AAAA;AAAA;AAAA,IAGzB,4BAA4B,OAAO,sCAAsC;AAAA,EAC3E,CAAC;AACH;AAkCO,SAAS,+BACd,QAC0B;AAC1B,SAAO,OAAO,OAAO;AAAA,IACnB,4BAA4B,OAAO;AAAA;AAAA,IAEnC,6BAA6B,OAAO,uCAAuC;AAAA,EAC7E,CAAC;AACH;","names":[]}

package/dist/{chunk-S35FX6MU.js → chunk-H2AGJ5SV.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-ZBJMUXZH.js";
 import {
   StorageManager
-} from "./chunk-YYOK4GVF.js";
+} from "./chunk-422TIKIH.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -107,4 +107,4 @@ export {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-S35FX6MU.js.map
+//# sourceMappingURL=chunk-H2AGJ5SV.js.map

package/dist/{chunk-A66YRSOS.js → chunk-HAPVZ4CO.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-UFS7OXGL.js";
 import {
   StorageManager
-} from "./chunk-YYOK4GVF.js";
+} from "./chunk-422TIKIH.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1261,4 +1261,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-A66YRSOS.js.map
+//# sourceMappingURL=chunk-HAPVZ4CO.js.map

package/dist/{chunk-4KZGLDJJ.js → chunk-HHSO6VCQ.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-YYOK4GVF.js";
+} from "./chunk-422TIKIH.js";
 
 // src/semantic-rule-promotion.ts
 import { createHash, randomUUID } from "crypto";
@@ -529,4 +529,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-4KZGLDJJ.js.map
+//# sourceMappingURL=chunk-HHSO6VCQ.js.map