@remnic/core 9.65.1 → 9.65.3

package/src/types.ts

@@ -11,8 +11,13 @@ import type { ContradictionLocalizationConfig, ContradictionScanConfig } from ".
 import type { GraphPathScoringConfig } from "./graph-path-scoring-config.js";
 export type { ContradictionLocalizationConfig, ContradictionScanConfig } from "./contradiction-config.js";
 export type { GraphPathScoringConfig } from "./graph-path-scoring-config.js";
+import type { DriftDetectionSettings, MemoryDriftProvenance, RecallDriftAnnotation } from "./preferences/drift-types.js";
+import type { ProceduralMaintenanceConfig } from "./procedural/maintenance-config.js";
+import type { ActionGateConfig } from "./coding/action-gate.js";
 
 import type { AmbientCaptureProvenance, BufferTurnOwner, SecurityConfig, OriginMetadata } from "./security/types.js";
+export type MemorySubject = "user" | "agent";
+export type SubjectGuardMode = "off" | "warn" | "enforce";
 export type ReasoningEffort = "none" | "low" | "medium" | "high";
 export type TriggerMode = "smart" | "every_n" | "time_based";
 export type ConvergeConflictPolicy = "newest-wins" | "manual";
@@ -383,7 +388,6 @@ export interface DreamsPhasesConfig {
   deepSleep: DreamsDeepSleepConfig;
 }
 
