@remnic/core 10.0.37 → 10.0.39

package/dist/chunk-TJ5YGCPV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-judge.ts"],"sourcesContent":["/**\n * Extraction Judge — LLM-as-judge fact-worthiness gate (issue #376).\n *\n * Evaluates extracted facts against a durability rubric before they are\n * persisted. Facts that are unlikely to be useful 30+ days from now or\n * across sessions are rejected (or shadow-logged depending on config).\n *\n * Design constraints:\n *   - Corrections and principles are auto-approved (safety bypass).\n *   - Critical-importance facts are auto-approved.\n *   - Batches respect extractionJudgeBatchSize.\n *   - Content-hash caching avoids redundant LLM calls.\n *   - LLM calls use extractionJudgeTimeoutMs (default 20s: measured 2.1-2.5 s\n *     per compact verdict request with a batch-scaled completion budget on a\n *     small fast judge model; 13-22 s per compact call, 41 s verbose, on the\n *     big shared core model — raise it there; the old 150s default only\n *     papered over 59-305s verbose replies).\n */\n\nimport { createHash } from \"node:crypto\";\nimport { log } from \"./logger.js\";\nimport type { PluginConfig, ImportanceLevel } from \"./types.js\";\nimport type { LocalLlmClient } from \"./local-llm.js\";\nimport { type FallbackLlmClient, gatewayTaskChainOptions } from \"./fallback-llm.js\";\nimport { extractJsonCandidates } from \"./json-extract.js\";\nimport { normalizeProcedureSteps } from \"./procedural/procedure-types.js\";\nimport { OUTPUT_LANGUAGE_POLICY } from \"./extraction-prompt.js\";\n\n// ---------------------------------------------------------------------------\n// Public interfaces\n// ---------------------------------------------------------------------------\n\nexport interface JudgeCandidate {\n  text: string;\n  category: string;\n  confidence: number;\n  tags?: string[];\n  /** Local importance level, set by caller before judging. */\n  importanceLevel?: ImportanceLevel;\n}\n\n/**\n * Verdict kinds (issue #562, PR 1).\n *\n * - `\"accept\"`: fact is durable, persist it.\n * - `\"reject\"`: fact is not durable, drop it.\n * - `\"defer\"`: fact is ambiguous; push it back into the buffer for another\n *   pass with fresh context. Inspired by MemReader (arxiv 2604.07877).\n *\n * PR 1 only introduces the type. No emit path produces `\"defer\"` yet — the\n * defer-capable prompt, buffer re-routing, telemetry, and GRPO data\n * collection are landing in PRs 2, 3, and 4 respectively.\n */\nexport type JudgeVerdictKind = \"accept\" | \"reject\" | \"defer\";\n\n/**\n * Judge verdict shape.\n *\n * Back-compat note: `kind` is optional. Verdicts serialized before PR 1\n * (both in-memory cache entries and any persisted caches) only carry\n * `{ durable, reason }`. Downstream consumers must either read `durable`\n * directly, or use {@link getVerdictKind} / {@link isDurableVerdict} which\n * gracefully fall back to the boolean when `kind` is missing, and ignore\n * unknown future `kind` values rather than crashing.\n */\nexport interface JudgeVerdict {\n  /**\n   * True iff the fact should be persisted. For `\"defer\"` verdicts this is\n   * `false` — a deferred fact is not (yet) persisted, so callers that only\n   * look at `durable` will treat defer as \"skip this turn\", which matches\n   * the pre-PR-1 fail-closed behavior for non-accepted verdicts.\n   */\n  durable: boolean;\n  reason: string;\n  /**\n   * Optional explicit verdict kind. Added in PR 1 of issue #562. Legacy\n   * verdicts (including cache entries produced before this field existed)\n   * do not set `kind`; use {@link getVerdictKind} to read this safely.\n   */\n  kind?: JudgeVerdictKind;\n}\n\n/**\n * Resolve a verdict's effective kind.\n *\n * - If `kind` is explicitly set to one of the known values, return it.\n * - If `kind` is absent, infer from `durable` (back-compat with pre-PR-1\n *   cache entries and emit paths that have not been updated yet).\n * - If `kind` is set to an unrecognised value (forward-compat, e.g. a\n *   future cache entry loaded by an older build), fall back to `durable`\n *   so we never crash on unknown strings.\n */\nexport function getVerdictKind(verdict: JudgeVerdict): JudgeVerdictKind {\n  const raw = verdict.kind;\n  if (raw === \"accept\" || raw === \"reject\" || raw === \"defer\") {\n    return raw;\n  }\n  return verdict.durable ? \"accept\" : \"reject\";\n}\n\n/**\n * Type guard: returns `true` only for verdicts that should be persisted.\n * Treats both `\"reject\"` and `\"defer\"` as \"not durable\" — defer means the\n * caller should re-evaluate later, not write now.\n */\nexport function isDurableVerdict(verdict: JudgeVerdict): boolean {\n  return getVerdictKind(verdict) === \"accept\";\n}\n\n/**\n * Validate a cache entry loaded from persistence / another process.\n *\n * Strict: accepts legacy `{ durable, reason }` entries and new entries\n * whose `kind` is one of the three known `JudgeVerdictKind` values.\n * Rejects structurally wrong types and unknown `kind` strings so the\n * type-guard narrowing is sound — callers that receive\n * `value is JudgeVerdict` can safely treat `kind` as the declared\n * union.\n *\n * Forward-compat is handled by {@link normalizeCachedVerdict}, which\n * drops unknown `kind` strings before validation so a newer build's\n * cache entry still loads instead of being rejected.\n */\nexport function isValidCachedVerdict(value: unknown): value is JudgeVerdict {\n  if (typeof value !== \"object\" || value === null) return false;\n  const v = value as Record<string, unknown>;\n  if (typeof v.durable !== \"boolean\") return false;\n  if (typeof v.reason !== \"string\") return false;\n  if (v.kind !== undefined) {\n    if (v.kind !== \"accept\" && v.kind !== \"reject\" && v.kind !== \"defer\") {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Forward-compatible cache-entry loader.\n *\n * Drops unknown `kind` strings to `undefined` (so `getVerdictKind` can\n * fall back to `durable`), then validates structurally. Non-string\n * `kind` values are still treated as structural violations and rejected.\n * Returns the sanitised verdict, or `null` when the entry is structurally\n * unusable.\n */\nexport function normalizeCachedVerdict(value: unknown): JudgeVerdict | null {\n  if (typeof value !== \"object\" || value === null) return null;\n  const v = value as Record<string, unknown>;\n  if (typeof v.durable !== \"boolean\") return null;\n  if (typeof v.reason !== \"string\") return null;\n  let kind: JudgeVerdictKind | undefined;\n  if (v.kind !== undefined) {\n    if (typeof v.kind !== \"string\") return null;\n    if (v.kind === \"accept\" || v.kind === \"reject\" || v.kind === \"defer\") {\n      kind = v.kind;\n    }\n    // Unknown string `kind`: dropped to undefined for forward-compat.\n  }\n  const out: JudgeVerdict = { durable: v.durable, reason: v.reason };\n  if (kind !== undefined) out.kind = kind;\n  return out;\n}\n\nexport interface JudgeBatchResult {\n  verdicts: Map<number, JudgeVerdict>;\n  /** Number of verdicts served from cache. */\n  cached: number;\n  /** Number of verdicts produced by an LLM call. */\n  judged: number;\n  /** Total wall-clock time in milliseconds. */\n  elapsed: number;\n  /**\n   * Number of verdicts in this batch that resolved to `\"defer\"` (issue #562,\n   * PR 2). Callers can use this to decide whether to retain buffer turns for\n   * the next extraction pass.\n   */\n  deferred: number;\n  /**\n   * Number of defers that were forcibly converted to `\"reject\"` because the\n   * same candidate text had already been deferred at least\n   * `extractionJudgeMaxDeferrals` times. Rolled out of `deferred` — a\n   * candidate counted here is *not* also in `deferred`.\n   */\n  deferredCappedToReject: number;\n}\n\n/**\n * Per-verdict observation emitted by `judgeFactDurability` when an\n * `onVerdict` callback is supplied (issue #562, PR 3). Used to wire the\n * observation ledger / telemetry stream without coupling the judge module\n * directly to filesystem I/O. One event is emitted for every resolved\n * verdict, including auto-approved and cache-hit paths.\n */\nexport interface JudgeVerdictObservation {\n  verdict: JudgeVerdict;\n  /** The original `JudgeCandidate` passed in (same reference). */\n  candidate: JudgeCandidate;\n  /** SHA-256 of `text\\0category`, same key the cache/deferCounter use. */\n  contentHash: string;\n  /** Verdict resolution path. Useful for debugging + dashboards. */\n  source: \"auto-approve\" | \"cache\" | \"llm\" | \"llm-cap-rejected\" | \"fail-open\";\n  /**\n   * How many times this candidate had already been deferred before this\n   * verdict resolved. 0 when the candidate had never been deferred.\n   */\n  priorDeferrals: number;\n  /**\n   * Milliseconds from batch start to now. Shared across verdicts emitted in\n   * the same batch.\n   */\n  elapsedMs: number;\n}\n\n// ---------------------------------------------------------------------------\n// Prompt (embedded; mirrors prompts/extraction_judge.prompt.md)\n// ---------------------------------------------------------------------------\n\nexport const JUDGE_SYSTEM_PROMPT = `You are a memory curator evaluating whether extracted facts are **durable** — worth storing for long-term recall across sessions.\n\nA fact is **durable** if it will still be useful 30+ days from now and is relevant across multiple sessions, not just the current task.\n\nThe user message is a JSON array of candidates: [{\"index\": 0, \"text\": \"...\", \"category\": \"...\", \"confidence\": 0.5}, ...].\n\nVerdicts:\n- \"accept\" — durable. Personal preferences, identities, relationships; decisions with rationale that affect future work; corrections to previously held beliefs; principles, rules, or constraints the user wants respected; stable facts about projects, tools, or workflows; commitments, deadlines, or obligations.\n- \"reject\" — not durable. Transient task details (\"currently debugging line 42\"); ephemeral state (\"the build is running now\"); routine operations (\"ran npm install\"); conversational filler; anything stale within hours; step-by-step instructions for a one-time task.\n- \"defer\" — MIGHT be durable but the candidate alone cannot say: ambiguous referents (\"he said they'd follow up\"), in-progress statements that may become durable once completed, future commitments with unclear subject or timeline. Defer is NOT a soft reject: use it only when another turn of context would genuinely change the verdict; when torn between accept and reject, lean accept — losing a useful fact is worse than keeping a marginal one.\n\nReply with a JSON object with a single \"verdicts\" key, exactly one object per input candidate:\n{\"verdicts\": [{\"index\": <candidate index>, \"kind\": \"accept\" | \"reject\" | \"defer\"}]}\n\nRules:\n1. The top level must be one object {\"verdicts\": [...]} — JSON mode rejects a bare top-level array.\n2. Copy each object's \"index\" from the input candidate. One object per candidate, exactly.\n3. No other fields — no \"reason\", no \"durable\", no commentary.\n4. Output valid JSON only. No markdown fences.\n5. ${OUTPUT_LANGUAGE_POLICY}\n\nExample output:\n{\"verdicts\": [{\"index\": 0, \"kind\": \"accept\"}, {\"index\": 1, \"kind\": \"reject\"}, {\"index\": 2, \"kind\": \"defer\"}]}`;\n\n// ---------------------------------------------------------------------------\n// Judge request assembly (PR 3264 follow-up)\n// ---------------------------------------------------------------------------\n\n/** Completion tokens reserved per candidate verdict (measured 13 on a small judge model). */\nconst JUDGE_TOKENS_PER_CANDIDATE = 24;\n/** Ceiling on one judge reply: the old flat budget. */\nexport const MAX_JUDGE_TOKENS = 2048;\n/**\n * Extra completion tokens for a judge call routed through the Responses API. Reasoning tokens count against\n * `max_output_tokens`, so the compact verdict budget alone can be spent before a reasoning-enabled model answers; the\n * unparsed batch would then fail open as durable. A cap, not a target: a non-reasoning model still writes a short reply.\n */\nexport const JUDGE_REASONING_HEADROOM_TOKENS = 1024;\n/** Largest batch whose verdict array fits MAX_JUDGE_TOKENS; a larger configured batch is split. */\nexport const MAX_JUDGE_BATCH = Math.floor(MAX_JUDGE_TOKENS / JUDGE_TOKENS_PER_CANDIDATE);\n\n/**\n * Compact completion budget for one judge call. A verdict is\n * `{\"index\":12,\"kind\":\"reject\"}` (~14 tokens), so the old flat 2048 only gave\n * a slow model room to produce 59-305s replies that hid inside the timeout.\n * Scales with the batch size (about 24 tokens per candidate verdict, measured\n * 13 per verdict on a small judge model) so a large batch is never truncated;\n * capped at 2048, the old flat budget.\n */\nexport function judgeMaxTokens(batchSize: number): number {\n  return Math.min(MAX_JUDGE_TOKENS, Math.max(64, batchSize * JUDGE_TOKENS_PER_CANDIDATE));\n}\n\n/** One indexed candidate entry in a judge request payload. */\nexport interface JudgeRequestEntry {\n  index: number;\n  text: string;\n  category: string;\n  confidence: number;\n}\n\n/** Full judge LLM request: messages plus the completion budget. */\nexport interface JudgeRequest {\n  messages: Array<{ role: \"system\" | \"user\"; content: string }>;\n  maxTokens: number;\n}\n\n/** Build a full judge request body: messages plus the completion budget. */\nexport function buildJudgeRequest(entries: readonly JudgeRequestEntry[]): JudgeRequest {\n  return {\n    messages: [\n      { role: \"system\", content: JUDGE_SYSTEM_PROMPT },\n      { role: \"user\", content: JSON.stringify(entries) },\n    ],\n    maxTokens: judgeMaxTokens(entries.length),\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Content-hash cache (in-memory, per-process fallback)\n// ---------------------------------------------------------------------------\n\n/** Maximum entries before evicting the oldest half. */\nconst VERDICT_CACHE_MAX_SIZE = 10_000;\n\n/** Module-level fallback cache, used when callers do not pass their own. */\nconst defaultVerdictCache = new Map<string, JudgeVerdict>();\n\n/**\n * Per-content-hash deferral counter (issue #562, PR 2).\n *\n * When the judge emits a `\"defer\"` verdict for a candidate whose content\n * has already been deferred `extractionJudgeMaxDeferrals` times, the verdict\n * is forcibly converted to `\"reject\"` so a pathological LLM response cannot\n * produce an infinite defer loop.\n *\n * Module-level with a size cap so stale test state cannot leak between runs\n * in the unlikely case a caller does not clear it between processes.\n */\nconst defaultDeferCounts = new Map<string, number>();\nconst DEFER_COUNT_MAX_SIZE = 20_000;\n\nfunction cacheKey(text: string, category: string): string {\n  return createHash(\"sha256\").update(`${text}\\0${category}`).digest(\"hex\");\n}\n\n/**\n * Resolve the effective defer cap from config, defaulting to 2 when the\n * config value is missing or non-positive. Matches the PR 2 spec.\n */\nfunction resolveDeferCap(config: PluginConfig): number {\n  const raw = (config as { extractionJudgeMaxDeferrals?: number })\n    .extractionJudgeMaxDeferrals;\n  if (typeof raw === \"number\" && Number.isFinite(raw) && raw >= 1) {\n    return Math.floor(raw);\n  }\n  return 2;\n}\n\n/**\n * Enforce the max-size invariant on a verdict cache. When the cache exceeds\n * VERDICT_CACHE_MAX_SIZE, the oldest half of entries are deleted (Map\n * iteration order is insertion order).\n */\nfunction enforceMaxCacheSize(cache: Map<string, JudgeVerdict>): void {\n  if (cache.size <= VERDICT_CACHE_MAX_SIZE) return;\n  const deleteCount = Math.floor(cache.size / 2);\n  let deleted = 0;\n  for (const key of cache.keys()) {\n    if (deleted >= deleteCount) break;\n    cache.delete(key);\n    deleted++;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Categories that bypass the judge (safety / correctness)\n// ---------------------------------------------------------------------------\n\nconst AUTO_APPROVE_CATEGORIES = new Set([\"correction\", \"principle\"]);\n\n/** Explicit trigger phrasing — procedures must match to persist (issue #519). */\nconst PROCEDURE_TRIGGER_RE =\n  /(when you|whenever|before you|before running|always\\s|first\\b.*\\bthen|to deploy|to ship|run these steps|follow these steps|how (i|we)\\s|recipe for|workflow|each time you)/i;\n\n/**\n * Deterministic gate for extracted `procedure` memories: ≥2 steps with non-empty\n * intents and explicit trigger wording in title and/or steps.\n */\nexport function validateProcedureExtraction(input: {\n  content: string;\n  procedureSteps?: unknown;\n}): JudgeVerdict {\n  const steps = normalizeProcedureSteps(input.procedureSteps);\n  if (steps.length < 2) {\n    return { durable: false, reason: \"Procedure requires at least two steps with intents\" };\n  }\n  const combined = [input.content, ...steps.map((s) => s.intent)].join(\" \").toLowerCase();\n  if (!PROCEDURE_TRIGGER_RE.test(combined)) {\n    return { durable: false, reason: \"Procedure missing explicit trigger phrasing\" };\n  }\n  return { durable: true, reason: \"Procedure structure validated\" };\n}\n\n// ---------------------------------------------------------------------------\n// Core judge function\n// ---------------------------------------------------------------------------\n\n/**\n * Evaluate a batch of candidate facts for durability.\n *\n * Auto-approves corrections, principles, and critical-importance facts.\n * Remaining candidates are batched (up to extractionJudgeBatchSize),\n * checked against an in-memory content-hash cache, and sent to the LLM\n * for verdict.\n */\nexport async function judgeFactDurability(\n  candidates: JudgeCandidate[],\n  config: PluginConfig,\n  localLlm: LocalLlmClient | null,\n  fallbackLlm: FallbackLlmClient | null,\n  cache?: Map<string, JudgeVerdict>,\n  deferCounts?: Map<string, number>,\n  onVerdict?: (observation: JudgeVerdictObservation) => void,\n): Promise<JudgeBatchResult> {\n  const startMs = Date.now();\n  const verdicts = new Map<number, JudgeVerdict>();\n  let cached = 0;\n  let judged = 0;\n  let deferred = 0;\n  let deferredCappedToReject = 0;\n\n  // Use caller-provided cache for per-orchestrator scoping, or fall back\n  // to the module-level default cache.\n  const verdictCache = cache ?? defaultVerdictCache;\n  const deferCountMap = deferCounts ?? defaultDeferCounts;\n  const deferCap = resolveDeferCap(config);\n\n  // Lazy emit (Codex P2): when `onVerdict` is undefined (default path —\n  // telemetry off), payload construction is skipped entirely. Callers\n  // pass a factory instead of a pre-built observation so the `sha256`\n  // `contentHash` and surrounding object allocation only run when a\n  // subscriber is present. For large batches with telemetry off this\n  // removes per-verdict overhead that would otherwise fire on every\n  // auto-approved / cache / fail-open path.\n  const emit = (build: () => JudgeVerdictObservation): void => {\n    if (!onVerdict) return;\n    let observation: JudgeVerdictObservation;\n    try {\n      observation = build();\n    } catch (err) {\n      log.debug(\n        `extraction-judge: onVerdict builder threw (non-fatal): ${err instanceof Error ? err.message : String(err)}`,\n      );\n      return;\n    }\n    try {\n      onVerdict(observation);\n    } catch (err) {\n      // Fail-open: telemetry errors must never block extraction.\n      log.debug(\n        `extraction-judge: onVerdict callback threw (non-fatal): ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n  };\n\n  if (candidates.length === 0) {\n    return {\n      verdicts,\n      cached,\n      judged,\n      elapsed: 0,\n      deferred,\n      deferredCappedToReject,\n    };\n  }\n\n  // Indices that need LLM judgment\n  const pendingIndices: number[] = [];\n\n  for (let i = 0; i < candidates.length; i++) {\n    const c = candidates[i];\n\n    // Auto-approve safety categories\n    if (AUTO_APPROVE_CATEGORIES.has(c.category)) {\n      const v: JudgeVerdict = {\n        durable: true,\n        reason: `Auto-approved: ${c.category} category bypasses judge`,\n      };\n      verdicts.set(i, v);\n      emit(() => ({\n        verdict: v,\n        candidate: c,\n        contentHash: cacheKey(c.text, c.category),\n        source: \"auto-approve\",\n        priorDeferrals: 0,\n        elapsedMs: Date.now() - startMs,\n      }));\n      continue;\n    }\n\n    // Auto-approve critical importance\n    if (c.importanceLevel === \"critical\") {\n      const v: JudgeVerdict = {\n        durable: true,\n        reason: \"Auto-approved: critical importance\",\n      };\n      verdicts.set(i, v);\n      emit(() => ({\n        verdict: v,\n        candidate: c,\n        contentHash: cacheKey(c.text, c.category),\n        source: \"auto-approve\",\n        priorDeferrals: 0,\n        elapsedMs: Date.now() - startMs,\n      }));\n      continue;\n    }\n\n    // Check cache\n    const key = cacheKey(c.text, c.category);\n    const cachedVerdict = verdictCache.get(key);\n    if (cachedVerdict) {\n      verdicts.set(i, cachedVerdict);\n      cached++;\n      emit(() => ({\n        verdict: cachedVerdict,\n        candidate: c,\n        contentHash: key,\n        source: \"cache\",\n        priorDeferrals: deferCountMap.get(key) ?? 0,\n        elapsedMs: Date.now() - startMs,\n      }));\n      continue;\n    }\n\n    pendingIndices.push(i);\n  }\n\n  // If all resolved without LLM, return early\n  if (pendingIndices.length === 0) {\n    return {\n      verdicts,\n      cached,\n      judged,\n      elapsed: Date.now() - startMs,\n      deferred,\n      deferredCappedToReject,\n    };\n  }\n\n  // Batch the pending candidates up to batchSize\n  const batchSize = Math.min(config.extractionJudgeBatchSize, MAX_JUDGE_BATCH);\n  // Defer bookkeeping spans the WHOLE call, not one batch: identical candidates can land in different batches, and each key\n  // must advance the defer cap once and decide against the same prior count (the snapshot taken at its first sighting).\n  const deferredThisCall = new Set<string>();\n  const priorDefersSeen = new Map<string, number>();\n  for (let batchStart = 0; batchStart < pendingIndices.length; batchStart += batchSize) {\n    const batchIndices = pendingIndices.slice(batchStart, batchStart + batchSize);\n    const request = buildJudgeRequest(\n      batchIndices.map((idx) => ({\n        index: idx,\n        text: candidates[idx].text,\n        category: candidates[idx].category,\n        confidence: candidates[idx].confidence,\n      })),\n    );\n\n    try {\n      const llmResponse = await callJudgeLlm(request, config, localLlm, fallbackLlm);\n\n      if (llmResponse) {\n        const parsed = parseJudgeResponse(llmResponse, batchIndices);\n        // Per-call defer-increment dedupe (codex P2): a single extraction\n        // pass must not advance the cap more than once for identical\n        // candidate content, even if the same text appears several times in\n        // one LLM response or in different batches of one call. Duplicate\n        // hits share the first sighting's `priorDeferrals` snapshot.\n        for (const [idx, rawVerdict] of parsed.entries()) {\n          const c = candidates[idx];\n          const key = cacheKey(c.text, c.category);\n          let verdict = rawVerdict;\n          let source: JudgeVerdictObservation[\"source\"] = \"llm\";\n          if (!priorDefersSeen.has(key)) priorDefersSeen.set(key, deferCountMap.get(key) ?? 0);\n          const priorDefers = priorDefersSeen.get(key) ?? 0;\n\n          // Defer cap (issue #562, PR 2). A candidate that has already been\n          // deferred `deferCap` times is forcibly rejected so a pathological\n          // LLM response cannot produce an infinite defer loop.\n          if (getVerdictKind(verdict) === \"defer\") {\n            if (priorDefers >= deferCap) {\n              verdict = {\n                durable: false,\n                reason: `Defer cap reached (${deferCap} prior defers); rejecting`,\n                kind: \"reject\",\n              };\n              source = \"llm-cap-rejected\";\n              // Only clear + count the cap conversion once per batch for\n              // this key — duplicates in the same response all resolve to\n              // reject but should not inflate the cap-rejection counter.\n              if (!deferredThisCall.has(key)) {\n                deferCountMap.delete(key);\n                deferredCappedToReject++;\n                deferredThisCall.add(key);\n              }\n            } else if (!deferredThisCall.has(key)) {\n              deferCountMap.set(key, priorDefers + 1);\n              deferred++;\n              deferredThisCall.add(key);\n              // Bound the per-process defer-counter map.\n              if (deferCountMap.size > DEFER_COUNT_MAX_SIZE) {\n                const drop = Math.floor(deferCountMap.size / 2);\n                let dropped = 0;\n                for (const k of deferCountMap.keys()) {\n                  if (dropped >= drop) break;\n                  deferCountMap.delete(k);\n                  dropped++;\n                }\n              }\n            }\n            // else: duplicate defer for a key already counted this call —\n            // no additional counter increment, verdict still marked defer.\n          } else {\n            // On accept/reject, clear any outstanding defer counter so a\n            // future reappearance of the same text starts fresh.\n            deferCountMap.delete(key);\n            priorDefersSeen.set(key, 0);\n            deferredThisCall.delete(key);\n          }\n\n          verdicts.set(idx, verdict);\n          judged++;\n          // Cache non-defer verdicts. Defer is intentionally NOT cached:\n          // caching it would short-circuit the re-evaluation pass that is\n          // the entire point of the defer verdict.\n          if (getVerdictKind(verdict) !== \"defer\") {\n            verdictCache.set(key, verdict);\n          }\n          emit(() => ({\n            verdict,\n            candidate: c,\n            contentHash: key,\n            source,\n            priorDeferrals: priorDefers,\n            elapsedMs: Date.now() - startMs,\n          }));\n        }\n        // Evict oldest entries if cache exceeds max size\n        enforceMaxCacheSize(verdictCache);\n      }\n    } catch (err) {\n      // Fail-open: if the LLM call fails, approve all candidates in this batch\n      log.warn(\n        `extraction-judge: LLM call failed, approving batch (fail-open): ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n\n    // Fill in any missing verdicts from this batch (fail-open: approve).\n    // Clear defer counts so a transient outage doesn't leave stale state\n    // that causes later defers to hit the cap early.\n    for (const idx of batchIndices) {\n      if (!verdicts.has(idx)) {\n        const c = candidates[idx];\n        const hash = cacheKey(c.text, c.category);\n        // Capture the prior deferral count BEFORE clearing so the\n        // telemetry event reflects the true state rather than always 0.\n        const priorDefers = deferCountMap.get(hash) ?? 0;\n        deferCountMap.delete(hash);\n        priorDefersSeen.set(hash, 0);\n        deferredThisCall.delete(hash);\n        const v: JudgeVerdict = {\n          durable: true,\n          reason: \"Approved by default (judge unavailable or parse error)\",\n        };\n        verdicts.set(idx, v);\n        emit(() => {\n          return {\n            verdict: v,\n            candidate: c,\n            contentHash: hash,\n            source: \"fail-open\",\n            priorDeferrals: priorDefers,\n            elapsedMs: Date.now() - startMs,\n          };\n        });\n      }\n    }\n  }\n\n  return {\n    verdicts,\n    cached,\n    judged,\n    elapsed: Date.now() - startMs,\n    deferred,\n    deferredCappedToReject,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// LLM call helpers\n// ---------------------------------------------------------------------------\n\nasync function callJudgeLlm(\n  request: JudgeRequest,\n  config: PluginConfig,\n  localLlm: LocalLlmClient | null,\n  fallbackLlm: FallbackLlmClient | null,\n): Promise<string | null> {\n  const { messages, maxTokens } = request;\n\n  const modelOverride = config.extractionJudgeModel || undefined;\n\n  // When modelSource is \"gateway\", skip localLlm and go directly to fallback\n  // (the gateway-routed backend). This respects the operator's explicit\n  // routing preference.\n  const skipLocal = config.modelSource === \"gateway\";\n\n  // Route judge-gated extractions through the SAME shared resolution as every\n  // other background task (taskModelChain > gatewayAgentId in gateway mode), so\n  // the judge never silently falls back to the persona/default chain when a\n  // task chain is configured (gotcha #22, #39). Issue #1365 / PR #1425.\n  const gatewayChain = gatewayTaskChainOptions(config);\n\n  // Try local LLM first (unless modelSource says gateway)\n  if (localLlm && !skipLocal) {\n    try {\n      const result = await (localLlm as any).chatCompletion(messages, {\n        temperature: 0.1,\n        maxTokens,\n        // A verdict needs no reasoning: keep a thinking-capable model from spending the compact budget on it.\n        disableThinking: true,\n        responseFormat: { type: \"json_object\" },\n        timeoutMs: config.extractionJudgeTimeoutMs,\n        // The client applies timeoutMs per attempt and retries an abort once:\n        // one deadline signal bounds the whole call to the configured time.\n        signal: AbortSignal.timeout(config.extractionJudgeTimeoutMs),\n        operation: \"extraction-judge\",\n        ...(modelOverride ? { model: modelOverride } : {}),\n      });\n      if (result?.content) {\n        return result.content;\n      }\n    } catch (err) {\n      log.debug(\n        `extraction-judge: local LLM failed, trying fallback: ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n  }\n\n  // Try fallback LLM\n  if (fallbackLlm) {\n    try {\n      const result = await fallbackLlm.chatCompletion(\n        messages as Array<{ role: \"system\" | \"user\" | \"assistant\"; content: string }>,\n        {\n          temperature: 0.1,\n          maxTokens,\n          reasoningHeadroomTokens: JUDGE_REASONING_HEADROOM_TOKENS,\n          timeoutMs: config.extractionJudgeTimeoutMs,\n          ...(modelOverride ? { model: modelOverride } : {}),\n          ...gatewayChain,\n        },\n      );\n      if (result?.content) {\n        return result.content;\n      }\n    } catch (err) {\n      log.debug(\n        `extraction-judge: fallback LLM failed: ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n  }\n\n  return null;\n}\n\ninterface JudgeVerdictItem {\n  index?: number;\n  kind?: string;\n  action?: string;\n  durable?: boolean;\n  reason?: string;\n}\n\n/** What a judge model may return: a bare array, or one object wrapping verdicts. */\ninterface JudgeEnvelope {\n  verdicts?: JudgeVerdictItem[];\n  index?: number;\n}\n\ntype ParsedJudgeJson = JudgeVerdictItem[] | JudgeEnvelope | null | undefined;\n\n/**\n * Normalise the object shapes a judge model returns to a verdict array.\n * Requested shape {\"verdicts\": [...]} (response_format json_object forces a\n * top-level object); a single verdict object counts as one verdict at its\n * index, never the whole batch; legacy: any array-valued key.\n */\nfunction unwrapJudgeEnvelope(parsed: ParsedJudgeJson): JudgeVerdictItem[] | null {\n  if (!parsed || Array.isArray(parsed)) return null;\n  if (Array.isArray(parsed.verdicts)) return parsed.verdicts;\n  if (Number.isInteger(parsed.index)) return [parsed];\n  for (const v of Object.values(parsed)) {\n    if (Array.isArray(v)) return v;\n  }\n  return null;\n}\n\n// ---------------------------------------------------------------------------\n// Response parsing\n// ---------------------------------------------------------------------------\n\nfunction parseJudgeResponse(\n  raw: string,\n  expectedIndices: number[],\n): Map<number, JudgeVerdict> {\n  const result = new Map<number, JudgeVerdict>();\n  const expectedSet = new Set(expectedIndices);\n\n  try {\n    // Try direct parse first, then fall back to JSON extraction\n    let parsed: ParsedJudgeJson;\n    try {\n      parsed = JSON.parse(raw);\n    } catch {\n      const candidates = extractJsonCandidates(raw);\n      if (candidates.length > 0) {\n        parsed = JSON.parse(candidates[0]);\n      }\n    }\n\n    if (!Array.isArray(parsed)) {\n      const unwrapped = unwrapJudgeEnvelope(parsed);\n      if (unwrapped === null) {\n        log.debug(\"extraction-judge: response is not an array, cannot parse\");\n        return result;\n      }\n      parsed = unwrapped;\n    }\n\n    for (const item of parsed) {\n      if (\n        typeof item !== \"object\" ||\n        item === null ||\n        typeof (item as any).index !== \"number\"\n      ) {\n        continue;\n      }\n      const idx = (item as any).index as number;\n      if (!expectedSet.has(idx)) continue;\n\n      // Parse kind first — it's the primary signal in PR 2 and above.\n      // Fall back to durable for pre-PR-2 model responses that only return\n      // the boolean.\n      let kind: JudgeVerdictKind | undefined;\n      const rawKind = (item as any).kind;\n      const rawAction = (item as any).action;\n      if (rawKind === \"accept\" || rawKind === \"reject\" || rawKind === \"defer\") {\n        kind = rawKind;\n      } else if (\n        rawAction === \"accept\" ||\n        rawAction === \"reject\" ||\n        rawAction === \"defer\"\n      ) {\n        // Tolerate `action` as an alias — MemReader uses that word in the\n        // paper and models may echo it.\n        kind = rawAction;\n      }\n\n      const hasDurable = typeof (item as any).durable === \"boolean\";\n      const durableFromModel = hasDurable\n        ? ((item as any).durable as boolean)\n        : undefined;\n\n      // Resolve the durable flag from kind when present; otherwise trust\n      // the model's boolean; otherwise fail-open to durable=true.\n      let durable: boolean;\n      if (kind === \"accept\") {\n        durable = true;\n      } else if (kind === \"reject\" || kind === \"defer\") {\n        durable = false;\n      } else if (durableFromModel !== undefined) {\n        durable = durableFromModel;\n      } else {\n        durable = true; // fail-open\n      }\n\n      const reason =\n        typeof (item as any).reason === \"string\"\n          ? ((item as any).reason as string).slice(0, 120)\n          : \"No reason provided\";\n\n      const verdict: JudgeVerdict = { durable, reason };\n      if (kind !== undefined) verdict.kind = kind;\n      result.set(idx, verdict);\n    }\n  } catch (err) {\n    log.debug(\n      `extraction-judge: failed to parse response: ${err instanceof Error ? err.message : String(err)}`,\n    );\n  }\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Cache management (exposed for testing)\n// ---------------------------------------------------------------------------\n\n/** Clear the in-memory default verdict cache. Primarily for tests. */\nexport function clearVerdictCache(): void {\n  defaultVerdictCache.clear();\n  defaultDeferCounts.clear();\n}\n\n/** Return the current default verdict cache size. Primarily for tests. */\nexport function verdictCacheSize(): number {\n  return defaultVerdictCache.size;\n}\n\n/** Create a new per-instance verdict cache. Orchestrators should hold one. */\nexport function createVerdictCache(): Map<string, JudgeVerdict> {\n  return new Map();\n}\n\n/**\n * Create a new per-instance defer-counter map. Orchestrators should hold one\n * alongside their verdict cache so defer counts survive across extraction\n * passes within a single orchestrator but do not leak across orchestrators.\n */\nexport function createDeferCountMap(): Map<string, number> {\n  return new Map();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAmBA,SAAS,kBAAkB;AAyEpB,SAAS,eAAe,SAAyC;AACtE,QAAM,MAAM,QAAQ;AACpB,MAAI,QAAQ,YAAY,QAAQ,YAAY,QAAQ,SAAS;AAC3D,WAAO;AAAA,EACT;AACA,SAAO,QAAQ,UAAU,WAAW;AACtC;AAOO,SAAS,iBAAiB,SAAgC;AAC/D,SAAO,eAAe,OAAO,MAAM;AACrC;AAgBO,SAAS,qBAAqB,OAAuC;AAC1E,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,IAAI;AACV,MAAI,OAAO,EAAE,YAAY,UAAW,QAAO;AAC3C,MAAI,OAAO,EAAE,WAAW,SAAU,QAAO;AACzC,MAAI,EAAE,SAAS,QAAW;AACxB,QAAI,EAAE,SAAS,YAAY,EAAE,SAAS,YAAY,EAAE,SAAS,SAAS;AACpE,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAWO,SAAS,uBAAuB,OAAqC;AAC1E,MAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;AACxD,QAAM,IAAI;AACV,MAAI,OAAO,EAAE,YAAY,UAAW,QAAO;AAC3C,MAAI,OAAO,EAAE,WAAW,SAAU,QAAO;AACzC,MAAI;AACJ,MAAI,EAAE,SAAS,QAAW;AACxB,QAAI,OAAO,EAAE,SAAS,SAAU,QAAO;AACvC,QAAI,EAAE,SAAS,YAAY,EAAE,SAAS,YAAY,EAAE,SAAS,SAAS;AACpE,aAAO,EAAE;AAAA,IACX;AAAA,EAEF;AACA,QAAM,MAAoB,EAAE,SAAS,EAAE,SAAS,QAAQ,EAAE,OAAO;AACjE,MAAI,SAAS,OAAW,KAAI,OAAO;AACnC,SAAO;AACT;AAwDO,IAAM,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,KAmB9B,sBAAsB;AAAA;AAAA;AAAA;AAU3B,IAAM,6BAA6B;AAE5B,IAAM,mBAAmB;AAMzB,IAAM,kCAAkC;AAExC,IAAM,kBAAkB,KAAK,MAAM,mBAAmB,0BAA0B;AAUhF,SAAS,eAAe,WAA2B;AACxD,SAAO,KAAK,IAAI,kBAAkB,KAAK,IAAI,IAAI,YAAY,0BAA0B,CAAC;AACxF;AAiBO,SAAS,kBAAkB,SAAqD;AACrF,SAAO;AAAA,IACL,UAAU;AAAA,MACR,EAAE,MAAM,UAAU,SAAS,oBAAoB;AAAA,MAC/C,EAAE,MAAM,QAAQ,SAAS,KAAK,UAAU,OAAO,EAAE;AAAA,IACnD;AAAA,IACA,WAAW,eAAe,QAAQ,MAAM;AAAA,EAC1C;AACF;AAOA,IAAM,yBAAyB;AAG/B,IAAM,sBAAsB,oBAAI,IAA0B;AAa1D,IAAM,qBAAqB,oBAAI,IAAoB;AACnD,IAAM,uBAAuB;AAE7B,SAAS,SAAS,MAAc,UAA0B;AACxD,SAAO,WAAW,QAAQ,EAAE,OAAO,GAAG,IAAI,KAAK,QAAQ,EAAE,EAAE,OAAO,KAAK;AACzE;AAMA,SAAS,gBAAgB,QAA8B;AACrD,QAAM,MAAO,OACV;AACH,MAAI,OAAO,QAAQ,YAAY,OAAO,SAAS,GAAG,KAAK,OAAO,GAAG;AAC/D,WAAO,KAAK,MAAM,GAAG;AAAA,EACvB;AACA,SAAO;AACT;AAOA,SAAS,oBAAoB,OAAwC;AACnE,MAAI,MAAM,QAAQ,uBAAwB;AAC1C,QAAM,cAAc,KAAK,MAAM,MAAM,OAAO,CAAC;AAC7C,MAAI,UAAU;AACd,aAAW,OAAO,MAAM,KAAK,GAAG;AAC9B,QAAI,WAAW,YAAa;AAC5B,UAAM,OAAO,GAAG;AAChB;AAAA,EACF;AACF;AAMA,IAAM,0BAA0B,oBAAI,IAAI,CAAC,cAAc,WAAW,CAAC;AAGnE,IAAM,uBACJ;AAMK,SAAS,4BAA4B,OAG3B;AACf,QAAM,QAAQ,wBAAwB,MAAM,cAAc;AAC1D,MAAI,MAAM,SAAS,GAAG;AACpB,WAAO,EAAE,SAAS,OAAO,QAAQ,qDAAqD;AAAA,EACxF;AACA,QAAM,WAAW,CAAC,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,KAAK,GAAG,EAAE,YAAY;AACtF,MAAI,CAAC,qBAAqB,KAAK,QAAQ,GAAG;AACxC,WAAO,EAAE,SAAS,OAAO,QAAQ,8CAA8C;AAAA,EACjF;AACA,SAAO,EAAE,SAAS,MAAM,QAAQ,gCAAgC;AAClE;AAcA,eAAsB,oBACpB,YACA,QACA,UACA,aACA,OACA,aACA,WAC2B;AAC3B,QAAM,UAAU,KAAK,IAAI;AACzB,QAAM,WAAW,oBAAI,IAA0B;AAC/C,MAAI,SAAS;AACb,MAAI,SAAS;AACb,MAAI,WAAW;AACf,MAAI,yBAAyB;AAI7B,QAAM,eAAe,SAAS;AAC9B,QAAM,gBAAgB,eAAe;AACrC,QAAM,WAAW,gBAAgB,MAAM;AASvC,QAAM,OAAO,CAAC,UAA+C;AAC3D,QAAI,CAAC,UAAW;AAChB,QAAI;AACJ,QAAI;AACF,oBAAc,MAAM;AAAA,IACtB,SAAS,KAAK;AACZ,UAAI;AAAA,QACF,0DAA0D,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,MAC5G;AACA;AAAA,IACF;AACA,QAAI;AACF,gBAAU,WAAW;AAAA,IACvB,SAAS,KAAK;AAEZ,UAAI;AAAA,QACF,2DAA2D,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,MAC7G;AAAA,IACF;AAAA,EACF;AAEA,MAAI,WAAW,WAAW,GAAG;AAC3B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS;AAAA,MACT;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAGA,QAAM,iBAA2B,CAAC;AAElC,WAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AAC1C,UAAM,IAAI,WAAW,CAAC;AAGtB,QAAI,wBAAwB,IAAI,EAAE,QAAQ,GAAG;AAC3C,YAAM,IAAkB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ,kBAAkB,EAAE,QAAQ;AAAA,MACtC;AACA,eAAS,IAAI,GAAG,CAAC;AACjB,WAAK,OAAO;AAAA,QACV,SAAS;AAAA,QACT,WAAW;AAAA,QACX,aAAa,SAAS,EAAE,MAAM,EAAE,QAAQ;AAAA,QACxC,QAAQ;AAAA,QACR,gBAAgB;AAAA,QAChB,WAAW,KAAK,IAAI,IAAI;AAAA,MAC1B,EAAE;AACF;AAAA,IACF;AAGA,QAAI,EAAE,oBAAoB,YAAY;AACpC,YAAM,IAAkB;AAAA,QACtB,SAAS;AAAA,QACT,QAAQ;AAAA,MACV;AACA,eAAS,IAAI,GAAG,CAAC;AACjB,WAAK,OAAO;AAAA,QACV,SAAS;AAAA,QACT,WAAW;AAAA,QACX,aAAa,SAAS,EAAE,MAAM,EAAE,QAAQ;AAAA,QACxC,QAAQ;AAAA,QACR,gBAAgB;AAAA,QAChB,WAAW,KAAK,IAAI,IAAI;AAAA,MAC1B,EAAE;AACF;AAAA,IACF;AAGA,UAAM,MAAM,SAAS,EAAE,MAAM,EAAE,QAAQ;AACvC,UAAM,gBAAgB,aAAa,IAAI,GAAG;AAC1C,QAAI,eAAe;AACjB,eAAS,IAAI,GAAG,aAAa;AAC7B;AACA,WAAK,OAAO;AAAA,QACV,SAAS;AAAA,QACT,WAAW;AAAA,QACX,aAAa;AAAA,QACb,QAAQ;AAAA,QACR,gBAAgB,cAAc,IAAI,GAAG,KAAK;AAAA,QAC1C,WAAW,KAAK,IAAI,IAAI;AAAA,MAC1B,EAAE;AACF;AAAA,IACF;AAEA,mBAAe,KAAK,CAAC;AAAA,EACvB;AAGA,MAAI,eAAe,WAAW,GAAG;AAC/B,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,SAAS,KAAK,IAAI,IAAI;AAAA,MACtB;AAAA,MACA;AAAA,IACF;AAAA,EACF;AAGA,QAAM,YAAY,KAAK,IAAI,OAAO,0BAA0B,eAAe;AAG3E,QAAM,mBAAmB,oBAAI,IAAY;AACzC,QAAM,kBAAkB,oBAAI,IAAoB;AAChD,WAAS,aAAa,GAAG,aAAa,eAAe,QAAQ,cAAc,WAAW;AACpF,UAAM,eAAe,eAAe,MAAM,YAAY,aAAa,SAAS;AAC5E,UAAM,UAAU;AAAA,MACd,aAAa,IAAI,CAAC,SAAS;AAAA,QACzB,OAAO;AAAA,QACP,MAAM,WAAW,GAAG,EAAE;AAAA,QACtB,UAAU,WAAW,GAAG,EAAE;AAAA,QAC1B,YAAY,WAAW,GAAG,EAAE;AAAA,MAC9B,EAAE;AAAA,IACJ;AAEA,QAAI;AACF,YAAM,cAAc,MAAM,aAAa,SAAS,QAAQ,UAAU,WAAW;AAE7E,UAAI,aAAa;AACf,cAAM,SAAS,mBAAmB,aAAa,YAAY;AAM3D,mBAAW,CAAC,KAAK,UAAU,KAAK,OAAO,QAAQ,GAAG;AAChD,gBAAM,IAAI,WAAW,GAAG;AACxB,gBAAM,MAAM,SAAS,EAAE,MAAM,EAAE,QAAQ;AACvC,cAAI,UAAU;AACd,cAAI,SAA4C;AAChD,cAAI,CAAC,gBAAgB,IAAI,GAAG,EAAG,iBAAgB,IAAI,KAAK,cAAc,IAAI,GAAG,KAAK,CAAC;AACnF,gBAAM,cAAc,gBAAgB,IAAI,GAAG,KAAK;AAKhD,cAAI,eAAe,OAAO,MAAM,SAAS;AACvC,gBAAI,eAAe,UAAU;AAC3B,wBAAU;AAAA,gBACR,SAAS;AAAA,gBACT,QAAQ,sBAAsB,QAAQ;AAAA,gBACtC,MAAM;AAAA,cACR;AACA,uBAAS;AAIT,kBAAI,CAAC,iBAAiB,IAAI,GAAG,GAAG;AAC9B,8BAAc,OAAO,GAAG;AACxB;AACA,iCAAiB,IAAI,GAAG;AAAA,cAC1B;AAAA,YACF,WAAW,CAAC,iBAAiB,IAAI,GAAG,GAAG;AACrC,4BAAc,IAAI,KAAK,cAAc,CAAC;AACtC;AACA,+BAAiB,IAAI,GAAG;AAExB,kBAAI,cAAc,OAAO,sBAAsB;AAC7C,sBAAM,OAAO,KAAK,MAAM,cAAc,OAAO,CAAC;AAC9C,oBAAI,UAAU;AACd,2BAAW,KAAK,cAAc,KAAK,GAAG;AACpC,sBAAI,WAAW,KAAM;AACrB,gCAAc,OAAO,CAAC;AACtB;AAAA,gBACF;AAAA,cACF;AAAA,YACF;AAAA,UAGF,OAAO;AAGL,0BAAc,OAAO,GAAG;AACxB,4BAAgB,IAAI,KAAK,CAAC;AAC1B,6BAAiB,OAAO,GAAG;AAAA,UAC7B;AAEA,mBAAS,IAAI,KAAK,OAAO;AACzB;AAIA,cAAI,eAAe,OAAO,MAAM,SAAS;AACvC,yBAAa,IAAI,KAAK,OAAO;AAAA,UAC/B;AACA,eAAK,OAAO;AAAA,YACV;AAAA,YACA,WAAW;AAAA,YACX,aAAa;AAAA,YACb;AAAA,YACA,gBAAgB;AAAA,YAChB,WAAW,KAAK,IAAI,IAAI;AAAA,UAC1B,EAAE;AAAA,QACJ;AAEA,4BAAoB,YAAY;AAAA,MAClC;AAAA,IACF,SAAS,KAAK;AAEZ,UAAI;AAAA,QACF,mEAAmE,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,MACrH;AAAA,IACF;AAKA,eAAW,OAAO,cAAc;AAC9B,UAAI,CAAC,SAAS,IAAI,GAAG,GAAG;AACtB,cAAM,IAAI,WAAW,GAAG;AACxB,cAAM,OAAO,SAAS,EAAE,MAAM,EAAE,QAAQ;AAGxC,cAAM,cAAc,cAAc,IAAI,IAAI,KAAK;AAC/C,sBAAc,OAAO,IAAI;AACzB,wBAAgB,IAAI,MAAM,CAAC;AAC3B,yBAAiB,OAAO,IAAI;AAC5B,cAAM,IAAkB;AAAA,UACtB,SAAS;AAAA,UACT,QAAQ;AAAA,QACV;AACA,iBAAS,IAAI,KAAK,CAAC;AACnB,aAAK,MAAM;AACT,iBAAO;AAAA,YACL,SAAS;AAAA,YACT,WAAW;AAAA,YACX,aAAa;AAAA,YACb,QAAQ;AAAA,YACR,gBAAgB;AAAA,YAChB,WAAW,KAAK,IAAI,IAAI;AAAA,UAC1B;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,SAAS,KAAK,IAAI,IAAI;AAAA,IACtB;AAAA,IACA;AAAA,EACF;AACF;AAMA,eAAe,aACb,SACA,QACA,UACA,aACwB;AACxB,QAAM,EAAE,UAAU,UAAU,IAAI;AAEhC,QAAM,gBAAgB,OAAO,wBAAwB;AAKrD,QAAM,YAAY,OAAO,gBAAgB;AAMzC,QAAM,eAAe,wBAAwB,MAAM;AAGnD,MAAI,YAAY,CAAC,WAAW;AAC1B,QAAI;AACF,YAAM,SAAS,MAAO,SAAiB,eAAe,UAAU;AAAA,QAC9D,aAAa;AAAA,QACb;AAAA;AAAA,QAEA,iBAAiB;AAAA,QACjB,gBAAgB,EAAE,MAAM,cAAc;AAAA,QACtC,WAAW,OAAO;AAAA;AAAA;AAAA,QAGlB,QAAQ,YAAY,QAAQ,OAAO,wBAAwB;AAAA,QAC3D,WAAW;AAAA,QACX,GAAI,gBAAgB,EAAE,OAAO,cAAc,IAAI,CAAC;AAAA,MAClD,CAAC;AACD,UAAI,QAAQ,SAAS;AACnB,eAAO,OAAO;AAAA,MAChB;AAAA,IACF,SAAS,KAAK;AACZ,UAAI;AAAA,QACF,wDAAwD,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,MAC1G;AAAA,IACF;AAAA,EACF;AAGA,MAAI,aAAa;AACf,QAAI;AACF,YAAM,SAAS,MAAM,YAAY;AAAA,QAC/B;AAAA,QACA;AAAA,UACE,aAAa;AAAA,UACb;AAAA,UACA,yBAAyB;AAAA,UACzB,WAAW,OAAO;AAAA,UAClB,GAAI,gBAAgB,EAAE,OAAO,cAAc,IAAI,CAAC;AAAA,UAChD,GAAG;AAAA,QACL;AAAA,MACF;AACA,UAAI,QAAQ,SAAS;AACnB,eAAO,OAAO;AAAA,MAChB;AAAA,IACF,SAAS,KAAK;AACZ,UAAI;AAAA,QACF,0CAA0C,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,MAC5F;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAwBA,SAAS,oBAAoB,QAAoD;AAC/E,MAAI,CAAC,UAAU,MAAM,QAAQ,MAAM,EAAG,QAAO;AAC7C,MAAI,MAAM,QAAQ,OAAO,QAAQ,EAAG,QAAO,OAAO;AAClD,MAAI,OAAO,UAAU,OAAO,KAAK,EAAG,QAAO,CAAC,MAAM;AAClD,aAAW,KAAK,OAAO,OAAO,MAAM,GAAG;AACrC,QAAI,MAAM,QAAQ,CAAC,EAAG,QAAO;AAAA,EAC/B;AACA,SAAO;AACT;AAMA,SAAS,mBACP,KACA,iBAC2B;AAC3B,QAAM,SAAS,oBAAI,IAA0B;AAC7C,QAAM,cAAc,IAAI,IAAI,eAAe;AAE3C,MAAI;AAEF,QAAI;AACJ,QAAI;AACF,eAAS,KAAK,MAAM,GAAG;AAAA,IACzB,QAAQ;AACN,YAAM,aAAa,sBAAsB,GAAG;AAC5C,UAAI,WAAW,SAAS,GAAG;AACzB,iBAAS,KAAK,MAAM,WAAW,CAAC,CAAC;AAAA,MACnC;AAAA,IACF;AAEA,QAAI,CAAC,MAAM,QAAQ,MAAM,GAAG;AAC1B,YAAM,YAAY,oBAAoB,MAAM;AAC5C,UAAI,cAAc,MAAM;AACtB,YAAI,MAAM,0DAA0D;AACpE,eAAO;AAAA,MACT;AACA,eAAS;AAAA,IACX;AAEA,eAAW,QAAQ,QAAQ;AACzB,UACE,OAAO,SAAS,YAChB,SAAS,QACT,OAAQ,KAAa,UAAU,UAC/B;AACA;AAAA,MACF;AACA,YAAM,MAAO,KAAa;AAC1B,UAAI,CAAC,YAAY,IAAI,GAAG,EAAG;AAK3B,UAAI;AACJ,YAAM,UAAW,KAAa;AAC9B,YAAM,YAAa,KAAa;AAChC,UAAI,YAAY,YAAY,YAAY,YAAY,YAAY,SAAS;AACvE,eAAO;AAAA,MACT,WACE,cAAc,YACd,cAAc,YACd,cAAc,SACd;AAGA,eAAO;AAAA,MACT;AAEA,YAAM,aAAa,OAAQ,KAAa,YAAY;AACpD,YAAM,mBAAmB,aACnB,KAAa,UACf;AAIJ,UAAI;AACJ,UAAI,SAAS,UAAU;AACrB,kBAAU;AAAA,MACZ,WAAW,SAAS,YAAY,SAAS,SAAS;AAChD,kBAAU;AAAA,MACZ,WAAW,qBAAqB,QAAW;AACzC,kBAAU;AAAA,MACZ,OAAO;AACL,kBAAU;AAAA,MACZ;AAEA,YAAM,SACJ,OAAQ,KAAa,WAAW,WAC1B,KAAa,OAAkB,MAAM,GAAG,GAAG,IAC7C;AAEN,YAAM,UAAwB,EAAE,SAAS,OAAO;AAChD,UAAI,SAAS,OAAW,SAAQ,OAAO;AACvC,aAAO,IAAI,KAAK,OAAO;AAAA,IACzB;AAAA,EACF,SAAS,KAAK;AACZ,QAAI;AAAA,MACF,+CAA+C,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;AAAA,IACjG;AAAA,EACF;AAEA,SAAO;AACT;AAOO,SAAS,oBAA0B;AACxC,sBAAoB,MAAM;AAC1B,qBAAmB,MAAM;AAC3B;AAGO,SAAS,mBAA2B;AACzC,SAAO,oBAAoB;AAC7B;AAGO,SAAS,qBAAgD;AAC9D,SAAO,oBAAI,IAAI;AACjB;AAOO,SAAS,sBAA2C;AACzD,SAAO,oBAAI,IAAI;AACjB;","names":[]}

