@remnic/plugin-openclaw 1.0.6 → 1.0.8

package/README.md

@@ -38,6 +38,42 @@ Then restart the gateway:
 launchctl kickstart -k gui/501/ai.openclaw.gateway
 ```
 
+## Benchmarking The OpenClaw Chain
+
+The benchmark CLI can now exercise the real OpenClaw-backed answer path instead
+of only the stripped retrieval harness. Use the `openclaw-chain` runtime
+profile to load the Remnic plugin config from `openclaw.json`, route answer
+generation through the configured gateway chain, and optionally attach a
+provider-backed judge:
+
+```bash
+remnic bench run longmemeval \
+  --runtime-profile openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --gateway-agent-id memory-primary
+
+remnic bench run longmemeval \
+  --runtime-profile openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --gateway-agent-id memory-primary \
+  --judge-provider openai \
+  --judge-model gpt-5.4-mini
+```
+
+To compare the stripped harness, direct Remnic runtime, and OpenClaw chain in a
+single pass, run a profile matrix:
+
+```bash
+remnic bench run longmemeval \
+  --matrix baseline,real,openclaw-chain \
+  --openclaw-config ~/.openclaw/openclaw.json \
+  --remnic-config ~/.config/remnic/config.json
+```
+
+Each stored result records its `runtimeProfile`, provider metadata, and the
+resolved Remnic config so benchmark comparisons can distinguish retrieval-only
+runs from real runtime and OpenClaw chain runs.
+
 ## What it does
 
 This plugin hooks into the OpenClaw gateway lifecycle:

package/dist/{calibration-3JHF25QT.js → calibration-BAC7KNKR.js}

@@ -1,6 +1,7 @@
 import {
   FallbackLlmClient
-} from "./chunk-3SA5F4WT.js";
+} from "./chunk-NXLHSCLU.js";
+import "./chunk-3A5ELHTT.js";
 import {
   listJsonFiles
 } from "./chunk-5LE4HTVL.js";

package/dist/{causal-consolidation-EBLROS42.js → causal-consolidation-33R5JTPX.js}

@@ -1,8 +1,13 @@
 import {
   buildExtensionsBlockForConsolidation,
   runPostConsolidationMaterialize
-} from "./chunk-QHMR3D7U.js";
-import "./chunk-KPMXWORS.js";
+} from "./chunk-BQLPVRIU.js";
+import {
+  FallbackLlmClient
+} from "./chunk-NXLHSCLU.js";
+import "./chunk-3A5ELHTT.js";
+import "./chunk-JJSNPSCD.js";
+import "./chunk-6OJAU466.js";
 import {
   readChainIndex,
   resolveChainsDir
@@ -10,9 +15,6 @@ import {
 import {
   isRecord
 } from "./chunk-YHH3SXKD.js";
-import {
-  FallbackLlmClient
-} from "./chunk-3SA5F4WT.js";
 import {
   listJsonFiles,
   readJsonFile

package/dist/chunk-3A5ELHTT.js

@@ -0,0 +1,61 @@
+// ../remnic-core/src/json-extract.ts
+function stripCodeFences(text) {
+  return text.replace(/```(?:json)?\s*([\s\S]*?)```/gi, (_m, inner) => String(inner).trim());
+}
+function extractJsonCandidates(text) {
+  const trimmed = text.trim();
+  const cleaned = stripCodeFences(trimmed);
+  const candidates = [];
+  if (cleaned.length > 0) candidates.push(cleaned);
+  candidates.push(...scanBalancedJsonBlocks(cleaned));
+  const objMatch = cleaned.match(/\{[\s\S]*\}/);
+  if (objMatch) candidates.push(objMatch[0]);
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.map((c) => c.trim()).filter((c) => c.length > 0).filter((c) => {
+    if (seen.has(c)) return false;
+    seen.add(c);
+    return true;
+  });
+}
+function scanBalancedJsonBlocks(text) {
+  const out = [];
+  const opens = /* @__PURE__ */ new Set(["{", "["]);
+  const closes = { "{": "}", "[": "]" };
+  for (let i = 0; i < text.length; i++) {
+    const start = text[i];
+    if (!opens.has(start)) continue;
+    const expectedClose = closes[start];
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let j = i; j < text.length; j++) {
+      const ch = text[j];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+        continue;
+      }
+      if (ch === start) depth++;
+      if (ch === expectedClose) depth--;
+      if (depth === 0) {
+        out.push(text.slice(i, j + 1).trim());
+        i = j;
+        break;
+      }
+    }
+  }
+  return out;
+}
+
+export {
+  extractJsonCandidates
+};

package/dist/chunk-5ZW5XJQ6.js

@@ -0,0 +1,125 @@
+import {
+  log
+} from "./chunk-UFU5GGGA.js";
+
+// ../remnic-core/src/extraction-judge-telemetry.ts
+import path from "path";
+import { appendFile, mkdir, readFile } from "fs/promises";
+var EXTRACTION_JUDGE_VERDICT_CATEGORY = "EXTRACTION_JUDGE_VERDICT";
+function judgeTelemetryPath(memoryDir) {
+  return path.join(
+    memoryDir,
+    "state",
+    "observation-ledger",
+    "extraction-judge-verdicts.jsonl"
+  );
+}
+async function recordJudgeVerdict(event, options) {
+  if (!options.enabled) return;
+  const filePath = judgeTelemetryPath(options.memoryDir);
+  try {
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await appendFile(filePath, `${JSON.stringify(event)}
+`, "utf-8");
+  } catch (err) {
+    log.debug(
+      `extraction-judge-telemetry: append failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function readJudgeVerdictStats(memoryDir, opts = {}) {
+  const filePath = judgeTelemetryPath(memoryDir);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") {
+      return {
+        total: 0,
+        accept: 0,
+        reject: 0,
+        defer: 0,
+        deferCapTriggered: 0,
+        meanElapsedMs: 0,
+        deferRate: 0,
+        malformed: 0
+      };
+    }
+    throw err;
+  }
+  let total = 0;
+  let accept = 0;
+  let reject = 0;
+  let defer = 0;
+  let deferCapTriggered = 0;
+  let elapsedSum = 0;
+  let malformed = 0;
+  let firstTs;
+  let lastTs;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      malformed += 1;
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      malformed += 1;
+      continue;
+    }
+    const p = parsed;
+    if (p.category !== EXTRACTION_JUDGE_VERDICT_CATEGORY) {
+      malformed += 1;
+      continue;
+    }
+    const ts = typeof p.ts === "string" ? p.ts : null;
+    if (ts === null) {
+      malformed += 1;
+      continue;
+    }
+    const tsMs = Date.parse(ts);
+    if (!Number.isFinite(tsMs)) {
+      malformed += 1;
+      continue;
+    }
+    if (typeof opts.sinceMs === "number" && tsMs < opts.sinceMs) continue;
+    if (typeof opts.untilMs === "number" && tsMs >= opts.untilMs) continue;
+    const kind = p.verdictKind;
+    if (kind === "accept") accept += 1;
+    else if (kind === "reject") reject += 1;
+    else if (kind === "defer") defer += 1;
+    else {
+      malformed += 1;
+      continue;
+    }
+    if (p.deferCapTriggered === true) deferCapTriggered += 1;
+    if (typeof p.elapsedMs === "number" && Number.isFinite(p.elapsedMs)) {
+      elapsedSum += p.elapsedMs;
+    }
+    total += 1;
+    if (firstTs === void 0 || ts < firstTs) firstTs = ts;
+    if (lastTs === void 0 || ts > lastTs) lastTs = ts;
+  }
+  return {
+    total,
+    accept,
+    reject,
+    defer,
+    deferCapTriggered,
+    meanElapsedMs: total > 0 ? elapsedSum / total : 0,
+    deferRate: total > 0 ? defer / total : 0,
+    firstTs,
+    lastTs,
+    malformed
+  };
+}
+
+export {
+  EXTRACTION_JUDGE_VERDICT_CATEGORY,
+  judgeTelemetryPath,
+  recordJudgeVerdict,
+  readJudgeVerdictStats
+};

