@remnic/core 9.65.1 → 9.65.3

package/dist/{chunk-KPBLJCCV.js → chunk-PDVQ5JU3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-3PXVYJMC.js";
+} from "./chunk-WN5FSGLE.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-KPBLJCCV.js.map
+//# sourceMappingURL=chunk-PDVQ5JU3.js.map

package/dist/{chunk-7BY7V4YX.js → chunk-Q4WONDMJ.js}

@@ -6,7 +6,7 @@ import {
   migrateUnscopedPairsToNamespace,
   readPair,
   writePairs
-} from "./chunk-35NN3ZFA.js";
+} from "./chunk-CTVWELNK.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
@@ -548,6 +548,7 @@ export {
   verdictCacheSize,
   judgeContradictionPairs,
   ACTIVE_STATUSES,
-  runContradictionScan
+  runContradictionScan,
+  resolveScanStorage
 };
-//# sourceMappingURL=chunk-7BY7V4YX.js.map
+//# sourceMappingURL=chunk-Q4WONDMJ.js.map

package/dist/{chunk-7BY7V4YX.js.map → chunk-Q4WONDMJ.js.map}

@@ -1 +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    { text: a.textA.trim(), category: (a.categoryA ?? \"\").trim() },\n    { text: a.textB.trim(), category: (a.categoryB ?? \"\").trim() },\n  ].sort((left, right) => {\n    const leftKey = JSON.stringify(left);\n    const rightKey = JSON.stringify(right);\n    return leftKey.localeCompare(rightKey);\n  });\n  const normalized = JSON.stringify(sides);\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  let conservativeFallback: ContradictionJudgeResult[] | null = null;\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.length > 0\n          ? item.pairKey\n          : null;\n        const input = pairKeyVal\n          ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal)\n          : null;\n\n        if (!input) continue;\n\n        matchedKeys.add(pairKey(input.memoryIdA, input.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: input.memoryIdA,\n          memoryIdB: input.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 (matchedKeys.size > 0) return results;\n      if (results.length > 0 && conservativeFallback === null) {\n        conservativeFallback = results;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  if (conservativeFallback !== null) return conservativeFallback;\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 { resolveNamespaceCapabilities } from \"../capabilities.js\";\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  readPair,\n  isCoolingDown,\n  memoryHashesChanged,\n  computeMemoryContentHash,\n  computePairId,\n  migrateUnscopedPairsToNamespace,\n  type ContradictionPair,\n} from \"./contradiction-review.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\nimport { isSupportPassportPrivateMemory } from \"../support-passport/card-projection.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 ScanStorageResolution {\n  storage: StorageManager;\n  namespace?: string;\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  /** Resolver for namespace-scoped storage. Required for scans when namespaces are enabled. */\n  storageForNamespace?: (\n    namespace: string | undefined,\n  ) => StorageManager | ScanStorageResolution | Promise<StorageManager | ScanStorageResolution>;\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 { config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm } = deps;\n  const requestedNamespace = normalizeScanNamespace(deps.namespace);\n  const scanConfig = config.contradictionScan;\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  const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);\n  if (resolveNamespaceCapabilities(config).namespaces && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {\n    const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });\n    if (migrated > 0) {\n      log.info(\"[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s\", migrated, namespace);\n    }\n  }\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(scanStorage)\n    : embeddingLookup;\n\n  // 1. Load active memories in scan categories\n  const memories = await loadEligibleMemories(scanStorage);\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. Prepare exact existing-pair lookup for cooldown checking.\n  // Pair IDs are deterministic, so lookup the candidate's file directly instead\n  // of paging through the review queue and risking a bounded-list miss.\n  const existingPairCache = new Map<string, ContradictionPair | undefined>();\n  const getExistingPair = (pairId: string): ContradictionPair | undefined => {\n    if (!existingPairCache.has(pairId)) {\n      existingPairCache.set(pairId, readPair(memoryDir, pairId) ?? undefined);\n    }\n    return existingPairCache.get(pairId);\n  };\n\n  // 3. Generate candidate pairs\n  const candidates = await generatePairs(memories, getExistingPair, scanConfig, namespace, 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. Build judge inputs. Candidate generation already preserves strategy\n  // priority and caps work at maxPairsPerRun.\n  const judgeInputs: ContradictionJudgeInput[] = candidates.pairs.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  const currentMemoryHashes = memoryContentHashMap(memories);\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      memoryContentHashes: pairMemoryContentHashes(result.memoryIdA, result.memoryIdB, currentMemoryHashes),\n      namespace,\n    });\n  }\n\n  const written = writePairs(memoryDir, queueEntries, { cooldownDays: scanConfig.cooldownDays });\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  getExistingPair: (pairId: string) => ContradictionPair | undefined,\n  scanConfig: PluginConfig[\"contradictionScan\"],\n  namespace: string | undefined,\n  embeddingLookup?: SemanticDedupLookup,\n): Promise<PairGenResult> {\n  const pairs: CandidatePair[] = [];\n  let skipped = 0;\n  const seen = new Set<string>();\n  const maxPairs = Math.max(0, Math.floor(scanConfig.maxPairsPerRun));\n  if (maxPairs === 0) return { pairs, skipped };\n\n  const orderedMemories = [...memories].sort(compareMemoryId);\n  const currentMemoryHashes = memoryContentHashMap(orderedMemories);\n\n  const pushCandidate = (pair: CandidatePair): void => {\n    if (pairs.length < maxPairs) pairs.push(pair);\n  };\n\n  const hasCapacity = (): boolean => pairs.length < maxPairs;\n  const isSkippedByCooldown = (existing: ContradictionPair | undefined): boolean => {\n    if (!existing || !isCoolingDown(existing, scanConfig.cooldownDays)) return false;\n    return !memoryHashesChanged(\"\", existing, (memoryId) => currentMemoryHashes.get(memoryId) ?? null);\n  };\n\n  // Build index by entityRef for fast lookup\n  const byEntity = new Map<string, MemoryFile[]>();\n  for (const mem of orderedMemories) {\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  entityPairs:\n  for (const entity of [...byEntity.keys()].sort()) {\n    const group = byEntity.get(entity) ?? [];\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        if (!hasCapacity()) break entityPairs;\n        const a = group[i];\n        const b = group[j];\n        const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n\n        if (seen.has(pairId)) continue;\n        seen.add(pairId);\n\n        // Check cooldown\n        const existing = getExistingPair(pairId);\n        if (isSkippedByCooldown(existing)) {\n          skipped++;\n          continue;\n        }\n\n        pushCandidate({\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 a shared entityRef\n  topicPairs:\n  for (let i = 0; i < orderedMemories.length; i++) {\n    for (let j = i + 1; j < orderedMemories.length; j++) {\n      if (!hasCapacity()) break topicPairs;\n      const a = orderedMemories[i];\n      const b = orderedMemories[j];\n      if (shareEntityRef(a, b)) continue;\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!, namespace);\n      if (seen.has(pairId)) continue;\n      seen.add(pairId);\n\n      const existing = getExistingPair(pairId);\n      if (isSkippedByCooldown(existing)) {\n        skipped++;\n        continue;\n      }\n\n      pushCandidate({\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 && hasCapacity()) {\n    const memoryById = new Map(orderedMemories.map((m) => [m.frontmatter.id!, m]));\n    embeddingPairs:\n    for (const mem of orderedMemories) {\n      if (!hasCapacity()) break;\n      const id = mem.frontmatter.id!;\n      try {\n        const hits = (await embeddingLookup(mem.content, 20)).sort((a, b) =>\n          b.score - a.score || a.id.localeCompare(b.id),\n        );\n        for (const hit of hits) {\n          if (!hasCapacity()) break embeddingPairs;\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, namespace);\n          if (seen.has(pairId)) continue;\n          seen.add(pairId);\n\n          const existing = getExistingPair(pairId);\n          if (isSkippedByCooldown(existing)) {\n            skipped++;\n            continue;\n          }\n\n          pushCandidate({\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  return { pairs, skipped };\n}\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nfunction normalizeScanNamespace(namespace: string | undefined): string | undefined {\n  const trimmed = namespace?.trim();\n  return trimmed ? trimmed : undefined;\n}\n\nasync function resolveScanStorage(\n  deps: ScanDependencies,\n  namespace: string | undefined,\n): Promise<ScanStorageResolution> {\n  if (!resolveNamespaceCapabilities(deps.config).namespaces) {\n    const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);\n    if (namespace && namespace !== defaultNamespace) {\n      throw new Error(`unsupported namespace: ${namespace}`);\n    }\n    return { storage: deps.storage, namespace: undefined };\n  }\n\n  if (deps.storageForNamespace) {\n    const resolved = await deps.storageForNamespace(namespace);\n    if (isScanStorageResolution(resolved)) {\n      return {\n        storage: resolved.storage,\n        namespace: normalizeScanNamespace(resolved.namespace) ?? fallbackResolvedNamespace(deps, namespace),\n      };\n    }\n    if (!isStorageManagerLike(resolved)) {\n      throw new Error(\"storageForNamespace must return a StorageManager or { storage: StorageManager, namespace?: string }\");\n    }\n    return {\n      storage: resolved,\n      namespace: fallbackResolvedNamespace(deps, namespace),\n    };\n  }\n\n  throw new Error(\n    \"contradiction scans require storageForNamespace when namespaces are enabled so callers can enforce namespace access\",\n  );\n}\n\nfunction isScanStorageResolution(value: StorageManager | ScanStorageResolution): value is ScanStorageResolution {\n  if (isStorageManagerLike(value)) return false;\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { storage?: unknown };\n  return isStorageManagerLike(candidate.storage);\n}\n\nfunction isStorageManagerLike(value: unknown): value is StorageManager {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { readAllMemories?: unknown };\n  return typeof candidate.readAllMemories === \"function\";\n}\n\nfunction fallbackResolvedNamespace(deps: ScanDependencies, namespace: string | undefined): string | undefined {\n  if (namespace) return namespace;\n  return resolveNamespaceCapabilities(deps.config).namespaces ? deps.config.defaultNamespace : undefined;\n}\n\nfunction isDefaultNamespaceScan(\n  config: PluginConfig,\n  requestedNamespace: string | undefined,\n  resolvedNamespace: string,\n): boolean {\n  if (requestedNamespace === undefined) return true;\n  return requestedNamespace === config.defaultNamespace || resolvedNamespace === config.defaultNamespace;\n}\n\nasync function loadEligibleMemories(storage: StorageManager): 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    if (isSupportPassportPrivateMemory(mem)) return false;\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    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\nfunction shareEntityRef(a: MemoryFile, b: MemoryFile): boolean {\n  const entityA = a.frontmatter.entityRef?.trim();\n  const entityB = b.frontmatter.entityRef?.trim();\n  return Boolean(entityA && entityB && entityA === entityB);\n}\n\nfunction compareMemoryId(a: MemoryFile, b: MemoryFile): number {\n  return (a.frontmatter.id ?? \"\").localeCompare(b.frontmatter.id ?? \"\");\n}\n\nfunction memoryContentHashMap(memories: MemoryFile[]): Map<string, string> {\n  const hashes = new Map<string, string>();\n  for (const memory of memories) {\n    const id = memory.frontmatter.id;\n    if (!id) continue;\n    hashes.set(id, computeMemoryContentHash(memory.content, memory.frontmatter.category as string | undefined));\n  }\n  return hashes;\n}\n\nfunction pairMemoryContentHashes(\n  memoryIdA: string,\n  memoryIdB: string,\n  currentMemoryHashes: Map<string, string>,\n): Record<string, string> | undefined {\n  const hashA = currentMemoryHashes.get(memoryIdA);\n  const hashB = currentMemoryHashes.get(memoryIdB);\n  if (!hashA || !hashB) return undefined;\n  return {\n    [memoryIdA]: hashA,\n    [memoryIdB]: hashB,\n  };\n}\n"],"mappings":"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","names":[]}
+{"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    { text: a.textA.trim(), category: (a.categoryA ?? \"\").trim() },\n    { text: a.textB.trim(), category: (a.categoryB ?? \"\").trim() },\n  ].sort((left, right) => {\n    const leftKey = JSON.stringify(left);\n    const rightKey = JSON.stringify(right);\n    return leftKey.localeCompare(rightKey);\n  });\n  const normalized = JSON.stringify(sides);\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  let conservativeFallback: ContradictionJudgeResult[] | null = null;\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.length > 0\n          ? item.pairKey\n          : null;\n        const input = pairKeyVal\n          ? inputs.find((p) => pairKey(p.memoryIdA, p.memoryIdB) === pairKeyVal)\n          : null;\n\n        if (!input) continue;\n\n        matchedKeys.add(pairKey(input.memoryIdA, input.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: input.memoryIdA,\n          memoryIdB: input.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 (matchedKeys.size > 0) return results;\n      if (results.length > 0 && conservativeFallback === null) {\n        conservativeFallback = results;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  if (conservativeFallback !== null) return conservativeFallback;\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 { resolveNamespaceCapabilities } from \"../capabilities.js\";\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  readPair,\n  isCoolingDown,\n  memoryHashesChanged,\n  computeMemoryContentHash,\n  computePairId,\n  migrateUnscopedPairsToNamespace,\n  type ContradictionPair,\n} from \"./contradiction-review.js\";\nimport type { LocalLlmClient } from \"../local-llm.js\";\nimport type { FallbackLlmClient } from \"../fallback-llm.js\";\nimport { isSupportPassportPrivateMemory } from \"../support-passport/card-projection.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 ScanStorageResolution {\n  storage: StorageManager;\n  namespace?: string;\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  /** Resolver for namespace-scoped storage. Required for scans when namespaces are enabled. */\n  storageForNamespace?: (\n    namespace: string | undefined,\n  ) => StorageManager | ScanStorageResolution | Promise<StorageManager | ScanStorageResolution>;\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 { config, memoryDir, embeddingLookup, embeddingLookupFactory, localLlm, fallbackLlm } = deps;\n  const requestedNamespace = normalizeScanNamespace(deps.namespace);\n  const scanConfig = config.contradictionScan;\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  const { storage: scanStorage, namespace } = await resolveScanStorage(deps, requestedNamespace);\n  if (resolveNamespaceCapabilities(config).namespaces && namespace !== undefined && isDefaultNamespaceScan(config, requestedNamespace, namespace)) {\n    const migrated = migrateUnscopedPairsToNamespace(memoryDir, namespace, { cooldownDays: scanConfig.cooldownDays });\n    if (migrated > 0) {\n      log.info(\"[contradiction-scan] migrated %d legacy unscoped review pairs to namespace %s\", migrated, namespace);\n    }\n  }\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(scanStorage)\n    : embeddingLookup;\n\n  // 1. Load active memories in scan categories\n  const memories = await loadEligibleMemories(scanStorage);\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. Prepare exact existing-pair lookup for cooldown checking.\n  // Pair IDs are deterministic, so lookup the candidate's file directly instead\n  // of paging through the review queue and risking a bounded-list miss.\n  const existingPairCache = new Map<string, ContradictionPair | undefined>();\n  const getExistingPair = (pairId: string): ContradictionPair | undefined => {\n    if (!existingPairCache.has(pairId)) {\n      existingPairCache.set(pairId, readPair(memoryDir, pairId) ?? undefined);\n    }\n    return existingPairCache.get(pairId);\n  };\n\n  // 3. Generate candidate pairs\n  const candidates = await generatePairs(memories, getExistingPair, scanConfig, namespace, 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. Build judge inputs. Candidate generation already preserves strategy\n  // priority and caps work at maxPairsPerRun.\n  const judgeInputs: ContradictionJudgeInput[] = candidates.pairs.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  const currentMemoryHashes = memoryContentHashMap(memories);\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      memoryContentHashes: pairMemoryContentHashes(result.memoryIdA, result.memoryIdB, currentMemoryHashes),\n      namespace,\n    });\n  }\n\n  const written = writePairs(memoryDir, queueEntries, { cooldownDays: scanConfig.cooldownDays });\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  getExistingPair: (pairId: string) => ContradictionPair | undefined,\n  scanConfig: PluginConfig[\"contradictionScan\"],\n  namespace: string | undefined,\n  embeddingLookup?: SemanticDedupLookup,\n): Promise<PairGenResult> {\n  const pairs: CandidatePair[] = [];\n  let skipped = 0;\n  const seen = new Set<string>();\n  const maxPairs = Math.max(0, Math.floor(scanConfig.maxPairsPerRun));\n  if (maxPairs === 0) return { pairs, skipped };\n\n  const orderedMemories = [...memories].sort(compareMemoryId);\n  const currentMemoryHashes = memoryContentHashMap(orderedMemories);\n\n  const pushCandidate = (pair: CandidatePair): void => {\n    if (pairs.length < maxPairs) pairs.push(pair);\n  };\n\n  const hasCapacity = (): boolean => pairs.length < maxPairs;\n  const isSkippedByCooldown = (existing: ContradictionPair | undefined): boolean => {\n    if (!existing || !isCoolingDown(existing, scanConfig.cooldownDays)) return false;\n    return !memoryHashesChanged(\"\", existing, (memoryId) => currentMemoryHashes.get(memoryId) ?? null);\n  };\n\n  // Build index by entityRef for fast lookup\n  const byEntity = new Map<string, MemoryFile[]>();\n  for (const mem of orderedMemories) {\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  entityPairs:\n  for (const entity of [...byEntity.keys()].sort()) {\n    const group = byEntity.get(entity) ?? [];\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        if (!hasCapacity()) break entityPairs;\n        const a = group[i];\n        const b = group[j];\n        const pairId = computePairId(a.frontmatter.id!, b.frontmatter.id!, namespace);\n\n        if (seen.has(pairId)) continue;\n        seen.add(pairId);\n\n        // Check cooldown\n        const existing = getExistingPair(pairId);\n        if (isSkippedByCooldown(existing)) {\n          skipped++;\n          continue;\n        }\n\n        pushCandidate({\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 a shared entityRef\n  topicPairs:\n  for (let i = 0; i < orderedMemories.length; i++) {\n    for (let j = i + 1; j < orderedMemories.length; j++) {\n      if (!hasCapacity()) break topicPairs;\n      const a = orderedMemories[i];\n      const b = orderedMemories[j];\n      if (shareEntityRef(a, b)) continue;\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!, namespace);\n      if (seen.has(pairId)) continue;\n      seen.add(pairId);\n\n      const existing = getExistingPair(pairId);\n      if (isSkippedByCooldown(existing)) {\n        skipped++;\n        continue;\n      }\n\n      pushCandidate({\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 && hasCapacity()) {\n    const memoryById = new Map(orderedMemories.map((m) => [m.frontmatter.id!, m]));\n    embeddingPairs:\n    for (const mem of orderedMemories) {\n      if (!hasCapacity()) break;\n      const id = mem.frontmatter.id!;\n      try {\n        const hits = (await embeddingLookup(mem.content, 20)).sort((a, b) =>\n          b.score - a.score || a.id.localeCompare(b.id),\n        );\n        for (const hit of hits) {\n          if (!hasCapacity()) break embeddingPairs;\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, namespace);\n          if (seen.has(pairId)) continue;\n          seen.add(pairId);\n\n          const existing = getExistingPair(pairId);\n          if (isSkippedByCooldown(existing)) {\n            skipped++;\n            continue;\n          }\n\n          pushCandidate({\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  return { pairs, skipped };\n}\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nfunction normalizeScanNamespace(namespace: string | undefined): string | undefined {\n  const trimmed = namespace?.trim();\n  return trimmed ? trimmed : undefined;\n}\n\n/**\n * Resolve the namespace-scoped storage a scan must read and write through.\n *\n * Exported and narrowed to the fields it actually reads so sibling scans\n * (preference drift, issue #2371) share ONE namespace resolver rather than\n * re-deriving the read/write namespace independently — the divergence the\n * namespace/ACL scenario matrix in AGENTS.md exists to prevent.\n */\nexport async function resolveScanStorage(\n  deps: Pick<ScanDependencies, \"config\" | \"storage\" | \"storageForNamespace\">,\n  namespace: string | undefined,\n): Promise<ScanStorageResolution> {\n  if (!resolveNamespaceCapabilities(deps.config).namespaces) {\n    const defaultNamespace = normalizeScanNamespace(deps.config.defaultNamespace);\n    if (namespace && namespace !== defaultNamespace) {\n      throw new Error(`unsupported namespace: ${namespace}`);\n    }\n    return { storage: deps.storage, namespace: undefined };\n  }\n\n  if (deps.storageForNamespace) {\n    const resolved = await deps.storageForNamespace(namespace);\n    if (isScanStorageResolution(resolved)) {\n      return {\n        storage: resolved.storage,\n        namespace: normalizeScanNamespace(resolved.namespace) ?? fallbackResolvedNamespace(deps, namespace),\n      };\n    }\n    if (!isStorageManagerLike(resolved)) {\n      throw new Error(\"storageForNamespace must return a StorageManager or { storage: StorageManager, namespace?: string }\");\n    }\n    return {\n      storage: resolved,\n      namespace: fallbackResolvedNamespace(deps, namespace),\n    };\n  }\n\n  throw new Error(\n    \"contradiction scans require storageForNamespace when namespaces are enabled so callers can enforce namespace access\",\n  );\n}\n\nfunction isScanStorageResolution(value: StorageManager | ScanStorageResolution): value is ScanStorageResolution {\n  if (isStorageManagerLike(value)) return false;\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { storage?: unknown };\n  return isStorageManagerLike(candidate.storage);\n}\n\nfunction isStorageManagerLike(value: unknown): value is StorageManager {\n  if (typeof value !== \"object\" || value === null) return false;\n  const candidate = value as { readAllMemories?: unknown };\n  return typeof candidate.readAllMemories === \"function\";\n}\n\nfunction fallbackResolvedNamespace(\n  deps: Pick<ScanDependencies, \"config\">,\n  namespace: string | undefined,\n): string | undefined {\n  if (namespace) return namespace;\n  return resolveNamespaceCapabilities(deps.config).namespaces ? deps.config.defaultNamespace : undefined;\n}\n\nfunction isDefaultNamespaceScan(\n  config: PluginConfig,\n  requestedNamespace: string | undefined,\n  resolvedNamespace: string,\n): boolean {\n  if (requestedNamespace === undefined) return true;\n  return requestedNamespace === config.defaultNamespace || resolvedNamespace === config.defaultNamespace;\n}\n\nasync function loadEligibleMemories(storage: StorageManager): 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    if (isSupportPassportPrivateMemory(mem)) return false;\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    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\nfunction shareEntityRef(a: MemoryFile, b: MemoryFile): boolean {\n  const entityA = a.frontmatter.entityRef?.trim();\n  const entityB = b.frontmatter.entityRef?.trim();\n  return Boolean(entityA && entityB && entityA === entityB);\n}\n\nfunction compareMemoryId(a: MemoryFile, b: MemoryFile): number {\n  return (a.frontmatter.id ?? \"\").localeCompare(b.frontmatter.id ?? \"\");\n}\n\nfunction memoryContentHashMap(memories: MemoryFile[]): Map<string, string> {\n  const hashes = new Map<string, string>();\n  for (const memory of memories) {\n    const id = memory.frontmatter.id;\n    if (!id) continue;\n    hashes.set(id, computeMemoryContentHash(memory.content, memory.frontmatter.category as string | undefined));\n  }\n  return hashes;\n}\n\nfunction pairMemoryContentHashes(\n  memoryIdA: string,\n  memoryIdB: string,\n  currentMemoryHashes: Map<string, string>,\n): Record<string, string> | undefined {\n  const hashA = currentMemoryHashes.get(memoryIdA);\n  const hashB = currentMemoryHashes.get(memoryIdB);\n  if (!hashA || !hashB) return undefined;\n  return {\n    [memoryIdA]: hashA,\n    [memoryIdB]: hashB,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ESCQ6LY7.js → chunk-QFMO32TO.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-SYJ6EKKE.js";
+} from "./chunk-EIVIB73I.js";
 import {
   StorageManager
-} from "./chunk-DEFI2QBT.js";
+} from "./chunk-PAYGC3BD.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -1005,4 +1005,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-ESCQ6LY7.js.map
+//# sourceMappingURL=chunk-QFMO32TO.js.map