package/dist/{chunk-G2SRB62M.js → chunk-TTQYX7VU.js}

@@ -1,6 +1,6 @@
 import {
   defineOperation
-} from "./chunk-QEGE5QCL.js";
+} from "./chunk-7IANFJ24.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -71,4 +71,4 @@ defineOperation({
     })
   })
 });
-//# sourceMappingURL=chunk-G2SRB62M.js.map
+//# sourceMappingURL=chunk-TTQYX7VU.js.map

package/dist/{chunk-TDCR6PQL.js → chunk-TWRPWJJT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-BT7NVCML.js";
 import {
   isMemorySubject
-} from "./chunk-E5PVMB3I.js";
+} from "./chunk-SDXBR5QO.js";
 import {
   assemblePersistedBody
 } from "./chunk-JDSVLVCG.js";
@@ -443,4 +443,4 @@ export {
   buildAccessWriteRequestFingerprint,
   buildObserveRequestFingerprint
 };
-//# sourceMappingURL=chunk-TDCR6PQL.js.map
+//# sourceMappingURL=chunk-TWRPWJJT.js.map

package/dist/{chunk-KC5SVCUJ.js → chunk-U66CTIF5.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-R6TCM47S.js";
+} from "./chunk-5KZNWERU.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-KC5SVCUJ.js.map
+//# sourceMappingURL=chunk-U66CTIF5.js.map

