@remnic/core 9.65.2 → 9.65.4

package/src/review/review-deck.ts

@@ -0,0 +1,311 @@
+import { createHash } from "node:crypto";
+
+export type ReviewDeckChoice = "keep" | "prepare_fix" | "not_true";
+export type ReviewDeckRisk = "reversible";
+
+export interface ReviewDeckEvidence {
+  sourceMemoryId?: string;
+  sourceDate?: string;
+  excerpt?: string;
+  relation: "supports" | "conflicts" | "origin";
+}
+
+export interface ReviewDeckItem {
+  schemaVersion: 1;
+  itemId: string;
+  source: "review";
+  sourceId: string;
+  memoryId?: string;
+  content: string;
+  category?: string;
+  lifecycleState?: string;
+  confidence?: number;
+  confidenceTier?: string;
+  reviewReason: string;
+  reviewReasonLabel: string;
+  supportCount: number;
+  provenance: readonly ReviewDeckEvidence[];
+  allowedChoices: readonly ReviewDeckChoice[];
+  choiceRisk: Readonly<Record<ReviewDeckChoice, ReviewDeckRisk | "unavailable">>;
+  namespace: string;
+  revision: string;
+}
+
+export interface ReviewDeckPage {
+  schemaVersion: 1;
+  items: readonly ReviewDeckItem[];
+  nextCursor?: string;
+  total: number;
+}
+
+export type ReviewDeckActionRequest =
+  | { schemaVersion: 1; itemId: string; revision: string; action: "keep" | "not_true"; idempotencyKey: string }
+  | { schemaVersion: 1; itemId: string; revision: string; action: "prepare_fix"; correctionText: string; idempotencyKey: string };
+
+export interface ReviewDeckActionReceipt {
+  schemaVersion: 1;
+  receiptId: string;
+  itemId: string;
+  action: "keep" | "not_true" | "prepare_fix" | "undo";
+  outcome: "planned" | "applied" | "conflict" | "failed";
+  effect: string;
+  undoAvailable: boolean;
+  appliedRevision?: string;
+  correctionPlanId?: string;
+  correctionPreview?: unknown;
+}
+
+export interface ReviewDeckUndoRequest {
+  schemaVersion: 1;
+  receiptId: string;
+  expectedRevision: string;
+  idempotencyKey: string;
+}
+
+export interface ReviewDeckSourceRow {
+  itemId: string;
+  filePath: string;
+  fileContent: string;
+  revision: string;
+  content: string;
+  category?: string;
+  confidence?: number;
+  confidenceTier?: string;
+  reviewReason: string;
+  created: string;
+  source?: string;
+  blockedBy?: string;
+  lifecycleState?: string;
+  context?: string;
+}
+
+export interface ReviewDeckSnapshot {
+  corpusVersion: string;
+  total: number;
+  rows: readonly ReviewDeckSourceRow[];
+}
+
+export interface ReviewDeckCursorScope {
+  principalDigest: string;
+  namespace: string;
+  filterDigest: string;
+  corpusVersion: string;
+}
+
+export class ReviewDeckCursorError extends Error {
+  constructor(message = "Invalid review deck cursor") {
+    super(message);
+    this.name = "ReviewDeckCursorError";
+  }
+}
+
+const ALLOWED_CHOICES = ["keep", "prepare_fix", "not_true"] as const satisfies readonly ReviewDeckChoice[];
+const REVERSIBLE_RISK = {
+  keep: "reversible",
+  prepare_fix: "reversible",
+  not_true: "reversible",
+} as const satisfies Record<ReviewDeckChoice, ReviewDeckRisk>;
+
+const REVIEW_REASON_LABELS: Record<string, string> = {
+  low_confidence: "Low confidence",
+  suggestion: "Suggested memory",
+  tombstone_blocked: "Blocked by a deletion",
+  contradiction: "Conflicts with another memory",
+  duplicate: "Possible duplicate",
+};
+
+const EXCERPT_LIMIT = 240;
+
+export function computeReviewItemRevision(fileContent: string): string {
+  return `rv1:${createHash("sha256").update(fileContent).digest("hex")}`;
+}
+
+export function projectReviewDeckItem(row: ReviewDeckSourceRow, namespace: string): ReviewDeckItem {
+  const provenance = provenanceFromRow(row);
+  return {
+    schemaVersion: 1,
+    itemId: row.itemId,
+    source: "review",
+    sourceId: row.itemId,
+    memoryId: row.itemId,
+    content: row.content,
+    ...(row.category !== undefined ? { category: row.category } : {}),
+    ...(row.lifecycleState !== undefined ? { lifecycleState: row.lifecycleState } : {}),
+    ...(row.confidence !== undefined ? { confidence: row.confidence } : {}),
+    ...(row.confidenceTier !== undefined ? { confidenceTier: row.confidenceTier } : {}),
+    reviewReason: row.reviewReason,
+    reviewReasonLabel: reviewReasonLabel(row.reviewReason),
+    supportCount: provenance.filter((entry) => entry.relation === "supports").length,
+    provenance,
+    allowedChoices: ALLOWED_CHOICES,
+    choiceRisk: REVERSIBLE_RISK,
+    namespace,
+    revision: row.revision,
+  };
+}
+
+export function compareReviewDeckRows(a: ReviewDeckSourceRow, b: ReviewDeckSourceRow): number {
+  const aBlocked = a.blockedBy && a.blockedBy.length > 0 ? 0 : 1;
+  const bBlocked = b.blockedBy && b.blockedBy.length > 0 ? 0 : 1;
+  if (aBlocked !== bBlocked) return aBlocked - bBlocked;
+  const aConfidence = a.confidence ?? 0.5;
+  const bConfidence = b.confidence ?? 0.5;
+  if (aConfidence !== bConfidence) return aConfidence < bConfidence ? -1 : 1;
+  if (a.created !== b.created) return a.created < b.created ? -1 : 1;
+  if (a.itemId !== b.itemId) return a.itemId < b.itemId ? -1 : 1;
+  return 0;
+}
+
+export function encodeReviewDeckCursor(scope: ReviewDeckCursorScope, lastSortKey: string): string {
+  return Buffer.from(
+    JSON.stringify({
+      v: 1,
+      p: scope.principalDigest,
+      n: scope.namespace,
+      f: scope.filterDigest,
+      c: scope.corpusVersion,
+      k: lastSortKey,
+    }),
+    "utf8",
+  ).toString("base64url");
+}
+
+export function decodeReviewDeckCursor(cursor: string, scope: ReviewDeckCursorScope): string {
+  const payload = parseCursorPayload(cursor);
+  if (
+    payload.p !== scope.principalDigest
+    || payload.n !== scope.namespace
+    || payload.f !== scope.filterDigest
+    || payload.c !== scope.corpusVersion
+  ) {
+    throw new ReviewDeckCursorError("Review deck cursor scope mismatch");
+  }
+  return payload.k;
+}
+
+export function buildReviewDeckPage(
+  rows: readonly ReviewDeckSourceRow[],
+  opts: { scope: ReviewDeckCursorScope; cursor?: string; limit: number },
+): ReviewDeckPage {
+  const sorted = [...rows].sort(compareReviewDeckRows);
+  const limit = Math.max(0, opts.limit);
+  let start = 0;
+  if (opts.cursor !== undefined) {
+    const lastSortKey = decodeReviewDeckCursor(opts.cursor, opts.scope);
+    start = sorted.findIndex((row) => reviewDeckSortKey(row) > lastSortKey);
+    if (start < 0) start = sorted.length;
+  }
+  const pageRows = limit === 0 ? [] : sorted.slice(start, start + limit);
+  const items = pageRows.map((row) => projectReviewDeckItem(row, opts.scope.namespace));
+  const consumed = start + pageRows.length;
+  const nextCursor =
+    pageRows.length > 0 && consumed < sorted.length
+      ? encodeReviewDeckCursor(opts.scope, reviewDeckSortKey(pageRows[pageRows.length - 1]))
+      : undefined;
+  return {
+    schemaVersion: 1,
+    items,
+    total: sorted.length,
+    ...(nextCursor !== undefined ? { nextCursor } : {}),
+  };
+}
+
+function reviewDeckSortKey(row: ReviewDeckSourceRow): string {
+  const blocked = row.blockedBy && row.blockedBy.length > 0 ? "0" : "1";
+  return `${blocked}\t${(row.confidence ?? 0.5).toFixed(6)}\t${row.created}\t${row.itemId}`;
+}
+
+function reviewReasonLabel(reason: string): string {
+  const known = REVIEW_REASON_LABELS[reason];
+  if (known) return known;
+  const words = reason.split("_").filter((part) => part.length > 0);
+  if (words.length === 0) return "Review";
+  return words
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+}
+
+function provenanceFromRow(row: ReviewDeckSourceRow): ReviewDeckEvidence[] {
+  const fm = parseFrontmatterFields(row.fileContent);
+  const source = nonempty(row.source) ?? nonempty(fm.source);
+  const context = nonempty(row.context) ?? nonempty(fm.context);
+  const created = nonempty(row.created) ?? nonempty(fm.created);
+  const supportIds = idList(fm.supports);
+  const conflictIds = [...idList(fm.conflicts), ...idList(fm.contradicts)];
+  const relatedIds = idList(fm.relatedMemoryIds);
+  const relatedRelation = row.reviewReason === "contradiction" ? "conflicts" : "supports";
+  const provenance: ReviewDeckEvidence[] = [];
+  if (source !== undefined || context !== undefined) {
+    provenance.push({
+      relation: "origin",
+      ...(created !== undefined ? { sourceDate: created } : {}),
+      excerpt: truncateExcerpt(context ?? source ?? ""),
+    });
+  }
+  for (const sourceMemoryId of supportIds) {
+    provenance.push({ relation: "supports", sourceMemoryId });
+  }
+  for (const sourceMemoryId of conflictIds) {
+    provenance.push({ relation: "conflicts", sourceMemoryId });
+  }
+  for (const sourceMemoryId of relatedIds) {
+    if (supportIds.includes(sourceMemoryId) || conflictIds.includes(sourceMemoryId)) continue;
+    provenance.push({ relation: relatedRelation, sourceMemoryId });
+  }
+  return provenance;
+}
+
+function parseFrontmatterFields(content: string): Record<string, string> {
+  if (!content.startsWith("---\n")) return {};
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const fields: Record<string, string> = {};
+  for (const line of content.slice(4, end).split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    fields[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 1).trim();
+  }
+  return fields;
+}
+
+function idList(value: string | undefined): string[] {
+  if (value === undefined || value.length === 0) return [];
+  return value
+    .replace(/^\[|\]$/g, "")
+    .split(",")
+    .map((part) => part.trim().replace(/^["']|["']$/g, ""))
+    .filter((part) => part.length > 0);
+}
+
+function nonempty(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  return value.trim().length > 0 ? value : undefined;
+}
+
+function truncateExcerpt(value: string): string {
+  return value.length <= EXCERPT_LIMIT ? value : value.slice(0, EXCERPT_LIMIT);
+}
+
+function parseCursorPayload(cursor: string): { v: 1; p: string; n: string; f: string; c: string; k: string } {
+  if (cursor.length === 0) throw new ReviewDeckCursorError("Malformed review deck cursor");
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+  } catch {
+    throw new ReviewDeckCursorError("Malformed review deck cursor");
+  }
+  if (!parsed || typeof parsed !== "object") throw new ReviewDeckCursorError("Malformed review deck cursor");
+  const record = parsed as Record<string, unknown>;
+  if (record.v !== 1) throw new ReviewDeckCursorError("Unsupported review deck cursor schema");
+  if (
+    typeof record.p !== "string"
+    || typeof record.n !== "string"
+    || typeof record.f !== "string"
+    || typeof record.c !== "string"
+    || typeof record.k !== "string"
+    || record.k.length === 0
+  ) {
+    throw new ReviewDeckCursorError("Malformed review deck cursor");
+  }
+  return { v: 1, p: record.p, n: record.n, f: record.f, c: record.c, k: record.k };
+}

package/src/storage.ts

@@ -13,11 +13,8 @@ import {
 } from "node:fs/promises";
 import { appendFileSync, createReadStream, mkdirSync, readFileSync, statSync } from "node:fs";
 import { createHash } from "node:crypto";
-import {
-  computeContentHash,
-  computeLegacyContentHash,
-  normalizeContent,
-} from "./content-hash.js";
+import { computeLegacyContentHash, normalizeContent } from "./content-hash.js";
+import { parseDriftProvenance, serializeDriftProvenance } from "./preferences/drift-types.js";
 import { raceAbort } from "./abort-error.js";
 import { checkCorpusReadAbort, type CorpusReadOptions } from "./corpus-read-cancellation.js";
 import { selectArtifactMatches, type ArtifactSearchOptions } from "./artifact-search.js";
@@ -28,7 +25,6 @@ import { createMemorySnapshot } from "./memory-snapshot.js";
 import { assertMemoryFrontmatterId, warnProjectionFallback } from "./storage-guards.js";
 import { createTombstoneMigrationSourceContents } from "./storage/tombstone-migration-sources.js";
 import { MemoryReadStore, readWindowedMemories, type WindowedMemoryReadOptions, type WindowedMemoryReadResult } from "./storage/memory-read-store.js";
-import { hasSupersessionAudit } from "./storage/supersession-audit.js";
 import { runCommittedInvalidation } from "./storage/committed-invalidation.js";
 import { renderProfileWithLastUpdated, stripOkfProfileFrontmatter, withOkfProfileFrontmatter } from "./storage/profile-header.js";
 import { parseQuestionFile as parseQuestionFileText } from "./storage/questions-file.js";
@@ -408,6 +404,7 @@ function serializeFrontmatter(fm: MemoryFrontmatter): string {
     assertMemoryWorthCounter("mw_fail", fm.mw_fail);
     lines.push(`mw_fail: ${fm.mw_fail}`);
   }
+  lines.push(...serializeDriftProvenance(fm));
   // Importance scoring
   if (fm.importance) {
     lines.push(`importanceScore: ${fm.importance.score}`);
@@ -919,6 +916,7 @@ export function parseFrontmatter(raw: string): { frontmatter: MemoryFrontmatter;
       // Memory Worth counters (issue #560)
       mw_success,
       mw_fail,
+      ...parseDriftProvenance(fm),
       // Importance scoring
       importance,
       // Chunking

package/src/types.ts

@@ -11,7 +11,10 @@ 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 { SkillProjectionConfig } from "./procedural/skill-projection.js";
+import type { ActionGateConfig } from "./coding/action-gate.js";
 
 import type { AmbientCaptureProvenance, BufferTurnOwner, SecurityConfig, OriginMetadata } from "./security/types.js";
 export type MemorySubject = "user" | "agent";
@@ -388,11 +391,8 @@ export interface DreamsPhasesConfig {
 
 export interface ProceduralConfig {
   enabled: boolean;
-  /** Minimum cluster size before emitting a candidate; `0` disables mining (`minOccurrences_zero`). */
   minOccurrences: number;
-  /** Minimum success rate from trajectory outcomes in [0, 1]. */
   successFloor: number;
-  /** When auto-promotion is enabled, promote pending_review → active after this many occurrences. */
   autoPromoteOccurrences: number;
   autoPromoteEnabled: boolean;
   lookbackDays: number;
@@ -400,6 +400,7 @@ export interface ProceduralConfig {
   proceduralMiningCronAutoRegister: boolean;
   recallMaxProcedures: number;
   maintenance: ProceduralMaintenanceConfig;
+  skillProjection: SkillProjectionConfig;
 }
 
 /**
@@ -682,7 +683,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;
@@ -1252,6 +1253,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).
@@ -2803,7 +2806,7 @@ 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;
@@ -3463,7 +3466,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/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":[]}