@remnic/plugin-openclaw 1.0.34 → 1.0.36

package/dist/chunk-FQRSVYY4.js

@@ -1,110 +0,0 @@
-// ../remnic-core/src/routing/engine.ts
-var DEFAULT_CATEGORIES = [
-  "fact",
-  "preference",
-  "correction",
-  "entity",
-  "decision",
-  "relationship",
-  "principle",
-  "commitment",
-  "moment",
-  "skill",
-  "rule",
-  "procedure",
-  "reasoning_trace"
-];
-function normalizeNamespace(namespace) {
-  return namespace.trim();
-}
-function isLikelyUnsafeRegex(pattern) {
-  const value = pattern.trim();
-  if (value.length === 0) return true;
-  if (value.length > 120) return true;
-  if (/\\[1-9]/.test(value)) return true;
-  if (/\(\?<?[=!]/.test(value)) return true;
-  if (/\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)[+*{]/.test(value)) return true;
-  if (/(^|[^\\])[()|]/.test(value)) return true;
-  const quantifierCount = (value.match(/(^|[^\\])[*+?]/g)?.length ?? 0) + (value.match(/(^|[^\\])\{/g)?.length ?? 0);
-  if (quantifierCount > 1) return true;
-  return false;
-}
-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);
-}
-function validateRouteTarget(target, options) {
-  if (!target || typeof target !== "object") {
-    return { ok: false, error: "target must be an object" };
-  }
-  const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);
-  const allowedNamespaces = options?.allowedNamespaces ? new Set(options.allowedNamespaces.map((v) => v.trim()).filter((v) => v.length > 0)) : null;
-  const normalized = {};
-  if (typeof target.category === "string") {
-    if (!allowedCategories.has(target.category)) {
-      return { ok: false, error: `invalid category: ${target.category}` };
-    }
-    normalized.category = target.category;
-  }
-  if (typeof target.namespace === "string") {
-    const namespace = normalizeNamespace(target.namespace);
-    if (!isSafeRouteNamespace(namespace)) {
-      return { ok: false, error: `invalid namespace: ${target.namespace}` };
-    }
-    if (allowedNamespaces && !allowedNamespaces.has(namespace)) {
-      return { ok: false, error: `namespace not allowed: ${namespace}` };
-    }
-    normalized.namespace = namespace;
-  }
-  if (!normalized.category && !normalized.namespace) {
-    return { ok: false, error: "target must include category or namespace" };
-  }
-  return { ok: true, target: normalized };
-}
-function doesRuleMatch(rule, text) {
-  if (!rule || typeof rule !== "object") return false;
-  if (rule.enabled === false) return false;
-  if (typeof rule.pattern !== "string") return false;
-  const pattern = rule.pattern.trim();
-  if (pattern.length === 0) return false;
-  if (rule.patternType === "keyword") {
-    return text.toLowerCase().includes(pattern.toLowerCase());
-  }
-  if (rule.patternType !== "regex") {
-    return false;
-  }
-  if (isLikelyUnsafeRegex(pattern)) {
-    return false;
-  }
-  try {
-    return new RegExp(pattern, "i").test(text);
-  } catch {
-    return false;
-  }
-}
-function selectRouteRule(text, rules, options) {
-  const ranked = rules.map((rule, index) => ({ rule, index })).sort((a, b) => {
-    if (b.rule.priority !== a.rule.priority) return b.rule.priority - a.rule.priority;
-    return a.index - b.index;
-  });
-  for (const entry of ranked) {
-    if (!doesRuleMatch(entry.rule, text)) continue;
-    const validation = validateRouteTarget(entry.rule.target, options);
-    if (!validation.ok || !validation.target) continue;
-    return {
-      rule: entry.rule,
-      target: validation.target
-    };
-  }
-  return null;
-}
-
-export {
-  isSafeRouteNamespace,
-  validateRouteTarget,
-  selectRouteRule
-};

package/dist/chunk-GUSMRW4H.js