package/dist/{chunk-HQSPXTQO.js → chunk-QXIQPCCN.js}

@@ -296,4 +296,4 @@ async function searchHarmonicRetrieval(options) {
 export {
   searchHarmonicRetrieval
 };
-//# sourceMappingURL=chunk-HQSPXTQO.js.map
+//# sourceMappingURL=chunk-QXIQPCCN.js.map

package/dist/{chunk-CFRBTATE.js → chunk-R47WINCY.js}

@@ -4,10 +4,10 @@ import {
 } from "./chunk-VI637ILW.js";
 import {
   composeSalvagedEnvelope
-} from "./chunk-UYCIS6V5.js";
+} from "./chunk-JCWY73FK.js";
 import {
   StorageManager
-} from "./chunk-DEFI2QBT.js";
+} from "./chunk-PAYGC3BD.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1283,4 +1283,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-CFRBTATE.js.map
+//# sourceMappingURL=chunk-R47WINCY.js.map

package/dist/{chunk-G72IPMR7.js → chunk-R4OCGPSH.js}

@@ -1,6 +1,6 @@
 import {
   EXTRACTION_RESPONSE_PLACEHOLDERS
-} from "./chunk-JG22O53B.js";
+} from "./chunk-7CBKAQIG.js";
 import {
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
@@ -69,4 +69,4 @@ export {
   extractionAttributes,
   extractionCueAnchors
 };
-//# sourceMappingURL=chunk-G72IPMR7.js.map
+//# sourceMappingURL=chunk-R4OCGPSH.js.map

package/dist/{chunk-LCU5R6TQ.js → chunk-RAIUTAZZ.js}

@@ -1,6 +1,9 @@
 import {
   normalizeTags
 } from "./chunk-BT7NVCML.js";
+import {
+  isMemorySubject
+} from "./chunk-RIAM7DND.js";
 import {
   assemblePersistedBody
 } from "./chunk-JDSVLVCG.js";
@@ -190,6 +193,17 @@ function composeMemoryEnvelope(input, ctx, opts = {}) {
       confidence = input.confidence;
     }
   }
