@remnic/plugin-openclaw 1.0.35 → 1.0.37

package/dist/{chunk-FGTYFLL5.js → chunk-TXOEHSVP.js}

@@ -1,18 +1,18 @@
-import {
-  CAPSULE_ID_PATTERN,
-  CapsuleBlockSchema,
-  ExportBundleV2Schema,
-  ExportManifestV2Schema
-} from "./chunk-4LYQ4ONL.js";
 import {
   listFilesRecursive,
   sha256File,
   toPosixRelPath,
   writeJsonFile
-} from "./chunk-NKVIN6RD.js";
+} from "./chunk-YKV4EFUI.js";
+import {
+  CAPSULE_ID_PATTERN,
+  CapsuleBlockSchema,
+  ExportBundleV2Schema,
+  ExportManifestV2Schema
+} from "./chunk-QCCP4RU5.js";
 import {
   encryptCapsuleFile
-} from "./chunk-SSFTU6LP.js";
+} from "./chunk-ZS6VABML.js";
 
 // ../remnic-core/src/transfer/capsule-export.ts
 import * as fsReadModule0 from "fs/promises";
@@ -20,27 +20,33 @@ const mkdir = fsReadModule0.mkdir;
 const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
 const stat = fsReadModule0.stat;
 const writeFile = fsReadModule0.writeFile;
-import path from "path";
+import path2 from "path";
 import { gzipSync } from "zlib";
 
 // ../remnic-core/src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
-var EXPORT_SCHEMA_VERSION = 1;
 var CAPSULE_SCHEMA_VERSION = 2;
 
-// ../remnic-core/src/transfer/capsule-export.ts
-var DEFAULT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+// ../remnic-core/src/transfer/exclusions.ts
+import path from "path";
+var DEFAULT_TRANSFER_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
-  // Never export the secure-store directory: it contains the encryption
-  // header (KDF params + verifier) which is security-sensitive and
-  // machine-specific. The passphrase is not stored here, but including
-  // the header in a capsule would let an attacker brute-force the
-  // passphrase offline if the capsule is intercepted.
   ".secure-store",
-  // Exclude .capsules to avoid recursive self-inclusion.
   ".capsules"
 ]);
+function computeTransferOutputRel(rootAbs, outputAbs) {
+  const rel = path.relative(rootAbs, outputAbs);
+  if (rel === "") {
+    throw new Error("transfer export output path must not equal the memory directory");
+  }
+  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+  if (path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join("/");
+}
+
+// ../remnic-core/src/transfer/capsule-export.ts
+var DEFAULT_EXCLUDE_DIRS = DEFAULT_TRANSFER_EXCLUDE_DIRS;
 var TRANSCRIPTS_DIR = "transcripts";
 var PEERS_DIR = "peers";
 async function exportCapsule(opts) {
@@ -49,16 +55,16 @@ async function exportCapsule(opts) {
   const includeKinds = normalizeIncludeKinds(opts.includeKinds);
   const peerFilter = normalizePeerIds(opts.peerIds);
   const transcriptsOverride = opts.includeTranscripts === true;
-  const rootAbs = path.resolve(opts.root);
+  const rootAbs = path2.resolve(opts.root);
   await assertIsDirectory(rootAbs);
-  const outDirAbs = path.resolve(opts.outDir ?? path.join(rootAbs, ".capsules"));
+  const outDirAbs = path2.resolve(opts.outDir ?? path2.join(rootAbs, ".capsules"));
   if (outDirAbs === rootAbs) {
     throw new Error(
       "exportCapsule: 'outDir' must not equal 'root'. Choose a separate directory (default: <root>/.capsules) so the export does not overwrite or shadow the source tree."
     );
   }
   await mkdir(outDirAbs, { recursive: true });
-  const outDirRelPosix = computeOutDirRel(rootAbs, outDirAbs);
+  const outDirRelPosix = computeTransferOutputRel(rootAbs, outDirAbs);
   const filesAbs = await listFilesRecursive(rootAbs);
   const records = [];
   const manifestFiles = [];
@@ -92,8 +98,8 @@ async function exportCapsule(opts) {
     manifest,
     records
   });
-  const archivePath = path.join(outDirAbs, `${opts.name}.capsule.json.gz`);
-  const manifestPath = path.join(outDirAbs, `${opts.name}.manifest.json`);
+  const archivePath = path2.join(outDirAbs, `${opts.name}.capsule.json.gz`);
+  const manifestPath = path2.join(outDirAbs, `${opts.name}.manifest.json`);
   await writeJsonFile(manifestPath, manifest);
   const json = JSON.stringify(bundle);
   const gz = gzipSync(Buffer.from(json, "utf-8"));
@@ -209,13 +215,6 @@ function normalizePeerIds(peerIds) {
   }
   return set;
 }
-function computeOutDirRel(rootAbs, outDirAbs) {
-  const rel = path.relative(rootAbs, outDirAbs);
-  if (rel === "") return null;
-  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
-  if (path.isAbsolute(rel)) return null;
-  return rel.split(path.sep).join("/");
-}
 async function assertIsDirectory(absPath) {
   const st = await stat(absPath).catch(() => null);
   if (!st || !st.isDirectory()) {
@@ -271,8 +270,6 @@ function buildCapsuleBlock(name, override) {
 }
 
 export {
-  EXPORT_FORMAT,
-  EXPORT_SCHEMA_VERSION,
   exportCapsule,
   isValidCapsuleSince
 };

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
+};