package/dist/{chunk-D2AKUKAQ.js → chunk-UIK3U36O.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   parseQmdExplain
-} from "./chunk-AYXRK264.js";
+} from "./chunk-RROFIAYI.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -645,4 +645,4 @@ export {
   appendMemoryToGraphContext,
   resolvePersistedMemoryRelativePath
 };
-//# sourceMappingURL=chunk-D2AKUKAQ.js.map
+//# sourceMappingURL=chunk-UIK3U36O.js.map

package/dist/{chunk-XLEP7SS3.js → chunk-UMSH4I3E.js}

@@ -1,7 +1,7 @@
 import {
   canonicalCategoryForAlias,
   categoryAliasCoercion
-} from "./chunk-YC2C67F7.js";
+} from "./chunk-CRXGQRNA.js";
 
 // src/access-observe-write-category.ts
 function splitCanonicalWriteRequest(request) {
@@ -22,4 +22,4 @@ function splitCanonicalWriteRequest(request) {
 export {
   splitCanonicalWriteRequest
 };
-//# sourceMappingURL=chunk-XLEP7SS3.js.map
+//# sourceMappingURL=chunk-UMSH4I3E.js.map

package/dist/{chunk-X7Y7WX73.js → chunk-UVYI6VIX.js}

@@ -246,4 +246,4 @@ export {
   decryptCapsuleFile,
   decryptCapsuleFileInMemory
 };
-//# sourceMappingURL=chunk-X7Y7WX73.js.map
+//# sourceMappingURL=chunk-UVYI6VIX.js.map

package/dist/{chunk-LHBOFROT.js → chunk-V2XMG7GM.js}

@@ -1,6 +1,6 @@
 import {
   createSearchBackend
-} from "./chunk-P5CUEB2Q.js";
+} from "./chunk-4QLKVZH6.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
@@ -508,4 +508,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-LHBOFROT.js.map
+//# sourceMappingURL=chunk-V2XMG7GM.js.map

package/dist/chunk-VA3GNAWQ.js

@@ -0,0 +1,58 @@
+// src/extraction-window-drain.ts
+function chunkExtractionWindow(turns, maxChars) {
+  if (turns.length === 0) return [];
+  const budget = Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : Number.POSITIVE_INFINITY;
+  const chunks = [];
+  let current = [];
+  let currentChars = 0;
+  for (const turn of turns) {
+    const turnChars = turn.content.length;
+    if (current.length > 0 && currentChars + turnChars > budget) {
+      chunks.push(current);
+      current = [];
+      currentChars = 0;
+    }
+    current.push(turn);
+    currentChars += turnChars;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+var DRAIN_DEFERRAL_REASONS = {
+  provider_circuit_open: true,
+  extraction_backoff: true
+};
+function classifyDrainResult(result) {
+  if (result.status !== "skipped") return "drained";
+  if (result.reason === "empty_extraction_result") {
+    return result.retainedBuffer === true ? "failed" : "drained";
+  }
+  if (result.reason !== void 0 && result.reason in DRAIN_DEFERRAL_REASONS) return "deferred";
+  return "drained";
+}
+function mergeDrainResults(previous, next) {
+  if (previous === null) return next;
+  const completed = previous.status === "completed" || next.status === "completed";
+  const merged = {
+    status: completed ? "completed" : "skipped",
+    persistedCount: previous.persistedCount + next.persistedCount,
+    durableOutputCount: previous.durableOutputCount + next.durableOutputCount
+  };
+  if (!completed) merged.reason = next.reason ?? previous.reason;
+  if (previous.postPersistMetadataFailed === true || next.postPersistMetadataFailed === true) {
+    merged.postPersistMetadataFailed = true;
+  }
+  return merged;
+}
+function extractionWindowBudgetChars(input) {
+  if (!input.registry || !input.localExtractionActive) return Number.POSITIVE_INFINITY;
+  return input.registry.calculateContextSizes(input.model, input.maxContext).maxInputChars;
+}
+
+export {
+  chunkExtractionWindow,
+  classifyDrainResult,
+  mergeDrainResults,
+  extractionWindowBudgetChars
+};
+//# sourceMappingURL=chunk-VA3GNAWQ.js.map

package/dist/chunk-VA3GNAWQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-window-drain.ts"],"sourcesContent":["/**\n * Trigger-drain helpers (extraction trigger stall fix).\n *\n * A session whose buffered window outgrows the extraction model's context\n * never drains: the trigger fires `extract_batch` on every observe, the\n * oversized request fails, nothing is cleared, and the window only grows.\n * These helpers split such a window into budget-fitting chunks and classify\n * each extraction run so the caller can drain successes, defer on breaker/\n * backoff retention, and drop repeatedly failing chunks.\n */\n\nimport type { ExtractionRunResult } from \"./orchestration/extraction-run.js\";\n\n/**\n * Split `turns` into chunks whose summed content length stays within\n * `maxChars`. Chunks keep turn order and never split a turn; a single turn\n * longer than the budget becomes its own chunk (the extraction prompt still\n * clamps per-turn content). A non-positive or non-finite budget, or an empty\n * window, yields at most one chunk (no chunking).\n */\nexport function chunkExtractionWindow<T extends { content: string }>(\n  turns: readonly T[],\n  maxChars: number,\n): T[][] {\n  if (turns.length === 0) return [];\n  const budget =\n    Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : Number.POSITIVE_INFINITY;\n  const chunks: T[][] = [];\n  let current: T[] = [];\n  let currentChars = 0;\n  for (const turn of turns) {\n    const turnChars = turn.content.length;\n    if (current.length > 0 && currentChars + turnChars > budget) {\n      chunks.push(current);\n      current = [];\n      currentChars = 0;\n    }\n    current.push(turn);\n    currentChars += turnChars;\n  }\n  if (current.length > 0) chunks.push(current);\n  return chunks;\n}\n\nexport type DrainVerdict = \"drained\" | \"deferred\" | \"failed\";\n\n/**\n * Run results that deliberately RETAIN the buffer (provider breaker open,\n * per-fingerprint backoff) are deferrals, not chunk failures — counting them\n * would drop good content during a provider outage.\n */\nconst DRAIN_DEFERRAL_REASONS = {\n  provider_circuit_open: true,\n  extraction_backoff: true,\n};\n\nexport function classifyDrainResult(result: ExtractionRunResult): DrainVerdict {\n  if (result.status !== \"skipped\") return \"drained\";\n  // An empty result is a failure only when the run kept the window for retry;\n  // otherwise it extracted fine, found nothing durable, and cleared its turns.\n  if (result.reason === \"empty_extraction_result\") {\n    return result.retainedBuffer === true ? \"failed\" : \"drained\";\n  }\n  if (result.reason !== undefined && result.reason in DRAIN_DEFERRAL_REASONS) return \"deferred\";\n  return \"drained\";\n}\n\n/**\n * Combine chunk results into the single `ExtractionRunResult` the queue\n * contract settles with: counts sum, any completed chunk completes the drain,\n * and the last non-completed reason wins.\n */\nexport function mergeDrainResults(\n  previous: ExtractionRunResult | null,\n  next: ExtractionRunResult,\n): ExtractionRunResult {\n  if (previous === null) return next;\n  const completed = previous.status === \"completed\" || next.status === \"completed\";\n  const merged: ExtractionRunResult = {\n    status: completed ? \"completed\" : \"skipped\",\n    persistedCount: previous.persistedCount + next.persistedCount,\n    durableOutputCount: previous.durableOutputCount + next.durableOutputCount,\n  };\n  if (!completed) merged.reason = next.reason ?? previous.reason;\n  if (previous.postPersistMetadataFailed === true || next.postPersistMetadataFailed === true) {\n    merged.postPersistMetadataFailed = true;\n  }\n  return merged;\n}\n\n/** The slice of ModelRegistry the drain budget needs. */\nexport interface WindowBudgetRegistry {\n  calculateContextSizes(modelId: string, maxContextOverride?: number): { maxInputChars: number };\n}\n\n/**\n * Character budget for one extraction request. The learned local-model window\n * only describes the extractor when the local LLM does the extracting; with a\n * gateway extractor, a disabled local LLM, or no registry (legacy hosts, test\n * doubles) there is no budget and the window runs in one request as before.\n */\nexport function extractionWindowBudgetChars(input: {\n  registry: WindowBudgetRegistry | undefined;\n  localExtractionActive: boolean;\n  model: string;\n  maxContext: number | undefined;\n}): number {\n  if (!input.registry || !input.localExtractionActive) return Number.POSITIVE_INFINITY;\n  return input.registry.calculateContextSizes(input.model, input.maxContext).maxInputChars;\n}\n"],"mappings":";AAoBO,SAAS,sBACd,OACA,UACO;AACP,MAAI,MAAM,WAAW,EAAG,QAAO,CAAC;AAChC,QAAM,SACJ,OAAO,SAAS,QAAQ,KAAK,WAAW,IAAI,KAAK,MAAM,QAAQ,IAAI,OAAO;AAC5E,QAAM,SAAgB,CAAC;AACvB,MAAI,UAAe,CAAC;AACpB,MAAI,eAAe;AACnB,aAAW,QAAQ,OAAO;AACxB,UAAM,YAAY,KAAK,QAAQ;AAC/B,QAAI,QAAQ,SAAS,KAAK,eAAe,YAAY,QAAQ;AAC3D,aAAO,KAAK,OAAO;AACnB,gBAAU,CAAC;AACX,qBAAe;AAAA,IACjB;AACA,YAAQ,KAAK,IAAI;AACjB,oBAAgB;AAAA,EAClB;AACA,MAAI,QAAQ,SAAS,EAAG,QAAO,KAAK,OAAO;AAC3C,SAAO;AACT;AASA,IAAM,yBAAyB;AAAA,EAC7B,uBAAuB;AAAA,EACvB,oBAAoB;AACtB;AAEO,SAAS,oBAAoB,QAA2C;AAC7E,MAAI,OAAO,WAAW,UAAW,QAAO;AAGxC,MAAI,OAAO,WAAW,2BAA2B;AAC/C,WAAO,OAAO,mBAAmB,OAAO,WAAW;AAAA,EACrD;AACA,MAAI,OAAO,WAAW,UAAa,OAAO,UAAU,uBAAwB,QAAO;AACnF,SAAO;AACT;AAOO,SAAS,kBACd,UACA,MACqB;AACrB,MAAI,aAAa,KAAM,QAAO;AAC9B,QAAM,YAAY,SAAS,WAAW,eAAe,KAAK,WAAW;AACrE,QAAM,SAA8B;AAAA,IAClC,QAAQ,YAAY,cAAc;AAAA,IAClC,gBAAgB,SAAS,iBAAiB,KAAK;AAAA,IAC/C,oBAAoB,SAAS,qBAAqB,KAAK;AAAA,EACzD;AACA,MAAI,CAAC,UAAW,QAAO,SAAS,KAAK,UAAU,SAAS;AACxD,MAAI,SAAS,8BAA8B,QAAQ,KAAK,8BAA8B,MAAM;AAC1F,WAAO,4BAA4B;AAAA,EACrC;AACA,SAAO;AACT;AAaO,SAAS,4BAA4B,OAKjC;AACT,MAAI,CAAC,MAAM,YAAY,CAAC,MAAM,sBAAuB,QAAO,OAAO;AACnE,SAAO,MAAM,SAAS,sBAAsB,MAAM,OAAO,MAAM,UAAU,EAAE;AAC7E;","names":[]}

package/dist/{chunk-NQOM6PHO.js → chunk-VCOCOBUS.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-5KBIOI4G.js";
 import {
   composeSalvagedEnvelope
-} from "./chunk-JH2ALMPR.js";
+} from "./chunk-WR5POHQ3.js";
 import {
   resolveDefaultNamespaceRoot
-} from "./chunk-FBAHBFT5.js";
+} from "./chunk-4HJ2QK32.js";
 import {
   StorageManager,
   readRawMemoryDocument
-} from "./chunk-R6TCM47S.js";
+} from "./chunk-5KZNWERU.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -22,7 +22,7 @@ import {
 } from "./chunk-BJMBJZ2Y.js";
 import {
   readMaybeEncryptedLines
-} from "./chunk-UJDTXWMT.js";
+} from "./chunk-QIMGULGN.js";
 import {
   writeFileAtomically
 } from "./chunk-BTNNL7ZW.js";