+  let subject;
+  if (input.subject !== void 0) {
+    if (!isMemorySubject(input.subject)) {
+      hygiene.flag(
+        "subject",
+        `must be "user" or "agent" (got ${JSON.stringify(input.subject)}) \u2014 dropped`
+      );
+    } else {
+      subject = input.subject;
+    }
+  }
   const validAt = input.validAt === void 0 ? void 0 : validateIsoTimestamp("validAt", input.validAt);
   const now = ctx.now ? ctx.now() : /* @__PURE__ */ new Date();
   if (!(now instanceof Date) || Number.isNaN(now.getTime())) {
@@ -212,11 +226,12 @@ function composeMemoryEnvelope(input, ctx, opts = {}) {
     structuredAttributes: attributes?.canonical,
     rawStructuredAttributes: attributes?.raw,
     entityRef: normalizeOptionalString("entityRef", input.entityRef, hygiene),
+    origin: normalizeOptionalString("origin", input.origin, hygiene),
+    subject,
     confidence,
     ttl: normalizeOptionalString("ttl", input.ttl, hygiene),
     validAt,
     sourceConnector: normalizeOptionalString("sourceConnector", input.sourceConnector, hygiene),
-    origin: normalizeOptionalString("origin", input.origin, hygiene),
     sourceReason: normalizeOptionalString("sourceReason", input.sourceReason, hygiene),
     source: ctx.source.trim(),
     composedAt: now.toISOString(),
@@ -308,8 +323,9 @@ function sealedWriteToLegacyArgs(envelope, extras = {}) {
       // extras — a conditional spread let extras.sourceConnector smuggle
       // unvalidated connector provenance past the sealed envelope when the
       // envelope had none.
+      origin: envelope.origin,
       sourceConnector: envelope.sourceConnector,
-      origin: envelope.origin
+      subject: envelope.subject
     }
   };
 }
