@remnic/core 1.1.11 → 1.1.12

package/dist/cli.js

@@ -88,13 +88,13 @@ import {
   runWorkProductStatusCliCommand,
   runWorkProjectCliCommand,
   runWorkTaskCliCommand
-} from "./chunk-363MWCD3.js";
-import "./chunk-6XA7UN4Z.js";
-import "./chunk-KBYWQWSB.js";
+} from "./chunk-7ZM3BFKK.js";
+import "./chunk-ZNQN6ZTA.js";
 import "./chunk-MXC3AP5I.js";
-import "./chunk-ZL4S7ARC.js";
-import "./chunk-I6BQZSML.js";
+import "./chunk-X7HPGUVG.js";
+import "./chunk-Y3VMVTYX.js";
 import "./chunk-AJA46VX5.js";
+import "./chunk-DZZPC36E.js";
 import "./chunk-HL4DB7TO.js";
 import "./chunk-ZPKBYX2F.js";
 import "./chunk-3SLRNYNG.js";
@@ -102,29 +102,29 @@ import "./chunk-LIRZNNUP.js";
 import "./chunk-Y4Z4I6WK.js";
 import "./chunk-5HRY2WRF.js";
 import "./chunk-ASAITVLA.js";
-import "./chunk-SRBJUAMP.js";
+import "./chunk-FMEBPEAO.js";
 import "./chunk-PYXS46O7.js";
 import "./chunk-3QKK7QOS.js";
-import "./chunk-RXTFCYQF.js";
+import "./chunk-JESOB2HO.js";
 import "./chunk-JRNQ3RNA.js";
-import "./chunk-PB5KW5PL.js";
+import "./chunk-WEJG4TB5.js";
 import "./chunk-CULXMQJH.js";
 import "./chunk-E6K4NIEU.js";
-import "./chunk-57QNCUEZ.js";
+import "./chunk-EABGC2TL.js";
+import "./chunk-HL5LRPNA.js";
 import "./chunk-YRMVARQP.js";
-import "./chunk-P77UEOU2.js";
 import "./chunk-U66YHYC7.js";
-import "./chunk-EABGC2TL.js";
+import "./chunk-P77UEOU2.js";
 import "./chunk-4IS4SXIQ.js";
 import "./chunk-6TBWYBJ3.js";
-import "./chunk-HMDCOMYU.js";
 import "./chunk-JXS5PDQ7.js";
+import "./chunk-HMDCOMYU.js";
+import "./chunk-7SEAZFFB.js";
 import "./chunk-K6WK37A6.js";
 import "./chunk-AJU4PJGY.js";
 import "./chunk-C6QPK5GG.js";
-import "./chunk-7SEAZFFB.js";
 import "./chunk-FYIYMQ5N.js";
-import "./chunk-6Z6UH6TK.js";
+import "./chunk-HY3L4WKC.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-OZHRDTDX.js";
 import "./chunk-4WMCPJWX.js";
@@ -132,56 +132,57 @@ import "./chunk-6HZ6AO2P.js";
 import "./chunk-URB2WSKZ.js";
 import "./chunk-PVGDJXVK.js";
 import "./chunk-NGAVDO7E.js";
-import "./chunk-36CTNQY7.js";
-import "./chunk-Y5KDIOKF.js";
+import "./chunk-RVPLBATS.js";
+import "./chunk-XAMBKFQS.js";
+import "./chunk-C5BCH4ZS.js";
 import "./chunk-IQT3XTKW.js";
-import "./chunk-WGK4VHGP.js";
-import "./chunk-QIGOEM65.js";
+import "./chunk-MNU6ZBWT.js";
+import "./chunk-IB3BFHGN.js";
 import "./chunk-BT7NVCML.js";
-import "./chunk-O4XJUPSF.js";
-import "./chunk-SOBJ6NEY.js";
 import "./chunk-H7XKCNR6.js";
-import "./chunk-EYNQTST2.js";
+import "./chunk-E2UCDP5S.js";
+import "./chunk-SOBJ6NEY.js";
 import "./chunk-D54LZC5L.js";
-import "./chunk-EQINRHYR.js";
-import "./chunk-2YMTO4ZJ.js";
-import "./chunk-EIR5VLIH.js";
-import "./chunk-HJYHRE4S.js";
-import "./chunk-IBX3VFOM.js";
+import "./chunk-QDZ2RLEC.js";
+import "./chunk-JKDVIE52.js";
+import "./chunk-242S3I2A.js";
+import "./chunk-D4GAOFF6.js";
 import "./chunk-5UM2VJ6D.js";
+import "./chunk-4YM32CRU.js";
+import "./chunk-EIR5VLIH.js";
 import "./chunk-PCUKNJAZ.js";
 import "./chunk-EEQLFRUM.js";
 import "./chunk-NBNN5GOB.js";
 import "./chunk-OR64ZGRZ.js";
+import "./chunk-QDW3E4RD.js";
 import "./chunk-GVPWB7EY.js";
 import "./chunk-2LGMW3DJ.js";
-import "./chunk-QDW3E4RD.js";
 import "./chunk-GDFS42HT.js";
 import "./chunk-RK2Y4XOM.js";
 import "./chunk-2LSZVONP.js";
 import "./chunk-WIICJPET.js";
 import "./chunk-G2WADRQ3.js";
-import "./chunk-74EMIVE4.js";
-import "./chunk-IXEJRKCZ.js";
-import "./chunk-DT5TVLJE.js";
-import "./chunk-N5AKDXAI.js";
-import "./chunk-TBBDFYXW.js";
-import "./chunk-WTFWLUSX.js";
-import "./chunk-MCC6KDQF.js";
+import "./chunk-ZVTKDVVM.js";
+import "./chunk-3B6KIRBH.js";
 import "./chunk-YNJHCGDT.js";
 import "./chunk-NN2DKE4T.js";
-import "./chunk-VQXK37XA.js";
-import "./chunk-PFV5C235.js";
-import "./chunk-RULE4VG5.js";
+import "./chunk-23ZZK64Y.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-XJKFSSDW.js";
+import "./chunk-PFV5C235.js";
+import "./chunk-RULE4VG5.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-FAAFWE4G.js";
+import "./chunk-IXEJRKCZ.js";
 import "./chunk-MARWOCVP.js";