@@ -42,7 +42,7 @@ import {
 } from "./chunk-C5LWPYS3.js";
 import {
   readMaybeEncryptedFile
-} from "./chunk-TYGLV6ZG.js";
+} from "./chunk-EYGOM6AI.js";
 import {
   assertPathInsideRoot
 } from "./chunk-C7HJ3NEI.js";
@@ -1869,4 +1869,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-NQOM6PHO.js.map
+//# sourceMappingURL=chunk-VCOCOBUS.js.map

package/dist/{chunk-4P4VLPGB.js → chunk-VECRSYQG.js}

@@ -400,4 +400,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-4P4VLPGB.js.map
+//# sourceMappingURL=chunk-VECRSYQG.js.map

package/dist/{chunk-ID2PLENW.js → chunk-VHBGJAYC.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TOTT6S2V.js";
 import {
   isRecallDisclosure
-} from "./chunk-A6PKEU7T.js";
+} from "./chunk-PARM6OYL.js";
 import {
   normalizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -312,4 +312,4 @@ export {
   RecallXrayBuilder,
   summarizeDisclosureTokens
 };
-//# sourceMappingURL=chunk-ID2PLENW.js.map
+//# sourceMappingURL=chunk-VHBGJAYC.js.map

package/dist/{chunk-RVYXSS3Q.js → chunk-VIS23B6O.js}

@@ -3,7 +3,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-U4JXQCJ3.js";
+} from "./chunk-GLB6VV3J.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -30,6 +30,9 @@ import {
   stripUntrustedFactSpans,
   truncateLocalExtractionConversation
 } from "./chunk-3SL52JKD.js";
