@remnic/core 1.1.12 → 1.1.14

package/dist/chunk-47VWKCAF.js

@@ -0,0 +1,273 @@
+import {
+  readPair,
+  resolvePair
+} from "./chunk-APO3DCMU.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// 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
+};
+//# sourceMappingURL=chunk-47VWKCAF.js.map

package/dist/chunk-47VWKCAF.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/contradiction/resolution.ts"],"sourcesContent":["/**\n * Resolution Verbs — executes user-chosen resolution actions on contradiction pairs (issue #520).\n *\n * All resolution paths delegate to StorageManager.supersedeMemory. Do not\n * reimplement supersession logic here (rule 22: deduplicate resolution).\n */\n\nimport type { StorageManager } from \"../storage.js\";\nimport type { MemoryCategory, MemoryFile } from \"../types.js\";\nimport type { ResolutionVerb } from \"./contradiction-review.js\";\nimport { resolvePair, readPair } from \"./contradiction-review.js\";\nimport { log } from \"../logger.js\";\n\nexport interface ResolutionResult {\n  pairId: string;\n  verb: ResolutionVerb;\n  /** Memory IDs affected by the resolution. */\n  affectedIds: string[];\n  /** Human-readable status. */\n  message: string;\n}\n\nexport interface ExecuteResolutionOptions {\n  /** Existing merged memory to supersede both source memories to. */\n  mergedMemoryId?: string;\n  /** Content for a new merged memory. Required for merge when mergedMemoryId is omitted. */\n  mergedContent?: string;\n  /** Category for a newly created merged memory. Defaults to the shared source category, or fact. */\n  mergedCategory?: MemoryCategory;\n  /** Resolve storage for the pair namespace, or the default namespace for legacy unscoped pairs. */\n  storageForNamespace?: (namespace: string | undefined) => StorageManager | Promise<StorageManager>;\n}\n\nconst VALID_VERBS: ResolutionVerb[] = [\"keep-a\", \"keep-b\", \"merge\", \"both-valid\", \"needs-more-context\"];\n\nexport function isValidResolutionVerb(value: string): value is ResolutionVerb {\n  return VALID_VERBS.includes(value as ResolutionVerb);\n}\n\n/**\n * Execute a resolution verb on a contradiction pair.\n *\n * - `keep-a`: Supersede B, keep A active.\n * - `keep-b`: Supersede A, keep B active.\n * - `merge`: Create or verify a real merged memory, then supersede both inputs.\n * - `both-valid`: Mark pair as reviewed; no memories are superseded.\n * - `needs-more-context`: Defer; no action, short cooldown.\n */\nexport async function executeResolution(\n  memoryDir: string,\n  storage: StorageManager,\n  pairId: string,\n  verb: ResolutionVerb,\n  options: ExecuteResolutionOptions = {},\n): Promise<ResolutionResult> {\n  if (typeof verb !== \"string\" || !isValidResolutionVerb(verb)) {\n    throw new Error(`Invalid contradiction resolution verb: ${String(verb)}`);\n  }\n\n  const pair = readPair(memoryDir, pairId);\n  if (!pair) {\n    return { pairId, verb, affectedIds: [], message: `Pair ${pairId} not found` };\n  }\n\n  if (pair.namespace && !options.storageForNamespace) {\n    throw new Error(\n      \"contradiction resolution requires storageForNamespace for namespaced pairs so callers resolve the correct namespace storage\",\n    );\n  }\n\n  const resolutionStorage = options.storageForNamespace\n    ? await options.storageForNamespace(pair.namespace)\n    : storage;\n\n  if (pair.resolution && pair.resolution !== \"needs-more-context\") {\n    return { pairId, verb, affectedIds: [], message: `Pair already resolved with verb \"${pair.resolution}\"` };\n  }\n\n  const [idA, idB] = pair.memoryIds;\n  const affectedIds: string[] = [];\n  let message = \"\";\n  let supersedeFailed = false;\n\n  switch (verb) {\n    case \"keep-a\": {\n      const keepTarget = await validateKeepTarget(resolutionStorage, pairId, idA);\n      if (!keepTarget.ok) {\n        supersedeFailed = true;\n        message = keepTarget.message;\n        break;\n      }\n      const sourceB = await loadSourceSnapshot(resolutionStorage, idB);\n      const ok = sourceB\n        ? await supersedeSafe(resolutionStorage, idB, idA, \"contradiction-resolution:keep-a\")\n        : false;\n      if (ok) { affectedIds.push(idB); message = `Kept ${idA}, superseded ${idB}`; }\n      else {\n        supersedeFailed = true;\n        const rolledBack = sourceB\n          ? await restoreMemorySnapshot(resolutionStorage, sourceB, \"contradiction-resolution:keep-a-rollback\")\n          : false;\n        message = rolledBack\n          ? `Supersede failed for ${idB}; restored ${idB} and did not resolve`\n          : `Supersede failed for ${idB}; rollback incomplete for ${idB} and pair is not resolved`;\n      }\n      break;\n    }\n    case \"keep-b\": {\n      const keepTarget = await validateKeepTarget(resolutionStorage, pairId, idB);\n      if (!keepTarget.ok) {\n        supersedeFailed = true;\n        message = keepTarget.message;\n        break;\n      }\n      const sourceA = await loadSourceSnapshot(resolutionStorage, idA);\n      const ok = sourceA\n        ? await supersedeSafe(resolutionStorage, idA, idB, \"contradiction-resolution:keep-b\")\n        : false;\n      if (ok) { affectedIds.push(idA); message = `Kept ${idB}, superseded ${idA}`; }\n      else {\n        supersedeFailed = true;\n        const rolledBack = sourceA\n          ? await restoreMemorySnapshot(resolutionStorage, sourceA, \"contradiction-resolution:keep-b-rollback\")\n          : false;\n        message = rolledBack\n          ? `Supersede failed for ${idA}; restored ${idA} and did not resolve`\n          : `Supersede failed for ${idA}; rollback incomplete for ${idA} and pair is not resolved`;\n      }\n      break;\n    }\n    case \"merge\": {\n      const replacement = await prepareMergeReplacement(resolutionStorage, pairId, idA, idB, options);\n      if (!replacement.ok) {\n        supersedeFailed = true;\n        message = replacement.message;\n        break;\n      }\n\n      const okA = await supersedeSafe(resolutionStorage, idA, replacement.mergedId, \"contradiction-resolution:merge\");\n      if (!okA) {\n        supersedeFailed = true;\n        const rolledBackA = await restoreMemorySnapshot(resolutionStorage, replacement.sourceA);\n        message = rolledBackA\n          ? `Merge failed for ${idA}; restored ${idA} and did not resolve`\n          : `Merge failed for ${idA}; rollback incomplete for ${idA} and pair is not resolved`;\n        if (rolledBackA) {\n          await cleanupCreatedReplacement(resolutionStorage, replacement);\n        }\n        break;\n      }\n\n      const okB = await supersedeSafe(resolutionStorage, idB, replacement.mergedId, \"contradiction-resolution:merge\");\n      if (!okB) {\n        supersedeFailed = true;\n        const rolledBackA = await restoreMemorySnapshot(resolutionStorage, replacement.sourceA);\n        const rolledBackB = await restoreMemorySnapshot(resolutionStorage, replacement.sourceB);\n        message = rolledBackA && rolledBackB\n          ? `Merge failed for ${idB}; restored ${idA} and ${idB} and did not resolve`\n          : `Merge failed for ${idB}; rollback incomplete for ${[\n            rolledBackA ? undefined : idA,\n            rolledBackB ? undefined : idB,\n          ].filter(Boolean).join(\", \")} and pair is not resolved`;\n        if (rolledBackA && rolledBackB) {\n          await cleanupCreatedReplacement(resolutionStorage, replacement);\n        }\n        break;\n      }\n\n      affectedIds.push(idA, idB);\n      message = `Both memories superseded by merged ${replacement.mergedId}`;\n      break;\n    }\n    case \"both-valid\": {\n      message = \"Pair marked as both-valid; cooldown applied\";\n      break;\n    }\n    case \"needs-more-context\": {\n      message = \"Deferred; no action taken, short cooldown applied\";\n      break;\n    }\n  }\n\n  if (!supersedeFailed) {\n    resolvePair(memoryDir, pairId, verb);\n  }\n  log.info(\"[contradiction-resolution] pair=%s verb=%s affected=%d\", pairId, verb, affectedIds.length);\n  return { pairId, verb, affectedIds, message };\n}\n\ntype MergeReplacement =\n  | {\n      ok: true;\n      mergedId: string;\n      sourceA: MemoryFile;\n      sourceB: MemoryFile;\n      created: boolean;\n    }\n  | {\n      ok: false;\n      message: string;\n    };\n\nasync function prepareMergeReplacement(\n  storage: StorageManager,\n  pairId: string,\n  idA: string,\n  idB: string,\n  options: ExecuteResolutionOptions,\n): Promise<MergeReplacement> {\n  const sourceA = await storage.getMemoryById(idA);\n  const sourceB = await storage.getMemoryById(idB);\n  if (!sourceA || !sourceB) {\n    return { ok: false, message: `Merge requires both source memories to exist; not resolving ${pairId}` };\n  }\n\n  const requestedMergedId = options.mergedMemoryId?.trim();\n  if (requestedMergedId) {\n    if (requestedMergedId === idA || requestedMergedId === idB) {\n      return { ok: false, message: \"Merge replacement must be distinct from both source memories; not resolving\" };\n    }\n    const replacement = await storage.getMemoryById(requestedMergedId);\n    if (!replacement) {\n      return { ok: false, message: `Merged memory ${requestedMergedId} not found; not resolving` };\n    }\n    const replacementStatus = replacement.frontmatter.status ?? \"active\";\n    if (replacementStatus !== \"active\") {\n      return {\n        ok: false,\n        message: `Merged memory ${requestedMergedId} is ${replacementStatus}; not resolving`,\n      };\n    }\n    return { ok: true, mergedId: requestedMergedId, sourceA, sourceB, created: false };\n  }\n\n  const mergedContent = options.mergedContent;\n  if (typeof mergedContent !== \"string\" || mergedContent.trim().length === 0) {\n    return {\n      ok: false,\n      message: \"Merge requires mergedMemoryId or mergedContent; no memories changed\",\n    };\n  }\n\n  const category = options.mergedCategory ?? mergedMemoryCategory(sourceA, sourceB);\n  let mergedId: string;\n  try {\n    mergedId = await storage.writeMemory(category, mergedContent, {\n      actor: \"contradiction-resolution\",\n      confidence: Math.min(sourceA.frontmatter.confidence ?? 0.8, sourceB.frontmatter.confidence ?? 0.8),\n      tags: [\"contradiction-resolution\", \"merge\"],\n      source: \"contradiction-resolution\",\n      lineage: [idA, idB],\n      derivedFrom: [idA, idB],\n      derivedVia: \"merge\",\n    });\n  } catch (err) {\n    log.warn(\n      \"[contradiction-resolution] merged memory creation failed for %s: %s\",\n      pairId,\n      err instanceof Error ? err.message : err,\n    );\n    return { ok: false, message: `Merged memory could not be created; not resolving ${pairId}` };\n  }\n  const replacement = await storage.getMemoryById(mergedId);\n  if (!replacement) {\n    await cleanupMemoryId(storage, mergedId);\n    return { ok: false, message: `Merged memory ${mergedId} could not be verified; not resolving` };\n  }\n  return { ok: true, mergedId, sourceA, sourceB, created: true };\n}\n\nfunction mergedMemoryCategory(sourceA: MemoryFile, sourceB: MemoryFile): MemoryCategory {\n  return sourceA.frontmatter.category === sourceB.frontmatter.category\n    ? sourceA.frontmatter.category\n    : \"fact\";\n}\n\ntype KeepTargetValidation =\n  | { ok: true }\n  | { ok: false; message: string };\n\nasync function validateKeepTarget(\n  storage: StorageManager,\n  pairId: string,\n  keepId: string,\n): Promise<KeepTargetValidation> {\n  const target = await loadSourceSnapshot(storage, keepId);\n  if (!target) {\n    return { ok: false, message: `Kept memory ${keepId} not found; not resolving ${pairId}` };\n  }\n\n  const status = target.frontmatter.status ?? \"active\";\n  if (status !== \"active\") {\n    return { ok: false, message: `Kept memory ${keepId} is ${status}; not resolving ${pairId}` };\n  }\n\n  return { ok: true };\n}\n\nasync function loadSourceSnapshot(storage: StorageManager, memoryId: string): Promise<MemoryFile | null> {\n  try {\n    return await storage.getMemoryById(memoryId);\n  } catch (err) {\n    log.warn(\n      \"[contradiction-resolution] source snapshot failed for %s: %s\",\n      memoryId,\n      err instanceof Error ? err.message : err,\n    );\n    return null;\n  }\n}\n\nasync function restoreMemorySnapshot(\n  storage: StorageManager,\n  memory: MemoryFile,\n  reasonCode = \"contradiction-resolution:merge-rollback\",\n): Promise<boolean> {\n  try {\n    const current = await storage.getMemoryById(memory.frontmatter.id);\n    if (!current) return false;\n    const restoredFrontmatter: Partial<MemoryFile[\"frontmatter\"]> = {\n      ...memory.frontmatter,\n      status: memory.frontmatter.status,\n      supersededBy: memory.frontmatter.supersededBy,\n      supersededAt: memory.frontmatter.supersededAt,\n    };\n    return await storage.writeMemoryFrontmatter(current, restoredFrontmatter, {\n      actor: \"contradiction-resolution\",\n      reasonCode,\n    });\n  } catch (err) {\n    log.warn(\n      \"[contradiction-resolution] rollback failed for %s: %s\",\n      memory.frontmatter.id,\n      err instanceof Error ? err.message : err,\n    );\n    return false;\n  }\n}\n\nasync function cleanupCreatedReplacement(storage: StorageManager, replacement: Extract<MergeReplacement, { ok: true }>): Promise<void> {\n  if (!replacement.created) return;\n  await cleanupMemoryId(storage, replacement.mergedId);\n}\n\nasync function cleanupMemoryId(storage: StorageManager, memoryId: string): Promise<void> {\n  try {\n    const memory = await storage.getMemoryById(memoryId);\n    const invalidated = await storage.invalidateMemory(memoryId);\n    if (invalidated && memory?.frontmatter.category === \"fact\") {\n      await storage.removeFactContentHashesForMemories([memory]);\n    }\n  } catch (err) {\n    log.warn(\n      \"[contradiction-resolution] cleanup failed for merged memory %s: %s\",\n      memoryId,\n      err instanceof Error ? err.message : err,\n    );\n  }\n}\n\nasync function supersedeSafe(\n  storage: StorageManager,\n  oldId: string,\n  newId: string,\n  reason: string,\n): Promise<boolean> {\n  try {\n    const result = await storage.supersedeMemory(oldId, newId, reason);\n    if (result === false) {\n      log.warn(\"[contradiction-resolution] supersede returned false for %s → %s\", oldId, newId);\n      return false;\n    }\n    return true;\n  } catch (err) {\n    log.warn(\n      \"[contradiction-resolution] supersede failed %s → %s: %s\",\n      oldId,\n      newId,\n      err instanceof Error ? err.message : err,\n    );\n    return false;\n  }\n}\n"],"mappings":"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","names":["replacement"]}