package/dist/chunk-6OJAU466.js

@@ -0,0 +1,148 @@
+// ../remnic-core/src/page-versioning.ts
+import { createHash } from "crypto";
+import path from "path";
+import {
+  access,
+  mkdir,
+  readFile,
+  writeFile,
+  unlink
+} from "fs/promises";
+var NOOP_LOGGER = {
+  debug: () => {
+  },
+  warn: () => {
+  }
+};
+var writeLocks = /* @__PURE__ */ new Map();
+function withPageLock(pageKey, fn) {
+  const prev = writeLocks.get(pageKey) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  writeLocks.set(pageKey, next.then(() => {
+  }, () => {
+  }));
+  return next;
+}
+function contentHash(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function sidecarKey(pagePath) {
+  const withoutExt = pagePath.replace(/\.md$/i, "");
+  return withoutExt.replace(/[\\/]/g, "__");
+}
+function sidecarDir(memoryDir, sidecar, pagePath) {
+  return path.join(memoryDir, sidecar, sidecarKey(pagePath));
+}
+function manifestPath(memoryDir, sidecar, pagePath) {
+  return path.join(sidecarDir(memoryDir, sidecar, pagePath), "manifest.json");
+}
+async function fileExists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readManifest(memoryDir, sidecar, pagePath) {
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  try {
+    const raw = await readFile(mp, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { pagePath, versions: [], currentVersion: "0" };
+    }
+    const obj = parsed;
+    const versions = Array.isArray(obj.versions) ? obj.versions : [];
+    const currentVersion = typeof obj.currentVersion === "string" ? obj.currentVersion : "0";
+    return { pagePath: typeof obj.pagePath === "string" ? obj.pagePath : pagePath, versions, currentVersion };
+  } catch {
+    return { pagePath, versions: [], currentVersion: "0" };
+  }
+}
+async function writeManifest(memoryDir, sidecar, pagePath, history) {
+  const dir = sidecarDir(memoryDir, sidecar, pagePath);
+  await mkdir(dir, { recursive: true });
+  const mp = manifestPath(memoryDir, sidecar, pagePath);
+  await writeFile(mp, JSON.stringify(history, null, 2) + "\n", "utf-8");
+}
+async function createVersion(pagePath, content, trigger, config, log = NOOP_LOGGER, note, memoryDir) {
+  const { sidecarDir: sidecar, maxVersionsPerPage } = config;
+  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);
+  const mPath = manifestPath(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+  return withPageLock(mPath, async () => {
+    const history = await readManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    const nextId = String(history.versions.length > 0 ? Math.max(...history.versions.map((v) => Number(v.versionId))) + 1 : 1);
+    const hash = contentHash(content);
+    const version = {
+      versionId: nextId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      contentHash: hash,
+      sizeBytes: Buffer.byteLength(content, "utf-8"),
+      trigger,
+      ...note !== void 0 ? { note } : {}
+    };
+    const dir = sidecarDir(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir));
+    await mkdir(dir, { recursive: true });
+    const ext = path.extname(pagePath) || ".md";
+    const snapshotPath = path.join(dir, `${nextId}${ext}`);
+    await writeFile(snapshotPath, content, "utf-8");
+    history.versions.push(version);
+    history.currentVersion = nextId;
+    if (maxVersionsPerPage > 0 && history.versions.length > maxVersionsPerPage) {
+      const toRemove = history.versions.splice(0, history.versions.length - maxVersionsPerPage);
+      for (const old of toRemove) {
+        const oldPath = path.join(dir, `${old.versionId}${ext}`);
+        try {
+          await unlink(oldPath);
+        } catch {
+          log.debug(`page-versioning: could not remove old snapshot ${oldPath}`);
+        }
+      }
+    }
+    await writeManifest(resolvedMemoryDir, sidecar, relPath(pagePath, resolvedMemoryDir), history);
+    log.debug(`page-versioning: created version ${nextId} for ${pagePath} (trigger=${trigger})`);
+    return version;
+  });
+}
+async function getVersion(pagePath, versionId, config, memoryDir) {
+  const resolvedMemoryDir = memoryDir ?? resolveMemoryDir(pagePath);
+  const rel = relPath(pagePath, resolvedMemoryDir);
+  const ext = path.extname(pagePath) || ".md";
+  const dir = sidecarDir(resolvedMemoryDir, config.sidecarDir, rel);
+  const snapshotPath = path.join(dir, `${versionId}${ext}`);
+  if (!await fileExists(snapshotPath)) {
+    throw new Error(`Version ${versionId} not found for ${pagePath}`);
+  }
+  return readFile(snapshotPath, "utf-8");
+}
+function resolveMemoryDir(pagePath) {
+  const knownSubdirs = /* @__PURE__ */ new Set([
+    "facts",
+    "corrections",
+    "entities",
+    "state",
+    "artifacts",
+    "questions",
+    "profiles"
+  ]);
+  let dir = path.dirname(pagePath);
+  for (let depth = 0; depth < 5; depth++) {
+    const base = path.basename(dir);
+    if (knownSubdirs.has(base) || /^\d{4}-\d{2}-\d{2}$/.test(base)) {
+      dir = path.dirname(dir);
+    } else {
+      break;
+    }
+  }
+  return dir;
+}
+function relPath(pagePath, memoryDir) {
+  return path.relative(memoryDir, pagePath);
+}
+
+export {
+  sidecarKey,
+  createVersion,
+  getVersion
+};

