@remnic/plugin-openclaw 1.0.53 → 9.3.515

package/dist/chunk-TH5FF5SC.js

@@ -1,16 +0,0 @@
-// ../remnic-core/src/routing/engine.ts
-function normalizeNamespace(namespace) {
-  return namespace.trim();
-}
-function isSafeRouteNamespace(namespace) {
-  const value = normalizeNamespace(namespace);
-  if (value.length === 0) return false;
-  if (value === ".") return false;
-  if (value.includes("/") || value.includes("\\")) return false;
-  if (value.includes("..")) return false;
-  return /^[A-Za-z0-9._-]{1,64}$/.test(value);
-}
-
-export {
-  isSafeRouteNamespace
-};

package/dist/chunk-TXOEHSVP.js

@@ -1,275 +0,0 @@
-import {
-  listFilesRecursive,
-  sha256File,
-  toPosixRelPath,
-  writeJsonFile
-} from "./chunk-YKV4EFUI.js";
-import {
-  CAPSULE_ID_PATTERN,
-  CapsuleBlockSchema,
-  ExportBundleV2Schema,
-  ExportManifestV2Schema
-} from "./chunk-QCCP4RU5.js";
-import {
-  encryptCapsuleFile
-} from "./chunk-ZS6VABML.js";
-
-// ../remnic-core/src/transfer/capsule-export.ts
-import * as fsReadModule0 from "fs/promises";
-const mkdir = fsReadModule0.mkdir;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const stat = fsReadModule0.stat;
-const writeFile = fsReadModule0.writeFile;
-import path2 from "path";
-import { gzipSync } from "zlib";
-
-// ../remnic-core/src/transfer/constants.ts
-var EXPORT_FORMAT = "openclaw-engram-export";
-var CAPSULE_SCHEMA_VERSION = 2;
-
-// ../remnic-core/src/transfer/exclusions.ts
-import path from "path";
-var DEFAULT_TRANSFER_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
-  "node_modules",
-  ".git",
-  ".secure-store",
-  ".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) {
-  validateName(opts.name);
-  const sinceMs = parseSince(opts.since);
-  const includeKinds = normalizeIncludeKinds(opts.includeKinds);
-  const peerFilter = normalizePeerIds(opts.peerIds);
-  const transcriptsOverride = opts.includeTranscripts === true;
-  const rootAbs = path2.resolve(opts.root);
-  await assertIsDirectory(rootAbs);
-  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 = computeTransferOutputRel(rootAbs, outDirAbs);
-  const filesAbs = await listFilesRecursive(rootAbs);
-  const records = [];
-  const manifestFiles = [];
-  for (const abs of filesAbs) {
-    const relPosix = toPosixRelPath(abs, rootAbs);
-    if (!shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride)) continue;
-    if (sinceMs !== null) {
-      const st = await stat(abs);
-      if (st.mtimeMs < sinceMs) continue;
-    }
-    const content = await fileReader(abs, "utf-8");
-    records.push({ path: relPosix, content });
-    const { sha256, bytes } = await sha256File(abs);
-    manifestFiles.push({ path: relPosix, sha256, bytes });
-  }
-  records.sort((a, b) => a.path.localeCompare(b.path));
-  manifestFiles.sort((a, b) => a.path.localeCompare(b.path));
-  const capsule = buildCapsuleBlock(opts.name, opts.capsule);
-  const includesTranscripts = transcriptsOverride || (includeKinds ?? /* @__PURE__ */ new Set()).has(TRANSCRIPTS_DIR);
-  const createdAtMs = opts.now ?? Date.now();
-  const manifest = ExportManifestV2Schema.parse({
-    format: EXPORT_FORMAT,
-    schemaVersion: CAPSULE_SCHEMA_VERSION,
-    createdAt: new Date(createdAtMs).toISOString(),
-    pluginVersion: opts.pluginVersion ?? "0.0.0",
-    includesTranscripts,
-    files: manifestFiles,
-    capsule
-  });
-  const bundle = ExportBundleV2Schema.parse({
-    manifest,
-    records
-  });
-  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"));
-  await writeFile(archivePath, gz);
-  if (opts.encrypt === true) {
-    if (!opts.memoryDir) {
-      throw new Error(
-        "exportCapsule: 'memoryDir' is required when 'encrypt' is true so the secure-store key can be retrieved."
-      );
-    }
-    const { encPath } = await encryptCapsuleFile({
-      sourceGzPath: archivePath,
-      memoryDir: opts.memoryDir
-    });
-    const { unlink } = await import("fs/promises");
-    await unlink(archivePath);
-    return { archivePath: encPath, manifestPath, manifest, encryptedArchivePath: encPath };
-  }
-  return { archivePath, manifestPath, manifest, encryptedArchivePath: null };
-}
-function validateName(name) {
-  if (typeof name !== "string" || !CAPSULE_ID_PATTERN.test(name)) {
-    throw new Error(
-      `exportCapsule: invalid capsule name. Expected /${CAPSULE_ID_PATTERN.source}/`
-    );
-  }
-  if (name.length > 64) {
-    throw new Error(
-      "exportCapsule: invalid capsule name. Must be 64 characters or fewer."
-    );
-  }
-}
-var ISO_8601_RE = /^\d{4}-\d{2}-\d{2}(?:[Tt]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:[Zz]|[+-]\d{2}:?\d{2}))?$/;
-function parseSince(since) {
-  if (since === void 0) return null;
-  if (typeof since !== "string" || since.trim() === "") {
-    throw new Error("exportCapsule: 'since' must be a non-empty ISO-8601 string");
-  }
-  if (!ISO_8601_RE.test(since)) {
-    throw new Error(
-      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
-    );
-  }
-  const ms = Date.parse(since);
-  if (!Number.isFinite(ms)) {
-    throw new Error(
-      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
-    );
-  }
-  assertCalendarRoundTrip(since, ms);
-  return ms;
-}
-function isValidCapsuleSince(since) {
-  try {
-    parseSince(since);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function assertCalendarRoundTrip(since, ms) {
-  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(since);
-  if (!m) return;
-  const wantY = Number(m[1]);
-  const wantMo = Number(m[2]);
-  const wantD = Number(m[3]);
-  const offsetMatch = /([+-])(\d{2}):?(\d{2})$/.exec(since);
-  let displayMs = ms;
-  if (offsetMatch) {
-    const sign = offsetMatch[1] === "-" ? -1 : 1;
-    const offsetMin = sign * (Number(offsetMatch[2]) * 60 + Number(offsetMatch[3]));
-    displayMs = ms + offsetMin * 6e4;
-  }
-  const dd = new Date(displayMs);
-  const gotY = dd.getUTCFullYear();
-  const gotMo = dd.getUTCMonth() + 1;
-  const gotD = dd.getUTCDate();
-  if (gotY !== wantY || gotMo !== wantMo || gotD !== wantD) {
-    throw new Error(
-      `exportCapsule: 'since' is not a valid ISO-8601 timestamp: ${since}`
-    );
-  }
-}
-function normalizeIncludeKinds(kinds) {
-  if (kinds === void 0) return null;
-  const set = /* @__PURE__ */ new Set();
-  for (const raw of kinds) {
-    if (typeof raw !== "string" || raw.trim() === "") {
-      throw new Error("exportCapsule: 'includeKinds' entries must be non-empty strings");
-    }
-    if (raw.includes("/") || raw.includes("\\")) {
-      throw new Error(
-        `exportCapsule: 'includeKinds' entries must be top-level segment names, got: ${raw}`
-      );
-    }
-    set.add(raw);
-  }
-  return set;
-}
-function normalizePeerIds(peerIds) {
-  if (peerIds === void 0) return null;
-  const set = /* @__PURE__ */ new Set();
-  for (const raw of peerIds) {
-    if (typeof raw !== "string" || raw.trim() === "") {
-      throw new Error("exportCapsule: 'peerIds' entries must be non-empty strings");
-    }
-    if (raw.includes("/") || raw.includes("\\") || raw === "." || raw === "..") {
-      throw new Error(
-        `exportCapsule: 'peerIds' entries must be plain segment names, got: ${raw}`
-      );
-    }
-    set.add(raw);
-  }
-  return set;
-}
-async function assertIsDirectory(absPath) {
-  const st = await stat(absPath).catch(() => null);
-  if (!st || !st.isDirectory()) {
-    throw new Error(
-      `exportCapsule: 'root' must be an existing directory: ${absPath}`
-    );
-  }
-}
-function shouldInclude(relPosix, includeKinds, peerFilter, outDirRelPosix, transcriptsOverride = false) {
-  const parts = relPosix.split("/");
-  if (parts.some((p) => DEFAULT_EXCLUDE_DIRS.has(p))) return false;
-  if (outDirRelPosix !== null) {
-    if (relPosix === outDirRelPosix) return false;
-    if (relPosix.startsWith(`${outDirRelPosix}/`)) return false;
-  }
-  const top = parts[0];
-  if (top === TRANSCRIPTS_DIR && !transcriptsOverride && (includeKinds === null || !includeKinds.has(TRANSCRIPTS_DIR))) {
-    return false;
-  }
-  if (includeKinds !== null) {
-    if (parts.length < 2) return false;
-    if (!includeKinds.has(top)) return false;
-  }
-  if (top === PEERS_DIR && peerFilter !== null) {
-    if (peerFilter.size === 0) return false;
-    if (parts.length < 2) return false;
-    if (!peerFilter.has(parts[1])) return false;
-  }
-  return true;
-}
-function buildCapsuleBlock(name, override) {
-  const parent = override?.parent ?? null;
-  const parentCapsule = override && Object.prototype.hasOwnProperty.call(override, "parentCapsule") ? override.parentCapsule ?? null : parent?.capsuleId ?? null;
-  const merged = {
-    id: name,
-    version: override?.version ?? "0.1.0",
-    schemaVersion: override?.schemaVersion ?? "taxonomy-v1",
-    parentCapsule,
-    parent,
-    description: override?.description ?? "",
-    retrievalPolicy: override?.retrievalPolicy ?? {
-      tierWeights: {},
-      directAnswerEnabled: false
-    },
-    includes: override?.includes ?? {
-      taxonomy: false,
-      identityAnchors: false,
-      peerProfiles: false,
-      procedural: false
-    }
-  };
-  return CapsuleBlockSchema.parse(merged);
-}
-
-export {
-  exportCapsule,
-  isValidCapsuleSince
-};

package/dist/chunk-UFU5GGGA.js

@@ -1,47 +0,0 @@
-// ../remnic-core/src/logger.ts
-var NOOP_LOGGER = {
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  },
-  debug() {
-  }
-};
-var _backend = NOOP_LOGGER;
-var _debug = false;
-var CONSOLE_LOGGER = {
-  info: console.info.bind(console),
-  warn: console.warn.bind(console),
-  error: console.error.bind(console),
-  debug: console.debug.bind(console)
-};
-function initLogger(backend, debug) {
-  _backend = backend ?? CONSOLE_LOGGER;
-  _debug = debug ?? false;
-}
-var log = {
-  info(msg, ...args) {
-    _backend.info(`remnic: ${msg}`, ...args);
-  },
-  warn(msg, ...args) {
-    _backend.warn(`remnic: ${msg}`, ...args);
-  },
-  error(msg, err) {
-    const detail = err instanceof Error ? err.message : err ? String(err) : "";
-    _backend.error(
-      `remnic: ${msg}${detail ? ` \u2014 ${detail}` : ""}`
-    );
-  },
-  debug(msg, ...args) {
-    if (!_debug) return;
-    const fn = _backend.debug ?? _backend.info;
-    fn(`remnic [debug]: ${msg}`, ...args);
-  }
-};
-
-export {
-  initLogger,
-  log
-};

package/dist/chunk-UZJ7EERS.js

@@ -1,272 +0,0 @@
-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
-};