package/dist/chunk-4CRG46BG.js

@@ -0,0 +1,271 @@
+import {
+  resolveWorkProductLedgerDir,
+  validateWorkProductLedgerEntry
+} from "./chunk-CULXMQJH.js";
+import {
+  TranscriptManager
+} from "./chunk-5375UYTQ.js";
+import {
+  resolveCommitmentLedgerDir,
+  validateCommitmentLedgerEntry
+} from "./chunk-2KI4QFHU.js";
+import {
+  parseConfig
+} from "./chunk-2QR3XXIC.js";
+import {
+  resolveObjectiveStateStoreDir,
+  validateObjectiveStateSnapshot
+} from "./chunk-5UM2VJ6D.js";
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalStringArray,
+  recordStoreDay,
+  validateStringRecord
+} from "./chunk-DGXUHMOV.js";
+import {
+  listJsonFiles,
+  readJsonFile
+} from "./chunk-LPSF4OQH.js";
+
+// src/resume-bundles.ts
+import path from "path";
+import { mkdir, writeFile } from "fs/promises";
+var DEFAULT_RESUME_BUNDLE_REF_LIMIT = 5;
+function resolveResumeBundleDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path.join(memoryDir, "state", "resume-bundles");
+}
+function validateResumeBundle(raw) {
+  if (!isRecord(raw)) throw new Error("resume bundle must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  const source = assertString(raw.source, "source");
+  if (!["tool_result", "cli", "system", "manual"].includes(source)) {
+    throw new Error("source must be one of tool_result|cli|system|manual");
+  }
+  const recordedAt = assertIsoRecordedAt(assertString(raw.recordedAt, "recordedAt"));
+  if (!Number.isFinite(Date.parse(recordedAt))) {
+    throw new Error("recordedAt must be an ISO timestamp");
+  }
+  return {
+    schemaVersion: 1,
+    bundleId: assertSafePathSegment(assertString(raw.bundleId, "bundleId"), "bundleId"),
+    recordedAt,
+    sessionKey: assertString(raw.sessionKey, "sessionKey"),
+    source,
+    scope: assertString(raw.scope, "scope"),
+    summary: assertString(raw.summary, "summary"),
+    objectiveStateSnapshotRefs: optionalStringArray(raw.objectiveStateSnapshotRefs, "objectiveStateSnapshotRefs"),
+    workProductEntryRefs: optionalStringArray(raw.workProductEntryRefs, "workProductEntryRefs"),
+    commitmentEntryRefs: optionalStringArray(raw.commitmentEntryRefs, "commitmentEntryRefs"),
+    keyFacts: optionalStringArray(raw.keyFacts, "keyFacts"),
+    nextActions: optionalStringArray(raw.nextActions, "nextActions"),
+    riskFlags: optionalStringArray(raw.riskFlags, "riskFlags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function readValidatedItems(options) {
+  const files = await listJsonFiles(options.rootDir);
+  const items = [];
+  for (const filePath of files) {
+    try {
+      items.push(options.validate(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return items;
+}
+async function readObjectiveStateSnapshotsForSession(options) {
+  const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);
+  const items = await readValidatedItems({
+    rootDir: path.join(rootDir, "snapshots"),
+    validate: validateObjectiveStateSnapshot
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+async function readWorkProductEntriesForSession(options) {
+  const rootDir = resolveWorkProductLedgerDir(options.memoryDir, options.workProductLedgerDir);
+  const items = await readValidatedItems({
+    rootDir: path.join(rootDir, "entries"),
+    validate: validateWorkProductLedgerEntry
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+async function readCommitmentEntriesForSession(options) {
+  const rootDir = resolveCommitmentLedgerDir(options.memoryDir, options.commitmentLedgerDir);
+  const items = await readValidatedItems({
+    rootDir: path.join(rootDir, "entries"),
+    validate: validateCommitmentLedgerEntry
+  });
+  return items.filter((item) => item.sessionKey === options.sessionKey).filter((item) => options.state ? item.state === options.state : true).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
+}
+function buildRecoveryFact(recoverySummary) {
+  return recoverySummary.healthy ? `Transcript recovery healthy with ${recoverySummary.issueCount} issue(s), ${recoverySummary.incompleteTurns} incomplete turn(s), and ${recoverySummary.brokenChains} broken chain(s).` : `Transcript recovery flagged ${recoverySummary.issueCount} issue(s), ${recoverySummary.incompleteTurns} incomplete turn(s), and ${recoverySummary.brokenChains} broken chain(s); checkpoint healthy: ${recoverySummary.checkpointHealthy ? "yes" : "no"}.`;
+}
+function buildBundleSummary(options) {
+  const parts = [
+    `${options.openCommitmentCount} open commitment(s)`,
+    `${options.workProductCount} recent work product(s)`,
+    `${options.objectiveSnapshotCount} recent objective-state snapshot(s)`
+  ];
+  if (options.recoveryHealthy === false) {
+    parts.push("transcript recovery issues remain");
+  }
+  return `Resume ${options.sessionKey}: ${parts.join(", ")}.`;
+}
+async function buildResumeBundleFromState(options) {
+  const recordedAt = assertIsoRecordedAt(options.recordedAt, "recordedAt");
+  const maxRefsPerStore = Math.max(1, Math.floor(options.maxRefsPerStore ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT));
+  const objectiveSnapshots = options.objectiveStateMemoryEnabled ? await readObjectiveStateSnapshotsForSession({
+    memoryDir: options.memoryDir,
+    objectiveStateStoreDir: options.objectiveStateStoreDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore
+  }) : [];
+  const workProducts = options.creationMemoryEnabled ? await readWorkProductEntriesForSession({
+    memoryDir: options.memoryDir,
+    workProductLedgerDir: options.workProductLedgerDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore
+  }) : [];
+  const commitments = options.creationMemoryEnabled && options.commitmentLedgerEnabled ? await readCommitmentEntriesForSession({
+    memoryDir: options.memoryDir,
+    commitmentLedgerDir: options.commitmentLedgerDir,
+    sessionKey: options.sessionKey,
+    maxResults: maxRefsPerStore,
+    state: "open"
+  }) : [];
+  const openCommitments = commitments;
+  const recordedAtMs = Date.parse(recordedAt);
+  const overdueCommitments = openCommitments.filter((entry) => {
+    if (!entry.dueAt) return false;
+    const dueAtMs = Date.parse(entry.dueAt);
+    return Number.isFinite(dueAtMs) && dueAtMs < recordedAtMs;
+  });
+  let recoverySummary;
+  if (options.transcriptEnabled) {
+    const transcript = new TranscriptManager(parseConfig({
+      memoryDir: options.memoryDir,
+      transcriptEnabled: true
+    }));
+    await transcript.initialize();
+    recoverySummary = await transcript.getRecoverySummary(options.sessionKey);
+  }
+  const keyFacts = [
+    recoverySummary ? buildRecoveryFact(recoverySummary) : void 0,
+    workProducts[0]?.summary,
+    objectiveSnapshots[0]?.summary
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  const nextActions = openCommitments.map((entry) => entry.summary).filter((summary, index, values) => values.indexOf(summary) === index).slice(0, maxRefsPerStore);
+  const riskFlags = [
+    recoverySummary && !recoverySummary.healthy ? buildRecoveryFact(recoverySummary) : void 0,
+    ...objectiveSnapshots.filter((snapshot) => snapshot.outcome === "failure" || snapshot.outcome === "partial").map((snapshot) => snapshot.summary),
+    ...overdueCommitments.map((entry) => `Overdue commitment: ${entry.summary}`)
+  ].filter(
+    (value, index, values) => typeof value === "string" && value.length > 0 && values.indexOf(value) === index
+  );
+  return validateResumeBundle({
+    schemaVersion: 1,
+    bundleId: options.bundleId,
+    recordedAt,
+    sessionKey: options.sessionKey,
+    source: options.source ?? "system",
+    scope: options.scope,
+    summary: buildBundleSummary({
+      sessionKey: options.sessionKey,
+      openCommitmentCount: openCommitments.length,
+      workProductCount: workProducts.length,
+      objectiveSnapshotCount: objectiveSnapshots.length,
+      recoveryHealthy: recoverySummary?.healthy
+    }),
+    objectiveStateSnapshotRefs: objectiveSnapshots.map((snapshot) => snapshot.snapshotId),
+    workProductEntryRefs: workProducts.map((entry) => entry.entryId),
+    commitmentEntryRefs: openCommitments.map((entry) => entry.entryId),
+    keyFacts: keyFacts.length > 0 ? keyFacts : void 0,
+    nextActions: nextActions.length > 0 ? nextActions : void 0,
+    riskFlags: riskFlags.length > 0 ? riskFlags : void 0
+  });
+}
+async function recordResumeBundle(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const validated = validateResumeBundle(options.bundle);
+  const day = recordStoreDay(validated.recordedAt);
+  const bundlesDir = path.join(rootDir, "bundles", day);
+  const filePath = path.join(bundlesDir, `${validated.bundleId}.json`);
+  await mkdir(bundlesDir, { recursive: true });
+  await writeFile(filePath, JSON.stringify(validated, null, 2), "utf8");
+  return filePath;
+}
+async function readResumeBundles(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const files = await listJsonFiles(path.join(rootDir, "bundles"));
+  const bundles = [];
+  const invalidBundles = [];
+  for (const filePath of files) {
+    try {
+      bundles.push(validateResumeBundle(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidBundles.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, bundles, invalidBundles };
+}
+async function getResumeBundleStatus(options) {
+  const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
+  const bundlesDir = path.join(rootDir, "bundles");
+  if (!options.enabled) {
+    return {
+      enabled: false,
+      rootDir,
+      bundlesDir,
+      bundles: {
+        total: 0,
+        valid: 0,
+        invalid: 0,
+        bySource: {}
+      },
+      invalidBundles: []
+    };
+  }
+  const { files, bundles, invalidBundles } = await readResumeBundles(options);
+  let latestBundle;
+  const bySource = {};
+  for (const bundle of bundles) {
+    bySource[bundle.source] = (bySource[bundle.source] ?? 0) + 1;
+    if (!latestBundle || Date.parse(bundle.recordedAt) > Date.parse(latestBundle.recordedAt)) {
+      latestBundle = bundle;
+    }
+  }
+  return {
+    enabled: options.enabled,
+    rootDir,
+    bundlesDir,
+    bundles: {
+      total: files.length,
+      valid: bundles.length,
+      invalid: invalidBundles.length,
+      bySource,
+      latestBundleId: latestBundle?.bundleId,
+      latestRecordedAt: latestBundle?.recordedAt,
+      latestSessionKey: latestBundle?.sessionKey
+    },
+    latestBundle,
+    invalidBundles
+  };
+}
+
+export {
+  resolveResumeBundleDir,
+  validateResumeBundle,
+  buildResumeBundleFromState,
+  recordResumeBundle,
+  getResumeBundleStatus
+};
+//# sourceMappingURL=chunk-4CRG46BG.js.map