package/dist/{chunk-QHMR3D7U.js → chunk-BQLPVRIU.js}

@@ -1,6 +1,7 @@
 import {
-  StorageManager
-} from "./chunk-KPMXWORS.js";
+  StorageManager,
+  isConsolidationOperator
+} from "./chunk-JJSNPSCD.js";
 import {
   countRecallTokenOverlap,
   normalizeRecallTokens
@@ -936,6 +937,109 @@ Write ONLY the consolidated memory content (no metadata, no explanation, no prea
 function parseConsolidationResponse(response) {
   return response.trim();
 }
+function chooseConsolidationOperator(cluster) {
+  if (cluster.memories.length <= 1) return "update";
+  return "merge";
+}
+function buildOperatorAwareConsolidationPrompt(cluster) {
+  const memoryTexts = cluster.memories.map(
+    (m, i) => `Memory ${i + 1} (${m.frontmatter.id}, created ${m.frontmatter.created}):
+${m.content}`
+  ).join("\n\n");
+  return `You are a memory consolidation system.  The following ${cluster.memories.length} memories in the "${cluster.category}" category contain overlapping information.
+
+Pick exactly ONE consolidation operator for this cluster and return a JSON object.
+
+Operator vocabulary:
+  - "merge"  \u2014 multiple distinct source memories overlap and should be collapsed into one canonical memory (most common).
+  - "update" \u2014 one source memory carries a stale value that a newer source supersedes within the same logical fact.
+  - "split"  \u2014 a single logical source really encodes multiple distinct facts that should be separated (rare; if you pick split, still emit ONE canonical body \u2014 the write path will chunk it later).
+
+Output JSON ONLY, no prose before or after.  The "operator" key MUST be set to exactly one of the three strings "merge", "update", or "split" \u2014 never a pipe-separated placeholder like "merge|update|split".  Example shape:
+  {
+    "operator": "merge",
+    "output": "<the canonical memory text>"
+  }
+
+The "output" value must:
+1. Preserve ALL unique information from every source memory
+2. Remove redundancy and repetition
+3. Use clear, concise language
+4. Match the "${cluster.category}" category and tone
+5. NOT add information that isn't in the sources
+
+${memoryTexts}
+
+Return ONLY the JSON object:`;
+}
+function parseOperatorAwareConsolidationResponse(response, cluster) {
+  const fallback = {
+    operator: chooseConsolidationOperator(cluster),
+    output: response.trim()
+  };
+  const trimmed = response.trim();
+  if (trimmed.length === 0) return fallback;
+  const fenced = /^```(?:json)?\s*([\s\S]*?)```\s*$/u.exec(trimmed);
+  const payload = fenced ? fenced[1].trim() : trimmed;
+  const parsed = findLastJsonObjectWithOperator(payload);
+  if (parsed === void 0) return fallback;
+  if (typeof parsed !== "object" || parsed === null) return fallback;
+  const obj = parsed;
+  const rawOperator = typeof obj.operator === "string" ? obj.operator.trim().toLowerCase() : "";
+  const rawOutput = typeof obj.output === "string" ? obj.output : "";
+  const operator = isConsolidationOperator(rawOperator) ? rawOperator : chooseConsolidationOperator(cluster);
+  const output = rawOutput.trim().length > 0 ? rawOutput.trim() : response.trim();
+  return { operator, output };
+}
+function findLastJsonObjectWithOperator(text) {
+  let searchFrom = 0;
+  let last = void 0;
+  while (searchFrom < text.length) {
+    const start = text.indexOf("{", searchFrom);
+    if (start < 0) return last;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    let closed = false;
+    let endIdx = -1;
+    for (let i = start; i < text.length; i++) {
+      const ch = text[i];
+      if (inString) {
+        if (escape) {
+          escape = false;
+        } else if (ch === "\\") {
+          escape = true;
+        } else if (ch === '"') {
+          inString = false;
+        }
+        continue;
+      }
+      if (ch === '"') {
+        inString = true;
+      } else if (ch === "{") {
+        depth += 1;
+      } else if (ch === "}") {
+        depth -= 1;
+        if (depth === 0) {
+          closed = true;
+          endIdx = i;
+          break;
+        }
+      }
+    }
+    if (!closed) return last;
+    const slice = text.slice(start, endIdx + 1);
+    try {
+      const parsed = JSON.parse(slice);
+      if (typeof parsed === "object" && parsed !== null && "operator" in parsed) {
+        last = parsed;
+      }
+    } catch {
+    }
+    searchFrom = endIdx + 1;
+  }
+  return last;
+}
 async function buildExtensionsBlockForConsolidation(config) {
   if (!config.memoryExtensionsEnabled) return "";
   const root = resolveExtensionsRoot(config);
@@ -955,6 +1059,9 @@ export {
   findSimilarClusters,
   buildConsolidationPrompt,
   parseConsolidationResponse,
+  chooseConsolidationOperator,
+  buildOperatorAwareConsolidationPrompt,
+  parseOperatorAwareConsolidationResponse,
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };

package/dist/chunk-DIZW6H5J.js

@@ -0,0 +1,136 @@
+// ../remnic-core/src/contradiction/contradiction-review.ts
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+function computePairId(memoryIdA, memoryIdB) {
+  const sorted = [memoryIdA, memoryIdB].sort();
+  return createHash("sha256").update(sorted.join("::")).digest("hex").slice(0, 24);
+}
+function reviewDir(memoryDir) {
+  return path.join(memoryDir, ".review", "contradictions");
+}
+function pairPath(memoryDir, pairId) {
+  if (pairId.includes("/") || pairId.includes("\\") || pairId.includes("..")) {
+    throw new Error(`Invalid pairId: ${pairId}`);
+  }
+  return path.join(reviewDir(memoryDir), `${pairId}.json`);
+}
+function ensureDir(memoryDir) {
+  const dir = reviewDir(memoryDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function writePair(memoryDir, pair) {
+  ensureDir(memoryDir);
+  const pairId = computePairId(pair.memoryIds[0], pair.memoryIds[1]);
+  const existing = readPair(memoryDir, pairId);
+  if (existing?.resolution) {
+    return existing;
+  }
+  if (existing && existing.confidence >= pair.confidence) {
+    return existing;
+  }
+  const full = {
+    ...pair,
+    pairId,
+    lastReviewedAt: existing?.lastReviewedAt,
+    resolution: existing?.resolution
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(full, null, 2), "utf-8");
+  fs.renameSync(tmpPath, filePath);
+  return full;
+}
+function writePairs(memoryDir, pairs) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const pair of pairs) {
+    const key = computePairId(pair.memoryIds[0], pair.memoryIds[1]);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push(writePair(memoryDir, pair));
+  }
+  return results;
+}
+function readPair(memoryDir, pairId) {
+  const filePath = pairPath(memoryDir, pairId);
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.memoryIds)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function listPairs(memoryDir, options) {
+  const startTime = Date.now();
+  const dir = reviewDir(memoryDir);
+  const { filter = "all", namespace, limit = 50 } = options ?? {};
+  const pairs = [];
+  let total = 0;
+  if (!fs.existsSync(dir)) {
+    return { pairs: [], total: 0, durationMs: Date.now() - startTime };
+  }
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith(".json")) continue;
+    try {
+      const raw = fs.readFileSync(path.join(dir, entry), "utf-8");
+      const pair = JSON.parse(raw);
+      if (typeof pair !== "object" || pair === null) continue;
+      if (!Array.isArray(pair.memoryIds)) continue;
+      if (namespace && pair.namespace !== namespace) continue;
+      if (filter === "unresolved") {
+        if (pair.resolution) continue;
+        if (pair.verdict === "independent") continue;
+      } else if (filter !== "all" && pair.verdict !== filter) {
+        continue;
+      }
+      total++;
+      if (pairs.length < limit) pairs.push(pair);
+    } catch {
+      continue;
+    }
+  }
+  return { pairs, total, durationMs: Date.now() - startTime };
+}
+function isCoolingDown(pair, cooldownDays) {
+  if (cooldownDays <= 0) return false;
+  if (!pair.lastReviewedAt) return false;
+  const lastReviewed = new Date(pair.lastReviewedAt).getTime();
+  if (!Number.isFinite(lastReviewed)) return false;
+  const cooldownMs = cooldownDays * 24 * 60 * 60 * 1e3;
+  return Date.now() < lastReviewed + cooldownMs;
+}
+function resolvePair(memoryDir, pairId, verb) {
+  const existing = readPair(memoryDir, pairId);
+  if (!existing) return null;
+  const updated = {
+    ...existing,
+    lastReviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resolution: verb
+  };
+  const filePath = pairPath(memoryDir, pairId);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(updated, null, 2), "utf-8");
+  fs.renameSync(tmpPath, filePath);
+  return updated;
+}
+function memoryHashesChanged(_memoryDir, _pair, _getCurrentHash) {
+  return false;
+}
+
+export {
+  computePairId,
+  writePair,
+  writePairs,
+  readPair,
+  listPairs,
+  isCoolingDown,
+  resolvePair,
+  memoryHashesChanged
+};