@@ -330,6 +346,9 @@ var FINGERPRINT_EXEMPT_FIELDS = [
   // Free-text provenance note; carries no identity.
   // Origin is provenance metadata, not write identity (#1955).
   "origin",
+  // Subject is derived classification metadata (#2372): two writes identical
+  // except subject are the same memory for dedup purposes.
+  "subject",
   "sourceReason"
 ];
 var FINGERPRINT_SCOPE_FIELDS = [
@@ -423,4 +442,4 @@ export {
   buildAccessWriteRequestFingerprint,
   buildObserveRequestFingerprint
 };
-//# sourceMappingURL=chunk-LCU5R6TQ.js.map
+//# sourceMappingURL=chunk-RAIUTAZZ.js.map

package/dist/chunk-RAIUTAZZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/write-envelope.ts"],"sourcesContent":["/**\n * Sealed memory-write envelope (issue #1989, umbrella #1988).\n *\n * THE single stamping point for cross-cutting memory-creation fields.\n *\n * Why this exists: PR #1852 needed 27 rework commits because adding one\n * cross-cutting field (`sourceConnector`) required hand-editing every\n * write call site and every idempotency payload, and reviewers discovered\n * missed sites one round at a time. This module removes the fan-out:\n *\n *   1. `composeMemoryEnvelope()` is the only way to mint a\n *      `SealedMemoryEnvelope` — the brand is a non-exported `unique symbol`,\n *      so a hand-built object literal fails `tsc` (`npm run check-types`\n *      is already a required repo-wide gate; the type system IS the fence).\n *   2. `buildWriteIdempotencyPayload()` derives every access-surface\n *      idempotency payload from ONE ordered field registry\n *      (`WRITE_FINGERPRINT_FIELDS`). Adding a fingerprint-relevant field is\n *      a one-line registry change picked up by every surface; forgetting to\n *      classify a new `MemoryWriteInput` field is a compile error (see the\n *      exhaustiveness guards at the bottom of this file).\n *\n * PR1 scope (no call-site changes): the composer, the registry, and the\n * payload builder, fully tested. PR2–PR4 migrate storage entry points and\n * the write call sites onto this module (see #1989 for the slicing).\n */\n\nimport { isMemorySubject } from \"./memory-subject.js\";\nimport type { MemoryCategory, MemorySubject } from \"./types.js\";\nimport { normalizeTags } from \"./recall-tag-filter.js\";\nimport { parseFlexibleIsoTimestamp } from \"./utils/iso-timestamp.js\";\nimport { assemblePersistedBody } from \"./structured-attributes.js\";\n\n// ---------------------------------------------------------------------------\n// Input surface\n// ---------------------------------------------------------------------------\n\n/**\n * Every cross-cutting memory-creation field lives HERE and only here.\n *\n * When you add a field you MUST also add it to either\n * `WRITE_FINGERPRINT_FIELDS` or `FINGERPRINT_EXEMPT_FIELDS` — the\n * exhaustiveness guard below makes forgetting a compile error.\n */\nexport interface MemoryWriteInput {\n  /** Raw memory content. Must be non-empty after trimming. */\n  content: string;\n  /** Memory category — validated against the canonical category set. */\n  category: MemoryCategory;\n  /** Free-form labels; normalized (trim/dedupe) and capped, see TAG_LIMITS. */\n  tags?: string[];\n  /** String→string structured attributes; non-string values are rejected. */\n  structuredAttributes?: Record<string, string>;\n  /** Entity file reference (e.g. `person-jane-doe`). */\n  entityRef?: string;\n  /** Extraction confidence in [0, 1]. */\n  confidence?: number;\n  /** Opaque TTL expression (e.g. `90d` or an ISO date) — validated non-empty. */\n  ttl?: string;\n  /** Event-time validity start (ISO 8601). */\n  validAt?: string;\n  /** Connector identity that produced this write (issue #1852). */\n  sourceConnector?: string;\n  /** Origin class stamped at creation time (issue #1955). */\n  origin?: string;\n  /** Whom the memory models (issue #2372): \"user\" or \"agent\". */\n  subject?: MemorySubject;\n  /** Human-readable provenance note. */\n  sourceReason?: string;\n}\n\n/** Context supplied by the write path, not by the payload author. */\nexport interface WriteContext {\n  /** Frontmatter `source` string (e.g. `extraction`, `wearable:bee`). */\n  source: string;\n  /** Clock override for tests. */\n  now?: () => Date;\n}\n\n/** Scope facts that participate in idempotency but never in frontmatter. */\nexport interface FingerprintScope {\n  /** Access surface performing the write (e.g. `memory_store`, `observe`). */\n  surface: string;\n  namespace?: string;\n  principal?: string;\n  codingContext?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Normalization limits (single source of truth — docs/tags.md contract)\n// ---------------------------------------------------------------------------\n\nexport const TAG_LIMITS = Object.freeze({\n  /** Maximum number of tags persisted per memory. */\n  maxTags: 50,\n  /** Maximum length of a single tag. */\n  maxTagLength: 256,\n});\n\nexport const STRUCTURED_ATTRIBUTE_LIMITS = Object.freeze({\n  /** Maximum number of structured attributes per memory. */\n  maxEntries: 64,\n  /** Maximum length of one attribute key. */\n  maxKeyLength: 128,\n  /** Maximum length of one attribute value. */\n  maxValueLength: 1024,\n});\n\nconst MEMORY_CATEGORY_TABLE: Record<MemoryCategory, true> = {\n  fact: true,\n  preference: true,\n  correction: true,\n  entity: true,\n  decision: true,\n  relationship: true,\n  principle: true,\n  commitment: true,\n  moment: true,\n  skill: true,\n  rule: true,\n  procedure: true,\n  reasoning_trace: true,\n};\n\nconst MEMORY_CATEGORY_NAMES = Object.keys(MEMORY_CATEGORY_TABLE).sort();\n\nexport function isMemoryCategory(value: string): value is MemoryCategory {\n  return Object.prototype.hasOwnProperty.call(MEMORY_CATEGORY_TABLE, value);\n}\n\n// ---------------------------------------------------------------------------\n// Sealed envelope\n// ---------------------------------------------------------------------------\n\ndeclare const sealed: unique symbol;\n\n/**\n * A normalized, validated memory-write envelope.\n *\n * Opaque: only `composeMemoryEnvelope()` can mint one. Storage creation\n * entry points accept this type (PR2), so every write path is forced\n * through the composer at compile time.\n */\nexport interface SealedMemoryEnvelope {\n  readonly [sealed]: true;\n  /**\n   * Caller-supplied content VERBATIM (validated non-empty-after-trim).\n   * `StorageManager.writeMemory` persists content byte-for-byte (callers\n   * that trim, e.g. explicit capture, do so before composing), so the\n   * envelope must not transform it — the earlier compose-time trim/sanitize\n   * broke byte-parity with extraction writes and was removed in PR2.\n   */\n  readonly content: string;\n  /**\n   * The exact body persistence will write: attribute-suffix enrichment then\n   * combined sanitization, produced by the SAME `assemblePersistedBody`\n   * helper `writeMemory` uses (issue #1989 PR2; AGENTS.md §13). This is the\n   * form write-idempotency fingerprints hash.\n   */\n  readonly persistedBody: string;\n  /** Injection patterns matched during body assembly (empty = clean). */\n  readonly sanitizeViolations: readonly string[];\n  /**\n   * Salvage-mode hygiene notes (empty in strict mode): each dropped/clamped\n   * invalid optional field is recorded here — visible, never silent\n   * (repo rule 34). Callers persisting machine-generated input log these.\n   */\n  readonly salvageNotes: readonly string[];\n  readonly category: MemoryCategory;\n  readonly tags: readonly string[];\n  /**\n   * CANONICAL attributes (keys trim+lowercase, values trim) — the form\n   * fingerprints and downstream consumers use; stable across caller casing.\n   */\n  readonly structuredAttributes: Readonly<Record<string, string>> | undefined;\n  /**\n   * The validated ORIGINAL attribute map, byte-preserved. `writeMemory`\n   * persists frontmatter attributes raw (canonicalizing only the body\n   * suffix via normalizeAttributePairs) — a pre-existing raw/canonical\n   * inconsistency (supersession keys read the raw form). The sealed path\n   * preserves those bytes; canonicalizing the frontmatter at the storage\n   * boundary is a follow-up once the legacy path retires (#1989 PR4).\n   */\n  readonly rawStructuredAttributes: Readonly<Record<string, string>> | undefined;\n  readonly entityRef: string | undefined;\n  readonly confidence: number | undefined;\n  readonly ttl: string | undefined;\n  readonly validAt: string | undefined;\n  readonly sourceConnector: string | undefined;\n  readonly origin: string | undefined;\n  readonly subject: MemorySubject | undefined;\n  readonly sourceReason: string | undefined;\n  readonly source: string;\n  /** ISO timestamp the envelope was composed (from ctx.now). */\n  readonly composedAt: string;\n}\n\nfunction fail(field: string, message: string): never {\n  throw new Error(`composeMemoryEnvelope: ${field} ${message}`);\n}\n\n/**\n * Compose-time input hygiene mode (issue #1989 PR2, review round on #2014).\n *\n * - `strict` (default): every invalid field throws — correct for OPERATOR\n *   and API input (explicit capture, memory_store), where a bad value is a\n *   caller bug that must surface.\n * - `salvage`: for MACHINE-GENERATED input (LLM extraction, wearable\n *   ingestion). One malformed fact from an extractor must not abort a whole\n *   persistence batch that legacy `writeMemory` would have accepted.\n *   Invalid tags/attributes/optional fields are DROPPED with a note pushed\n *   to `envelope.salvageNotes` — visible, never silent (repo rule 34);\n *   callers log the notes. Content, category, ctx.source, and validAt stay\n *   FATAL in both modes (legacy writeMemory also throws on bad validAt, and\n *   a write without valid content/category cannot proceed).\n */\nexport interface ComposeEnvelopeOptions {\n  salvage?: boolean;\n}\n\n/** Internal reporter: throws in strict mode, records a note in salvage. */\ninterface Hygiene {\n  salvage: boolean;\n  notes: string[];\n  flag(field: string, message: string): void;\n}\n\nfunction makeHygiene(salvage: boolean): Hygiene {\n  const notes: string[] = [];\n  return {\n    salvage,\n    notes,\n    flag(field: string, message: string): void {\n      if (!salvage) fail(field, message);\n      notes.push(`${field} ${message}`);\n    },\n  };\n}\n\n/**\n * Validate and CANONICALIZE `validAt` via the repo's shared flexible ISO\n * parser (`utils/iso-timestamp.ts`) — the same family durable writes use, so\n * the envelope can never accept a value storage would reject or reinterpret\n * (review findings on #1998: no second validation convention; reduced\n * precision like `2026-07-17T09:30Z` is valid; offsets are bounded ±14:00;\n * `Date.parse` alone is not an ISO validator).\n *\n * Canonical form is the epoch round-trip (`Date.toISOString()`), so\n * fingerprints are identical for `...T09:30Z`, `...T09:30:00.000Z`, and the\n * same instant expressed with an offset (§13 hash-consistency).\n */\nfunction validateIsoTimestamp(field: string, value: string): string {\n  const trimmed = value.trim();\n  if (trimmed.length === 0) fail(field, \"must be a non-empty ISO 8601 timestamp\");\n  const epochMs = parseFlexibleIsoTimestamp(trimmed);\n  if (epochMs === null) {\n    fail(\n      field,\n      `is not a valid ISO 8601 date/timestamp: ${JSON.stringify(value)} (date-only, reduced precision, Z, and ±HH:MM offsets up to ±14:00 are accepted; calendar overflow is not)`,\n    );\n  }\n  return new Date(epochMs).toISOString();\n}\n\nfunction normalizeEnvelopeTags(raw: string[] | undefined, hygiene: Hygiene): readonly string[] {\n  if (raw === undefined) return Object.freeze([]);\n  if (!Array.isArray(raw)) {\n    hygiene.flag(\"tags\", \"must be an array of strings — dropped\");\n    return Object.freeze([]);\n  }\n  const usable: string[] = [];\n  for (const tag of raw) {\n    if (typeof tag !== \"string\") {\n      hygiene.flag(\"tags\", `entries must be strings (got ${typeof tag})`);\n      continue;\n    }\n    if (tag.trim().length > TAG_LIMITS.maxTagLength) {\n      hygiene.flag(\"tags\", `entry exceeds ${TAG_LIMITS.maxTagLength} characters: ${JSON.stringify(tag.slice(0, 40))}…`);\n      continue;\n    }\n    usable.push(tag);\n  }\n  let normalized = normalizeTags(usable) ?? [];\n  if (normalized.length > TAG_LIMITS.maxTags) {\n    hygiene.flag(\"tags\", `exceed the ${TAG_LIMITS.maxTags}-tag limit (got ${normalized.length}) — keeping the first ${TAG_LIMITS.maxTags}`);\n    normalized = normalized.slice(0, TAG_LIMITS.maxTags);\n  }\n  return Object.freeze(normalized);\n}\n\nfunction normalizeStructuredAttributes(\n  raw: Record<string, string> | undefined,\n  hygiene: Hygiene,\n): { canonical: Readonly<Record<string, string>>; raw: Readonly<Record<string, string>> } | undefined {\n  if (raw === undefined) return undefined;\n  if (\n    raw === null ||\n    typeof raw !== \"object\" ||\n    Array.isArray(raw) ||\n    (Object.getPrototypeOf(raw) !== Object.prototype && Object.getPrototypeOf(raw) !== null)\n  ) {\n    // Map/Date/class instances have empty Object.entries() and would\n    // silently normalize to \"no attributes\" (review finding on #1998\n    // round 5) — never a plain pass-through.\n    hygiene.flag(\"structuredAttributes\", \"must be a plain object of string values (Map, Date, and class instances are rejected) — dropped\");\n    return undefined;\n  }\n  let entries = Object.entries(raw);\n  if (entries.length === 0) return undefined;\n  if (entries.length > STRUCTURED_ATTRIBUTE_LIMITS.maxEntries) {\n    hygiene.flag(\n      \"structuredAttributes\",\n      `exceed the ${STRUCTURED_ATTRIBUTE_LIMITS.maxEntries}-entry limit (got ${entries.length}) — keeping the first ${STRUCTURED_ATTRIBUTE_LIMITS.maxEntries} in insertion order`,\n    );\n    entries = entries.slice(0, STRUCTURED_ATTRIBUTE_LIMITS.maxEntries);\n  }\n  // Keys that collide with Object.prototype machinery are REJECTED outright:\n  // `hashAccessIdempotencyPayload`'s stableStringify rebuilds objects with\n  // plain assignment, where a \"__proto__\" own property silently vanishes —\n  // so such a key can never round-trip through the fingerprint faithfully\n  // (review finding on #1998 round 3). Rejection beats smuggling (§1/§39).\n  const FORBIDDEN_ATTRIBUTE_KEYS = [\"__proto__\", \"constructor\", \"prototype\"];\n  const out: Record<string, string> = Object.create(null);\n  const survivingOriginal: Array<[string, string]> = [];\n  for (const [key, value] of entries) {\n    // Canonicalize exactly like storage's normalizeAttributePairs\n    // (storage.ts:1277): keys trim+lowercase, values trim — so the\n    // fingerprint and the persisted searchable form can never diverge\n    // (review finding on #1998; AGENTS.md §13 hash-consistency).\n    const cleanKey = key.trim().toLowerCase();\n    if (cleanKey.length === 0) {\n      hygiene.flag(\"structuredAttributes\", \"contain an empty key\");\n      continue;\n    }\n    if (cleanKey.length > STRUCTURED_ATTRIBUTE_LIMITS.maxKeyLength) {\n      hygiene.flag(\"structuredAttributes\", `key exceeds ${STRUCTURED_ATTRIBUTE_LIMITS.maxKeyLength} characters: ${JSON.stringify(cleanKey.slice(0, 40))}…`);\n      continue;\n    }\n    if (typeof value !== \"string\") {\n      hygiene.flag(\"structuredAttributes\", `value for ${JSON.stringify(cleanKey)} must be a string (got ${typeof value}) — stringify numbers/booleans at the call site`);\n      continue;\n    }\n    const cleanValue = value.trim();\n    if (FORBIDDEN_ATTRIBUTE_KEYS.includes(cleanKey)) {\n      hygiene.flag(\n        \"structuredAttributes\",\n        `contain the reserved key ${JSON.stringify(cleanKey)} — prototype-machinery names cannot round-trip through fingerprint serialization`,\n      );\n      continue;\n    }\n    if (cleanValue.length > STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength) {\n      hygiene.flag(\"structuredAttributes\", `value for ${JSON.stringify(cleanKey)} exceeds ${STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength} characters`);\n      continue;\n    }\n    if (Object.hasOwn(out, cleanKey)) {\n      hygiene.flag(\"structuredAttributes\", `contain duplicate key after canonicalization (trim + lowercase): ${JSON.stringify(cleanKey)}`);\n      continue;\n    }\n    out[cleanKey] = cleanValue;\n    survivingOriginal.push([key, value]);\n  }\n  if (Object.keys(out).length === 0) return undefined;\n  // Copy onto a normal object so downstream JSON/stableStringify behavior is\n  // unchanged; keys are already validated. The RAW map carries only the\n  // SURVIVING original pairs — dropped entries must not reach frontmatter.\n  return {\n    canonical: Object.freeze({ ...out }),\n    raw: Object.freeze(Object.fromEntries(survivingOriginal)),\n  };\n}\n\nfunction normalizeOptionalString(\n  field: string,\n  value: string | undefined,\n  hygiene: Hygiene,\n): string | undefined {\n  if (value === undefined) return undefined;\n  if (typeof value !== \"string\") {\n    hygiene.flag(field, `must be a string (got ${typeof value}) — dropped`);\n    return undefined;\n  }\n  const trimmed = value.trim();\n  if (trimmed.length === 0) {\n    hygiene.flag(field, \"must be non-empty when provided — dropped\");\n    return undefined;\n  }\n  return trimmed;\n}\n\n/**\n * Compose (normalize + validate + seal) a memory-write envelope.\n *\n * Strict mode (default) throws on any invalid input — never silently\n * defaults (AGENTS.md §1/§39). Salvage mode (`{ salvage: true }`, for\n * machine-generated input like LLM extraction) drops invalid OPTIONAL\n * fields with notes on `envelope.salvageNotes` instead of aborting the\n * batch; content/category/source/validAt stay fatal in both modes.\n */\nexport function composeMemoryEnvelope(\n  input: MemoryWriteInput,\n  ctx: WriteContext,\n  opts: ComposeEnvelopeOptions = {},\n): SealedMemoryEnvelope {\n  if (input === null || typeof input !== \"object\") fail(\"input\", \"must be an object\");\n  if (ctx === null || typeof ctx !== \"object\") fail(\"ctx\", \"must be an object\");\n  const hygiene = makeHygiene(opts.salvage === true);\n\n  if (typeof input.content !== \"string\" || input.content.trim().length === 0) {\n    fail(\"content\", \"must be a non-empty string\");\n  }\n  if (typeof input.category !== \"string\" || !isMemoryCategory(input.category)) {\n    fail(\n      \"category\",\n      `must be one of: ${MEMORY_CATEGORY_NAMES.join(\", \")} (got ${JSON.stringify(input.category)})`,\n    );\n  }\n  if (typeof ctx.source !== \"string\" || ctx.source.trim().length === 0) {\n    fail(\"ctx.source\", \"must be a non-empty string\");\n  }\n\n  let confidence: number | undefined;\n  if (input.confidence !== undefined) {\n    if (\n      typeof input.confidence !== \"number\" ||\n      !Number.isFinite(input.confidence) ||\n      input.confidence < 0 ||\n      input.confidence > 1\n    ) {\n      hygiene.flag(\n        \"confidence\",\n        `must be a finite number within [0, 1] (got ${String(input.confidence)}) — dropped (storage defaults apply)`,\n      );\n    } else {\n      confidence = input.confidence;\n    }\n  }\n\n  let subject: MemorySubject | undefined;\n  if (input.subject !== undefined) {\n    if (!isMemorySubject(input.subject)) {\n      hygiene.flag(\n        \"subject\",\n        `must be \"user\" or \"agent\" (got ${JSON.stringify(input.subject)}) — dropped`,\n      );\n    } else {\n      subject = input.subject;\n    }\n  }\n\n  // validAt stays FATAL in salvage too: legacy writeMemory throws on an\n  // invalid validAt (normalizeMemoryWriteTimestamp), so salvage-dropping it\n  // would CHANGE behavior rather than preserve it.\n  const validAt =\n    input.validAt === undefined ? undefined : validateIsoTimestamp(\"validAt\", input.validAt);\n\n  const now = ctx.now ? ctx.now() : new Date();\n  if (!(now instanceof Date) || Number.isNaN(now.getTime())) {\n    fail(\"ctx.now\", \"must return a valid Date\");\n  }\n\n  const attributes = normalizeStructuredAttributes(input.structuredAttributes, hygiene);\n  // Assemble the EXACT persisted form (attribute suffix + combined sanitize)\n  // with the same helper writeMemory uses — fingerprints hash this form, so\n  // envelope and storage cannot diverge (§13; #1998 round-8 thread resolved\n  // here in PR2 as promised). writeMemory assembles from the RAW map;\n  // normalizeAttributePairs canonicalizes internally, so raw and canonical\n  // maps yield the same suffix — asserted by the parity suite.\n  const assembled = assemblePersistedBody(\n    input.content,\n    attributes ? { ...attributes.raw } : undefined,\n  );\n  if (assembled.text.trim().length === 0) {\n    fail(\"content\", \"is empty after sanitization\");\n  }\n\n  const body = {\n    content: input.content,\n    persistedBody: assembled.text,\n    sanitizeViolations: Object.freeze([...assembled.violations]),\n    category: input.category,\n    tags: normalizeEnvelopeTags(input.tags, hygiene),\n    structuredAttributes: attributes?.canonical,\n    rawStructuredAttributes: attributes?.raw,\n    entityRef: normalizeOptionalString(\"entityRef\", input.entityRef, hygiene),\n    origin: normalizeOptionalString(\"origin\", input.origin, hygiene),\n    subject,\n    confidence,\n    ttl: normalizeOptionalString(\"ttl\", input.ttl, hygiene),\n    validAt,\n    sourceConnector: normalizeOptionalString(\"sourceConnector\", input.sourceConnector, hygiene),\n    sourceReason: normalizeOptionalString(\"sourceReason\", input.sourceReason, hygiene),\n    source: ctx.source.trim(),\n    composedAt: now.toISOString(),\n    salvageNotes: Object.freeze([...hygiene.notes]),\n  };\n  const envelope = Object.freeze(body) as unknown as SealedMemoryEnvelope;\n  SEALED_ENVELOPES.add(envelope);\n  return envelope;\n}\n\n// The runtime seal registry. The declared `sealed` unique symbol exists only\n// at the type level (compile-time fence); this WeakSet is the runtime fence.\nconst SEALED_ENVELOPES = new WeakSet<object>();\n\n/**\n * TOCTOU guard for the structural arm (#2014 round 4): a frozen object may\n * still carry ACCESSOR properties whose getters return different values on\n * each read — valid data during re-composition, forged data when the write\n * path reads the field again. Frozen DATA properties are immutable, so\n * requiring data-only descriptors (on the envelope and its array/map\n * fields) makes every later read provably identical to the validated one.\n */\nfunction hasOnlyFrozenDataProperties(value: object): boolean {\n  if (!Object.isFrozen(value)) return false;\n  // Inherited accessors are as dangerous as own ones (round 5): a frozen\n  // object can inherit a `tags` getter from a custom prototype. Composer\n  // envelopes are plain object literals and plain arrays — require exactly\n  // those prototypes so prototype-supplied getters cannot serve fields.\n  const proto = Object.getPrototypeOf(value);\n  if (Array.isArray(value)) {\n    if (proto !== Array.prototype) return false;\n  } else if (proto !== Object.prototype && proto !== null) {\n    return false;\n  }\n  for (const key of Reflect.ownKeys(value)) {\n    const descriptor = Object.getOwnPropertyDescriptor(value, key);\n    if (!descriptor || descriptor.get !== undefined || descriptor.set !== undefined) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Runtime check (belt) — the compile-time brand is the real fence.\n *\n * Fast path: WeakSet membership (same module graph). Fallback: RE-COMPOSITION\n * EQUIVALENCE — Node resolves `@remnic/core` through `dist/` for built\n * consumers and `src/` for tsx-loaded tests, and each graph gets its OWN\n * WeakSet, so identity alone would reject genuinely-sealed envelopes that\n * crossed a build boundary. The structural arm requires frozen DATA-only\n * properties (no accessors — TOCTOU guard, round 4), then re-runs the\n * STRICT composer on the candidate's own inputs and demands every envelope\n * field reproduce exactly (#2014 round 2: shape-only validation admitted\n * lookalikes with 51 tags or out-of-range confidence). A value that\n * survives has, by construction, passed every composer invariant, and its\n * fields cannot change between validation and the write that follows.\n *\n * `salvageNotes` is deliberately NOT compared: a legitimately salvage-minted\n * envelope carries notes while the strict re-composition of its (already\n * clean) surviving fields yields none. Notes are advisory provenance, not\n * identity — every load-bearing field is still verified.\n */\n\nexport function isSealedMemoryEnvelope(value: unknown): value is SealedMemoryEnvelope {\n  if (typeof value !== \"object\" || value === null) return false;\n  if (SEALED_ENVELOPES.has(value)) return true;\n  if (!hasOnlyFrozenDataProperties(value)) return false;\n  const v = value as Partial<SealedMemoryEnvelope>;\n  if (\n    typeof v.content !== \"string\" ||\n    typeof v.persistedBody !== \"string\" ||\n    typeof v.source !== \"string\" ||\n    typeof v.composedAt !== \"string\" ||\n    typeof v.category !== \"string\" ||\n    !isMemoryCategory(v.category) ||\n    !Array.isArray(v.tags) ||\n    !hasOnlyFrozenDataProperties(v.tags) ||\n    !Array.isArray(v.sanitizeViolations) ||\n    !hasOnlyFrozenDataProperties(v.sanitizeViolations) ||\n    !Array.isArray(v.salvageNotes) ||\n    !hasOnlyFrozenDataProperties(v.salvageNotes)\n  ) {\n    return false;\n  }\n  const attrs = v.rawStructuredAttributes;\n  if (\n    attrs !== undefined &&\n    (attrs === null || typeof attrs !== \"object\" || Array.isArray(attrs) || !hasOnlyFrozenDataProperties(attrs))\n  ) {\n    return false;\n  }\n  const canonicalAttrs = v.structuredAttributes;\n  if (\n    canonicalAttrs !== undefined &&\n    (canonicalAttrs === null ||\n      typeof canonicalAttrs !== \"object\" ||\n      Array.isArray(canonicalAttrs) ||\n      !hasOnlyFrozenDataProperties(canonicalAttrs))\n  ) {\n    return false;\n  }\n  let rebuilt: SealedMemoryEnvelope;\n  try {\n    rebuilt = composeMemoryEnvelope(\n      {\n        content: v.content,\n        category: v.category,\n        ...(v.tags.length > 0 ? { tags: [...(v.tags as string[])] } : {}),\n        ...(attrs !== undefined ? { structuredAttributes: { ...attrs } } : {}),\n        ...(v.entityRef !== undefined ? { entityRef: v.entityRef } : {}),\n        ...(v.confidence !== undefined ? { confidence: v.confidence } : {}),\n        ...(v.ttl !== undefined ? { ttl: v.ttl } : {}),\n        ...(v.validAt !== undefined ? { validAt: v.validAt } : {}),\n        ...(v.sourceConnector !== undefined ? { sourceConnector: v.sourceConnector } : {}),\n        ...(v.origin !== undefined ? { origin: v.origin } : {}),\n        ...(v.sourceReason !== undefined ? { sourceReason: v.sourceReason } : {}),\n      },\n      { source: v.source, now: () => new Date(v.composedAt as string) },\n    );\n  } catch {\n    // Strict re-composition rejected an input — the candidate carries a\n    // value the composer would never have minted.\n    return false;\n  }\n  const sameArray = (a: readonly string[], b: readonly string[]): boolean =>\n    a.length === b.length && a.every((entry, i) => entry === b[i]);\n  const sameMap = (\n    a: Readonly<Record<string, string>> | undefined,\n    b: Readonly<Record<string, string>> | undefined,\n  ): boolean => {\n    if (a === undefined || b === undefined) return a === b;\n    const ak = Object.keys(a);\n    const bk = Object.keys(b);\n    return ak.length === bk.length && ak.every((k) => Object.hasOwn(b, k) && a[k] === b[k]);\n  };\n  return (\n    rebuilt.content === v.content &&\n    rebuilt.persistedBody === v.persistedBody &&\n    rebuilt.category === v.category &&\n    rebuilt.source === v.source &&\n    rebuilt.composedAt === v.composedAt &&\n    rebuilt.confidence === v.confidence &&\n    rebuilt.entityRef === v.entityRef &&\n    rebuilt.ttl === v.ttl &&\n    rebuilt.validAt === v.validAt &&\n    rebuilt.sourceConnector === v.sourceConnector &&\n    rebuilt.origin === v.origin &&\n    rebuilt.sourceReason === v.sourceReason &&\n    sameArray(rebuilt.tags, v.tags as string[]) &&\n    sameArray(rebuilt.sanitizeViolations, v.sanitizeViolations as string[]) &&\n    sameMap(rebuilt.structuredAttributes, v.structuredAttributes) &&\n    sameMap(rebuilt.rawStructuredAttributes, attrs)\n  );\n}\n\n/**\n * The ONE mapping from a sealed envelope (+ extras) to the legacy\n * `writeMemory(category, content, options)` argument shape. Used by\n * `StorageManager.writeSealedMemory` AND by test doubles that stub storage —\n * so mock fidelity (AGENTS.md §21) cannot drift from production.\n */\nexport function sealedWriteToLegacyArgs(\n  envelope: SealedMemoryEnvelope,\n  extras: Record<string, unknown> = {},\n): { category: MemoryCategory; content: string; options: Record<string, unknown> } {\n  return {\n    category: envelope.category,\n    content: envelope.content,\n    options: {\n      ...extras,\n      confidence: envelope.confidence,\n      tags: envelope.tags.length > 0 ? [...envelope.tags] : undefined,\n      entityRef: envelope.entityRef,\n      source: envelope.source,\n      expiresAt: envelope.ttl,\n      validAt: envelope.validAt,\n      // RAW map for frontmatter byte-parity with the legacy path; the body\n      // suffix canonicalizes identically from either form.\n      structuredAttributes: envelope.rawStructuredAttributes\n        ? { ...envelope.rawStructuredAttributes }\n        : undefined,\n      // Unconditional (round 3): envelope-owned fields must ALWAYS overwrite\n      // extras — a conditional spread let extras.sourceConnector smuggle\n      // unvalidated connector provenance past the sealed envelope when the\n      // envelope had none.\n      origin: envelope.origin,\n      sourceConnector: envelope.sourceConnector,\n      subject: envelope.subject,\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Idempotency field registry\n// ---------------------------------------------------------------------------\n\n/**\n * Ordered registry of envelope fields that participate in write-idempotency\n * fingerprints. Adding a fingerprint-relevant field = one entry here; every\n * surface that builds its payload via `buildWriteIdempotencyPayload()` picks\n * it up automatically.\n */\nexport const WRITE_FINGERPRINT_FIELDS = [\n  \"content\",\n  \"category\",\n  \"tags\",\n  \"structuredAttributes\",\n  \"entityRef\",\n  \"ttl\",\n  \"validAt\",\n  \"sourceConnector\",\n] as const satisfies readonly (keyof MemoryWriteInput)[];\n\n/**\n * Envelope fields deliberately EXCLUDED from fingerprints. Exempting a field\n * is a visible, reviewable decision — this list exists so the exhaustiveness\n * guard can force every new `MemoryWriteInput` field to be classified.\n */\nexport const FINGERPRINT_EXEMPT_FIELDS = [\n  // Confidence is a scoring detail: two extractions of the same fact with\n  // slightly different confidence are the same write for dedup purposes.\n  \"confidence\",\n  // Free-text provenance note; carries no identity.\n  // Origin is provenance metadata, not write identity (#1955).\n  \"origin\",\n  // Subject is derived classification metadata (#2372): two writes identical\n  // except subject are the same memory for dedup purposes.\n  \"subject\",\n  \"sourceReason\",\n] as const satisfies readonly (keyof MemoryWriteInput)[];\n\n/** Scope keys always folded into the fingerprint payload. */\nexport const FINGERPRINT_SCOPE_FIELDS = [\n  \"surface\",\n  \"namespace\",\n  \"principal\",\n  \"codingContext\",\n] as const satisfies readonly (keyof FingerprintScope)[];\n\n// --- compile-time exhaustiveness guards ------------------------------------\n// A new MemoryWriteInput field that is in NEITHER list is a compile error;\n// a registry entry that names a non-existent field is a compile error; a\n// field in BOTH lists is a compile error.\n\ntype RegistryField = (typeof WRITE_FINGERPRINT_FIELDS)[number];\ntype ExemptField = (typeof FINGERPRINT_EXEMPT_FIELDS)[number];\ntype UnclassifiedField = Exclude<keyof MemoryWriteInput, RegistryField | ExemptField>;\ntype DoublyClassifiedField = RegistryField & ExemptField;\n\nconst assertEveryFieldClassified: UnclassifiedField extends never ? true : never = true;\nconst assertNoDoubleClassification: DoublyClassifiedField extends never ? true : never = true;\nvoid assertEveryFieldClassified;\nvoid assertNoDoubleClassification;\n\n// ---------------------------------------------------------------------------\n// Payload builder\n// ---------------------------------------------------------------------------\n\n/**\n * Build the canonical write-idempotency payload for a sealed envelope.\n *\n * Determinism guarantees (AGENTS.md §26):\n *   - tags are SORTED in the payload (tag order never changes identity);\n *   - structured attributes are serialized key-sorted by the existing\n *     `stableStringify` inside `hashAccessIdempotencyPayload`;\n *   - the payload shape is versioned (`v: 1`) so a future field-semantics\n *     change can migrate stored idempotency state explicitly instead of\n *     silently colliding.\n *\n * Feed the result to `hashAccessIdempotencyPayload()` — this module does\n * not hash so surfaces keep a single hashing implementation.\n */\nexport function buildWriteIdempotencyPayload(\n  envelope: SealedMemoryEnvelope,\n  scope: FingerprintScope,\n): Record<string, unknown> {\n  if (!isSealedMemoryEnvelope(envelope)) {\n    throw new Error(\n      \"buildWriteIdempotencyPayload: envelope must be minted by composeMemoryEnvelope\",\n    );\n  }\n  if (scope === null || typeof scope !== \"object\") {\n    throw new Error(\"buildWriteIdempotencyPayload: scope must be an object\");\n  }\n  if (typeof scope.surface !== \"string\" || scope.surface.trim().length === 0) {\n    throw new Error(\"buildWriteIdempotencyPayload: scope.surface must be a non-empty string\");\n  }\n\n  const fields: Record<string, unknown> = {};\n  for (const field of WRITE_FINGERPRINT_FIELDS) {\n    const value = envelope[field];\n    if (value === undefined) continue;\n    if (field === \"tags\") {\n      const tags = value as readonly string[];\n      if (tags.length === 0) continue;\n      fields.tags = [...tags].sort();\n      continue;\n    }\n    if (field === \"content\") {\n      // Fingerprints hash the PERSISTED form (attribute suffix + combined\n      // sanitize), not the raw input — one instant of stored state, one\n      // fingerprint (§13; issue #1989 PR2).\n      fields.content = envelope.persistedBody;\n      continue;\n    }\n    fields[field] = value;\n  }\n  // The write source (extraction vs wearable:bee vs observe replay, ...) is\n  // identity: the same content arriving from two different sources must not\n  // dedupe into one write (review finding on #1998). Not a MemoryWriteInput\n  // key, so it rides beside the registry fields explicitly.\n  fields.source = envelope.source;\n\n  const scopeOut: Record<string, string> = {};\n  for (const key of FINGERPRINT_SCOPE_FIELDS) {\n    const value = scope[key];\n    if (value === undefined) continue;\n    if (typeof value !== \"string\") {\n      throw new Error(`buildWriteIdempotencyPayload: scope.${key} must be a string`);\n    }\n    // Trimmed: \"ns\" and \"ns \" must not mint distinct fingerprints (review\n    // finding on #1998). Empty-after-trim optional scope values are dropped.\n    const cleanValue = value.trim();\n    if (key === \"surface\" || cleanValue.length > 0) {\n      scopeOut[key] = cleanValue;\n    }\n  }\n\n  return { v: 1, kind: \"memory-write\", fields, scope: scopeOut };\n}\n\n// ---------------------------------------------------------------------------\n// Access-surface request fingerprints (issue #1989 PR3)\n// ---------------------------------------------------------------------------\n//\n// The access surfaces (memory_store / suggestion_submit writes, their peek\n// twins, and observe) key their idempotency dedup on a hash of the RAW\n// request — computed BEFORE validation, and persisted indefinitely in\n// `AccessIdempotencyStore` (last-512 LRU, no time TTL). Those stored hashes\n// are load-bearing state: changing the payload shape would silently break\n// replay/conflict detection for every in-flight key. So these builders\n// REPRODUCE each surface's historical shape byte-for-byte (asserted by the\n// parity suite) instead of adopting the versioned envelope payload above —\n// a versioned migration of stored state is the explicit prerequisite for\n// unifying them (#1989 PR3 scope note).\n//\n// What centralizing buys even under byte-parity: one module now owns every\n// fingerprint shape, and the compile-time assertion below ties the write\n// shape to WRITE_FINGERPRINT_FIELDS — adding a fingerprint-relevant field\n// to MemoryWriteInput fails compilation here until the author decides how\n// the access surfaces represent it.\n\n/** The raw request fields the write surfaces fingerprint (legacy shape). */\nexport interface AccessWriteFingerprintParts {\n  schemaVersion: number;\n  namespace: string;\n  content: string;\n  category?: string;\n  confidence?: number;\n  tags?: string[];\n  entityRef?: string;\n  ttl?: string;\n  sourceReason?: string;\n  sourceConnector?: string;\n}\n\n// Registry coupling: every fingerprint-relevant MemoryWriteInput field must\n// either appear in AccessWriteFingerprintParts or be named in this explicit\n// exemption list. `structuredAttributes` and `validAt` are exempt because\n// the access write requests cannot express them today (ExplicitCaptureInput\n// has no such fields) — the moment they become representable, this type\n// stops compiling and forces a fingerprint decision (+ versioned state\n// migration) instead of a silent dedup gap.\ntype AccessSurfaceUnrepresentable = \"structuredAttributes\" | \"validAt\";\ntype UncoveredAccessFingerprintField = Exclude<\n  Extract<RegistryField, keyof MemoryWriteInput>,\n  keyof AccessWriteFingerprintParts | AccessSurfaceUnrepresentable\n>;\nconst assertAccessFingerprintCoversRegistry: UncoveredAccessFingerprintField extends never\n  ? true\n  : never = true;\nvoid assertAccessFingerprintCoversRegistry;\n\n/**\n * Fingerprint payload for `memory_store` / `suggestion_submit` (write AND\n * peek paths — both MUST call this so peek can never diverge from the\n * write it predicts). Key set and values reproduce the historical inline\n * literals exactly; `hashAccessIdempotencyPayload`'s stableStringify sorts\n * keys and drops `undefined`, so optional absent fields hash identically\n * to the old shape.\n */\nexport function buildAccessWriteRequestFingerprint(\n  parts: AccessWriteFingerprintParts,\n): Record<string, unknown> {\n  return {\n    schemaVersion: parts.schemaVersion,\n    content: parts.content,\n    category: parts.category,\n    confidence: parts.confidence,\n    namespace: parts.namespace,\n    tags: parts.tags,\n    entityRef: parts.entityRef,\n    ttl: parts.ttl,\n    sourceReason: parts.sourceReason,\n    sourceConnector: parts.sourceConnector,\n  };\n}\n\n/** The raw request fields the observe surface fingerprints (legacy shape). */\nexport interface ObserveFingerprintParts {\n  sessionKey: string;\n  messages: unknown;\n  namespace?: string;\n  skipExtraction?: boolean;\n  authenticatedPrincipal?: string;\n  cwd?: string;\n  projectTag?: string;\n  /** Resolved coding context — `null` (not undefined) when absent, matching the historical literal. */\n  effectiveCodingContext: unknown;\n  sourceConnector?: string;\n}\n\n/**\n * Fingerprint payload for `observe` — turn ingestion, not a memory write,\n * so it fingerprints session/message identity rather than MemoryWriteInput\n * fields. Shape reproduces the historical inline literal exactly.\n */\nexport function buildObserveRequestFingerprint(\n  parts: ObserveFingerprintParts,\n): Record<string, unknown> {\n  return {\n    sessionKey: parts.sessionKey,\n    messages: parts.messages,\n    namespace: parts.namespace,\n    skipExtraction: parts.skipExtraction,\n    authenticatedPrincipal: parts.authenticatedPrincipal,\n    cwd: parts.cwd,\n    projectTag: parts.projectTag,\n    effectiveCodingContext: parts.effectiveCodingContext,\n    sourceConnector: parts.sourceConnector,\n  };\n}\n"],"mappings":"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","names":[]}