@@ -1,12 +0,0 @@
-// ../remnic-core/src/version-utils.ts
-function compareVersions(a, b) {
-  for (let i = 0; i < 3; i += 1) {
-    if (a[i] > b[i]) return 1;
-    if (a[i] < b[i]) return -1;
-  }
-  return 0;
-}
-
-export {
-  compareVersions
-};

package/dist/chunk-MLKGABMK.js

@@ -1,9 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export {
-  __export
-};

package/dist/chunk-WPINX4MF.js

@@ -1,380 +0,0 @@
-import {
-  log
-} from "./chunk-UFU5GGGA.js";
-
-// ../remnic-core/src/boxes.ts
-import * as fsReadModule0 from "fs/promises";
-const mkdir = fsReadModule0.mkdir;
-const writeFile = fsReadModule0.writeFile;
-const fileReader = fsReadModule0["re"+"ad"+"Fi"+"le"];
-const readdir = fsReadModule0.readdir;
-import path from "path";
-import { createHash } from "crypto";
-var BOX_DIR = "boxes";
-var STATE_DIR = "state";
-var TRACES_FILE = "traces.json";
-var OPEN_BOX_STATE_FILE = "open-box.json";
-function topicOverlapScore(a, b) {
-  if (a.length === 0 || b.length === 0) return 0;
-  const setA = new Set(a.map((t) => t.toLowerCase()));
-  const setB = new Set(b.map((t) => t.toLowerCase()));
-  const intersection = [...setA].filter((t) => setB.has(t)).length;
-  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
-  return union === 0 ? 0 : intersection / union;
-}
-function makeBoxId() {
-  return `box-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-}
-function makeTraceId(topics) {
-  const key = topics.slice().sort().join(",");
-  return `trace-${createHash("sha256").update(key).digest("hex").slice(0, 8)}`;
-}
-function serializeBoxFrontmatter(fm) {
-  const lines = [
-    "---",
-    `id: ${fm.id}`,
-    `memoryKind: ${fm.memoryKind}`,
-    `createdAt: ${fm.createdAt}`,
-    `sealedAt: ${fm.sealedAt}`,
-    `sealReason: ${fm.sealReason}`,
-    `topics: [${fm.topics.map((t) => `"${t}"`).join(", ")}]`,
-    `memoryIds: [${fm.memoryIds.map((m) => `"${m}"`).join(", ")}]`
-  ];
-  if (fm.sessionKey) lines.push(`sessionKey: ${fm.sessionKey}`);
-  if (fm.traceId) lines.push(`traceId: ${fm.traceId}`);
-  if (fm.goal) lines.push(`goal: ${fm.goal.replace(/[\r\n]+/g, " ")}`);
-  if (fm.toolsUsed?.length) lines.push(`toolsUsed: [${fm.toolsUsed.map((t) => `"${t}"`).join(", ")}]`);
-  if (fm.outcome) lines.push(`outcome: ${fm.outcome}`);
-  lines.push("---");
-  return lines.join("\n");
-}
-function parseBoxFrontmatter(raw) {
-  const match = raw.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return null;
-  const fmBlock = match[1];
-  const fm = {};
-  for (const line of fmBlock.split("\n")) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) continue;
-    fm[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 1).trim();
-  }
-  const parseArray = (val) => {
-    if (!val) return [];
-    const m = val.match(/\[(.*)]/);
-    if (!m) return [];
-    return m[1].split(",").map((s) => s.trim().replace(/^"|"$/g, "")).filter(Boolean);
-  };
-  const outcome = fm.outcome;
-  return {
-    id: fm.id ?? "",
-    memoryKind: "box",
-    createdAt: fm.createdAt ?? "",
-    sealedAt: fm.sealedAt ?? "",
-    sealReason: fm.sealReason ?? "forced",
-    sessionKey: fm.sessionKey,
-    topics: parseArray(fm.topics),
-    memoryIds: parseArray(fm.memoryIds),
-    traceId: fm.traceId,
-    goal: fm.goal || void 0,
-    toolsUsed: fm.toolsUsed ? parseArray(fm.toolsUsed) : void 0,
-    outcome: outcome && ["success", "failure", "partial", "unknown"].includes(outcome) ? outcome : void 0
-  };
-}
-var BoxBuilder = class {
-  baseDir;
-  cfg;
-  openBox = null;
-  stateLoaded = false;
-  constructor(baseDir, cfg) {
-    this.baseDir = baseDir;
-    this.cfg = cfg;
-  }
-  get boxBaseDir() {
-    return path.join(this.baseDir, BOX_DIR);
-  }
-  get stateDir() {
-    return path.join(this.baseDir, STATE_DIR);
-  }
-  get openBoxStatePath() {
-    return path.join(this.stateDir, OPEN_BOX_STATE_FILE);
-  }
-  get tracesPath() {
-    return path.join(this.stateDir, TRACES_FILE);
-  }
-  // ── State persistence ────────────────────────────────────────────────────
-  async loadOpenBox() {
-    if (this.stateLoaded) return;
-    this.stateLoaded = true;
-    try {
-      const raw = await fileReader(this.openBoxStatePath, "utf-8");
-      this.openBox = JSON.parse(raw);
-    } catch {
-      this.openBox = null;
-    }
-  }
-  async saveOpenBox() {
-    await mkdir(this.stateDir, { recursive: true });
-    if (this.openBox) {
-      await writeFile(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
-    } else {
-      try {
-        await writeFile(this.openBoxStatePath, "null", "utf-8");
-      } catch {
-      }
-    }
-  }
-  async loadTraceIndex() {
-    try {
-      const raw = await fileReader(this.tracesPath, "utf-8");
-      const parsed = JSON.parse(raw);
-      parsed.traceLastSeen ??= {};
-      return parsed;
-    } catch {
-      return { traces: {}, boxToTrace: {}, traceTopics: {}, traceLastSeen: {} };
-    }
-  }
-  async saveTraceIndex(idx) {
-    try {
-      await mkdir(this.stateDir, { recursive: true });
-      await writeFile(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
-    } catch (err) {
-      log.warn(`[engram/boxes] Failed to save trace index: ${err.message}`);
-    }
-  }
-  // ── Core logic ────────────────────────────────────────────────────────────
-  /**
-   * Called after each extraction run.
-   * Decides whether to seal the current open box and/or start a new one.
-   */
-  async onExtraction(event) {
-    if (!this.cfg.memoryBoxesEnabled) return;
-    await this.loadOpenBox();
-    const newTopics = event.topics.filter(Boolean);
-    const now = new Date(event.timestamp);
-    const nowMs = now.getTime();
-    if (this.openBox) {
-      const lastActivity = new Date(this.openBox.lastActivityAt).getTime();
-      const timeGapMs = nowMs - lastActivity;
-      const overlap = topicOverlapScore(this.openBox.topics, newTopics);
-      const topicShifted = newTopics.length > 0 && overlap < this.cfg.boxTopicShiftThreshold;
-      const timeExpired = timeGapMs >= this.cfg.boxTimeGapMs;
-      const tooManyMemories = this.openBox.memoryIds.length + event.memoryIds.length > this.cfg.boxMaxMemories;
-      if (tooManyMemories) {
-        const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
-        this.openBox.topics = [...topicSet];
-        this.openBox.memoryIds.push(...event.memoryIds);
-        if (event.toolsUsed?.length) {
-          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
-          this.openBox.toolsUsed = [...toolSet];
-        }
-        await this.sealCurrent("max_memories");
-      } else if (topicShifted) {
-        await this.sealCurrent("topic_shift");
-        this.openBox = this.newBox(event, now.toISOString());
-        await this.saveOpenBox();
-      } else if (timeExpired) {
-        await this.sealCurrent("time_gap");
-        this.openBox = this.newBox(event, now.toISOString());
-        await this.saveOpenBox();
-      } else {
-        this.openBox.memoryIds.push(...event.memoryIds);
-        const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
-        this.openBox.topics = [...topicSet];
-        this.openBox.lastActivityAt = now.toISOString();
-        if (event.toolsUsed?.length) {
-          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
-          this.openBox.toolsUsed = [...toolSet];
-        }
-        await this.saveOpenBox();
-      }
-    } else {
-      this.openBox = this.newBox(event, now.toISOString());
-      if (this.openBox.memoryIds.length > this.cfg.boxMaxMemories) {
-        await this.sealCurrent("max_memories");
-      } else {
-        await this.saveOpenBox();
-      }
-    }
-  }
-  newBox(event, ts) {
-    return {
-      id: makeBoxId(),
-      createdAt: ts,
-      lastActivityAt: ts,
-      topics: event.topics.filter(Boolean),
-      memoryIds: [...event.memoryIds],
-      goal: event.goal,
-      toolsUsed: event.toolsUsed?.length ? [...event.toolsUsed] : void 0
-    };
-  }
-  /**
-   * Seal the current open box and write it to disk.
-   * Also runs trace weaving if enabled.
-   */
-  async sealCurrent(reason) {
-    await this.loadOpenBox();
-    if (!this.openBox) return null;
-    const box = this.openBox;
-    this.openBox = null;
-    if (box.memoryIds.length === 0 && box.topics.length === 0) {
-      await this.saveOpenBox();
-      return null;
-    }
-    const sealedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const day = sealedAt.slice(0, 10);
-    const dir = path.join(this.boxBaseDir, day);
-    await mkdir(dir, { recursive: true });
-    let traceId;
-    if (this.cfg.traceWeaverEnabled && box.topics.length > 0) {
-      traceId = await this.resolveTrace(box.id, box.topics);
-    }
-    const fm = {
-      id: box.id,
-      memoryKind: "box",
-      createdAt: box.createdAt,
-      sealedAt,
-      sealReason: reason,
-      topics: box.topics,
-      memoryIds: box.memoryIds,
-      traceId,
-      goal: box.goal,
-      toolsUsed: box.toolsUsed?.length ? box.toolsUsed : void 0,
-      outcome: "unknown"
-    };
-    const content = `${serializeBoxFrontmatter(fm)}
-
-<!-- Topics: ${box.topics.join(", ")} | Memories: ${box.memoryIds.length} -->
-`;
-    const filePath = path.join(dir, `${box.id}.md`);
-    await writeFile(filePath, content, "utf-8");
-    log.debug(`[boxes] sealed box ${box.id} (${reason}): ${box.memoryIds.length} memories, topics=[${box.topics.join(",")}]`);
-    await this.saveOpenBox();
-    return box.id;
-  }
-  // ── Trace Weaving ─────────────────────────────────────────────────────────
-  /**
-   * Find an existing trace that matches box topics, or create a new trace.
-   * Returns the traceId to assign to this box.
-   */
-  async resolveTrace(boxId, topics) {
-    const idx = await this.loadTraceIndex();
-    const lookbackMs = this.cfg.traceWeaverLookbackDays * 24 * 60 * 60 * 1e3;
-    const cutoff = new Date(Date.now() - lookbackMs);
-    let bestTraceId;
-    let bestScore = 0;
-    for (const [tid, traceTopics] of Object.entries(idx.traceTopics)) {
-      const lastSeen = idx.traceLastSeen[tid];
-      if (lastSeen && new Date(lastSeen) < cutoff) continue;
-      const score = topicOverlapScore(topics, traceTopics);
-      if (score >= this.cfg.traceWeaverOverlapThreshold && score > bestScore) {
-        bestScore = score;
-        bestTraceId = tid;
-      }
-    }
-    const traceId = bestTraceId ?? makeTraceId(topics);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (!idx.traces[traceId]) idx.traces[traceId] = [];
-    idx.traces[traceId].push(boxId);
-    idx.boxToTrace[boxId] = traceId;
-    idx.traceLastSeen[traceId] = now;
-    if (idx.traceTopics[traceId]) {
-      const merged = /* @__PURE__ */ new Set([...idx.traceTopics[traceId], ...topics]);
-      idx.traceTopics[traceId] = [...merged];
-    } else {
-      idx.traceTopics[traceId] = [...topics];
-    }
-    await this.saveTraceIndex(idx);
-    return traceId;
-  }
-  // ── Recall ────────────────────────────────────────────────────────────────
-  /**
-   * Read all sealed boxes from the last N days for recall injection.
-   */
-  async readRecentBoxes(days) {
-    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
-    const cutoffDateStr = cutoff.toISOString().slice(0, 10);
-    let topEntries;
-    try {
-      topEntries = await readdir(this.boxBaseDir, { withFileTypes: true, encoding: "utf-8" });
-    } catch {
-      return [];
-    }
-    const recentDirs = topEntries.filter((e) => e.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(e.name) && e.name >= cutoffDateStr).map((e) => path.join(this.boxBaseDir, e.name));
-    const legacyEntries = topEntries.filter(
-      (e) => !e.isDirectory() || !/^\d{4}-\d{2}-\d{2}$/.test(e.name)
-    );
-    const boxes = [];
-    const readDir = async (dir) => {
-      let files;
-      try {
-        files = (await readdir(dir)).filter((f) => f.endsWith(".md"));
-      } catch {
-        return;
-      }
-      const results = await Promise.all(
-        files.map(async (f) => {
-          try {
-            const raw = await fileReader(path.join(dir, f), "utf-8");
-            const parsed = parseBoxFrontmatter(raw);
-            return parsed && new Date(parsed.sealedAt) >= cutoff ? parsed : null;
-          } catch {
-            return null;
-          }
-        })
-      );
-      for (const r of results) {
-        if (r !== null) boxes.push(r);
-      }
-    };
-    await Promise.all(recentDirs.map(readDir));
-    for (const e of legacyEntries) {
-      const full = path.join(this.boxBaseDir, e.name);
-      if (e.isDirectory()) {
-        await readDir(full);
-      } else if (e.name.endsWith(".md")) {
-        try {
-          const raw = await fileReader(full, "utf-8");
-          const parsed = parseBoxFrontmatter(raw);
-          if (parsed && new Date(parsed.sealedAt) >= cutoff) boxes.push(parsed);
-        } catch {
-        }
-      }
-    }
-    boxes.sort((a, b) => new Date(b.sealedAt).getTime() - new Date(a.sealedAt).getTime());
-    return boxes;
-  }
-};
-
-// ../remnic-core/src/recall-tokenization.ts
-function normalizeRecallTokens(value, extraStopWords = []) {
-  const stopWords = /* @__PURE__ */ new Set([
-    "the",
-    "and",
-    "for",
-    "with",
-    "from",
-    "into",
-    "that",
-    "this",
-    "why",
-    "did",
-    ...extraStopWords
-  ]);
-  return value.toLowerCase().split(/[^a-z0-9]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !stopWords.has(token));
-}
-function countRecallTokenOverlap(queryTokens, value, extraStopWords = []) {
-  if (!value) return 0;
-  const tokens = new Set(normalizeRecallTokens(value, extraStopWords));
-  let matches = 0;
-  for (const token of queryTokens) {
-    if (tokens.has(token)) matches += 1;
-  }
-  return matches;
-}
-
-export {
-  topicOverlapScore,
-  BoxBuilder,
-  normalizeRecallTokens,
-  countRecallTokenOverlap
-};

package/dist/contradiction-review-SVGBS3V5.js

@@ -1,21 +0,0 @@
-import {
-  computePairId,
-  isCoolingDown,
-  listPairs,
-  memoryHashesChanged,
-  readPair,
-  resolvePair,
-  writePair,
-  writePairs
-} from "./chunk-DIZW6H5J.js";
-import "./chunk-MLKGABMK.js";
-export {
-  computePairId,
-  isCoolingDown,
-  listPairs,
-  memoryHashesChanged,
-  readPair,
-  resolvePair,
-  writePair,
-  writePairs
-};

package/dist/legacy-hook-compat-XQ7FP6FV.js

@@ -1,35 +0,0 @@
-import {
-  compareVersions
-} from "./chunk-GUSMRW4H.js";
-import "./chunk-MLKGABMK.js";
-
-// ../remnic-core/src/legacy-hook-compat.ts
-var FIRST_PUBLISHED_RUNTIME_WITHOUT_AGENT_HEARTBEAT = [2026, 1, 29];
-var OPENCLAW_VERSION_PREFIX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/;
-function parseOpenClawVersion(value) {
-  if (typeof value !== "string") return null;
-  const match = value.trim().match(OPENCLAW_VERSION_PREFIX);
-  if (!match) return null;
-  return {
-    triple: [
-      Number.parseInt(match[1], 10),
-      Number.parseInt(match[2], 10),
-      Number.parseInt(match[3], 10)
-    ],
-    prerelease: typeof match[4] === "string" && match[4].length > 0
-  };
-}
-function shouldRegisterTypedAgentHeartbeat(runtimeVersion) {
-  const parsed = parseOpenClawVersion(runtimeVersion);
-  if (!parsed) return false;
-  const comparison = compareVersions(
-    parsed.triple,
-    FIRST_PUBLISHED_RUNTIME_WITHOUT_AGENT_HEARTBEAT
-  );
-  if (comparison < 0) return true;
-  if (comparison > 0) return false;
-  return parsed.prerelease;
-}
-export {
-  shouldRegisterTypedAgentHeartbeat
-};

package/dist/path-JIEGNWFL.js

@@ -1,7 +0,0 @@
-import {
-  expandTildePath
-} from "./chunk-TDRJVMUP.js";
-import "./chunk-MLKGABMK.js";
-export {
-  expandTildePath
-};

package/dist/resolution-YITUVUTH.js

@@ -1,100 +0,0 @@
-import {
-  readPair,
-  resolvePair
-} from "./chunk-DIZW6H5J.js";
-import {
-  log
-} from "./chunk-UFU5GGGA.js";
-import "./chunk-MLKGABMK.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) {
-  const pair = readPair(memoryDir, pairId);
-  if (!pair) {
-    return { pairId, verb, affectedIds: [], message: `Pair ${pairId} not found` };
-  }
-  if (pair.resolution) {
-    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 ok = await supersedeSafe(storage, idB, idA, "contradiction-resolution:keep-a");
-      if (ok) {
-        affectedIds.push(idB);
-        message = `Kept ${idA}, superseded ${idB}`;
-      } else {
-        supersedeFailed = true;
-        message = `Supersede failed for ${idB}; not resolving`;
-      }
-      break;
-    }
-    case "keep-b": {
-      const ok = await supersedeSafe(storage, idA, idB, "contradiction-resolution:keep-b");
-      if (ok) {
-        affectedIds.push(idA);
-        message = `Kept ${idB}, superseded ${idA}`;
-      } else {
-        supersedeFailed = true;
-        message = `Supersede failed for ${idA}; not resolving`;
-      }
-      break;
-    }
-    case "merge": {
-      const mergedId = `merged-${pairId}`;
-      const okA = await supersedeSafe(storage, idA, mergedId, "contradiction-resolution:merge");
-      const okB = await supersedeSafe(storage, idB, mergedId, "contradiction-resolution:merge");
-      if (okA) affectedIds.push(idA);
-      if (okB) affectedIds.push(idB);
-      if (!okA || !okB) {
-        supersedeFailed = true;
-        message = `Merge incomplete: ${affectedIds.length}/2 superseded; not resolving to allow retry`;
-      } else {
-        message = `Both memories superseded by merged ${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 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 {
-  executeResolution,
-  isValidResolutionVerb
-};