-/** Procedural memory (issue #519): mining + recall gates. All sub-features default off. */
 export interface ProceduralConfig {
   enabled: boolean;
   /** Minimum cluster size before emitting a candidate; `0` disables mining (`minOccurrences_zero`). */
@@ -396,8 +400,8 @@ export interface ProceduralConfig {
   lookbackDays: number;
   /** When true, installer may register the nightly procedural mining cron (default off). */
   proceduralMiningCronAutoRegister: boolean;
-  /** Max procedure memories to inject on task-initiation recall (1–10). */
   recallMaxProcedures: number;
+  maintenance: ProceduralMaintenanceConfig;
 }
 
 /**
@@ -680,7 +684,7 @@ export interface SemanticChunkingConfigShape {
 }
 
 
-export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
+export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig, DriftDetectionSettings {
   openaiApiKey: string | undefined;
   openaiBaseUrl: string | undefined;
   model: string;
@@ -1041,14 +1045,11 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
   recallMaxConcurrentPerPrincipal: number;
   /** Coalesce identical concurrent recalls per principal; each caller gets its own clone. Default true. */
   recallSingleFlightEnabled: boolean;
-  // Memory Worth recall filter (issue #560 PR 4)
   /**
-   * When true, recall multiplies candidate scores by the Memory Worth
-   * factor computed from `mw_success` / `mw_fail` counters on each
-   * memory's frontmatter (see `computeMemoryWorth`). Memories with a
-   * history of failed sessions sink; neutral / uninstrumented memories
-   * are untouched (multiplier 1.0). Default false — flip to true in PR 5
-   * once the benchmark shows precision tie-or-win.
+   * When true, recall multiplies candidate scores by the Memory Worth factor
+   * from `mw_success` / `mw_fail` (see `computeMemoryWorth`): failed memories
+   * sink; neutral ones untouched (multiplier 1.0). Default false until the
+   * benchmark shows precision tie-or-win.
    */
   recallMemoryWorthFilterEnabled: boolean;
   /**
@@ -1253,6 +1254,8 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
   // by default — byte-for-byte pre-feature behaviour when `enabled === false`
   // (rule 39).
   codingKnowledge: CodingKnowledgeConfig;
+  /** Action-site failure gate (issue #2382). Off by default; advisory only. */
+  actionGate: ActionGateConfig;
   heartbeat: HeartbeatConfig;
   // Conversational memory inspection and correction (issue #1583). Off by
   // default — byte-identical pre-feature when enabled === false (rule 39).
@@ -1265,6 +1268,10 @@ export interface PluginConfig extends BoundedJsonlStateConfig, SecurityConfig {
   codexCompat: CodexCompatConfig;
   /** When true (default), LLM classifies facts as `"project"` or `"global"` scope for promotion across projects. */
   extractionScopeClassificationEnabled: boolean;
+  subjectClassification: { enabled: boolean };
+  subjectGuard: SubjectGuardMode;
+  /** Min accessCount reuse signal for promotion candidates (issue #2372). Default 3. */
+  promotionCandidates: { minAccessCount: number };
   // Extraction judge (issue #376)
   /** Enable the LLM-as-judge fact-worthiness gate on extracted facts. Default false (opt-in). */
   extractionJudgeEnabled: boolean;
@@ -2800,10 +2807,12 @@ export interface ImportanceScore {
   keywords: string[];
 }
 
-export interface MemoryFrontmatter extends SourceConnectorProvenance, OriginMetadata {
+export interface MemoryFrontmatter extends SourceConnectorProvenance, OriginMetadata, MemoryDriftProvenance {
   /** True when write-time classification ties this memory to its source connector's tools or commands. */
   toolScoped?: true;
   id: string;
+  /** Whom this memory models (issue #2372). The promotion guard treats absent as "user" (fail closed). */
+  subject?: MemorySubject;
   category: MemoryCategory;
   /** OKF v0.1 interop metadata (issue #1946). Inert: presentation only, never overrides `category`. */
   type?: string;
@@ -2824,12 +2833,8 @@ export interface MemoryFrontmatter extends SourceConnectorProvenance, OriginMeta
   /** Memory status: active (default), pending_review, rejected, quarantined, superseded, archived, or forgotten */
   status?: MemoryStatus;
   /**
-   * Tombstone block marker (issue #1579). When a new fact matches an active
-   * tombstone at the storage chokepoint, it is persisted with
-   * `status: "pending_review"` and this field set to the tombstone id — making
-   * the block VISIBLE (rule 34: never a silent drop) rather than silently
-   * discarding the extraction. Approving the memory through the review queue
-   * emits a revocation that re-allows the content.
+   * Tombstone block marker (issue #1579): persisted `pending_review` with this
+   * set to the tombstone id — a VISIBLE block (rule 34); approval revokes it.
    */
   blockedBy?: string;
   /** Which tombstone tier matched (`exact`/`normalized`/`keyed`/`semantic`). */
@@ -3234,29 +3239,25 @@ export interface ExtractedFact {
    */
   provenance?: "verified" | "unverified" | "none";
   /**
-   * Transient LLM-provided supporting quote (issue #1575 PR 2). Consumed by
-   * the post-parse validator to build `sources`, then stripped before the
-   * fact reaches persistence. NEVER included in content-hash dedup (rule 23 /
-   * checklist §13). Absent on facts that have already passed the validator.
+   * Transient LLM quote (issue #1575 PR 2): consumed by the post-parse
+   * validator to build `sources`, stripped before persistence, never in
+   * content-hash dedup (rule 23 / checklist §13).
    */
   quote?: string;
   /**
-   * Transient requireSpans signal (issue #1575 PR 2). Set by the provenance
-   * validator (`ProvenanceBuildResult.requireSpansPending`) when
-   * `provenance.requireSpans` is enabled and the quote could not be located
-   * in any source turn. Read by the persist path to route the fact to
-   * `pending_review` instead of `active`. Stripped before persistence —
-   * it never reaches frontmatter (chatgpt-codex-connector thread 4xB).
+   * Transient requireSpans signal (#1575 PR 2): quote unlocatable while
+   * `provenance.requireSpans` is on. Persist path routes the fact to
+   * `pending_review`. Stripped before persistence — never reaches frontmatter.
    */
   requireSpansPending?: boolean;
   promptedByQuestion?: string;
   /**
-   * Whether this fact is project-scoped or globally applicable.
-   * When `extractionScopeClassificationEnabled` is true, the extraction LLM
-   * classifies each fact. Default is `"project"` when a coding context is
-   * active, `"global"` when no coding context is present.
+   * Project- vs global-scoped; emitted when `extractionScopeClassificationEnabled`.
+   * Defaults to "project" with a coding context active, else "global".
    */
   scope?: MemoryScope;
+  /** Extractor-assigned subject, present only when subjectClassification.enabled (issue #2372). */
+  subject?: MemorySubject;
   /** Structured key-value attributes extracted from the content (e.g., product attributes, dates, quantities). */
   structuredAttributes?: Record<string, string>;
   /** When category is `procedure`, ordered steps with intents (persisted under procedures/). */
@@ -3466,7 +3467,7 @@ export interface ConsolidationObservation {
   merged: number;
   invalidated: number;
 }
-export interface QmdSearchResult extends OriginMetadata {
+export interface QmdSearchResult extends OriginMetadata, RecallDriftAnnotation {
   docid: string;
   path: string;
   snippet: string;

package/src/write-envelope.test.ts

@@ -9,6 +9,7 @@ import {
   WRITE_FINGERPRINT_FIELDS,
   buildWriteIdempotencyPayload,
   composeMemoryEnvelope,
+  sealedWriteToLegacyArgs,
   isSealedMemoryEnvelope,
   type FingerprintScope,
   type MemoryWriteInput,
@@ -198,6 +199,7 @@ test("registry and exempt list disjointly cover every MemoryWriteInput field", (
     sourceConnector: "bee",
     sourceReason: "r",
     origin: "user",
+    subject: "user",
   };
   for (const key of Object.keys(populated)) {
     assert.ok(classified.has(key), `field ${key} is not classified`);
@@ -682,3 +684,15 @@ test("structural fallback rejects prototype-inherited accessors (round 13)", ()
     "prototype-inherited getter lookalike must be rejected",
   );
 });
+
+test("sealedWriteToLegacyArgs always copies sourceConnector from the envelope", () => {
+  const envelope = composeMemoryEnvelope(
+    minimalInput({ sourceConnector: "chatgpt" }),
+    CTX,
+  );
+  const mapped = sealedWriteToLegacyArgs(envelope, { sourceConnector: "smuggled" });
+  assert.equal(mapped.options.sourceConnector, "chatgpt");
+  const empty = composeMemoryEnvelope(minimalInput(), CTX);
+  const cleared = sealedWriteToLegacyArgs(empty, { sourceConnector: "smuggled" });
+  assert.equal(cleared.options.sourceConnector, undefined);
+});

package/src/write-envelope.ts

@@ -24,7 +24,8 @@
  * the write call sites onto this module (see #1989 for the slicing).
  */
 
-import type { MemoryCategory } from "./types.js";
+import { isMemorySubject } from "./memory-subject.js";
+import type { MemoryCategory, MemorySubject } from "./types.js";
 import { normalizeTags } from "./recall-tag-filter.js";
 import { parseFlexibleIsoTimestamp } from "./utils/iso-timestamp.js";
 import { assemblePersistedBody } from "./structured-attributes.js";
@@ -61,6 +62,8 @@ export interface MemoryWriteInput {
   sourceConnector?: string;
   /** Origin class stamped at creation time (issue #1955). */
   origin?: string;
+  /** Whom the memory models (issue #2372): "user" or "agent". */
+  subject?: MemorySubject;
   /** Human-readable provenance note. */
   sourceReason?: string;
 }
@@ -184,6 +187,7 @@ export interface SealedMemoryEnvelope {
   readonly validAt: string | undefined;
   readonly sourceConnector: string | undefined;
   readonly origin: string | undefined;
+  readonly subject: MemorySubject | undefined;
   readonly sourceReason: string | undefined;
   readonly source: string;
   /** ISO timestamp the envelope was composed (from ctx.now). */
@@ -430,6 +434,18 @@ export function composeMemoryEnvelope(
     }
   }
 
+  let subject: MemorySubject | undefined;
+  if (input.subject !== undefined) {
+    if (!isMemorySubject(input.subject)) {
+      hygiene.flag(
+        "subject",
+        `must be "user" or "agent" (got ${JSON.stringify(input.subject)}) — dropped`,
+      );
+    } else {
+      subject = input.subject;
+    }
+  }
+
   // validAt stays FATAL in salvage too: legacy writeMemory throws on an
   // invalid validAt (normalizeMemoryWriteTimestamp), so salvage-dropping it
   // would CHANGE behavior rather than preserve it.
@@ -465,11 +481,12 @@ export function composeMemoryEnvelope(
     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(),
@@ -656,8 +673,9 @@ export function sealedWriteToLegacyArgs(
       // extras — a conditional spread let extras.sourceConnector smuggle
       // unvalidated connector provenance past the sealed envelope when the
       // envelope had none.
-      sourceConnector: envelope.sourceConnector,
       origin: envelope.origin,
+      sourceConnector: envelope.sourceConnector,
+      subject: envelope.subject,
     },
   };
 }
@@ -695,6 +713,9 @@ export const 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",
 ] as const satisfies readonly (keyof MemoryWriteInput)[];
 

package/dist/chunk-35NN3ZFA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/contradiction/contradiction-review.ts"],"sourcesContent":["/**\n * Contradiction Review Queue — storage for detected contradiction pairs (issue #520).\n *\n * Stores candidate pairs as JSON files under `memoryDir/.review/contradictions/`.\n * Pair IDs are deterministic (sha256 of sorted memory IDs plus namespace when scoped) so reruns are idempotent.\n *\n * Lifecycle:\n *   - `contradicts` → awaiting user review\n *   - `duplicates` → auto-flagged for dedup (still needs user approval)\n *   - `independent` / `both-valid` → dormant with cooldown\n */\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport type { ContradictionVerdict } from \"./contradiction-judge.js\";\n\n// ── Types ──────────────────────────────────────────────────────────────────────\n\nexport type ResolutionVerb = \"keep-a\" | \"keep-b\" | \"merge\" | \"both-valid\" | \"needs-more-context\";\n\nconst VALID_RESOLUTION_VERBS: readonly ResolutionVerb[] = [\n  \"keep-a\",\n  \"keep-b\",\n  \"merge\",\n  \"both-valid\",\n  \"needs-more-context\",\n];\n\nexport interface ContradictionPair {\n  /** Deterministic pair ID: sha256(sorted(memoryIdA, memoryIdB) plus namespace when scoped). */\n  pairId: string;\n  /** Memory IDs (sorted). */\n  memoryIds: [string, string];\n  /** Judge verdict. */\n  verdict: ContradictionVerdict;\n  /** Judge rationale. */\n  rationale: string;\n  /** Judge confidence in [0, 1]. */\n  confidence: number;\n  /** ISO timestamp when detected. */\n  detectedAt: string;\n  /** ISO timestamp when last reviewed by user. */\n  lastReviewedAt?: string;\n  /** Resolution verb applied by user. */\n  resolution?: ResolutionVerb;\n  /** ISO timestamp until which a non-terminal deferral remains hidden from review. */\n  deferredUntil?: string;\n  /** Content hashes captured for each referenced memory when this pair was judged. */\n  memoryContentHashes?: Record<string, string>;\n  /** Namespace scope. */\n  namespace?: string;\n}\n\nexport interface ContradictionListResult {\n  pairs: ContradictionPair[];\n  total: number;\n  durationMs: number;\n}\n\nexport type ContradictionFilter = ContradictionVerdict | \"all\" | \"unresolved\";\nexport interface WritePairOptions {\n  /** Cooldown used by scan callers to preserve still-dormant reviewed pairs. */\n  cooldownDays?: number;\n}\nconst NEEDS_MORE_CONTEXT_COOLDOWN_MS = 24 * 60 * 60 * 1000;\nconst UNSCOPED_MIGRATION_MARKER_PREFIX = \".unscoped-migrated-\";\nconst UNSCOPED_MIGRATION_MARKER_SUFFIX = \".done\";\n\n// ── Helpers ────────────────────────────────────────────────────────────────────\n\nexport function computePairId(memoryIdA: string, memoryIdB: string, namespace?: string): string {\n  const sorted = [memoryIdA, memoryIdB].sort();\n  const normalizedNamespace = namespace?.trim();\n  const scope = normalizedNamespace ? `ns:${normalizedNamespace}::` : \"\";\n  return createHash(\"sha256\").update(`${scope}${sorted.join(\"::\")}`).digest(\"hex\").slice(0, 24);\n}\n\nexport function isDefaultReviewNamespace(\n  defaultNamespace: string,\n  requestedNamespace: string | undefined,\n  resolvedNamespace: string,\n): boolean {\n  const requested = requestedNamespace?.trim();\n  return !requested || requested === defaultNamespace || resolvedNamespace === defaultNamespace;\n}\n\nfunction isTerminalResolution(resolution: ResolutionVerb | undefined): boolean {\n  return resolution === \"keep-a\" || resolution === \"keep-b\" || resolution === \"merge\";\n}\n\nfunction preservesDirectResolution(resolution: ResolutionVerb | undefined): boolean {\n  return isTerminalResolution(resolution) || resolution === \"both-valid\";\n}\n\nfunction isDormantReviewedPair(pair: ContradictionPair): boolean {\n  return pair.verdict === \"independent\" || pair.resolution === \"both-valid\";\n}\n\nfunction reviewStateRank(pair: ContradictionPair, cooldownDays?: number): number {\n  if (isTerminalResolution(pair.resolution)) return 5;\n  if (pair.resolution === \"both-valid\") return 4;\n  if (isDeferralActive(pair)) return 3;\n  if (isDormantReviewedPair(pair)) {\n    if (cooldownDays === undefined) return 2;\n    return isCoolingDown(pair, cooldownDays) ? 2 : 0;\n  }\n  return 1;\n}\n\nfunction parseIsoMillis(value: string | undefined): number | null {\n  if (!value) return null;\n  const millis = new Date(value).getTime();\n  return Number.isFinite(millis) ? millis : null;\n}\n\nfunction isDeferred(pair: Pick<ContradictionPair, \"resolution\" | \"deferredUntil\">): boolean {\n  return pair.resolution === \"needs-more-context\" || Boolean(pair.deferredUntil);\n}\n\nfunction deferralUntilMillis(pair: ContradictionPair): number | null {\n  const deferredUntil = parseIsoMillis(pair.deferredUntil);\n  if (deferredUntil !== null) return deferredUntil;\n\n  if (pair.resolution === \"needs-more-context\") {\n    const lastReviewed = parseIsoMillis(pair.lastReviewedAt);\n    return lastReviewed === null ? null : lastReviewed + NEEDS_MORE_CONTEXT_COOLDOWN_MS;\n  }\n\n  return null;\n}\n\nfunction isDeferralActive(pair: ContradictionPair): boolean {\n  const deferredUntil = deferralUntilMillis(pair);\n  return deferredUntil !== null && Date.now() < deferredUntil;\n}\n\nfunction isReviewActionable(pair: ContradictionPair): boolean {\n  return !isTerminalResolution(pair.resolution)\n    && !isDeferralActive(pair)\n    && pair.resolution !== \"both-valid\"\n    && pair.verdict !== \"independent\";\n}\n\nfunction compareReviewPairs(a: ContradictionPair, b: ContradictionPair): number {\n  const aActionable = isReviewActionable(a);\n  const bActionable = isReviewActionable(b);\n  if (aActionable !== bActionable) return aActionable ? -1 : 1;\n\n  const aDetectedAt = parseIsoMillis(a.detectedAt) ?? Number.POSITIVE_INFINITY;\n  const bDetectedAt = parseIsoMillis(b.detectedAt) ?? Number.POSITIVE_INFINITY;\n  if (aDetectedAt !== bDetectedAt) return aDetectedAt < bDetectedAt ? -1 : 1;\n\n  const aPairId = typeof a.pairId === \"string\" ? a.pairId : \"\";\n  const bPairId = typeof b.pairId === \"string\" ? b.pairId : \"\";\n  const pairIdOrder = aPairId.localeCompare(bPairId);\n  if (pairIdOrder !== 0) return pairIdOrder;\n\n  return a.memoryIds.join(\"\\0\").localeCompare(b.memoryIds.join(\"\\0\"));\n}\n\nfunction reviewStateMillis(pair: ContradictionPair): number {\n  return Math.max(\n    parseIsoMillis(pair.deferredUntil) ?? Number.NEGATIVE_INFINITY,\n    parseIsoMillis(pair.lastReviewedAt) ?? Number.NEGATIVE_INFINITY,\n    parseIsoMillis(pair.detectedAt) ?? Number.NEGATIVE_INFINITY,\n  );\n}\n\nfunction mergeMigratedPair(existing: ContradictionPair, migrated: ContradictionPair, options: WritePairOptions): ContradictionPair {\n  const existingRank = reviewStateRank(existing, options.cooldownDays);\n  const migratedRank = reviewStateRank(migrated, options.cooldownDays);\n  const selected = migratedRank > existingRank\n    ? migrated\n    : migratedRank < existingRank\n      ? existing\n      : reviewStateMillis(migrated) > reviewStateMillis(existing)\n        ? migrated\n        : existing;\n\n  return {\n    ...selected,\n    pairId: migrated.pairId,\n    namespace: migrated.namespace,\n  };\n}\n\nfunction reviewDir(memoryDir: string): string {\n  return path.join(memoryDir, \".review\", \"contradictions\");\n}\n\nfunction migrationMarkerPath(memoryDir: string, namespace: string): string {\n  const namespaceKey = createHash(\"sha256\").update(namespace).digest(\"hex\").slice(0, 16);\n  return path.join(reviewDir(memoryDir), `${UNSCOPED_MIGRATION_MARKER_PREFIX}${namespaceKey}${UNSCOPED_MIGRATION_MARKER_SUFFIX}`);\n}\n\nfunction clearUnscopedMigrationMarkers(memoryDir: string): void {\n  const dir = reviewDir(memoryDir);\n  if (!fs.existsSync(dir)) return;\n\n  try {\n    for (const entry of fs.readdirSync(dir)) {\n      if (entry.startsWith(UNSCOPED_MIGRATION_MARKER_PREFIX) && entry.endsWith(UNSCOPED_MIGRATION_MARKER_SUFFIX)) {\n        fs.rmSync(path.join(dir, entry), { force: true });\n      }\n    }\n  } catch {\n    // Marker cleanup is best-effort. The next migration/list call can recover.\n  }\n}\n\nfunction pairPath(memoryDir: string, pairId: string): string {\n  if (pairId.includes(\"/\") || pairId.includes(\"\\\\\") || pairId.includes(\"..\")) {\n    throw new Error(`Invalid pairId: ${pairId}`);\n  }\n  return path.join(reviewDir(memoryDir), `${pairId}.json`);\n}\n\nfunction isSafeReviewJsonFile(memoryDir: string, filePath: string): boolean {\n  const root = path.resolve(reviewDir(memoryDir));\n  const resolved = path.resolve(filePath);\n  const relative = path.relative(root, resolved);\n  if (relative === \"\" || relative.startsWith(\"..\") || path.isAbsolute(relative)) {\n    return false;\n  }\n\n  try {\n    return fs.lstatSync(resolved).isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction ensureDir(memoryDir: string): void {\n  const dir = reviewDir(memoryDir);\n  if (!fs.existsSync(dir)) {\n    fs.mkdirSync(dir, { recursive: true });\n  }\n}\n\nfunction uniqueTempPath(filePath: string): string {\n  return `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;\n}\n\nfunction writePairFile(filePath: string, pair: ContradictionPair): void {\n  const tmpPath = uniqueTempPath(filePath);\n  try {\n    fs.writeFileSync(tmpPath, JSON.stringify(pair, null, 2), \"utf-8\");\n    fs.renameSync(tmpPath, filePath);\n  } catch (error) {\n    try {\n      fs.rmSync(tmpPath, { force: true });\n    } catch {\n      // Best-effort cleanup only; preserve the original write failure.\n    }\n    throw error;\n  }\n}\n\nexport function computeMemoryContentHash(content: string, category?: string): string {\n  const normalized = JSON.stringify({\n    content: content.trim(),\n    category: (category ?? \"\").trim(),\n  });\n  return createHash(\"sha256\").update(normalized).digest(\"hex\").slice(0, 16);\n}\n\nfunction suppliedMemoryHashesChanged(\n  existing: ContradictionPair,\n  pair: Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] },\n): boolean {\n  if (!existing.memoryContentHashes || !pair.memoryContentHashes) return false;\n  return pair.memoryIds.some((memoryId) => {\n    const current = pair.memoryContentHashes?.[memoryId];\n    return typeof current === \"string\" && existing.memoryContentHashes?.[memoryId] !== current;\n  });\n}\n\n// ── Write ──────────────────────────────────────────────────────────────────────\n\n/**\n * Write a contradiction pair to the review queue.\n * Idempotent: if the pair already exists with a higher or equal confidence,\n * the existing entry is preserved.\n */\nexport function writePair(\n  memoryDir: string,\n  pair: Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] },\n  options: WritePairOptions = {},\n): ContradictionPair {\n  ensureDir(memoryDir);\n  if (pair.namespace === undefined) {\n    clearUnscopedMigrationMarkers(memoryDir);\n  }\n  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);\n  const existing = readPair(memoryDir, pairId);\n\n  // Preserve terminal user resolutions if already reviewed.\n  if (isTerminalResolution(existing?.resolution)) {\n    return existing!;\n  }\n  const contentChanged = Boolean(existing && suppliedMemoryHashesChanged(existing, pair));\n  if (existing?.resolution === \"both-valid\" && options.cooldownDays === undefined && !contentChanged) {\n    return existing;\n  }\n\n  // Preserve active deferrals, but allow expired deferrals to be refreshed.\n  const existingDeferralExpired = Boolean(existing && isDeferred(existing) && !isDeferralActive(existing));\n  if (existing && isDeferralActive(existing) && !contentChanged) {\n    return existing;\n  }\n\n  // Preserve same-verdict or still-cooling entries, but let expired dormant\n  // verdicts refresh when the judge now finds an actionable conflict.\n  const existingDormantCooldownActive = Boolean(\n    existing\n    && isDormantReviewedPair(existing)\n    && options.cooldownDays !== undefined\n    && isCoolingDown(existing, options.cooldownDays),\n  );\n  const dormantContentChanged = Boolean(\n    existing\n    && existingDormantCooldownActive\n    && contentChanged,\n  );\n  const existingDormantExpired = Boolean(\n    existing\n    && isDormantReviewedPair(existing)\n    && options.cooldownDays !== undefined\n    && !existingDormantCooldownActive,\n  );\n  if (\n    existing\n    && !existingDeferralExpired\n    && (\n      (existingDormantCooldownActive && !dormantContentChanged)\n      || (!existingDormantExpired && !contentChanged && existing.confidence >= pair.confidence)\n    )\n  ) {\n    return existing;\n  }\n\n  const full: ContradictionPair = {\n    ...pair,\n    pairId,\n    lastReviewedAt: (existingDeferralExpired || existingDormantExpired || contentChanged)\n      ? pair.lastReviewedAt\n      : (existing?.lastReviewedAt ?? pair.lastReviewedAt),\n    resolution: undefined,\n    deferredUntil: (existingDeferralExpired || existingDormantExpired || contentChanged)\n      ? undefined\n      : existing?.deferredUntil,\n  };\n\n  const filePath = pairPath(memoryDir, pairId);\n  writePairFile(filePath, full);\n\n  return full;\n}\n\n/**\n * Write multiple pairs, deduplicating inputs first (rule 49).\n */\nexport function writePairs(\n  memoryDir: string,\n  pairs: Array<Omit<ContradictionPair, \"pairId\"> & { memoryIds: [string, string] }>,\n  options: WritePairOptions = {},\n): ContradictionPair[] {\n  const seen = new Set<string>();\n  const results: ContradictionPair[] = [];\n\n  for (const pair of pairs) {\n    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);\n    if (seen.has(key)) continue;\n    seen.add(key);\n    results.push(writePair(memoryDir, pair, options));\n  }\n\n  return results;\n}\n\n// ── Read ───────────────────────────────────────────────────────────────────────\n\n/**\n * Read a single pair by ID. Returns null if not found.\n */\nexport function readPair(memoryDir: string, pairId: string): ContradictionPair | null {\n  const filePath = pairPath(memoryDir, pairId);\n  try {\n    if (!isSafeReviewJsonFile(memoryDir, filePath)) return null;\n    const raw = fs.readFileSync(filePath, \"utf-8\");\n    const parsed = JSON.parse(raw);\n    if (typeof parsed === \"object\" && parsed !== null && Array.isArray(parsed.memoryIds)) {\n      return parsed as ContradictionPair;\n    }\n    return null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * List pairs in the review queue, optionally filtered by verdict.\n */\nexport function listPairs(\n  memoryDir: string,\n  options?: {\n    filter?: ContradictionFilter;\n    namespace?: string;\n    includeUnscopedForNamespace?: boolean;\n    limit?: number;\n  },\n): ContradictionListResult {\n  const startTime = Date.now();\n  const dir = reviewDir(memoryDir);\n  const { filter = \"all\", namespace, includeUnscopedForNamespace = false, limit = 50 } = options ?? {};\n  const matchingPairs: ContradictionPair[] = [];\n  let total = 0;\n\n  if (!fs.existsSync(dir)) {\n    return { pairs: [], total: 0, durationMs: Date.now() - startTime };\n  }\n\n  for (const entry of fs.readdirSync(dir)) {\n    if (!entry.endsWith(\".json\")) continue;\n\n    try {\n      const filePath = path.join(dir, entry);\n      if (!isSafeReviewJsonFile(memoryDir, filePath)) continue;\n      const raw = fs.readFileSync(filePath, \"utf-8\");\n      const pair = JSON.parse(raw) as ContradictionPair;\n\n      if (typeof pair !== \"object\" || pair === null) continue;\n      if (!Array.isArray(pair.memoryIds)) continue;\n\n      // Namespace filter\n      if (namespace && pair.namespace !== namespace && !(includeUnscopedForNamespace && pair.namespace === undefined)) continue;\n\n      // Verdict filter\n      if (filter === \"unresolved\") {\n        if (isTerminalResolution(pair.resolution)) continue;\n        if (isDeferralActive(pair)) continue;\n        if (pair.resolution === \"both-valid\") continue;\n        if (pair.verdict === \"independent\") continue;\n      } else if (filter !== \"all\" && pair.verdict !== filter) {\n        continue;\n      }\n\n      total++;\n      matchingPairs.push(pair);\n    } catch {\n      continue;\n    }\n  }\n\n  matchingPairs.sort(compareReviewPairs);\n  const pairs: ContradictionPair[] = [];\n  for (const pair of matchingPairs) {\n    if (!(pairs.length < limit)) break;\n    pairs.push(pair);\n  }\n\n  return { pairs, total, durationMs: Date.now() - startTime };\n}\n\nexport function migrateUnscopedPairsToNamespace(memoryDir: string, namespace: string, options: WritePairOptions = {}): number {\n  const resolvedNamespace = namespace.trim();\n  if (!resolvedNamespace) return 0;\n\n  const dir = reviewDir(memoryDir);\n  if (!fs.existsSync(dir)) return 0;\n  const markerPath = migrationMarkerPath(memoryDir, resolvedNamespace);\n  if (fs.existsSync(markerPath)) return 0;\n\n  let migrated = 0;\n  let hadMigrationFailure = false;\n  for (const entry of fs.readdirSync(dir)) {\n    if (!entry.endsWith(\".json\")) continue;\n    const filePath = path.join(dir, entry);\n\n    try {\n      if (!isSafeReviewJsonFile(memoryDir, filePath)) continue;\n      const raw = fs.readFileSync(filePath, \"utf-8\");\n      const pair = JSON.parse(raw) as ContradictionPair;\n      if (typeof pair !== \"object\" || pair === null) continue;\n      if (!Array.isArray(pair.memoryIds)) continue;\n      if (pair.namespace !== undefined) continue;\n\n      const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], resolvedNamespace);\n      const migratedPair = { ...pair, namespace: resolvedNamespace, pairId };\n      const targetPath = pairPath(memoryDir, pairId);\n      try {\n        if (targetPath === filePath) {\n          writePairFile(filePath, migratedPair);\n        } else if (!fs.existsSync(targetPath)) {\n          writePairFile(targetPath, migratedPair);\n          fs.rmSync(filePath, { force: true });\n        } else {\n          if (!isSafeReviewJsonFile(memoryDir, targetPath)) {\n            hadMigrationFailure = true;\n            continue;\n          }\n          const existing = readPair(memoryDir, pairId);\n          writePairFile(targetPath, existing ? mergeMigratedPair(existing, migratedPair, options) : migratedPair);\n          fs.rmSync(filePath, { force: true });\n        }\n        migrated += 1;\n      } catch {\n        hadMigrationFailure = true;\n        continue;\n      }\n    } catch {\n      continue;\n    }\n  }\n\n  if (!hadMigrationFailure) {\n    try {\n      fs.writeFileSync(markerPath, `${new Date().toISOString()}\\n`, { encoding: \"utf-8\", flag: \"wx\" });\n    } catch {\n      // Another caller may have completed the same one-shot migration first.\n    }\n  }\n\n  return migrated;\n}\n\n// ── Cooldown ───────────────────────────────────────────────────────────────────\n\n/**\n * Check if a pair is within its cooldown window.\n * Returns true if the pair should be SKIPPED (still cooling down).\n */\nexport function isCoolingDown(pair: ContradictionPair, cooldownDays: number): boolean {\n  if (cooldownDays <= 0) return false; // rule 27: guard against 0\n\n  const deferredUntil = deferralUntilMillis(pair);\n  if (deferredUntil !== null) {\n    return Date.now() < deferredUntil;\n  }\n\n  if (!pair.lastReviewedAt) return false;\n\n  const lastReviewed = parseIsoMillis(pair.lastReviewedAt);\n  if (lastReviewed === null) return false;\n\n  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1000;\n  return Date.now() < lastReviewed + cooldownMs;\n}\n\n/**\n * Mark a pair as reviewed (sets lastReviewedAt and, for terminal verbs, resolution).\n */\nexport function resolvePair(\n  memoryDir: string,\n  pairId: string,\n  verb: ResolutionVerb,\n): ContradictionPair | null {\n  if (typeof verb !== \"string\" || !VALID_RESOLUTION_VERBS.includes(verb)) {\n    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);\n  }\n\n  if (verb === \"needs-more-context\") {\n    return deferPair(memoryDir, pairId);\n  }\n\n  const existing = readPair(memoryDir, pairId);\n  if (!existing) return null;\n  if (preservesDirectResolution(existing.resolution)) return existing;\n\n  const updated: ContradictionPair = {\n    ...existing,\n    lastReviewedAt: new Date().toISOString(),\n    resolution: verb,\n    deferredUntil: undefined,\n  };\n\n  const filePath = pairPath(memoryDir, pairId);\n  writePairFile(filePath, updated);\n\n  return updated;\n}\n\n/**\n * Defer a pair without terminally resolving it.\n */\nexport function deferPair(\n  memoryDir: string,\n  pairId: string,\n  deferredUntil = new Date(Date.now() + NEEDS_MORE_CONTEXT_COOLDOWN_MS).toISOString(),\n): ContradictionPair | null {\n  const existing = readPair(memoryDir, pairId);\n  if (!existing) return null;\n  if (preservesDirectResolution(existing.resolution)) return existing;\n\n  const updated: ContradictionPair = {\n    ...existing,\n    lastReviewedAt: new Date().toISOString(),\n    resolution: undefined,\n    deferredUntil,\n  };\n\n  const filePath = pairPath(memoryDir, pairId);\n  writePairFile(filePath, updated);\n\n  return updated;\n}\n\n/**\n * Check whether a pair's referenced memories have changed since detection,\n * which should override cooldown.\n */\nexport function memoryHashesChanged(\n  _memoryDir: string,\n  pair: ContradictionPair,\n  getCurrentHash: (memoryId: string) => string | null,\n): boolean {\n  if (!pair.memoryContentHashes) return false;\n\n  for (const memoryId of pair.memoryIds) {\n    const previousHash = pair.memoryContentHashes[memoryId];\n    if (typeof previousHash !== \"string\") continue;\n\n    const currentHash = getCurrentHash(memoryId);\n    if (currentHash !== null && currentHash !== previousHash) return true;\n  }\n\n  return false;\n}\n"],"mappings":"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","names":[]}