+import {
+  attachExtractionProvenance
+} from "./chunk-CIIHIAJ2.js";
 import {
   containsExtractionPlaceholder,
   extractionAttributes,
@@ -37,9 +40,6 @@ import {
   extractionText,
   isPlainRecord
 } from "./chunk-BVRZSI7Q.js";
-import {
-  attachExtractionProvenance
-} from "./chunk-CIIHIAJ2.js";
 import {
   classifyExtractionThrownError,
   classifyFallbackParseFailure,
@@ -83,14 +83,14 @@ import {
 } from "./chunk-5MA7ZLPD.js";
 import {
   LocalLlmClient
-} from "./chunk-74AY3S7U.js";
+} from "./chunk-JNLYHJG7.js";
 import {
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
 import {
   FallbackLlmClient,
   gatewayTaskChainOptions
-} from "./chunk-GMMZ45C4.js";
+} from "./chunk-AVVCPA7U.js";
 import {
   buildChatCompletionTokenLimit,
   shouldAssumeOpenAiChatCompletions
@@ -103,7 +103,7 @@ import {
 } from "./chunk-YBA52OKG.js";
 import {
   isMemoryCategory
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -2439,4 +2439,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-RVYXSS3Q.js.map
+//# sourceMappingURL=chunk-VIS23B6O.js.map

package/dist/{chunk-NMKETOAX.js → chunk-VSHWPOUB.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-FEHIOYML.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
@@ -1463,4 +1463,4 @@ export {
   serializeDecisionRecord,
   parseDecisionRecord
 };
-//# sourceMappingURL=chunk-NMKETOAX.js.map
+//# sourceMappingURL=chunk-VSHWPOUB.js.map

package/dist/{chunk-UBN5AOLT.js → chunk-W5EO4USJ.js}

@@ -9,7 +9,7 @@ import {
   SecureStoreLockedError,
   readMaybeEncryptedFile,
   writeMaybeEncryptedFile
-} from "./chunk-TYGLV6ZG.js";
+} from "./chunk-EYGOM6AI.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -577,4 +577,4 @@ export {
   FactHashIndexNotAuthoritativeError,
   ContentHashIndex
 };
-//# sourceMappingURL=chunk-UBN5AOLT.js.map
+//# sourceMappingURL=chunk-W5EO4USJ.js.map

package/dist/{chunk-Y7427SL7.js → chunk-WCGJK4NQ.js}

@@ -1,3 +1,6 @@
+import {
+  LcmDag
+} from "./chunk-7N4KAIGN.js";
 import {
   LcmWorkQueue
 } from "./chunk-MMCO4SRG.js";
@@ -14,9 +17,6 @@ import {
 import {
   LcmArchive
 } from "./chunk-WVP2I6C5.js";
-import {
-  LcmDag
-} from "./chunk-7N4KAIGN.js";
 import {
   nativeBindingRecoveryHint
 } from "./chunk-LD72P4YS.js";
@@ -602,4 +602,4 @@ export {
   extractLcmConfig,
   LcmEngine
 };
-//# sourceMappingURL=chunk-Y7427SL7.js.map
+//# sourceMappingURL=chunk-WCGJK4NQ.js.map

package/dist/{chunk-CCYXCT4B.js → chunk-WQYS47G4.js}

@@ -1,6 +1,6 @@
 import {
   isNamespaceKind
-} from "./chunk-7PG7QBWD.js";
+} from "./chunk-SRPGA6WN.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -40,4 +40,4 @@ export {
   positiveIntQueryParam,
   optionalNamespaceKindQueryParam
 };
-//# sourceMappingURL=chunk-CCYXCT4B.js.map
+//# sourceMappingURL=chunk-WQYS47G4.js.map

package/dist/{chunk-JH2ALMPR.js → chunk-WR5POHQ3.js}

@@ -1,6 +1,6 @@
 import {
   composeMemoryEnvelope
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -17,4 +17,4 @@ function composeSalvagedEnvelope(label, input, ctx) {
 export {
   composeSalvagedEnvelope
 };
-//# sourceMappingURL=chunk-JH2ALMPR.js.map
+//# sourceMappingURL=chunk-WR5POHQ3.js.map

package/dist/{chunk-DK5VMJL3.js → chunk-WT2VVYBM.js}

@@ -1,6 +1,6 @@
 import {
   parseEntityFile
-} from "./chunk-R6TCM47S.js";
+} from "./chunk-5KZNWERU.js";
 import {
   inferMemoryStatus
 } from "./chunk-7RJUVTVF.js";
@@ -253,4 +253,4 @@ export {
   WHO_KNOWS_MCP_TOOLS,
   handleWhoKnowsHttpQuery
 };
-//# sourceMappingURL=chunk-DK5VMJL3.js.map
+//# sourceMappingURL=chunk-WT2VVYBM.js.map

package/dist/{chunk-EHIKY2IA.js → chunk-WU5WTCH5.js}

@@ -5,7 +5,7 @@ import {
 import {
   TAG_LIMITS,
   composeMemoryEnvelope
-} from "./chunk-TDCR6PQL.js";
+} from "./chunk-TWRPWJJT.js";
 import {
   isTombstoneBlockedCaptureWriteLockBusy
 } from "./chunk-YET735EZ.js";
@@ -789,4 +789,4 @@ export {
   shouldProcessInlineExplicitCapture,
   InlineExplicitCaptureProcessor
 };
-//# sourceMappingURL=chunk-EHIKY2IA.js.map
+//# sourceMappingURL=chunk-WU5WTCH5.js.map

package/dist/{chunk-QKXPOLQD.js → chunk-WUBGMV3G.js}

@@ -1,3 +1,8 @@
+import {
+  ActivationPathTracker,
+  compareActivationPathCandidates,
+  reconstructActivationPath
+} from "./chunk-LXY5VVGM.js";
 import {
   assertGraphLockHeld,
   withGraphWriteLock,
@@ -12,11 +17,6 @@ import {
 import {
   emitGraphEvent
 } from "./chunk-DEUNUKTD.js";
-import {
-  ActivationPathTracker,
-  compareActivationPathCandidates,
-  reconstructActivationPath
-} from "./chunk-LXY5VVGM.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -758,4 +758,4 @@ export {
   applyPageRankRefinement,
   applyLateralInhibition
 };
-//# sourceMappingURL=chunk-QKXPOLQD.js.map
+//# sourceMappingURL=chunk-WUBGMV3G.js.map

package/dist/{chunk-O6YJI5VX.js → chunk-WUL6LDJ4.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-ID2PLENW.js";
+} from "./chunk-VHBGJAYC.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -620,4 +620,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-O6YJI5VX.js.map
+//# sourceMappingURL=chunk-WUL6LDJ4.js.map

package/dist/{chunk-5EILJ6W2.js → chunk-WXPBDEMW.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AAD2ZS6P.js";
 import {
   gatewayTaskChainOptions
-} from "./chunk-GMMZ45C4.js";
+} from "./chunk-AVVCPA7U.js";
 import {
   extractJsonCandidates
 } from "./chunk-YBA52OKG.js";
@@ -685,4 +685,4 @@ export {
   serializeFaithfulnessFields,
   parseFaithfulnessField
 };
-//# sourceMappingURL=chunk-5EILJ6W2.js.map
+//# sourceMappingURL=chunk-WXPBDEMW.js.map

package/dist/{chunk-U7HJBODU.js → chunk-XKTHJHSQ.js}

@@ -5,13 +5,13 @@ import {
   embeddingGenerationMembership,
   embeddingShardDirOf,
   isEmbeddingGenerationDirPath
-} from "./chunk-I73ZSORJ.js";
-import {
-  resolveSafeArchiveTarget
-} from "./chunk-GCGJW34D.js";
+} from "./chunk-OXSTKCYK.js";
 import {
   EMBEDDING_SHARD_FILE_PATTERN
 } from "./chunk-LDWE7OZS.js";
+import {
+  resolveSafeArchiveTarget
+} from "./chunk-GCGJW34D.js";
 import {
   EmbeddingIndexStorageError
 } from "./chunk-Y57GJDG5.js";
@@ -369,4 +369,4 @@ export {
   applyChangesetEmbeddingGenerations,
   buildChangesetGenerationManifest
 };
-//# sourceMappingURL=chunk-U7HJBODU.js.map
+//# sourceMappingURL=chunk-XKTHJHSQ.js.map

package/dist/{chunk-JFI3ATK4.js → chunk-XMYWYJM2.js}

@@ -16,7 +16,7 @@ import {
 } from "./chunk-QUIRIG2P.js";
 import {
   isEncryptedFile
-} from "./chunk-TYGLV6ZG.js";
+} from "./chunk-EYGOM6AI.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -452,4 +452,4 @@ export {
   augmentWithDirectAndTemporal,
   parallelRetrieval
 };
-//# sourceMappingURL=chunk-JFI3ATK4.js.map
+//# sourceMappingURL=chunk-XMYWYJM2.js.map

package/dist/{chunk-64S6X4IU.js → chunk-XTN54NML.js}

@@ -1,3 +1,6 @@
+import {
+  ClaudeCodeAdapter
+} from "./chunk-3JKYQBLC.js";
 import {
   CodexAdapter
 } from "./chunk-7RKSJVOQ.js";
@@ -7,9 +10,6 @@ import {
 import {
   ReplitAdapter
 } from "./chunk-SI36RWC3.js";
-import {
-  ClaudeCodeAdapter
-} from "./chunk-3JKYQBLC.js";
 import {
   headerValue
 } from "./chunk-NJAIR57U.js";
@@ -110,4 +110,4 @@ export {
   OpenCodeAdapter,
   AdapterRegistry
 };
-//# sourceMappingURL=chunk-64S6X4IU.js.map
+//# sourceMappingURL=chunk-XTN54NML.js.map