@remnic/plugin-openclaw 1.0.35 → 1.0.36

package/dist/chunk-UZJ7EERS.js

@@ -0,0 +1,272 @@
+import {
+  readPair,
+  resolvePair
+} from "./chunk-YJYZMLD5.js";
+import {
+  log
+} from "./chunk-UFU5GGGA.js";
+
+// ../remnic-core/src/contradiction/resolution.ts
+var VALID_VERBS = ["keep-a", "keep-b", "merge", "both-valid", "needs-more-context"];
+function isValidResolutionVerb(value) {
+  return VALID_VERBS.includes(value);
+}
+async function executeResolution(memoryDir, storage, pairId, verb, options = {}) {
+  if (typeof verb !== "string" || !isValidResolutionVerb(verb)) {
+    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);
+  }
+  const pair = readPair(memoryDir, pairId);
+  if (!pair) {
+    return { pairId, verb, affectedIds: [], message: `Pair ${pairId} not found` };
+  }
+  if (pair.namespace && !options.storageForNamespace) {
+    throw new Error(
+      "contradiction resolution requires storageForNamespace for namespaced pairs so callers resolve the correct namespace storage"
+    );
+  }
+  const resolutionStorage = options.storageForNamespace ? await options.storageForNamespace(pair.namespace) : storage;
+  if (pair.resolution && pair.resolution !== "needs-more-context") {
+    return { pairId, verb, affectedIds: [], message: `Pair already resolved with verb "${pair.resolution}"` };
+  }
+  const [idA, idB] = pair.memoryIds;
+  const affectedIds = [];
+  let message = "";
+  let supersedeFailed = false;
+  switch (verb) {
+    case "keep-a": {
+      const keepTarget = await validateKeepTarget(resolutionStorage, pairId, idA);
+      if (!keepTarget.ok) {
+        supersedeFailed = true;
+        message = keepTarget.message;
+        break;
+      }
+      const sourceB = await loadSourceSnapshot(resolutionStorage, idB);
+      const ok = sourceB ? await supersedeSafe(resolutionStorage, idB, idA, "contradiction-resolution:keep-a") : false;
+      if (ok) {
+        affectedIds.push(idB);
+        message = `Kept ${idA}, superseded ${idB}`;
+      } else {
+        supersedeFailed = true;
+        const rolledBack = sourceB ? await restoreMemorySnapshot(resolutionStorage, sourceB, "contradiction-resolution:keep-a-rollback") : false;
+        message = rolledBack ? `Supersede failed for ${idB}; restored ${idB} and did not resolve` : `Supersede failed for ${idB}; rollback incomplete for ${idB} and pair is not resolved`;
+      }
+      break;
+    }
+    case "keep-b": {
+      const keepTarget = await validateKeepTarget(resolutionStorage, pairId, idB);
+      if (!keepTarget.ok) {
+        supersedeFailed = true;
+        message = keepTarget.message;
+        break;
+      }
+      const sourceA = await loadSourceSnapshot(resolutionStorage, idA);
+      const ok = sourceA ? await supersedeSafe(resolutionStorage, idA, idB, "contradiction-resolution:keep-b") : false;
+      if (ok) {
+        affectedIds.push(idA);
+        message = `Kept ${idB}, superseded ${idA}`;
+      } else {
+        supersedeFailed = true;
+        const rolledBack = sourceA ? await restoreMemorySnapshot(resolutionStorage, sourceA, "contradiction-resolution:keep-b-rollback") : false;
+        message = rolledBack ? `Supersede failed for ${idA}; restored ${idA} and did not resolve` : `Supersede failed for ${idA}; rollback incomplete for ${idA} and pair is not resolved`;
+      }
+      break;
+    }
+    case "merge": {
+      const replacement = await prepareMergeReplacement(resolutionStorage, pairId, idA, idB, options);
+      if (!replacement.ok) {
+        supersedeFailed = true;
+        message = replacement.message;
+        break;
+      }
+      const okA = await supersedeSafe(resolutionStorage, idA, replacement.mergedId, "contradiction-resolution:merge");
+      if (!okA) {
+        supersedeFailed = true;
+        const rolledBackA = await restoreMemorySnapshot(resolutionStorage, replacement.sourceA);
+        message = rolledBackA ? `Merge failed for ${idA}; restored ${idA} and did not resolve` : `Merge failed for ${idA}; rollback incomplete for ${idA} and pair is not resolved`;
+        if (rolledBackA) {
+          await cleanupCreatedReplacement(resolutionStorage, replacement);
+        }
+        break;
+      }
+      const okB = await supersedeSafe(resolutionStorage, idB, replacement.mergedId, "contradiction-resolution:merge");
+      if (!okB) {
+        supersedeFailed = true;
+        const rolledBackA = await restoreMemorySnapshot(resolutionStorage, replacement.sourceA);
+        const rolledBackB = await restoreMemorySnapshot(resolutionStorage, replacement.sourceB);
+        message = rolledBackA && rolledBackB ? `Merge failed for ${idB}; restored ${idA} and ${idB} and did not resolve` : `Merge failed for ${idB}; rollback incomplete for ${[
+          rolledBackA ? void 0 : idA,
+          rolledBackB ? void 0 : idB
+        ].filter(Boolean).join(", ")} and pair is not resolved`;
+        if (rolledBackA && rolledBackB) {
+          await cleanupCreatedReplacement(resolutionStorage, replacement);
+        }
+        break;
+      }
+      affectedIds.push(idA, idB);
+      message = `Both memories superseded by merged ${replacement.mergedId}`;
+      break;
+    }
+    case "both-valid": {
+      message = "Pair marked as both-valid; cooldown applied";
+      break;
+    }
+    case "needs-more-context": {
+      message = "Deferred; no action taken, short cooldown applied";
+      break;
+    }
+  }
+  if (!supersedeFailed) {
+    resolvePair(memoryDir, pairId, verb);
+  }
+  log.info("[contradiction-resolution] pair=%s verb=%s affected=%d", pairId, verb, affectedIds.length);
+  return { pairId, verb, affectedIds, message };
+}
+async function prepareMergeReplacement(storage, pairId, idA, idB, options) {
+  const sourceA = await storage.getMemoryById(idA);
+  const sourceB = await storage.getMemoryById(idB);
+  if (!sourceA || !sourceB) {
+    return { ok: false, message: `Merge requires both source memories to exist; not resolving ${pairId}` };
+  }
+  const requestedMergedId = options.mergedMemoryId?.trim();
+  if (requestedMergedId) {
+    if (requestedMergedId === idA || requestedMergedId === idB) {
+      return { ok: false, message: "Merge replacement must be distinct from both source memories; not resolving" };
+    }
+    const replacement2 = await storage.getMemoryById(requestedMergedId);
+    if (!replacement2) {
+      return { ok: false, message: `Merged memory ${requestedMergedId} not found; not resolving` };
+    }
+    const replacementStatus = replacement2.frontmatter.status ?? "active";
+    if (replacementStatus !== "active") {
+      return {
+        ok: false,
+        message: `Merged memory ${requestedMergedId} is ${replacementStatus}; not resolving`
+      };
+    }
+    return { ok: true, mergedId: requestedMergedId, sourceA, sourceB, created: false };
+  }
+  const mergedContent = options.mergedContent;
+  if (typeof mergedContent !== "string" || mergedContent.trim().length === 0) {
+    return {
+      ok: false,
+      message: "Merge requires mergedMemoryId or mergedContent; no memories changed"
+    };
+  }
+  const category = options.mergedCategory ?? mergedMemoryCategory(sourceA, sourceB);
+  let mergedId;
+  try {
+    mergedId = await storage.writeMemory(category, mergedContent, {
+      actor: "contradiction-resolution",
+      confidence: Math.min(sourceA.frontmatter.confidence ?? 0.8, sourceB.frontmatter.confidence ?? 0.8),
+      tags: ["contradiction-resolution", "merge"],
+      source: "contradiction-resolution",
+      lineage: [idA, idB],
+      derivedFrom: [idA, idB],
+      derivedVia: "merge"
+    });
+  } catch (err) {
+    log.warn(
+      "[contradiction-resolution] merged memory creation failed for %s: %s",
+      pairId,
+      err instanceof Error ? err.message : err
+    );
+    return { ok: false, message: `Merged memory could not be created; not resolving ${pairId}` };
+  }
+  const replacement = await storage.getMemoryById(mergedId);
+  if (!replacement) {
+    await cleanupMemoryId(storage, mergedId);
+    return { ok: false, message: `Merged memory ${mergedId} could not be verified; not resolving` };
+  }
+  return { ok: true, mergedId, sourceA, sourceB, created: true };
+}
+function mergedMemoryCategory(sourceA, sourceB) {
+  return sourceA.frontmatter.category === sourceB.frontmatter.category ? sourceA.frontmatter.category : "fact";
+}
+async function validateKeepTarget(storage, pairId, keepId) {
+  const target = await loadSourceSnapshot(storage, keepId);
+  if (!target) {
+    return { ok: false, message: `Kept memory ${keepId} not found; not resolving ${pairId}` };
+  }
+  const status = target.frontmatter.status ?? "active";
+  if (status !== "active") {
+    return { ok: false, message: `Kept memory ${keepId} is ${status}; not resolving ${pairId}` };
+  }
+  return { ok: true };
+}
+async function loadSourceSnapshot(storage, memoryId) {
+  try {
+    return await storage.getMemoryById(memoryId);
+  } catch (err) {
+    log.warn(
+      "[contradiction-resolution] source snapshot failed for %s: %s",
+      memoryId,
+      err instanceof Error ? err.message : err
+    );
+    return null;
+  }
+}
+async function restoreMemorySnapshot(storage, memory, reasonCode = "contradiction-resolution:merge-rollback") {
+  try {
+    const current = await storage.getMemoryById(memory.frontmatter.id);
+    if (!current) return false;
+    const restoredFrontmatter = {
+      ...memory.frontmatter,
+      status: memory.frontmatter.status,
+      supersededBy: memory.frontmatter.supersededBy,
+      supersededAt: memory.frontmatter.supersededAt
+    };
+    return await storage.writeMemoryFrontmatter(current, restoredFrontmatter, {
+      actor: "contradiction-resolution",
+      reasonCode
+    });
+  } catch (err) {
+    log.warn(
+      "[contradiction-resolution] rollback failed for %s: %s",
+      memory.frontmatter.id,
+      err instanceof Error ? err.message : err
+    );
+    return false;
+  }
+}
+async function cleanupCreatedReplacement(storage, replacement) {
+  if (!replacement.created) return;
+  await cleanupMemoryId(storage, replacement.mergedId);
+}
+async function cleanupMemoryId(storage, memoryId) {
+  try {
+    const memory = await storage.getMemoryById(memoryId);
+    const invalidated = await storage.invalidateMemory(memoryId);
+    if (invalidated && memory?.frontmatter.category === "fact") {
+      await storage.removeFactContentHashesForMemories([memory]);
+    }
+  } catch (err) {
+    log.warn(
+      "[contradiction-resolution] cleanup failed for merged memory %s: %s",
+      memoryId,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+async function supersedeSafe(storage, oldId, newId, reason) {
+  try {
+    const result = await storage.supersedeMemory(oldId, newId, reason);
+    if (result === false) {
+      log.warn("[contradiction-resolution] supersede returned false for %s \u2192 %s", oldId, newId);
+      return false;
+    }
+    return true;
+  } catch (err) {
+    log.warn(
+      "[contradiction-resolution] supersede failed %s \u2192 %s: %s",
+      oldId,
+      newId,
+      err instanceof Error ? err.message : err
+    );
+    return false;
+  }
+}
+
+export {
+  isValidResolutionVerb,
+  executeResolution
+};

package/dist/chunk-YJYZMLD5.js

@@ -0,0 +1,360 @@
+// ../remnic-core/src/contradiction/contradiction-review.ts
+import fs from "fs";
+import path from "path";
+import { createHash, randomUUID } from "crypto";
+var VALID_RESOLUTION_VERBS = [
+  "keep-a",
+  "keep-b",
+  "merge",
+  "both-valid",
+  "needs-more-context"
+];
+var NEEDS_MORE_CONTEXT_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+var UNSCOPED_MIGRATION_MARKER_PREFIX = ".unscoped-migrated-";
+var UNSCOPED_MIGRATION_MARKER_SUFFIX = ".done";
+function computePairId(memoryIdA, memoryIdB, namespace) {
+  const sorted = [memoryIdA, memoryIdB].sort();
+  const normalizedNamespace = namespace?.trim();
+  const scope = normalizedNamespace ? `ns:${normalizedNamespace}::` : "";
+  return createHash("sha256").update(`${scope}${sorted.join("::")}`).digest("hex").slice(0, 24);
+}
+function isDefaultReviewNamespace(defaultNamespace, requestedNamespace, resolvedNamespace) {
+  const requested = requestedNamespace?.trim();
+  return !requested || requested === defaultNamespace || resolvedNamespace === defaultNamespace;
+}
+function isTerminalResolution(resolution) {
+  return resolution === "keep-a" || resolution === "keep-b" || resolution === "merge";
+}
+function preservesDirectResolution(resolution) {
+  return isTerminalResolution(resolution) || resolution === "both-valid";
+}
+function isDormantReviewedPair(pair) {
+  return pair.verdict === "independent" || pair.resolution === "both-valid";
+}
+function reviewStateRank(pair, cooldownDays) {
+  if (isTerminalResolution(pair.resolution)) return 5;
+  if (pair.resolution === "both-valid") return 4;
+  if (isDeferralActive(pair)) return 3;
+  if (isDormantReviewedPair(pair)) {
+    if (cooldownDays === void 0) return 2;
+    return isCoolingDown(pair, cooldownDays) ? 2 : 0;
+  }
+  return 1;
+}
+function parseIsoMillis(value) {
+  if (!value) return null;
+  const millis = new Date(value).getTime();
+  return Number.isFinite(millis) ? millis : null;
+}
+function isDeferred(pair) {
+  return pair.resolution === "needs-more-context" || Boolean(pair.deferredUntil);
+}
+function deferralUntilMillis(pair) {
+  const deferredUntil = parseIsoMillis(pair.deferredUntil);
+  if (deferredUntil !== null) return deferredUntil;
+  if (pair.resolution === "needs-more-context") {
+    const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
+    return lastReviewed === null ? null : lastReviewed + NEEDS_MORE_CONTEXT_COOLDOWN_MS;
+  }
+  return null;
+}
+function isDeferralActive(pair) {
+  const deferredUntil = deferralUntilMillis(pair);
+  return deferredUntil !== null && Date.now() < deferredUntil;
+}
+function reviewStateMillis(pair) {
+  return Math.max(
+    parseIsoMillis(pair.deferredUntil) ?? Number.NEGATIVE_INFINITY,
+    parseIsoMillis(pair.lastReviewedAt) ?? Number.NEGATIVE_INFINITY,
+    parseIsoMillis(pair.detectedAt) ?? Number.NEGATIVE_INFINITY
+  );
+}
+function mergeMigratedPair(existing, migrated, options) {
+  const existingRank = reviewStateRank(existing, options.cooldownDays);
+  const migratedRank = reviewStateRank(migrated, options.cooldownDays);
+  const selected = migratedRank > existingRank ? migrated : migratedRank < existingRank ? existing : reviewStateMillis(migrated) > reviewStateMillis(existing) ? migrated : existing;
+  return {
+    ...selected,
+    pairId: migrated.pairId,
+    namespace: migrated.namespace
+  };
+}
+function reviewDir(memoryDir) {
+  return path.join(memoryDir, ".review", "contradictions");
+}
+function migrationMarkerPath(memoryDir, namespace) {
+  const namespaceKey = createHash("sha256").update(namespace).digest("hex").slice(0, 16);
+  return path.join(reviewDir(memoryDir), `${UNSCOPED_MIGRATION_MARKER_PREFIX}${namespaceKey}${UNSCOPED_MIGRATION_MARKER_SUFFIX}`);
+}
+function clearUnscopedMigrationMarkers(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) return;
+  try {
+    for (const entry of fs.readdirSync(dir)) {
+      if (entry.startsWith(UNSCOPED_MIGRATION_MARKER_PREFIX) && entry.endsWith(UNSCOPED_MIGRATION_MARKER_SUFFIX)) {
+        fs.rmSync(path.join(dir, entry), { force: true });
+      }
+    }
+  } catch {
+  }
+}
+function pairPath(memoryDir, pairId) {
+  if (pairId.includes("/") || pairId.includes("\\") || pairId.includes("..")) {
+    throw new Error(`Invalid pairId: ${pairId}`);
+  }
+  return path.join(reviewDir(memoryDir), `${pairId}.json`);
+}
+function ensureDir(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function uniqueTempPath(filePath) {
+  return `${filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+}
+function writePairFile(filePath, pair) {
+  const tmpPath = uniqueTempPath(filePath);
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(pair, null, 2), "utf-8");
+    fs.renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      fs.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function computeMemoryContentHash(content, category) {
+  const normalized = JSON.stringify({
+    content: content.trim(),
+    category: (category ?? "").trim()
+  });
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function suppliedMemoryHashesChanged(existing, pair) {
+  if (!existing.memoryContentHashes || !pair.memoryContentHashes) return false;
+  return pair.memoryIds.some((memoryId) => {
+    const current = pair.memoryContentHashes?.[memoryId];
+    return typeof current === "string" && existing.memoryContentHashes?.[memoryId] !== current;
+  });
+}
+function writePair(memoryDir, pair, options = {}) {
+  ensureDir(memoryDir);
+  if (pair.namespace === void 0) {
+    clearUnscopedMigrationMarkers(memoryDir);
+  }
+  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
+  const existing = readPair(memoryDir, pairId);
+  if (isTerminalResolution(existing?.resolution)) {
+    return existing;
+  }
+  if (existing?.resolution === "both-valid" && options.cooldownDays === void 0) {
+    return existing;
+  }
+  const existingDeferralExpired = Boolean(existing && isDeferred(existing) && !isDeferralActive(existing));
+  if (existing && isDeferralActive(existing)) {
+    return existing;
+  }
+  const existingDormantCooldownActive = Boolean(
+    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && isCoolingDown(existing, options.cooldownDays)
+  );
+  const dormantContentChanged = Boolean(
+    existing && existingDormantCooldownActive && suppliedMemoryHashesChanged(existing, pair)
+  );
+  const existingDormantExpired = Boolean(
+    existing && isDormantReviewedPair(existing) && options.cooldownDays !== void 0 && !existingDormantCooldownActive
+  );
+  if (existing && !existingDeferralExpired && (existingDormantCooldownActive && !dormantContentChanged || !existingDormantExpired && !dormantContentChanged && existing.confidence >= pair.confidence)) {
+    return existing;
+  }
+  const full = {
+    ...pair,
+    pairId,
+    lastReviewedAt: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? pair.lastReviewedAt : existing?.lastReviewedAt ?? pair.lastReviewedAt,
+    resolution: void 0,
+    deferredUntil: existingDeferralExpired || existingDormantExpired || dormantContentChanged ? void 0 : existing?.deferredUntil
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, full);
+  return full;
+}
+function writePairs(memoryDir, pairs, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const pair of pairs) {
+    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1], pair.namespace);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push(writePair(memoryDir, pair, options));
+  }
+  return results;
+}
+function readPair(memoryDir, pairId) {
+  const filePath = pairPath(memoryDir, pairId);
+  try {
+    const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.memoryIds)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function listPairs(memoryDir, options) {
+  const startTime = Date.now();
+  const dir = reviewDir(memoryDir);
+  const { filter = "all", namespace, includeUnscopedForNamespace = false, limit = 50 } = options ?? {};
+  const pairs = [];
+  let total = 0;
+  if (!fs.existsSync(dir)) {
+    return { pairs: [], total: 0, durationMs: Date.now() - startTime };
+  }
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](path.join(dir, entry), "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (namespace && pair.namespace !== namespace && !(includeUnscopedForNamespace && pair.namespace === void 0)) continue;
+      if (filter === "unresolved") {
+        if (isTerminalResolution(pair.resolution)) continue;
+        if (isDeferralActive(pair)) continue;
+        if (pair.resolution === "both-valid") continue;
+        if (pair.verdict === "independent") continue;
+      } else if (filter !== "all" && pair.verdict !== filter) {
+        continue;
+      }
+      total++;
+      if (pairs.length < limit) pairs.push(pair);
+    } catch {
+      continue;
+    }
+  }
+  return { pairs, total, durationMs: Date.now() - startTime };
+}
+function migrateUnscopedPairsToNamespace(memoryDir, namespace, options = {}) {
+  const resolvedNamespace = namespace.trim();
+  if (!resolvedNamespace) return 0;
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) return 0;
+  const markerPath = migrationMarkerPath(memoryDir, resolvedNamespace);
+  if (fs.existsSync(markerPath)) return 0;
+  let migrated = 0;
+  let hadMigrationFailure = false;
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    const filePath = path.join(dir, entry);
+    try {
+      const raw = fs["re"+"ad"+"Fi"+"le"+"Sync"](filePath, "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (pair.namespace !== void 0) continue;
+      const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1], resolvedNamespace);
+      const migratedPair = { ...pair, namespace: resolvedNamespace, pairId };
+      const targetPath = pairPath(memoryDir, pairId);
+      try {
+        if (targetPath === filePath) {
+          writePairFile(filePath, migratedPair);
+        } else if (!fs.existsSync(targetPath)) {
+          writePairFile(targetPath, migratedPair);
+          fs.rmSync(filePath, { force: true });
+        } else {
+          const existing = readPair(memoryDir, pairId);
+          writePairFile(targetPath, existing ? mergeMigratedPair(existing, migratedPair, options) : migratedPair);
+          fs.rmSync(filePath, { force: true });
+        }
+        migrated += 1;
+      } catch {
+        hadMigrationFailure = true;
+        continue;
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!hadMigrationFailure) {
+    try {
+      fs.writeFileSync(markerPath, `${(/* @__PURE__ */ new Date()).toISOString()}
+`, { encoding: "utf-8", flag: "wx" });
+    } catch {
+    }
+  }
+  return migrated;
+}
+function isCoolingDown(pair, cooldownDays) {
+  if (cooldownDays <= 0) return false;
+  const deferredUntil = deferralUntilMillis(pair);
+  if (deferredUntil !== null) {
+    return Date.now() < deferredUntil;
+  }
+  if (!pair.lastReviewedAt) return false;
+  const lastReviewed = parseIsoMillis(pair.lastReviewedAt);
+  if (lastReviewed === null) return false;
+  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1e3;
+  return Date.now() < lastReviewed + cooldownMs;
+}
+function resolvePair(memoryDir, pairId, verb) {
+  if (typeof verb !== "string" || !VALID_RESOLUTION_VERBS.includes(verb)) {
+    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);
+  }
+  if (verb === "needs-more-context") {
+    return deferPair(memoryDir, pairId);
+  }
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  if (preservesDirectResolution(existing.resolution)) return existing;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: verb,
+    deferredUntil: void 0
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, updated);
+  return updated;
+}
+function deferPair(memoryDir, pairId, deferredUntil = new Date(Date.now() + NEEDS_MORE_CONTEXT_COOLDOWN_MS).toISOString()) {
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  if (preservesDirectResolution(existing.resolution)) return existing;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: void 0,
+    deferredUntil
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  writePairFile(filePath, updated);
+  return updated;
+}
+function memoryHashesChanged(_memoryDir, pair, getCurrentHash) {
+  if (!pair.memoryContentHashes) return false;
+  for (const memoryId of pair.memoryIds) {
+    const previousHash = pair.memoryContentHashes[memoryId];
+    if (typeof previousHash !== "string") continue;
+    const currentHash = getCurrentHash(memoryId);
+    if (currentHash !== null && currentHash !== previousHash) return true;
+  }
+  return false;
+}
+
+export {
+  computePairId,
+  isDefaultReviewNamespace,
+  computeMemoryContentHash,
+  writePair,
+  writePairs,
+  readPair,
+  listPairs,
+  migrateUnscopedPairsToNamespace,
+  isCoolingDown,
+  resolvePair,
+  deferPair,
+  memoryHashesChanged
+};