+import "./chunk-74EMIVE4.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-N5AKDXAI.js";
+import "./chunk-TBBDFYXW.js";
 import "./chunk-2ODBA7MQ.js";
 import "./chunk-DGXUHMOV.js";
 import "./chunk-LPSF4OQH.js";
@@ -189,15 +190,18 @@ import "./chunk-TVVEYCNW.js";
 import "./chunk-RFYAYKTD.js";
 import "./chunk-LBLXEFWK.js";
 import "./chunk-XKECPATV.js";
-import "./chunk-A4ACKWIW.js";
-import "./chunk-P73JTV34.js";
+import "./chunk-U5JMRGKX.js";
+import "./chunk-BBE34QBJ.js";
+import "./chunk-767ODGE6.js";
 import "./chunk-457A4P3L.js";
 import "./chunk-OA3L7BFR.js";
-import "./chunk-767ODGE6.js";
 import "./chunk-BJMBJZ2Y.js";
 import "./chunk-UKJAGEXH.js";
 import "./chunk-FP2373TW.js";
 import "./chunk-A6XUJE5D.js";
+import "./chunk-AH2JUU6X.js";
+import "./chunk-AC5LO7IU.js";
+import "./chunk-SOAU2OE2.js";
 import "./chunk-PZ5AY32C.js";
 export {
   filterNormalMemorySearchResults,

package/dist/codex-cli-fallback.d.ts

@@ -14,6 +14,7 @@ interface CodexCliFallbackConfig {
 }
 interface CodexCliFallbackOptions {
     timeoutMs?: number;
+    signal?: AbortSignal;
 }
 interface CodexCliFallbackResult {
     content: string;

package/dist/codex-cli-fallback.js

@@ -2,7 +2,7 @@ import {
   __codexCliFallbackTestHooks,
   callCodexCliFallback,
   setCodexCliFallbackRunnerForProcess
-} from "./chunk-KWBPHZUU.js";
+} from "./chunk-RK6F44Y6.js";
 import "./chunk-PZ5AY32C.js";
 export {
   __codexCliFallbackTestHooks,

package/dist/compression-optimizer.d.ts

@@ -1,5 +1,5 @@
 import { CompressionGuidelineOptimizerEventCounts, CompressionGuidelineOptimizerActionSummary, CompressionGuidelineOptimizerRuleUpdate, MemoryActionType, MemoryActionEvent, CompressionGuidelineOptimizerState } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 interface CompressionGuidelineCandidate {
     generatedAt: string;

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { PluginConfig } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 declare const DEFAULT_REASONING_MODEL = "gpt-5.2";
 declare const VALID_MEMORY_CATEGORIES: Set<string>;

package/dist/config.js

@@ -2,7 +2,7 @@ import {
   DEFAULT_REASONING_MODEL,
   VALID_MEMORY_CATEGORIES,
   parseConfig
-} from "./chunk-6Z6UH6TK.js";
+} from "./chunk-HY3L4WKC.js";
 import "./chunk-Z5LAYHGJ.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-MARWOCVP.js";

package/dist/consolidation-provenance-check.d.ts

@@ -2,7 +2,7 @@ import { StorageManager } from './storage.js';
 import './page-versioning.js';
 import './consolidation-operator.js';
 import './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './memory-projection-store-CY8TU40w.js';
 import 'better-sqlite3';
 

package/dist/consolidation-undo.d.ts

@@ -2,7 +2,7 @@ import { StorageManager } from './storage.js';
 import { VersioningConfig } from './page-versioning.js';
 import './consolidation-operator.js';
 import './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './memory-projection-store-CY8TU40w.js';
 import 'better-sqlite3';
 

package/dist/{contradiction-scan-3Z6YW7YA.js → contradiction-scan-QTXAMBUA.js}

@@ -135,7 +135,8 @@ async function callLlm(client, config, userMessage) {
   if ("chatCompletion" in client && typeof client.chatCompletion === "function") {
     const result = await client.chatCompletion(messages, {
       temperature: 0.1,
-      maxTokens: 4096
+      maxTokens: 4096,
+      operation: "contradiction-judge"
     });
     return result?.content ?? "";
   }
@@ -410,4 +411,4 @@ export {
   ACTIVE_STATUSES,
   runContradictionScan
 };
-//# sourceMappingURL=contradiction-scan-3Z6YW7YA.js.map
+//# sourceMappingURL=contradiction-scan-QTXAMBUA.js.map

package/dist/contradiction-scan-QTXAMBUA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contradiction/contradiction-judge.ts","../src/contradiction/contradiction-scan.ts"],"sourcesContent":["/**\n * Contradiction Judge — LLM-as-judge for semantic contradiction detection (issue #520).\n *\n * Pairs semantically-similar memories and classifies their relationship.\n * Reuses the extraction-judge adapter pattern but with a contradiction-specific\n * prompt and verdict taxonomy.\n *\n * Design constraints:\n *   - Default verdict on any failure is \"needs-user\" (rule 48: least-privileged default).\n *   - Never auto-resolve; all verdicts enter the review queue.\n *   - Content-hash caching avoids redundant LLM calls across runs.\n */\n\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\nimport { extractJsonCandidates } from \"../json-extract.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\nexport type ContradictionVerdict =\n  | \"contradicts\"\n  | \"independent\"\n  | \"duplicates\"\n  | \"needs-user\";\n\nexport interface ContradictionJudgeInput {\n  /** Memory ID of the first fact. */\n  memoryIdA: string;\n  /** Memory ID of the second fact. */\n  memoryIdB: string;\n  /** Content text of the first fact. */\n  textA: string;\n  /** Content text of the second fact. */\n  textB: string;\n  /** Category of the first fact (optional context). */\n  categoryA?: string;\n  /** Category of the second fact (optional context). */\n  categoryB?: string;\n}\n\nexport interface ContradictionJudgeResult {\n  /** Memory IDs of the pair. */\n  memoryIdA: string;\n  memoryIdB: string;\n  /** Verdict from the judge. */\n  verdict: ContradictionVerdict;\n  /** Human-readable rationale. */\n  rationale: string;\n  /** Confidence in [0, 1]. */\n  confidence: number;\n}\n\nexport interface ContradictionJudgeBatchResult {\n  /** Results keyed by pair key (\"idA:idB\"). */\n  results: Map<string, ContradictionJudgeResult>;\n  /** Number served from cache. */\n  cached: number;\n  /** Number produced by LLM call. */\n  judged: number;\n  /** Total wall-clock time in ms. */\n  elapsed: number;\n}\n\n// ── Prompt ─────────────────────────────────────────────────────────────────────\n\nconst CONTRADICTION_JUDGE_PROMPT = `You are a memory contradiction classifier. You will receive pairs of stored memories and must classify their semantic relationship.\n\nFor each pair, respond with a JSON array where each element has:\n- \"pairKey\": the pairKey provided in the input\n- \"verdict\": one of \"contradicts\", \"independent\", \"duplicates\", \"needs-user\"\n- \"rationale\": one sentence explaining why\n- \"confidence\": number between 0 and 1\n\nVERDICT DEFINITIONS:\n- \"contradicts\": The two memories make claims that cannot both be true. One must be wrong or outdated.\n- \"duplicates\": The two memories convey essentially the same information (near-paraphrase).\n- \"independent\": The memories are topically similar but do not conflict or duplicate.\n- \"needs-user\": Cannot determine with sufficient confidence; requires human review.\n\nIMPORTANT:\n- Be conservative. When in doubt, prefer \"needs-user\" over a wrong classification.\n- Two memories about the same entity/topic are NOT necessarily contradictory.\n- Temporal changes (\"Joshua uses pnpm\" vs \"Joshua switched to npm\") ARE contradictions.\n- Different aspects of the same entity (\"Joshua uses pnpm\" vs \"Joshua works on Remnic\") are \"independent\".`;\n\n// ── Cache ──────────────────────────────────────────────────────────────────────\n\n/** Module-level fallback cache — only used when caller does not supply one. */\nlet defaultVerdictCache: Map<string, ContradictionJudgeResult> = new Map();\nconst CACHE_MAX = 10_000;\n\nfunction pairKey(idA: string, idB: string): string {\n  const sorted = [idA, idB].sort();\n  return `${sorted[0]}:${sorted[1]}`;\n}\n\nfunction contentHash(a: ContradictionJudgeInput): string {\n  // Sort each side pair to be order-independent (matching pairKey behavior)\n  const sides = [\n    [a.textA.trim(), (a.categoryA ?? \"\").trim()].join(\"|\"),\n    [a.textB.trim(), (a.categoryB ?? \"\").trim()].join(\"|\"),\n  ].sort();\n  const normalized = sides.join(\"|||\");\n  return createHash(\"sha256\").update(normalized).digest(\"hex\").slice(0, 16);\n}\n\nexport function createVerdictCache(): Map<string, ContradictionJudgeResult> {\n  return new Map();\n}\n\nexport function clearVerdictCache(): void {\n  defaultVerdictCache.clear();\n}\n\nexport function verdictCacheSize(): number {\n  return defaultVerdictCache.size;\n}\n\n// ── Public API ──────────────────────────────────────────────────────────────────\n\n/**\n * Judge a batch of memory pairs for contradiction.\n *\n * Uses content-hash caching to skip pairs already judged in a prior run.\n * On any LLM failure, all unresolved pairs default to \"needs-user\".\n */\nexport async function judgeContradictionPairs(\n  pairs: ContradictionJudgeInput[],\n  config: PluginConfig,\n  localLlm: LocalLlmClient | null,\n  fallbackLlm: FallbackLlmClient | null,\n  cache?: Map<string, ContradictionJudgeResult>,\n): Promise<ContradictionJudgeBatchResult> {\n  const startTime = Date.now();\n  const results = new Map<string, ContradictionJudgeResult>();\n  const activeCache = cache ?? defaultVerdictCache;\n  let cached = 0;\n  let judged = 0;\n\n  // Partition into cached vs needs-judging\n  const toJudge: ContradictionJudgeInput[] = [];\n  for (const pair of pairs) {\n    const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n    const hash = contentHash(pair);\n    const cachedResult = activeCache.get(hash);\n    if (cachedResult) {\n      results.set(key, { ...cachedResult, memoryIdA: pair.memoryIdA, memoryIdB: pair.memoryIdB });\n      cached++;\n    } else {\n      toJudge.push(pair);\n    }\n  }\n\n  if (toJudge.length === 0) {\n    return { results, cached, judged, elapsed: Date.now() - startTime };\n  }\n\n  // Build the prompt with all pairs\n  const pairDescriptions = toJudge.map((p, i) => {\n    const pk = pairKey(p.memoryIdA, p.memoryIdB);\n    const catA = p.categoryA ? ` [${p.categoryA}]` : \"\";\n    const catB = p.categoryB ? ` [${p.categoryB}]` : \"\";\n    return `Pair ${i + 1} (pairKey: \"${pk}\"):${catA} \"${p.textA}\"${catB} \"${p.textB}\"`;\n  });\n\n  const userMessage = `Classify these ${toJudge.length} memory pair(s):\\n\\n${pairDescriptions.join(\"\\n\\n\")}`;\n\n  // Try LLM call\n  let llmResponse: string | null = null;\n\n  if (localLlm) {\n    try {\n      llmResponse = await callLlm(localLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] local LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  if (!llmResponse && fallbackLlm) {\n    try {\n      llmResponse = await callLlm(fallbackLlm, config, userMessage);\n    } catch (err) {\n      log.warn(\"[contradiction-judge] fallback LLM call failed: %s\", err instanceof Error ? err.message : err);\n    }\n  }\n\n  // Parse response or default to needs-user\n  if (llmResponse) {\n    const candidates = extractJsonCandidates(llmResponse);\n    const parsed = parseJudgeResponse(candidates, toJudge);\n\n    for (const result of parsed) {\n      const key = pairKey(result.memoryIdA, result.memoryIdB);\n      results.set(key, result);\n\n      // Update cache\n      const input = toJudge.find(\n        (p) => pairKey(p.memoryIdA, p.memoryIdB) === key,\n      );\n      if (input) {\n        const hash = contentHash(input);\n        if (activeCache.size >= CACHE_MAX) {\n          const firstKey = activeCache.keys().next().value;\n          if (firstKey !== undefined) activeCache.delete(firstKey);\n        }\n        activeCache.set(hash, result);\n      }\n      judged++;\n    }\n  } else {\n    // All unresolved → needs-user (rule 48)\n    for (const pair of toJudge) {\n      const key = pairKey(pair.memoryIdA, pair.memoryIdB);\n      const result: ContradictionJudgeResult = {\n        memoryIdA: pair.memoryIdA,\n        memoryIdB: pair.memoryIdB,\n        verdict: \"needs-user\",\n        rationale: \"LLM call failed; requires manual review\",\n        confidence: 0,\n      };\n      results.set(key, result);\n      judged++;\n    }\n  }\n\n  return { results, cached, judged, elapsed: Date.now() - startTime };\n}\n\n// ── Internals ──────────────────────────────────────────────────────────────────\n\nasync function callLlm(\n  client: LocalLlmClient | FallbackLlmClient,\n  config: PluginConfig,\n  userMessage: string,\n): Promise<string> {\n  const messages: Array<{ role: \"user\" | \"assistant\" | \"system\"; content: string }> = [\n    { role: \"system\", content: CONTRADICTION_JUDGE_PROMPT },\n    { role: \"user\", content: userMessage },\n  ];\n  if (\"chatCompletion\" in client && typeof client.chatCompletion === \"function\") {\n    const result = await client.chatCompletion(messages, {\n      temperature: 0.1,\n      maxTokens: 4096,\n      operation: \"contradiction-judge\",\n    });\n    return result?.content ?? \"\";\n  }\n  // FallbackLlmClient — try OpenAI-compatible chat completions\n  if (\"complete\" in client && typeof (client as Record<string, unknown>).complete === \"function\") {\n    const result = await (client as { complete: (msg: Array<{ role: string; content: string }>) => Promise<{ content: string }> }).complete(messages);\n    return result.content ?? \"\";\n  }\n  return \"\";\n}\n\nfunction parseJudgeResponse(\n  candidates: string[],\n  inputs: ContradictionJudgeInput[],\n): ContradictionJudgeResult[] {\n  const VALID_VERDICTS: ContradictionVerdict[] = [\"contradicts\", \"independent\", \"duplicates\", \"needs-user\"];\n\n  for (const candidate of candidates) {\n    try {\n      const parsed = JSON.parse(candidate);\n      const items = Array.isArray(parsed) ? parsed : [parsed];\n      const results: ContradictionJudgeResult[] = [];\n      const matchedKeys = new Set<string>();\n\n      for (const item of items) {\n        if (!item || typeof item !== \"object\") continue;\n\n        const verdict = typeof item.verdict === \"string\" && VALID_VERDICTS.includes(item.verdict as ContradictionVerdict)\n          ? (item.verdict as ContradictionVerdict)\n          : \"needs-user\";\n\n        const pairKeyVal = typeof item.pairKey === \"string\" ? item.pairKey : null;\n        const input = pairKeyVal\n          ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal)\n          : null;\n\n        // If we can't match the pairKey, fall back to index-based matching\n        const fallbackInput = input ?? inputs[results.length] ?? inputs[0];\n        if (!fallbackInput) continue;\n\n        matchedKeys.add(pairKey(fallbackInput.memoryIdA, fallbackInput.memoryIdB));\n\n        const confidence = typeof item.confidence === \"number\"\n          ? Math.min(1, Math.max(0, item.confidence))\n          : 0.5;\n\n        results.push({\n          memoryIdA: fallbackInput.memoryIdA,\n          memoryIdB: fallbackInput.memoryIdB,\n          verdict,\n          rationale: typeof item.rationale === \"string\" ? item.rationale : \"No rationale provided\",\n          confidence,\n        });\n      }\n\n      // Backfill any inputs the LLM omitted with needs-user\n      for (const inp of inputs) {\n        const key = pairKey(inp.memoryIdA, inp.memoryIdB);\n        if (!matchedKeys.has(key)) {\n          results.push({\n            memoryIdA: inp.memoryIdA,\n            memoryIdB: inp.memoryIdB,\n            verdict: \"needs-user\",\n            rationale: \"LLM response omitted this pair\",\n            confidence: 0,\n          });\n        }\n      }\n\n      if (results.length > 0) return results;\n    } catch {\n      continue;\n    }\n  }\n\n  // All parse attempts failed → needs-user for every input\n  return inputs.map((p) => ({\n    memoryIdA: p.memoryIdA,\n    memoryIdB: p.memoryIdB,\n    verdict: \"needs-user\" as ContradictionVerdict,\n    rationale: \"Failed to parse judge response\",\n    confidence: 0,\n  }));\n}\n\nexport { pairKey as _pairKey, contentHash as _contentHash };\n","/**\n * Contradiction Scan — pair generator + scan driver (issue #520).\n *\n * Nightly cron that pairs semantically-similar active memories within\n * the same namespace, sends candidate pairs to the LLM-as-judge\n * contradiction classifier, and drops contradicting pairs into a\n * review queue for user resolution.\n *\n * Pair generation (cheap pre-filter):\n *   1. Find candidate peers via embedding cosine >= similarityFloor.\n *   2. Restrict to pairs sharing at least one entityRef OR overlapping\n *      topic tokens >= topicOverlapFloor.\n *   3. Skip pairs already judged independent/both-valid within cooldown.\n *   4. Cap per-run work at maxPairsPerRun.\n */\n\nimport type { StorageManager } from \"../storage.js\";\nimport type { PluginConfig, MemoryFile, MemoryStatus } from \"../types.js\";\nimport type { SemanticDedupLookup } from \"../dedup/semantic.js\";\nimport { log } from \"../logger.js\";\nimport { judgeContradictionPairs, type ContradictionJudgeInput } from \"./contradiction-judge.js\";\nimport {\n  writePairs,\n  listPairs,\n  isCoolingDown,\n  computePairId,\n  type ContradictionPair,\n} from \"./contradiction-review.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\n/** The set of statuses that represent \"live\" memories eligible for scanning. */\nexport const ACTIVE_STATUSES: Set<MemoryStatus> = new Set([\"active\"]);\n\n/** High-value taxonomy buckets to scan. */\nconst SCAN_CATEGORIES = new Set([\n  \"decision\",\n  \"principle\",\n  \"rule\",\n  \"entity\",\n  \"fact\",\n  \"preference\",\n]);\n\nexport interface ScanResult {\n  /** Total active memories scanned. */\n  scanned: number;\n  /** Candidate pairs generated by the pre-filter. */\n  candidates: number;\n  /** Pairs sent to judge. */\n  judged: number;\n  /** Pairs written to review queue. */\n  queued: number;\n  /** Pairs skipped due to cooldown. */\n  cooledDown: number;\n  /** Total wall-clock time in ms. */\n  elapsedMs: number;\n}\n\nexport interface ScanDependencies {\n  storage: StorageManager;\n  config: PluginConfig;\n  memoryDir: string;\n  /** Pre-built embedding lookup. When provided, used as-is for Strategy 3. */\n  embeddingLookup?: SemanticDedupLookup;\n  /**\n   * Factory to build a namespace-scoped embedding lookup.\n   * When provided, takes precedence over `embeddingLookup`.\n   * The scan driver passes its own `storage` so the lookup queries the correct index.\n   */\n  embeddingLookupFactory?: (storage: StorageManager) => SemanticDedupLookup | undefined;\n  localLlm: LocalLlmClient | null;\n  fallbackLlm: FallbackLlmClient | null;\n  namespace?: string;\n}\n\n// ── Main scan driver ───────────────────────────────────────────────────────────\n\n/**\n * Run a contradiction scan over the memory corpus.\n *\n * This is the entry point called by the nightly cron and by the CLI.\n */\nexport async function runContradictionScan(deps: ScanDependencies): Promise<ScanResult> {\n  const startTime = Date.now();\n  const { storage, config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm, namespace } = deps;\n  const scanConfig = config.contradictionScan;\n\n  // Prefer the factory (which uses the scan's own storage for correct namespace scoping)\n  // over a pre-built lookup (which may use default-namespace storage).\n  const scopedEmbeddingLookup = embeddingLookupFactory\n    ? embeddingLookupFactory(storage)\n    : embeddingLookup;\n\n  if (!scanConfig.enabled) {\n    log.info(\"[contradiction-scan] disabled by config\");\n    return { scanned: 0, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: 0 };\n  }\n\n  // 1. Load active memories in scan categories\n  const memories = await loadEligibleMemories(storage, namespace);\n  log.info(\"[contradiction-scan] loaded %d eligible memories\", memories.length);\n\n  if (memories.length < 2) {\n    return { scanned: memories.length, candidates: 0, judged: 0, queued: 0, cooledDown: 0, elapsedMs: Date.now() - startTime };\n  }\n\n  // 2. Load existing review pairs for cooldown checking\n  const existingPairs = listPairs(memoryDir, { filter: \"all\", namespace, limit: 10000 }).pairs;\n  const existingMap = new Map<string, ContradictionPair>();\n  for (const p of existingPairs) {\n    existingMap.set(p.pairId, p);\n  }\n\n  // 3. Generate candidate pairs\n  const candidates = await generatePairs(memories, existingMap, scanConfig, scopedEmbeddingLookup);\n  const cooledDown = candidates.skipped;\n  log.info(\"[contradiction-scan] generated %d candidates (%d cooled down)\", candidates.pairs.length, cooledDown);\n\n  if (candidates.pairs.length === 0) {\n    return {\n      scanned: memories.length,\n      candidates: 0,\n      judged: 0,\n      queued: 0,\n      cooledDown,\n      elapsedMs: Date.now() - startTime,\n    };\n  }\n\n  // 4. Cap at maxPairsPerRun (deterministic selection by pairId)\n  const capped = candidates.pairs\n    .sort((a, b) => computePairId(a.idA, a.idB).localeCompare(computePairId(b.idA, b.idB)))\n    .slice(0, scanConfig.maxPairsPerRun);\n\n  // 5. Build judge inputs\n  const judgeInputs: ContradictionJudgeInput[] = capped.map((pair) => ({\n    memoryIdA: pair.idA,\n    memoryIdB: pair.idB,\n    textA: pair.textA,\n    textB: pair.textB,\n    categoryA: pair.categoryA,\n    categoryB: pair.categoryB,\n  }));\n\n  // 6. Send to judge (per-scan cache avoids module-level singleton leak)\n  const scanCache = new Map<string, import(\"./contradiction-judge.js\").ContradictionJudgeResult>();\n  const judgeResult = await judgeContradictionPairs(judgeInputs, config, localLlm, fallbackLlm, scanCache);\n  log.info(\"[contradiction-scan] judge completed: %d judged, %d cached in %dms\", judgeResult.judged, judgeResult.cached, judgeResult.elapsed);\n\n  // 7. Write to review queue\n  const queueEntries: Array<Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] }> = [];\n  for (const [key, result] of judgeResult.results) {\n    queueEntries.push({\n      memoryIds: [result.memoryIdA, result.memoryIdB],\n      verdict: result.verdict,\n      rationale: result.rationale,\n      confidence: result.confidence,\n      detectedAt: new Date().toISOString(),\n      // Set lastReviewedAt for non-actionable verdicts so cooldown prevents re-judging\n      lastReviewedAt: result.verdict === \"independent\" ? new Date().toISOString() : undefined,\n      namespace,\n    });\n  }\n\n  const written = writePairs(memoryDir, queueEntries);\n  const elapsed = Date.now() - startTime;\n  log.info(\"[contradiction-scan] complete: %d queued in %dms\", written.length, elapsed);\n\n  return {\n    scanned: memories.length,\n    candidates: candidates.pairs.length,\n    judged: judgeResult.judged,\n    queued: written.length,\n    cooledDown,\n    elapsedMs: elapsed,\n  };\n}\n\n// ── Pair generation ────────────────────────────────────────────────────────────\n\ninterface CandidatePair {\n  idA: string;\n  idB: string;\n  textA: string;\n  textB: string;\n  categoryA?: string;\n  categoryB?: string;\n}\n\ninterface PairGenResult {\n  pairs: CandidatePair[];\n  skipped: number;\n}\n\nasync function generatePairs(\n  memories: MemoryFile[],\n  existingPairs: Map<string, ContradictionPair>,\n  scanConfig: PluginConfig[\"contradictionScan\"],\n  embeddingLookup?: SemanticDedupLookup,\n): Promise<PairGenResult> {\n  const pairs: CandidatePair[] = [];\n  const embeddingPairs: CandidatePair[] = [];\n  let skipped = 0;\n  const seen = new Set<string>();\n\n  // Build index by entityRef for fast lookup\n  const byEntity = new Map<string, MemoryFile[]>();\n  for (const mem of memories) {\n    const entity = mem.frontmatter.entityRef;\n    if (entity) {\n      const existing = byEntity.get(entity) ?? [];\n      existing.push(mem);\n      byEntity.set(entity, existing);\n    }\n  }\n\n  // Strategy 1: Entity-ref based pairing (high precision)\n  for (const [, group] of byEntity) {\n    if (group.length < 2) continue;\n    for (let i = 0; i < group.length; i++) {\n      for (let j = i + 1; j < group.length; j++) {\n        const a = group[i];\n        const b = group[j];\n        const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!);\n\n        if (seen.has(pairId)) continue;\n        seen.add(pairId);\n\n        // Check cooldown\n        const existing = existingPairs.get(pairId);\n        if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {\n          skipped++;\n          continue;\n        }\n\n        pairs.push({\n          idA: a.frontmatter.id!,\n          idB: b.frontmatter.id!,\n          textA: a.content,\n          textB: b.content,\n          categoryA: a.frontmatter.category as string | undefined,\n          categoryB: b.frontmatter.category as string | undefined,\n        });\n      }\n    }\n  }\n\n  // Strategy 2: Tag/topic overlap for memories without shared entityRef\n  const noEntity = memories.filter((m) => !m.frontmatter.entityRef);\n  for (let i = 0; i < noEntity.length; i++) {\n    for (let j = i + 1; j < noEntity.length; j++) {\n      const a = noEntity[i];\n      const b = noEntity[j];\n      const overlap = jaccardOverlap(\n        (a.frontmatter.tags as string[]) ?? [],\n        (b.frontmatter.tags as string[]) ?? [],\n      );\n\n      if (overlap < scanConfig.topicOverlapFloor) continue;\n\n      const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!);\n      if (seen.has(pairId)) continue;\n      seen.add(pairId);\n\n      const existing = existingPairs.get(pairId);\n      if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {\n        skipped++;\n        continue;\n      }\n\n      pairs.push({\n        idA: a.frontmatter.id!,\n        idB: b.frontmatter.id!,\n        textA: a.content,\n        textB: b.content,\n        categoryA: a.frontmatter.category as string | undefined,\n        categoryB: b.frontmatter.category as string | undefined,\n      });\n    }\n  }\n\n  // Strategy 3: Embedding cosine similarity (enforces similarityFloor config)\n  if (embeddingLookup) {\n    const memoryById = new Map(memories.map((m) => [m.frontmatter.id!, m]));\n    for (const mem of memories) {\n      const id = mem.frontmatter.id!;\n      try {\n        const hits = await embeddingLookup(mem.content, 20);\n        for (const hit of hits) {\n          if (hit.score < scanConfig.similarityFloor) continue;\n          if (hit.id === id) continue;\n          const peer = memoryById.get(hit.id);\n          if (!peer) continue;\n\n          const pairId = computePairId(id, hit.id);\n          if (seen.has(pairId)) continue;\n          seen.add(pairId);\n\n          const existing = existingPairs.get(pairId);\n          if (existing && isCoolingDown(existing, scanConfig.cooldownDays)) {\n            skipped++;\n            continue;\n          }\n\n          embeddingPairs.push({\n            idA: id,\n            idB: hit.id,\n            textA: mem.content,\n            textB: peer.content,\n            categoryA: mem.frontmatter.category as string | undefined,\n            categoryB: peer.frontmatter.category as string | undefined,\n          });\n        }\n      } catch {\n        // Embedding backend unavailable — skip, entity-ref/tag strategies already covered\n      }\n    }\n  }\n\n  // Append embedding pairs after high-precision entity/topic pairs so the\n  // downstream sort+slice(maxPairsPerRun) keeps precision-first ordering.\n  pairs.push(...embeddingPairs);\n\n  return { pairs, skipped };\n}\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nasync function loadEligibleMemories(storage: StorageManager, namespace?: string): Promise<MemoryFile[]> {\n  let all: MemoryFile[];\n  try {\n    all = await storage.readAllMemories();\n  } catch {\n    return [];\n  }\n\n  return all.filter((mem) => {\n    const fm = mem.frontmatter;\n    // Only active memories (rule 53: explicit ACTIVE_STATUSES set)\n    const status = (fm.status as MemoryStatus) ?? \"active\";\n    if (!ACTIVE_STATUSES.has(status)) return false;\n\n    // Only scan high-value categories\n    const category = fm.category as string | undefined;\n    if (category && !SCAN_CATEGORIES.has(category)) return false;\n\n    // Must have content\n    if (!mem.content || mem.content.trim().length === 0) return false;\n\n    // Must have an ID\n    if (!fm.id) return false;\n\n    // Namespace scoping is handled at the storage layer — memoryDir is\n    // already namespace-scoped, so readAllMemories() returns only memories\n    // within the requested namespace.\n\n    return true;\n  });\n}\n\nfunction jaccardOverlap(a: string[], b: string[]): number {\n  if (a.length === 0 && b.length === 0) return 0;\n  const setA = new Set(a.map((t) => t.toLowerCase()));\n  const setB = new Set(b.map((t) => t.toLowerCase()));\n  let intersection = 0;\n  for (const item of setA) {\n    if (setB.has(item)) intersection++;\n  }\n  const union = setA.size + setB.size - intersection;\n  return union === 0 ? 0 : intersection / union;\n}\n"],"mappings":"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","names":[]}

package/dist/day-summary.d.ts

@@ -1,5 +1,5 @@
 import { PluginConfig, MemoryFile } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 declare function loadDaySummaryPrompt(): Promise<string>;
 declare function formatDaySummaryMemories(memories: string | MemoryFile[]): string;

package/dist/delinearize.d.ts

@@ -1,5 +1,5 @@
 import { EntityMention } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 /**
  * De-linearization transform (SimpleMem-inspired).

package/dist/direct-answer-wiring.d.ts

@@ -2,7 +2,7 @@ import { MemoryFile, PluginConfig } from './types.js';
 import { TrustZoneName } from './trust-zones.js';
 import { T as Taxonomy } from './types-DJhqDJUV.js';
 import { DirectAnswerResult } from './direct-answer.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 /**
  * Direct-answer wiring (issue #518 slice 3).

package/dist/direct-answer-wiring.js

@@ -1,6 +1,6 @@
 import {
   tryDirectAnswer
-} from "./chunk-6AUUAZEX.js";
+} from "./chunk-5NXIJZFX.js";
 import "./chunk-Y4FHOFJ2.js";
 import "./chunk-PVGDJXVK.js";
 import "./chunk-DT5TVLJE.js";

package/dist/direct-answer.d.ts

@@ -1,6 +1,6 @@
 import { MemoryFile } from './types.js';
 import { TrustZoneName } from './trust-zones.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 /**
  * Direct-answer retrieval tier eligibility (issue #518 slice 2).

package/dist/embedding-fallback.d.ts

@@ -1,5 +1,5 @@
 import { PluginConfig } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 /**
  * Thrown by `EmbeddingFallback.search()` (via `embed()`) when the embedding

package/dist/{engine-FOC3IJLA.js → engine-35M5BKQ7.js}

@@ -1,22 +1,22 @@
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-4DXC6HQQ.js";
-import "./chunk-IXEJRKCZ.js";
-import "./chunk-MCC6KDQF.js";
+} from "./chunk-FQDPCE3I.js";
+import "./chunk-3B6KIRBH.js";
 import "./chunk-YNJHCGDT.js";
 import "./chunk-NN2DKE4T.js";
-import "./chunk-VQXK37XA.js";
-import "./chunk-PFV5C235.js";
-import "./chunk-RULE4VG5.js";
+import "./chunk-23ZZK64Y.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-XJKFSSDW.js";
+import "./chunk-PFV5C235.js";
+import "./chunk-RULE4VG5.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-FVQJYWH7.js";
 import "./chunk-4DJQYKMN.js";
 import "./chunk-G7D6GZ5J.js";
 import "./chunk-FAAFWE4G.js";
+import "./chunk-IXEJRKCZ.js";
 import "./chunk-MARWOCVP.js";
 import "./chunk-2ODBA7MQ.js";
 import "./chunk-A6XUJE5D.js";
@@ -25,4 +25,4 @@ export {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
 };
-//# sourceMappingURL=engine-FOC3IJLA.js.map
+//# sourceMappingURL=engine-35M5BKQ7.js.map

package/dist/entity-retrieval.d.ts

@@ -4,7 +4,7 @@ import './page-versioning.js';
 import './consolidation-operator.js';
 import './memory-projection-store-CY8TU40w.js';
 import 'better-sqlite3';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 interface BuildEntityRecallSectionOptions {
     config: PluginConfig;

package/dist/entity-retrieval.js

@@ -3,16 +3,16 @@ import {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-LIO5X3CM.js";
+} from "./chunk-UVMUAWVT.js";
 import "./chunk-7SEAZFFB.js";
-import "./chunk-MCC6KDQF.js";
+import "./chunk-3B6KIRBH.js";
 import "./chunk-YNJHCGDT.js";
 import "./chunk-NN2DKE4T.js";
-import "./chunk-VQXK37XA.js";
-import "./chunk-PFV5C235.js";
-import "./chunk-RULE4VG5.js";
+import "./chunk-23ZZK64Y.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-XJKFSSDW.js";
+import "./chunk-PFV5C235.js";
+import "./chunk-RULE4VG5.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
 import "./chunk-FVQJYWH7.js";

package/dist/entity-schema.d.ts

@@ -1,5 +1,5 @@
 import { EntitySchemaDefinition, EntitySchemaSectionDefinition, EntityStructuredSection } from './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 
 declare function normalizeEntityText(value: string): string;
 declare function normalizeEntitySchemas(raw: unknown): Record<string, EntitySchemaDefinition> | undefined;

package/dist/event-order-recall.d.ts

@@ -0,0 +1,17 @@
+import { ExplicitCueRecallEngine } from './explicit-cue-recall.js';
+
+interface EventOrderRecallOptions {
+    engine: ExplicitCueRecallEngine | null | undefined;
+    sessionId?: string;
+    query: string;
+    maxChars: number;
+    maxItemChars?: number;
+    maxScanWindowTurns?: number;
+    maxScanWindowTokens?: number;
+    maxItems?: number;
+    title?: string;
+}
+declare function shouldRecallEventOrderEvidence(query: string): boolean;
+declare function buildEventOrderRecallSection(options: EventOrderRecallOptions): Promise<string>;
+
+export { type EventOrderRecallOptions, buildEventOrderRecallSection, shouldRecallEventOrderEvidence };

package/dist/event-order-recall.js

@@ -0,0 +1,11 @@
+import {
+  buildEventOrderRecallSection,
+  shouldRecallEventOrderEvidence
+} from "./chunk-6NKAQ74D.js";
+import "./chunk-PYPOFEMK.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  buildEventOrderRecallSection,
+  shouldRecallEventOrderEvidence
+};
+//# sourceMappingURL=event-order-recall.js.map

package/dist/event-order-recall.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/evidence-pack.d.ts

@@ -10,7 +10,9 @@ interface EvidencePackOptions {
     title?: string;
     maxChars: number;
     maxItemChars?: number;
+    query?: string;
 }
 declare function buildEvidencePack(items: readonly EvidencePackItem[], options: EvidencePackOptions): string;
+declare function insertAfterEvidenceHeading(evidence: string, title: string, insert: string): string;
 
-export { type EvidencePackItem, type EvidencePackOptions, buildEvidencePack };
+export { type EvidencePackItem, type EvidencePackOptions, buildEvidencePack, insertAfterEvidenceHeading };

package/dist/evidence-pack.js

@@ -1,8 +1,10 @@
 import {
-  buildEvidencePack
-} from "./chunk-74WWN7ZW.js";
+  buildEvidencePack,
+  insertAfterEvidenceHeading
+} from "./chunk-PYPOFEMK.js";
 import "./chunk-PZ5AY32C.js";
 export {
-  buildEvidencePack
+  buildEvidencePack,
+  insertAfterEvidenceHeading
 };
 //# sourceMappingURL=evidence-pack.js.map

package/dist/explicit-capture.d.ts

@@ -1,4 +1,4 @@
-import { O as Orchestrator } from './orchestrator-AOQMo7QI.js';
+import { O as Orchestrator } from './orchestrator-DDMPqU6R.js';
 import { MemoryCategory, PluginConfig } from './types.js';
 import './buffer.js';
 import './storage.js';
@@ -6,7 +6,7 @@ import './page-versioning.js';
 import './consolidation-operator.js';
 import './memory-projection-store-CY8TU40w.js';
 import 'better-sqlite3';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './port-B6VEDIkC.js';
 import './transcript.js';
 import './session-integrity.js';
@@ -20,6 +20,8 @@ import './relevance.js';
 import './negative.js';
 import './recall-state.js';
 import './recall-xray.js';
+import './memory-provenance.js';
+import './user-model.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
 import './semantic-consolidation-ByBXb-sf.js';

package/dist/explicit-cue-recall.d.ts

@@ -24,6 +24,7 @@ interface ExplicitCueRecallOptions {
     maxItemChars?: number;
     maxReferences?: number;
     includeBenchmarkAnchorCues?: boolean;
+    includeContentLexicalCues?: boolean;
     includeStructuredPlanCues?: boolean;
 }
 interface TrajectoryAnalysisRecallOptions {
@@ -45,11 +46,13 @@ declare function normalizeTurnExpansionEnd(stats: {
 declare function collectExplicitTurnReferences(query: string): ExplicitTurnReference[];
 declare function collectLexicalCues(query: string, options?: {
     includeBenchmarkAnchorCues?: boolean;
+    includeContentLexicalCues?: boolean;
     includeStructuredPlanCues?: boolean;
 }): string[];
 declare function collectQuestionSlotCues(query: string): string[];
+declare function collectContentLexicalCues(query: string): string[];
 declare function collectBenchmarkAnchorCues(query: string): string[];
 declare function collectStructuredPlanCues(query: string): string[];
 declare function collectTemporalLexicalCues(query: string): string[];
 
-export { type ExplicitCueRecallEngine, type ExplicitCueRecallOptions, type ExplicitTurnReference, type TrajectoryAnalysisRecallOptions, buildExplicitCueRecallSection, buildTrajectoryAnalysisRecallSection, collectBenchmarkAnchorCues, collectExplicitTurnReferences, collectLexicalCues, collectQuestionSlotCues, collectStructuredPlanCues, collectTemporalLexicalCues, normalizeTurnExpansionEnd };
+export { type ExplicitCueRecallEngine, type ExplicitCueRecallOptions, type ExplicitTurnReference, type TrajectoryAnalysisRecallOptions, buildExplicitCueRecallSection, buildTrajectoryAnalysisRecallSection, collectBenchmarkAnchorCues, collectContentLexicalCues, collectExplicitTurnReferences, collectLexicalCues, collectQuestionSlotCues, collectStructuredPlanCues, collectTemporalLexicalCues, normalizeTurnExpansionEnd };

package/dist/explicit-cue-recall.js

@@ -2,19 +2,21 @@ import {
   buildExplicitCueRecallSection,
   buildTrajectoryAnalysisRecallSection,
   collectBenchmarkAnchorCues,
+  collectContentLexicalCues,
   collectExplicitTurnReferences,
   collectLexicalCues,
   collectQuestionSlotCues,
   collectStructuredPlanCues,
   collectTemporalLexicalCues,
   normalizeTurnExpansionEnd
-} from "./chunk-S2JJBLJG.js";
-import "./chunk-74WWN7ZW.js";
+} from "./chunk-OAZ5MFUB.js";
+import "./chunk-PYPOFEMK.js";
 import "./chunk-PZ5AY32C.js";
 export {
   buildExplicitCueRecallSection,
   buildTrajectoryAnalysisRecallSection,
   collectBenchmarkAnchorCues,
+  collectContentLexicalCues,
   collectExplicitTurnReferences,
   collectLexicalCues,
   collectQuestionSlotCues,

package/dist/extraction-judge-telemetry.d.ts

@@ -1,6 +1,6 @@
 import { JudgeVerdictKind } from './extraction-judge.js';
 import './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './local-llm.js';
 import './model-registry.js';
 import './fallback-llm.js';

package/dist/extraction-judge-training.d.ts

@@ -1,6 +1,6 @@
 import { JudgeVerdictKind } from './extraction-judge.js';
 import './types.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './local-llm.js';
 import './model-registry.js';
 import './fallback-llm.js';

package/dist/extraction-judge.d.ts

@@ -1,7 +1,7 @@
 import { ImportanceLevel, PluginConfig } from './types.js';
 import { LocalLlmClient } from './local-llm.js';
 import { FallbackLlmClient } from './fallback-llm.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import './model-registry.js';
 
 /**

package/dist/extraction.d.ts

@@ -3,7 +3,7 @@ import { ContradictionVerificationResult, SuggestedLinks, MemorySummaryResult }
 import { PluginConfig, GatewayConfig, BufferTurn, ExtractionResult, MemoryFile, ConsolidationResult, DaySummaryResult } from './types.js';
 import { ModelRegistry } from './model-registry.js';
 import { ProfilingCollector } from './profiling.js';
-import './index-1qIcnbG1.js';
+import './index-DJ9QWMw-.js';
 import 'zod';
 
 declare class ExtractionEngine {