@remnic/cli 9.45.3 → 9.45.4

package/dist/index.js

@@ -18,18 +18,18 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 }
 
 // src/index.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import os from "os";
 import path15 from "path";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { gzipSync } from "zlib";
 import {
-  parseConfig as parseConfig5,
+  parseConfig as parseConfig6,
   isOpenaiApiKeyDisabled,
   resolveEnvVars,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord4,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord5,
   Orchestrator as Orchestrator3,
   EngramAccessService as EngramAccessService2,
   initLogger as initLogger2,
@@ -111,7 +111,7 @@ import {
   renderXray,
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES2,
-  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES3,
+  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES4,
   OFFLINE_SYNC_SNAPSHOT_BASE_MAX_BODY_BYTES,
   applyOfflineSyncFileContentChunk as applyOfflineSyncFileContentChunk2,
   applyOfflineSyncSnapshot,
@@ -190,6 +190,34 @@ async function runMeetingsBinaryCommand(rest) {
   }
 }
 
+// src/commands/external-wiki.ts
+import fs2 from "fs";
+import { parseConfig as parseConfig2, resolveRemnicConfigRecord as resolveRemnicConfigRecord2, runExternalWikiCliCommand } from "@remnic/core";
+async function runExternalWikiBinaryCommand(rest) {
+  let roots;
+  try {
+    const configPath = resolveConfigPath();
+    const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+    roots = parseConfig2(resolveRemnicConfigRecord2(raw)).externalWikis;
+  } catch {
+    console.error(
+      "external-wiki: failed to load the Remnic config - run `remnic doctor` and check the config file for errors"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const code = await runExternalWikiCliCommand(roots, rest, {
+      stdout: process.stdout,
+      stderr: process.stderr
+    });
+    if (code !== 0) process.exitCode = code;
+  } catch {
+    console.error("external-wiki: search failed");
+    process.exitCode = 1;
+  }
+}
+
 // src/optional-module-loader.ts
 function isSpecifierNotFoundError(err, specifier) {
   if (!err || typeof err !== "object") {
@@ -240,19 +268,19 @@ async function loadWecloneExportModule() {
 }
 
 // src/converge.ts
-import * as fs3 from "fs";
-import { createHash as createHash2 } from "crypto";
+import * as fs4 from "fs";
+import { createHash as createHash3 } from "crypto";
 import * as path2 from "path";
 import {
   CONVERGE_CONFLICT_POLICIES,
   DEFAULT_CONVERGE_CONFLICT_POLICY,
-  parseConfig as parseConfig2,
+  parseConfig as parseConfig3,
   buildOfflineSyncSnapshotFromBase,
-  OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
-  OFFLINE_SYNC_CHANGESET_FORMAT,
-  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2,
-  applyOfflineSyncFileContentChunk
+  applyOfflineSyncFileContentChunk,
+  isInternalRemnicStatePath as isInternalRemnicStatePath3,
+  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES3
 } from "@remnic/core";
+import { parseFrontmatter } from "@remnic/core/storage.js";
 import { resolveCorpusNamespaceRoots } from "@remnic/core/corpus-watermark.js";
 import { listNamespaces } from "@remnic/core/namespaces/migrate.js";
 import {
@@ -262,7 +290,8 @@ import {
   defaultConvergeCursorPath,
   deriveConvergeCursorBase,
   readConvergeCursor,
-  writeConvergeCursor
+  writeConvergeCursor,
+  normalizeConvergePeerUrl as normalizeConvergePeerUrl2
 } from "@remnic/core/reconcile/cursor.js";
 import {
   buildReconcileManifest,
@@ -271,7 +300,7 @@ import {
 
 // src/offline-storage-io.ts
 import { mkdtemp, readdir, lstat, rm } from "fs/promises";
-import fs2 from "fs";
+import fs3 from "fs";
 import path from "path";
 import { createHash, createDecipheriv } from "crypto";
 import {
@@ -337,6 +366,7 @@ async function createOfflineStorageIo(memoryDir, configuredStorage) {
   const { storage, secureStoreKey } = configuredStorage ?? await createConfiguredOfflineStorage(memoryDir);
   return {
     readFile: async ({ filePath }) => storage.readOfflineSyncFile(filePath),
+    readDeletionRevisions: () => storage.readDeletionRevisions(),
     readFileDigest: async ({ filePath }) => {
       const hash = createHash("sha256");
       let bytes = 0;
@@ -364,7 +394,8 @@ async function createOfflineStorageIo(memoryDir, configuredStorage) {
     writeFile: async ({ filePath, content }) => storage.writeOfflineSyncFile(filePath, content),
     writeStagingFile: async ({ filePath, content }) => storage.writeOfflineSyncStagingFile(filePath, content),
     writeFileChunks: async ({ filePath, chunks }) => storage.writeOfflineSyncFileChunks(filePath, chunks),
-    deleteFile: async ({ filePath }) => storage.deleteOfflineSyncFile(filePath)
+    deleteFile: async ({ filePath, mtimeMs }) => storage.deleteOfflineSyncFile(filePath, mtimeMs ?? null),
+    recordDeletionRevision: async ({ filePath, mtimeMs }) => storage.recordReplicatedDeletionRevision(filePath, mtimeMs)
   };
 }
 var OFFLINE_DECRYPT_STAGING_ORPHAN_MS = 60 * 60 * 1e3;
@@ -407,7 +438,7 @@ async function* readOfflineSyncFileChunks(options) {
   });
 }
 async function readFilePrefix(filePath, length) {
-  const handle = await fs2.promises.open(filePath, "r");
+  const handle = await fs3.promises.open(filePath, "r");
   try {
     const out = Buffer.alloc(length);
     const { bytesRead } = await handle.read(out, 0, length, 0);
@@ -417,7 +448,7 @@ async function readFilePrefix(filePath, length) {
   }
 }
 async function* readPlainOfflineFileChunks(filePath, chunkSize) {
-  const stream = fs2.createReadStream(filePath, { highWaterMark: chunkSize });
+  const stream = fs3.createReadStream(filePath, { highWaterMark: chunkSize });
   for await (const chunk of stream) {
     yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
   }
@@ -460,9 +491,9 @@ async function* readEncryptedOfflineFileChunks(options) {
       });
       decipher.setAuthTag(authTag);
       decipher.setAAD(Buffer.concat([secureStoreEnvelopeHeaderAad(salt), aad]));
-      const output = fs2.createWriteStream(tempPath, { mode: 384 });
+      const output = fs3.createWriteStream(tempPath, { mode: 384 });
       try {
-        const stream = fs2.createReadStream(options.filePath, {
+        const stream = fs3.createReadStream(options.filePath, {
           start: MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE,
           highWaterMark: options.chunkSize
         });
@@ -471,16 +502,16 @@ async function* readEncryptedOfflineFileChunks(options) {
             Buffer.isBuffer(encryptedChunk) ? encryptedChunk : Buffer.from(encryptedChunk)
           );
           if (plain.length > 0 && !output.write(plain)) {
-            await new Promise((resolve, reject) => {
-              output.once("drain", resolve);
+            await new Promise((resolve2, reject) => {
+              output.once("drain", resolve2);
               output.once("error", reject);
             });
           }
         }
         const finalPlain = decipher.final();
         if (finalPlain.length > 0 && !output.write(finalPlain)) {
-          await new Promise((resolve, reject) => {
-            output.once("drain", resolve);
+          await new Promise((resolve2, reject) => {
+            output.once("drain", resolve2);
             output.once("error", reject);
           });
         }
@@ -516,9 +547,9 @@ function offlineFileAadCandidates(filePath, memoryDir) {
   return candidates;
 }
 async function closeWriteStream(stream) {
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     stream.once("error", reject);
-    stream.end(() => resolve());
+    stream.end(() => resolve2());
   });
 }
 function secureStoreEnvelopeHeaderAad(salt) {
@@ -530,39 +561,215 @@ function secureStoreEnvelopeHeaderAad(salt) {
 
 // src/converge.ts
 import { resolveAgentAccessAuthToken } from "@remnic/core/resolve-auth-token.js";
-async function readLocalTombstones(rootDir) {
-  const shaSet = /* @__PURE__ */ new Set();
-  const candidates = [
-    path2.join(rootDir, "state", "tombstones.jsonl"),
-    path2.join(rootDir, "tombstones.jsonl")
-  ];
-  for (const tombPath of candidates) {
+
+// src/converge-peer-transport.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  isInternalRemnicStatePath as isInternalRemnicStatePath2,
+  OFFLINE_SYNC_CHANGESET_FORMAT,
+  OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
+  OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES as OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2
+} from "@remnic/core";
+import { normalizeConvergePeerUrl } from "@remnic/core/reconcile/cursor.js";
+
+// src/converge-peer-manifest.ts
+import { isInternalRemnicStatePath } from "@remnic/core";
+import {
+  RECONCILE_MANIFEST_FORMAT,
+  RECONCILE_MANIFEST_SCHEMA_VERSION
+} from "@remnic/core/reconcile/manifest.js";
+var SHA256_PATTERN = /^[a-f0-9]{64}$/i;
+var MEMORY_STATUSES = /* @__PURE__ */ new Set([
+  "active",
+  "pending_review",
+  "rejected",
+  "quarantined",
+  "superseded",
+  "archived",
+  "forgotten"
+]);
+var BODY_FIELDS = ["body", "content", "contentBase64", "rawContent"];
+function record(value, message) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(message);
+  return value;
+}
+function assertBodyFree(value, message) {
+  if (BODY_FIELDS.some((field) => field in value)) throw new Error(message);
+}
+function optionalNonNegativeNumber(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    throw new Error(`peer manifest file had invalid ${name}`);
+  }
+  return value;
+}
+function parseMemory(value) {
+  if (value === void 0) return void 0;
+  const memory = record(value, "peer manifest file had malformed memory metadata");
+  assertBodyFree(memory, "peer manifest memory metadata contained a raw body");
+  if (typeof memory.id !== "string" || memory.id.length === 0) {
+    throw new Error("peer manifest memory metadata had invalid id");
+  }
+  if (typeof memory.category !== "string" || memory.category.length === 0) {
+    throw new Error("peer manifest memory metadata had invalid category");
+  }
+  if (typeof memory.contentHash !== "string" || !SHA256_PATTERN.test(memory.contentHash)) {
+    throw new Error("peer manifest memory metadata had invalid contentHash");
+  }
+  if (typeof memory.status !== "string" || !MEMORY_STATUSES.has(memory.status)) {
+    throw new Error("peer manifest memory metadata had invalid status");
+  }
+  return {
+    id: memory.id,
+    category: memory.category,
+    contentHash: memory.contentHash.toLowerCase(),
+    status: memory.status
+  };
+}
+function parseFile(value) {
+  const file = record(value, "peer manifest row had malformed file metadata");
+  assertBodyFree(file, "peer manifest file row contained a raw body");
+  if (typeof file.path !== "string" || file.path.length === 0) {
+    throw new Error("peer manifest file had invalid path");
+  }
+  if (isInternalRemnicStatePath(file.path)) return void 0;
+  if (typeof file.sha256 !== "string" || !SHA256_PATTERN.test(file.sha256)) {
+    throw new Error("peer manifest file had invalid sha256");
+  }
+  const bytes = optionalNonNegativeNumber(file.bytes, "bytes");
+  const mtimeMs = optionalNonNegativeNumber(file.mtimeMs, "mtimeMs");
+  const memory = parseMemory(file.memory);
+  return {
+    path: file.path,
+    sha256: file.sha256.toLowerCase(),
+    ...bytes === void 0 ? {} : { bytes },
+    ...mtimeMs === void 0 ? {} : { mtimeMs },
+    ...memory === void 0 ? {} : { memory }
+  };
+}
+async function* responseLines(response) {
+  if (!response.body) throw new Error("peer manifest response had no body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let pending = "";
+  try {
+    for (; ; ) {
+      const { value, done } = await reader.read();
+      pending += decoder.decode(value, { stream: !done });
+      let newline = pending.indexOf("\n");
+      while (newline >= 0) {
+        const line = pending.slice(0, newline).replace(/\r$/, "");
+        pending = pending.slice(newline + 1);
+        if (line.trim().length > 0) yield line;
+        newline = pending.indexOf("\n");
+      }
+      if (done) break;
+    }
+    if (pending.trim().length > 0) yield pending.replace(/\r$/, "");
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function parsePeerManifestStream(response, expectedNamespace) {
+  let headerSeen = false;
+  const files = [];
+  for await (const line of responseLines(response)) {
+    let value;
     try {
-      const content = await fs3.promises.readFile(tombPath, "utf-8");
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const record = JSON.parse(trimmed);
-          if (typeof record.contentHash === "string" && /^[0-9a-f]{64}$/i.test(record.contentHash)) {
-            shaSet.add(record.contentHash.toLowerCase());
-          }
-          if (typeof record.fileSha256 === "string" && /^[0-9a-f]{64}$/i.test(record.fileSha256)) {
-            shaSet.add(record.fileSha256.toLowerCase());
-          }
-        } catch {
-        }
-      }
+      value = JSON.parse(line);
     } catch {
+      throw new Error(`invalid peer manifest for namespace ${expectedNamespace}: row was not JSON`);
     }
+    const row = record(value, `invalid peer manifest for namespace ${expectedNamespace}: row was not an object`);
+    assertBodyFree(row, `invalid peer manifest for namespace ${expectedNamespace}: row contained a raw body`);
+    if (!headerSeen) {
+      if (row.type !== "manifest" || row.namespace !== expectedNamespace || row.format !== RECONCILE_MANIFEST_FORMAT || row.schemaVersion !== RECONCILE_MANIFEST_SCHEMA_VERSION) {
+        throw new Error(`invalid peer manifest for namespace ${expectedNamespace}: malformed header`);
+      }
+      headerSeen = true;
+      continue;
+    }
+    if (row.type !== "file") {
+      throw new Error(`invalid peer manifest for namespace ${expectedNamespace}: malformed row type`);
+    }
+    const file = parseFile(row.file);
+    if (file) files.push(file);
   }
-  return shaSet;
+  if (!headerSeen) throw new Error(`invalid peer manifest for namespace ${expectedNamespace}: missing header`);
+  return {
+    format: RECONCILE_MANIFEST_FORMAT,
+    schemaVersion: RECONCILE_MANIFEST_SCHEMA_VERSION,
+    files
+  };
 }
-async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalThis.fetch) {
-  let base = peerUrl;
-  while (base.endsWith("/")) {
-    base = base.slice(0, -1);
+
+// src/converge-peer-transport.ts
+var DEFAULT_PEER_REQUEST_TIMEOUT_MS = 3e4;
+function normalizePeerBaseUrl(peerUrl) {
+  const normalized = normalizeConvergePeerUrl(peerUrl);
+  const url = new URL(normalized);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`unsupported peer URL protocol: ${url.protocol}`);
   }
+  return normalized;
+}
+function assertTransferablePeerPath(filePath) {
+  if (isInternalRemnicStatePath2(filePath)) {
+    throw new Error(`peer transport rejects internal Remnic state path: ${filePath}`);
+  }
+}
+async function fetchPeerRequest(fetchImpl, input, init, timeoutMs) {
+  const timeoutSignal = AbortSignal.timeout(timeoutMs);
+  const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+  return fetchImpl(input, { ...init, signal });
+}
+async function fetchPeerSyncCapabilities(peerUrl, token, fetchImpl, timeoutMs) {
+  const base = normalizePeerBaseUrl(peerUrl);
+  const headers = token ? { authorization: `Bearer ${token}` } : {};
+  const routes = [
+    "/remnic/v1/offline-sync/capabilities",
+    "/engram/v1/offline-sync/capabilities"
+  ];
+  for (const route of routes) {
+    const response = await fetchPeerRequest(fetchImpl, `${base}${route}`, { headers }, timeoutMs);
+    if (response.status === 404 || response.status === 405) continue;
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(`peer capability authentication failed: HTTP ${response.status}`);
+    }
+    if (!response.ok) {
+      throw new Error(`peer capability request failed: HTTP ${response.status}`);
+    }
+    const payload = await response.json().catch(() => null);
+    if (!payload || typeof payload !== "object" || !("convergenceFinalization" in payload) || typeof payload.convergenceFinalization !== "boolean" || !("manifestStream" in payload) || typeof payload.manifestStream !== "boolean") {
+      throw new Error("peer capability response was malformed");
+    }
+    return {
+      convergenceFinalization: payload.convergenceFinalization,
+      manifestStream: payload.manifestStream
+    };
+  }
+  return null;
+}
+async function fetchPeerManifestStream(peerUrl, namespace, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  const base = normalizePeerBaseUrl(peerUrl);
+  const headers = token ? { authorization: `Bearer ${token}` } : {};
+  const routes = [
+    `/remnic/v1/offline-sync/manifest-stream?namespace=${encodeURIComponent(namespace)}&include_transcripts=false`,
+    `/engram/v1/offline-sync/manifest-stream?namespace=${encodeURIComponent(namespace)}&include_transcripts=false`
+  ];
+  for (const route of routes) {
+    const response = await fetchPeerRequest(fetchImpl, `${base}${route}`, { headers }, timeoutMs);
+    if (response.status === 404 || response.status === 405) continue;
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(`peer manifest authentication failed: HTTP ${response.status}`);
+    }
+    if (!response.ok) throw new Error(`peer manifest request failed: HTTP ${response.status}`);
+    return parsePeerManifestStream(response, namespace);
+  }
+  return null;
+}
+async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  const base = normalizePeerBaseUrl(peerUrl);
   const routes = [
     `/remnic/v1/offline-sync/snapshot?namespace=${encodeURIComponent(namespace)}&content=false`,
     `/engram/v1/offline-sync/snapshot?namespace=${encodeURIComponent(namespace)}&content=false`
@@ -572,7 +779,7 @@ async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalTh
   for (const route of routes) {
     let response;
     try {
-      response = await fetchImpl(`${base}${route}`, { headers });
+      response = await fetchPeerRequest(fetchImpl, `${base}${route}`, { headers }, timeoutMs);
     } catch (error) {
       lastFailure = error instanceof Error ? error.message : String(error);
       continue;
@@ -600,7 +807,7 @@ async function fetchPeerSnapshot(peerUrl, namespace, token, fetchImpl = globalTh
         mtimeMs: "mtimeMs" in item && typeof item.mtimeMs === "number" ? item.mtimeMs : void 0,
         bytes: "bytes" in item && typeof item.bytes === "number" ? item.bytes : void 0
       };
-    });
+    }).filter((file) => !isInternalRemnicStatePath2(file.path));
     const rawTombstones = "tombstones" in data ? data.tombstones : void 0;
     if (rawTombstones !== void 0 && !Array.isArray(rawTombstones)) {
       throw new Error(`invalid peer snapshot for namespace ${namespace}: tombstones must be an array`);
@@ -624,8 +831,9 @@ function requiredResponseNumber(response, name) {
   }
   return value;
 }
-async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchImpl = globalThis.fetch) {
-  const base = peerUrl.replace(/\/+$/, "");
+async function streamPeerFileContent(peerUrl, namespace, filePath, onChunk, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  assertTransferablePeerPath(filePath);
+  const base = normalizePeerBaseUrl(peerUrl);
   const routes = [
     "/remnic/v1/offline-sync/file-content",
     "/engram/v1/offline-sync/file-content"
@@ -634,16 +842,17 @@ async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchIm
     "content-type": "application/json",
     ...token ? { authorization: `Bearer ${token}` } : {}
   };
+  const hash = createHash2("sha256");
+  let offset = 0;
+  let expectedBytes;
+  let expectedSha256;
+  let mtimeMs;
   for (const route of routes) {
-    try {
-      const chunks = [];
-      const hash = createHash2("sha256");
-      let offset = 0;
-      let expectedBytes;
-      let expectedSha256;
-      let mtimeMs;
-      do {
-        const response = await fetchImpl(`${base}${route}`, {
+    let routeFailed = false;
+    do {
+      let response;
+      try {
+        response = await fetchPeerRequest(fetchImpl, `${base}${route}`, {
           method: "POST",
           headers,
           body: JSON.stringify({
@@ -653,116 +862,148 @@ async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchIm
             offset,
             length: OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES
           })
-        });
+        }, timeoutMs);
         if (!response.ok) throw new Error(`offline file content request failed: ${response.status}`);
-        const content = Buffer.from(await response.arrayBuffer());
+      } catch {
+        routeFailed = true;
+        break;
+      }
+      let content;
+      let totalBytes;
+      let responseMtimeMs;
+      let sha256;
+      try {
+        content = Buffer.from(await response.arrayBuffer());
         const chunkOffset = requiredResponseNumber(response, "x-remnic-chunk-offset");
         const chunkBytes = requiredResponseNumber(response, "x-remnic-chunk-bytes");
-        const totalBytes = requiredResponseNumber(response, "x-remnic-file-bytes");
-        const responseMtimeMs = requiredResponseNumber(response, "x-remnic-file-mtime-ms");
-        const sha256 = response.headers.get("x-remnic-file-sha256");
+        totalBytes = requiredResponseNumber(response, "x-remnic-file-bytes");
+        responseMtimeMs = requiredResponseNumber(response, "x-remnic-file-mtime-ms");
+        sha256 = response.headers.get("x-remnic-file-sha256");
         const encodedPath = response.headers.get("x-remnic-file-path");
-        if (!sha256 || chunkOffset !== offset || chunkBytes !== content.length || encodedPath !== null && decodeURIComponent(encodedPath) !== filePath || expectedBytes !== void 0 && expectedBytes !== totalBytes || expectedSha256 !== void 0 && expectedSha256 !== sha256) {
+        if (!sha256 || chunkOffset !== offset || chunkBytes !== content.length || encodedPath !== null && decodeURIComponent(encodedPath) !== filePath || expectedBytes !== void 0 && expectedBytes !== totalBytes || expectedSha256 !== void 0 && expectedSha256 !== sha256 || content.length === 0 && offset < totalBytes) {
           throw new Error(`offline file content response changed during transfer: ${filePath}`);
         }
-        if (content.length === 0 && offset < totalBytes) {
-          throw new Error(`offline file content chunk was empty before EOF: ${filePath}`);
-        }
-        expectedBytes = totalBytes;
-        expectedSha256 = sha256;
-        mtimeMs = responseMtimeMs;
-        chunks.push(content);
-        hash.update(content);
-        offset += content.length;
-      } while (expectedBytes === void 0 || offset < expectedBytes);
-      if (expectedBytes === void 0 || expectedSha256 === void 0 || mtimeMs === void 0 || offset !== expectedBytes || hash.digest("hex") !== expectedSha256) {
-        throw new Error(`offline file content checksum mismatch: ${filePath}`);
+      } catch {
+        routeFailed = true;
+        break;
       }
-      return {
-        content: Buffer.concat(chunks, expectedBytes),
-        sha256: expectedSha256,
-        bytes: expectedBytes,
-        mtimeMs
-      };
-    } catch {
-    }
+      expectedBytes = totalBytes;
+      expectedSha256 = sha256;
+      mtimeMs = responseMtimeMs;
+      await onChunk({
+        content,
+        offset,
+        sha256,
+        bytes: totalBytes,
+        mtimeMs: responseMtimeMs
+      });
+      hash.update(content);
+      offset += content.length;
+    } while (expectedBytes === void 0 || offset < expectedBytes);
+    if (!routeFailed && expectedBytes !== void 0 && offset === expectedBytes) break;
   }
-  return null;
+  if (expectedBytes === void 0 || expectedSha256 === void 0 || mtimeMs === void 0 || offset !== expectedBytes || hash.digest("hex") !== expectedSha256) {
+    return null;
+  }
+  return { sha256: expectedSha256, bytes: expectedBytes, mtimeMs };
 }
-function withoutTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
-  return value.slice(0, end);
+async function fetchPeerFileContent(peerUrl, namespace, filePath, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  const chunks = [];
+  const metadata = await streamPeerFileContent(
+    peerUrl,
+    namespace,
+    filePath,
+    async (chunk) => {
+      chunks.push(chunk.content);
+    },
+    token,
+    fetchImpl,
+    timeoutMs
+  );
+  if (!metadata) return null;
+  return {
+    ...metadata,
+    content: Buffer.concat(chunks, metadata.bytes)
+  };
 }
-async function postPeerFileContent(peerUrl, namespace, filePath, content, metadata, token, fetchImpl = globalThis.fetch) {
-  const base = withoutTrailingSlashes(peerUrl);
+async function postPeerFileContent(peerUrl, namespace, filePath, source, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  assertTransferablePeerPath(filePath);
+  const base = normalizePeerBaseUrl(peerUrl);
   const routes = [
     `/remnic/v1/offline-sync/apply-file-content?namespace=${encodeURIComponent(namespace)}`,
     `/engram/v1/offline-sync/apply-file-content?namespace=${encodeURIComponent(namespace)}`
   ];
+  let offset = 0;
   let previousAttemptFailed = false;
   for (const route of routes) {
-    try {
-      let offset = 0;
-      do {
-        const chunk = content.subarray(
-          offset,
-          Math.min(content.length, offset + OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2)
-        );
-        const headers = {
-          "content-type": "application/octet-stream",
-          "x-remnic-include-transcripts": "false",
-          "x-remnic-source-id": encodeURIComponent("remnic-converge"),
-          "x-remnic-file-path": encodeURIComponent(filePath),
-          "x-remnic-file-sha256": metadata.sha256,
-          "x-remnic-file-bytes": String(content.length),
-          "x-remnic-file-mtime-ms": String(metadata.mtimeMs),
-          "x-remnic-chunk-offset": String(offset),
-          ...metadata.baseSha256 ? { "x-remnic-base-sha256": metadata.baseSha256 } : {},
-          ...token ? { authorization: `Bearer ${token}` } : {}
-        };
-        const response = await fetchImpl(`${base}${route}`, {
+    let restartedRoute = false;
+    while (offset < source.bytes || source.bytes === 0 && offset === 0) {
+      const length = Math.min(OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2, source.bytes - offset);
+      let chunk;
+      try {
+        chunk = await source.readChunk(offset, length);
+      } catch {
+        return false;
+      }
+      if (chunk.length !== length) return false;
+      const headers = {
+        "content-type": "application/octet-stream",
+        "x-remnic-include-transcripts": "false",
+        "x-remnic-source-id": encodeURIComponent("remnic-converge"),
+        "x-remnic-file-path": encodeURIComponent(filePath),
+        "x-remnic-file-sha256": source.sha256,
+        "x-remnic-file-bytes": String(source.bytes),
+        "x-remnic-file-mtime-ms": String(source.mtimeMs),
+        "x-remnic-chunk-offset": String(offset),
+        ...source.baseSha256 ? { "x-remnic-base-sha256": source.baseSha256 } : {},
+        ...token ? { authorization: `Bearer ${token}` } : {}
+      };
+      let response;
+      try {
+        response = await fetchPeerRequest(fetchImpl, `${base}${route}`, {
           method: "POST",
           headers,
           body: new Uint8Array(chunk)
-        });
+        }, timeoutMs);
         if (!response.ok) throw new Error(`offline apply-file-content request failed: ${response.status}`);
-        const result = await response.json().catch(() => null);
-        if (!result || typeof result !== "object" || !("done" in result) || typeof result.done !== "boolean" || !("applied" in result) || typeof result.applied !== "boolean" || !("skipped" in result) || typeof result.skipped !== "boolean" || "conflict" in result && result.conflict) {
-          return false;
-        }
-        if (result.done) {
-          if (result.skipped) return previousAttemptFailed ? "applied" : "skipped";
-          if (result.applied && offset + chunk.length === content.length) return "applied";
-          return false;
-        }
-        if (result.applied || result.skipped || chunk.length === 0) {
-          return false;
+      } catch {
+        if (previousAttemptFailed && offset > 0 && !restartedRoute) {
+          offset = 0;
+          restartedRoute = true;
+          continue;
         }
-        offset += chunk.length;
-      } while (offset < content.length);
-      return false;
-    } catch {
-      previousAttemptFailed = true;
+        previousAttemptFailed = true;
+        break;
+      }
+      const result = await response.json().catch(() => null);
+      if (!result || typeof result !== "object" || !("done" in result) || typeof result.done !== "boolean" || !("applied" in result) || typeof result.applied !== "boolean" || !("skipped" in result) || typeof result.skipped !== "boolean" || "conflict" in result && result.conflict) {
+        return false;
+      }
+      if (result.done) {
+        if (result.skipped) return previousAttemptFailed ? "applied" : "skipped";
+        return result.applied && offset + chunk.length === source.bytes ? "applied" : false;
+      }
+      if (result.applied || result.skipped || chunk.length === 0) return false;
+      offset += chunk.length;
     }
   }
   return false;
 }
-async function postPeerConvergenceComplete(peerUrl, namespaces, token, fetchImpl = globalThis.fetch) {
-  const base = withoutTrailingSlashes(peerUrl);
+async function postPeerConvergenceComplete(peerUrl, namespaces, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  const base = normalizePeerBaseUrl(peerUrl);
   const query = namespaces.map((namespace) => `namespace=${encodeURIComponent(namespace)}`).join("&");
   const routes = [
     "/remnic/v1/offline-sync/convergence-complete",
     "/engram/v1/offline-sync/convergence-complete"
   ];
   for (const route of routes) {
-    const response = await fetchImpl(`${base}${route}?${query}`, {
+    const response = await fetchPeerRequest(fetchImpl, `${base}${route}?${query}`, {
       method: "POST",
       headers: {
         "x-remnic-source-id": encodeURIComponent("remnic-converge"),
         ...token ? { authorization: `Bearer ${token}` } : {}
       }
-    }).catch(() => null);
+    }, timeoutMs).catch(() => null);
     if (!response?.ok) continue;
     const result = await response.json().catch(() => null);
     if (result && typeof result === "object" && "namespaces" in result && Array.isArray(result.namespaces) && result.namespaces.length === namespaces.length && result.namespaces.every((namespace, index) => namespace === namespaces[index]) && "refreshed" in result && result.refreshed === true) {
@@ -771,8 +1012,9 @@ async function postPeerConvergenceComplete(peerUrl, namespaces, token, fetchImpl
   }
   return false;
 }
-async function postPeerFileDeletion(peerUrl, namespace, filePath, baseSha256, token, fetchImpl = globalThis.fetch) {
-  const base = withoutTrailingSlashes(peerUrl);
+async function postPeerFileDeletion(peerUrl, namespace, filePath, baseSha256, token, fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PEER_REQUEST_TIMEOUT_MS) {
+  assertTransferablePeerPath(filePath);
+  const base = normalizePeerBaseUrl(peerUrl);
   const routes = ["/remnic/v1/offline-sync/apply", "/engram/v1/offline-sync/apply"];
   const headers = {
     "content-type": "application/json",
@@ -781,7 +1023,7 @@ async function postPeerFileDeletion(peerUrl, namespace, filePath, baseSha256, to
   let previousAttemptFailed = false;
   for (const route of routes) {
     try {
-      const response = await fetchImpl(`${base}${route}`, {
+      const response = await fetchPeerRequest(fetchImpl, `${base}${route}`, {
         method: "POST",
         headers,
         body: JSON.stringify({
@@ -795,7 +1037,7 @@ async function postPeerFileDeletion(peerUrl, namespace, filePath, baseSha256, to
             changes: [{ type: "delete", path: filePath, baseSha256 }]
           }
         })
-      });
+      }, timeoutMs);
       if (!response.ok) throw new Error(`offline apply request failed: ${response.status}`);
       const result = await response.json().catch(() => null);
       if (!result || typeof result !== "object" || !("appliedDeletes" in result) || typeof result.appliedDeletes !== "number" || !("skipped" in result) || typeof result.skipped !== "number" || !("conflicts" in result) || !Array.isArray(result.conflicts) || result.conflicts.length > 0) {
@@ -810,6 +1052,73 @@ async function postPeerFileDeletion(peerUrl, namespace, filePath, baseSha256, to
   }
   return false;
 }
+
+// src/converge.ts
+var TOMBSTONE_PATHS = ["state/tombstones.jsonl", "tombstones.jsonl"];
+function parseTombstoneEvidence(content) {
+  const contentHashes = /* @__PURE__ */ new Set();
+  const fileSha256 = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const record2 = JSON.parse(trimmed);
+      if (typeof record2.contentHash === "string" && /^[0-9a-f]{64}$/i.test(record2.contentHash)) {
+        contentHashes.add(record2.contentHash.toLowerCase());
+      }
+      if (typeof record2.fileSha256 === "string" && /^[0-9a-f]{64}$/i.test(record2.fileSha256)) {
+        fileSha256.add(record2.fileSha256.toLowerCase());
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { contentHashes, fileSha256 };
+}
+function tombstonedFileDigests(evidence, manifest) {
+  const result = new Set(evidence.fileSha256);
+  for (const file of manifest?.files ?? []) {
+    if (file.memory && evidence.contentHashes.has(file.memory.contentHash.toLowerCase())) {
+      result.add(file.sha256.toLowerCase());
+    }
+  }
+  return result;
+}
+async function readLocalTombstoneEvidence(rootDir) {
+  const merged = { contentHashes: /* @__PURE__ */ new Set(), fileSha256: /* @__PURE__ */ new Set() };
+  for (const relativePath of TOMBSTONE_PATHS) {
+    let content;
+    try {
+      content = await fs4.promises.readFile(path2.join(rootDir, relativePath), "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    const parsed = parseTombstoneEvidence(content);
+    for (const value of parsed.contentHashes) merged.contentHashes.add(value);
+    for (const value of parsed.fileSha256) merged.fileSha256.add(value);
+  }
+  return merged;
+}
+async function discoverCursorNamespaces(memoryDir, peerUrl) {
+  const cursorDir = path2.join(path2.resolve(memoryDir), ".remnic", "state", "converge-cursors");
+  let entries;
+  try {
+    entries = await fs4.promises.readdir(cursorDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const cursor = await readConvergeCursor(path2.join(cursorDir, entry.name));
+    if (!cursor) throw new Error(`invalid converge cursor: ${entry.name}`);
+    if (path2.basename(defaultConvergeCursorPath(memoryDir, peerUrl, cursor.namespace)) !== entry.name) continue;
+    namespaces.add(cursor.namespace);
+  }
+  return [...namespaces].sort();
+}
 async function computeConvergePlan(options = {}) {
   const baseMap = /* @__PURE__ */ new Map();
   const semanticAgreementMap = /* @__PURE__ */ new Map();
@@ -825,7 +1134,7 @@ async function computeConvergePlan(options = {}) {
   if (options.baseFilesByNamespace) {
     for (const [ns, files] of options.baseFilesByNamespace) {
       namespacesToPlan.add(ns);
-      baseMap.set(ns, files);
+      baseMap.set(ns, files.filter((file) => !isInternalRemnicStatePath3(file.path)));
     }
   }
   if (options.semanticAgreementsByNamespace) {
@@ -837,7 +1146,7 @@ async function computeConvergePlan(options = {}) {
   if (options.localFilesByNamespace) {
     for (const [ns, files] of options.localFilesByNamespace) {
       namespacesToPlan.add(ns);
-      localMap.set(ns, files);
+      localMap.set(ns, files.filter((file) => !isInternalRemnicStatePath3(file.path)));
     }
   }
   if (options.localTombstonesByNamespace) {
@@ -854,7 +1163,7 @@ async function computeConvergePlan(options = {}) {
   if (options.peerFilesByNamespace) {
     for (const [ns, files] of options.peerFilesByNamespace) {
       namespacesToPlan.add(ns);
-      peerMap.set(ns, files);
+      peerMap.set(ns, files.filter((file) => !isInternalRemnicStatePath3(file.path)));
     }
   }
   if (options.peerTombstonesByNamespace) {
@@ -871,10 +1180,11 @@ async function computeConvergePlan(options = {}) {
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig2({});
+      config = parseConfig3({});
     } catch {
     }
   }
+  const memoryDir = options.cursorDir ?? config?.memoryDir;
   if (!options.localFilesByNamespace && config) {
     const roots = await resolveCorpusNamespaceRoots({ config });
     const discovered = await listNamespaces({ config });
@@ -884,47 +1194,55 @@ async function computeConvergePlan(options = {}) {
     for (const rootInfo of roots) {
       const ns = rootInfo.namespace;
       namespacesToPlan.add(ns);
-      try {
-        const snapshot = await buildOfflineSyncSnapshotFromBase({
-          root: rootInfo.rootDir,
-          sourceId: "local",
-          includeContent: false
-        });
-        const files = snapshot.files.map((record) => ({
-          path: record.path,
-          sha256: record.sha256,
-          mtimeMs: record.mtimeMs,
-          bytes: record.bytes
-        }));
-        localMap.set(ns, files);
-        try {
-          const io = await createOfflineStorageIo(rootInfo.rootDir);
-          localManifests.set(
-            ns,
-            await buildReconcileManifest({
-              files,
-              readFile: async (file) => {
-                const readFile2 = io.readFile;
-                if (!readFile2) throw new Error("offline storage cannot read reconciliation manifest files");
-                return await readFile2({
-                  root: rootInfo.rootDir,
-                  path: file.path,
-                  filePath: path2.join(rootInfo.rootDir, file.path)
-                });
-              }
-            })
-          );
-        } catch {
-          localManifests.delete(ns);
+      const snapshot = await buildOfflineSyncSnapshotFromBase({
+        root: rootInfo.rootDir,
+        sourceId: "local",
+        includeContent: false
+      });
+      const files = snapshot.files.filter((record2) => !isInternalRemnicStatePath3(record2.path)).map((record2) => ({
+        path: record2.path,
+        sha256: record2.sha256,
+        mtimeMs: record2.mtimeMs,
+        bytes: record2.bytes
+      }));
+      localMap.set(ns, files);
+      const evidence = await readLocalTombstoneEvidence(rootInfo.rootDir);
+      const io = await createOfflineStorageIo(rootInfo.rootDir);
+      let manifestReadFailed = false;
+      const manifest = await buildReconcileManifest({
+        files,
+        parseMemory: parseFrontmatter,
+        readFile: async (file) => {
+          const readFile2 = io.readFile;
+          if (!readFile2) {
+            manifestReadFailed = true;
+            throw new Error("offline storage cannot read reconciliation manifest files");
+          }
+          try {
+            return await readFile2({
+              root: rootInfo.rootDir,
+              path: file.path,
+              filePath: path2.join(rootInfo.rootDir, file.path)
+            });
+          } catch (error) {
+            manifestReadFailed = true;
+            throw error;
+          }
         }
-        const tombstones = await readLocalTombstones(rootInfo.rootDir);
-        localTombstones.set(ns, tombstones);
-      } catch {
-        localMap.set(ns, []);
+      });
+      if (manifestReadFailed) {
+        throw new Error(`failed to build local reconciliation manifest for namespace ${ns}`);
       }
+      localManifests.set(ns, manifest);
+      localTombstones.set(ns, tombstonedFileDigests(evidence, manifest));
     }
   }
   const peerUrl = options.peerUrl;
+  if (memoryDir && peerUrl) {
+    for (const namespace of await discoverCursorNamespaces(memoryDir, peerUrl)) {
+      namespacesToPlan.add(namespace);
+    }
+  }
   if (!options.peerFilesByNamespace && peerUrl) {
     let resolvedToken;
     if (options.peerToken) {
@@ -937,36 +1255,84 @@ async function computeConvergePlan(options = {}) {
       }
     }
     const fetchFn = options.fetchImpl ?? globalThis.fetch;
+    const timeoutMs = options.peerRequestTimeoutMs ?? DEFAULT_PEER_REQUEST_TIMEOUT_MS;
+    const capabilities = await fetchPeerSyncCapabilities(
+      peerUrl,
+      resolvedToken,
+      fetchFn,
+      timeoutMs
+    );
     for (const ns of namespacesToPlan) {
-      const peerData = await fetchPeerSnapshot(peerUrl, ns, resolvedToken, fetchFn);
-      peerMap.set(ns, peerData.files);
-      peerTombstones.set(ns, peerData.tombstones);
-      peerManifests.set(
-        ns,
-        await buildReconcileManifest({
-          files: peerData.files,
+      const peerData = await fetchPeerSnapshot(peerUrl, ns, resolvedToken, fetchFn, timeoutMs);
+      const streamedManifest = capabilities?.manifestStream ? await fetchPeerManifestStream(peerUrl, ns, resolvedToken, fetchFn, timeoutMs) : null;
+      const peerFiles = streamedManifest?.files ?? peerData.files;
+      peerMap.set(ns, peerFiles);
+      let peerManifest = streamedManifest;
+      if (!peerManifest) {
+        let readFailure;
+        peerManifest = await buildReconcileManifest({
+          files: peerFiles,
+          parseMemory: parseFrontmatter,
           cachedFiles: localManifests.get(ns)?.files,
           readFile: async (file) => {
-            const remote = await fetchPeerFileContent(peerUrl, ns, file.path, resolvedToken, fetchFn);
+            let remote;
+            try {
+              remote = await fetchPeerFileContent(peerUrl, ns, file.path, resolvedToken, fetchFn, timeoutMs);
+            } catch (error) {
+              readFailure = error instanceof Error ? error : new Error(String(error));
+              throw readFailure;
+            }
             if (!remote || remote.sha256 !== file.sha256) {
-              throw new Error(`failed to read peer reconciliation manifest file: ${file.path}`);
+              readFailure = new Error(`failed to read peer reconciliation manifest file: ${file.path}`);
+              throw readFailure;
             }
             return remote.content;
           }
-        })
-      );
+        });
+        if (readFailure) throw readFailure;
+      }
+      peerManifests.set(ns, peerManifest);
+      const evidence = { contentHashes: /* @__PURE__ */ new Set(), fileSha256: /* @__PURE__ */ new Set() };
+      for (const tombstonePath of TOMBSTONE_PATHS) {
+        const state = peerFiles.find((file) => file.path === tombstonePath);
+        if (!state) continue;
+        const remote = await fetchPeerFileContent(
+          peerUrl,
+          ns,
+          tombstonePath,
+          resolvedToken,
+          fetchFn,
+          timeoutMs
+        );
+        if (!remote || remote.sha256.toLowerCase() !== state.sha256.toLowerCase()) {
+          throw new Error(`failed to read peer tombstone evidence: ${tombstonePath}`);
+        }
+        const parsed = parseTombstoneEvidence(remote.content.toString("utf8"));
+        for (const value of parsed.contentHashes) evidence.contentHashes.add(value);
+        for (const value of parsed.fileSha256) evidence.fileSha256.add(value);
+      }
+      const mapped = tombstonedFileDigests(evidence, peerManifests.get(ns));
+      for (const digest of peerData.tombstones) mapped.add(digest);
+      peerTombstones.set(ns, mapped);
     }
   }
-  const memoryDir = options.cursorDir ?? config?.memoryDir;
   if (memoryDir && options.peerUrl && (!options.baseFilesByNamespace || !options.semanticAgreementsByNamespace)) {
     for (const ns of namespacesToPlan) {
       const cursorPath = defaultConvergeCursorPath(memoryDir, options.peerUrl, ns);
       const cursor = await readConvergeCursor(cursorPath);
       if (!options.baseFilesByNamespace && cursor?.baseFiles && cursor.baseFiles.length > 0) {
-        baseMap.set(ns, cursor.baseFiles);
+        baseMap.set(
+          ns,
+          cursor.baseFiles.filter((file) => !isInternalRemnicStatePath3(file.path))
+        );
       }
       if (!options.semanticAgreementsByNamespace && cursor?.semanticAgreements && cursor.semanticAgreements.length > 0) {
-        semanticAgreementMap.set(ns, cursor.semanticAgreements);
+        semanticAgreementMap.set(
+          ns,
+          cursor.semanticAgreements.filter(
+            (agreement) => !isInternalRemnicStatePath3(agreement.local.path) && !isInternalRemnicStatePath3(agreement.peer.path)
+          )
+        );
       }
     }
   }
@@ -1030,7 +1396,7 @@ async function executeConvergeApply(options = {}) {
   }
   if (options.dryRun) {
     return {
-      converged: false,
+      converged: plan.converged,
       status: "dry_run",
       plan,
       transfers: plannedTransfers,
@@ -1056,10 +1422,11 @@ async function executeConvergeApply(options = {}) {
     }
   }
   const fetchFn = options.fetchImpl ?? globalThis.fetch;
+  const timeoutMs = options.peerRequestTimeoutMs ?? DEFAULT_PEER_REQUEST_TIMEOUT_MS;
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig2({});
+      config = parseConfig3({});
     } catch {
     }
   }
@@ -1089,134 +1456,202 @@ async function executeConvergeApply(options = {}) {
         transferType = entry.localSha256 ? "push" : "delete-peer";
       }
     }
+    const localPath = entry.semanticAgreement?.local.path ?? entry.path;
+    const peerPath = entry.semanticAgreement?.peer.path ?? entry.path;
     if (transferType === "pull") {
-      let remoteFile = null;
-      const buffered = options.peerFileBuffers?.get(entry.namespace)?.get(entry.path);
+      const buffered = options.peerFileBuffers?.get(entry.namespace)?.get(peerPath);
+      if (options.localFileBuffers) {
+        let remoteFile = null;
+        if (buffered) {
+          const state = options.peerFilesByNamespace?.get(entry.namespace)?.find((file) => file.path === peerPath);
+          remoteFile = {
+            content: buffered,
+            sha256: state?.sha256 ?? entry.peerSha256 ?? createHash3("sha256").update(buffered).digest("hex"),
+            bytes: buffered.length,
+            mtimeMs: state?.mtimeMs ?? 0
+          };
+        } else if (options.peerUrl) {
+          remoteFile = await fetchPeerFileContent(
+            options.peerUrl,
+            entry.namespace,
+            peerPath,
+            resolvedToken,
+            fetchFn,
+            timeoutMs
+          );
+        }
+        if (!remoteFile || entry.peerSha256 && remoteFile.sha256 !== entry.peerSha256) {
+          actualTransfers.failed += 1;
+          continue;
+        }
+        let namespaceFiles = options.localFileBuffers.get(entry.namespace);
+        if (!namespaceFiles) {
+          namespaceFiles = /* @__PURE__ */ new Map();
+          options.localFileBuffers.set(entry.namespace, namespaceFiles);
+        }
+        namespaceFiles.set(localPath, remoteFile.content);
+        if (entry.action === "conflict") actualTransfers.conflictsResolved += 1;
+        else actualTransfers.pulled += 1;
+        continue;
+      }
+      const rootDir = rootMap.get(entry.namespace);
+      if (!rootDir) {
+        actualTransfers.failed += 1;
+        continue;
+      }
+      const io = await createOfflineStorageIo(rootDir);
+      const expectedLocalSha256 = entry.action === "conflict" ? entry.localSha256 : entry.baseSha256;
+      let transferComplete = false;
+      let transferRejected = false;
+      const applyChunk = async (chunk) => {
+        if (transferRejected) return;
+        if (entry.peerSha256 && chunk.sha256 !== entry.peerSha256) {
+          transferRejected = true;
+          return;
+        }
+        const chunkResult = await applyOfflineSyncFileContentChunk({
+          root: rootDir,
+          sourceId: "remnic-converge",
+          path: localPath,
+          sha256: chunk.sha256,
+          bytes: chunk.bytes,
+          mtimeMs: chunk.mtimeMs,
+          offset: chunk.offset,
+          content: chunk.content,
+          ...expectedLocalSha256 ? { baseSha256: expectedLocalSha256 } : {},
+          readFile: io.readFile,
+          readFileDigest: io.readFileDigest,
+          writeFile: io.writeFile,
+          writeStagingFile: io.writeStagingFile,
+          writeFileChunks: io.writeFileChunks
+        });
+        if (chunkResult.conflict) {
+          transferRejected = true;
+        } else if (chunkResult.done) {
+          transferComplete = chunkResult.applied || chunkResult.skipped;
+        } else if (chunkResult.applied || chunkResult.skipped || chunk.content.length === 0) {
+          transferRejected = true;
+        }
+      };
+      let metadata = null;
       if (buffered) {
-        const state = options.peerFilesByNamespace?.get(entry.namespace)?.find((file) => file.path === entry.path);
-        remoteFile = {
-          content: buffered,
-          sha256: state?.sha256 ?? entry.peerSha256 ?? createHash2("sha256").update(buffered).digest("hex"),
-          bytes: buffered.length,
-          mtimeMs: state?.mtimeMs ?? 0
-        };
+        const state = options.peerFilesByNamespace?.get(entry.namespace)?.find((file) => file.path === peerPath);
+        const sha256 = state?.sha256 ?? entry.peerSha256 ?? createHash3("sha256").update(buffered).digest("hex");
+        const bytes = buffered.length;
+        const mtimeMs = state?.mtimeMs ?? 0;
+        let offset = 0;
+        do {
+          const content = buffered.subarray(
+            offset,
+            Math.min(bytes, offset + OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES3)
+          );
+          await applyChunk({ content, offset, sha256, bytes, mtimeMs });
+          offset += content.length;
+        } while (!transferRejected && !transferComplete && offset < bytes);
+        metadata = { sha256, bytes, mtimeMs };
       } else if (options.peerUrl) {
-        remoteFile = await fetchPeerFileContent(
+        metadata = await streamPeerFileContent(
           options.peerUrl,
           entry.namespace,
-          entry.path,
+          peerPath,
+          applyChunk,
           resolvedToken,
-          fetchFn
+          fetchFn,
+          timeoutMs
         );
       }
-      if (remoteFile !== null && (!entry.peerSha256 || remoteFile.sha256 === entry.peerSha256)) {
-        if (options.localFileBuffers) {
-          let nsMap = options.localFileBuffers.get(entry.namespace);
-          if (!nsMap) {
-            nsMap = /* @__PURE__ */ new Map();
-            options.localFileBuffers.set(entry.namespace, nsMap);
-          }
-          nsMap.set(entry.path, remoteFile.content);
-          if (entry.action === "conflict") actualTransfers.conflictsResolved += 1;
-          else actualTransfers.pulled += 1;
-        } else {
-          const rootDir = rootMap.get(entry.namespace);
-          if (rootDir) {
-            const io = await createOfflineStorageIo(rootDir);
-            const expectedLocalSha256 = entry.action === "conflict" ? entry.localSha256 : entry.baseSha256;
-            let offset = 0;
-            let transferComplete = false;
-            do {
-              const chunk = remoteFile.content.subarray(
-                offset,
-                Math.min(
-                  remoteFile.content.length,
-                  offset + OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES2
-                )
-              );
-              const chunkResult = await applyOfflineSyncFileContentChunk({
-                root: rootDir,
-                sourceId: "remnic-converge",
-                path: entry.path,
-                sha256: remoteFile.sha256,
-                bytes: remoteFile.bytes,
-                mtimeMs: remoteFile.mtimeMs,
-                offset,
-                content: chunk,
-                ...expectedLocalSha256 ? { baseSha256: expectedLocalSha256 } : {},
-                readFile: io.readFile,
-                readFileDigest: io.readFileDigest,
-                writeFile: io.writeFile,
-                writeStagingFile: io.writeStagingFile,
-                writeFileChunks: io.writeFileChunks
-              });
-              if (chunkResult.conflict) {
-                break;
-              }
-              if (chunkResult.done) {
-                transferComplete = chunkResult.applied || chunkResult.skipped;
-                break;
-              }
-              if (chunkResult.applied || chunkResult.skipped || chunk.length === 0) {
-                break;
-              }
-              offset += chunk.length;
-            } while (offset < remoteFile.content.length);
-            if (transferComplete) {
-              if (entry.action === "conflict") actualTransfers.conflictsResolved += 1;
-              else actualTransfers.pulled += 1;
-            } else {
-              actualTransfers.failed += 1;
-            }
-          } else {
-            actualTransfers.failed += 1;
-          }
-        }
+      if (metadata && transferComplete && !transferRejected && (!entry.peerSha256 || metadata.sha256 === entry.peerSha256)) {
+        if (entry.action === "conflict") actualTransfers.conflictsResolved += 1;
+        else actualTransfers.pulled += 1;
       } else {
         actualTransfers.failed += 1;
       }
     } else if (transferType === "push") {
-      let content = null;
-      let mtimeMs = options.localFilesByNamespace?.get(entry.namespace)?.find((file) => file.path === entry.path)?.mtimeMs;
-      if (options.localFileBuffers?.get(entry.namespace)?.has(entry.path)) {
-        content = options.localFileBuffers.get(entry.namespace).get(entry.path);
-      } else {
+      const localBuffer = options.localFileBuffers?.get(entry.namespace)?.get(localPath);
+      let source = null;
+      let closeSource;
+      const expectedPeerSha256 = entry.action === "conflict" ? entry.peerSha256 : entry.baseSha256;
+      if (localBuffer && entry.localSha256) {
+        source = {
+          sha256: entry.localSha256,
+          bytes: localBuffer.length,
+          mtimeMs: options.localFilesByNamespace?.get(entry.namespace)?.find((file) => file.path === localPath)?.mtimeMs ?? 0,
+          ...expectedPeerSha256 ? { baseSha256: expectedPeerSha256 } : {},
+          readChunk: async (offset, length) => localBuffer.subarray(offset, offset + length)
+        };
+      } else if (entry.localSha256) {
         const rootDir = rootMap.get(entry.namespace);
         if (rootDir) {
-          const filePath = path2.join(rootDir, entry.path);
           try {
+            const filePath = path2.join(rootDir, localPath);
             const io = await createOfflineStorageIo(rootDir);
-            content = await io.readFile({ root: rootDir, path: entry.path, filePath });
-            mtimeMs ??= (await fs3.promises.stat(filePath)).mtimeMs;
+            const current = await io.readFileDigest({ root: rootDir, path: localPath, filePath });
+            if (current.sha256 !== entry.localSha256) {
+              throw new Error(`local file changed during push: ${localPath}`);
+            }
+            const stat = await fs4.promises.stat(filePath);
+            let chunks;
+            let chunkOffset = 0;
+            const resetChunks = async () => {
+              await chunks?.return?.();
+              chunks = io.readFileChunks({
+                root: rootDir,
+                path: localPath,
+                filePath,
+                chunkSize: OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES3
+              })[Symbol.asyncIterator]();
+              chunkOffset = 0;
+            };
+            closeSource = async () => {
+              await chunks?.return?.();
+            };
+            source = {
+              sha256: entry.localSha256,
+              bytes: current.bytes,
+              mtimeMs: stat.mtimeMs,
+              ...expectedPeerSha256 ? { baseSha256: expectedPeerSha256 } : {},
+              readChunk: async (offset, length) => {
+                if (!chunks || offset < chunkOffset) await resetChunks();
+                while (chunkOffset < offset) {
+                  const skipped = await chunks.next();
+                  if (skipped.done || chunkOffset + skipped.value.length > offset) {
+                    throw new Error(`cannot resume local file upload at offset ${offset}: ${localPath}`);
+                  }
+                  chunkOffset += skipped.value.length;
+                }
+                const next = await chunks.next();
+                if (next.done) return Buffer.alloc(0);
+                if (next.value.length > length) {
+                  throw new Error(`local file chunk exceeds requested length: ${localPath}`);
+                }
+                chunkOffset += next.value.length;
+                return next.value;
+              }
+            };
           } catch {
-            content = null;
+            source = null;
           }
         }
       }
-      if (content !== null) {
-        if (options.peerFileBuffers) {
-          let nsMap = options.peerFileBuffers.get(entry.namespace);
-          if (!nsMap) {
-            nsMap = /* @__PURE__ */ new Map();
-            options.peerFileBuffers.set(entry.namespace, nsMap);
+      try {
+        if (options.peerFileBuffers && localBuffer) {
+          let namespaceFiles = options.peerFileBuffers.get(entry.namespace);
+          if (!namespaceFiles) {
+            namespaceFiles = /* @__PURE__ */ new Map();
+            options.peerFileBuffers.set(entry.namespace, namespaceFiles);
           }
-          nsMap.set(entry.path, content);
+          namespaceFiles.set(peerPath, localBuffer);
           if (entry.action === "conflict") actualTransfers.conflictsResolved += 1;
           else actualTransfers.pushed += 1;
-        } else if (options.peerUrl && entry.localSha256) {
-          const expectedPeerSha256 = entry.action === "conflict" ? entry.peerSha256 : entry.baseSha256;
+        } else if (options.peerUrl && source) {
           const applied = await postPeerFileContent(
             options.peerUrl,
             entry.namespace,
-            entry.path,
-            content,
-            {
-              sha256: entry.localSha256,
-              mtimeMs: mtimeMs ?? 0,
-              ...expectedPeerSha256 ? { baseSha256: expectedPeerSha256 } : {}
-            },
+            peerPath,
+            source,
             resolvedToken,
-            fetchFn
+            fetchFn,
+            timeoutMs
           );
           if (applied) {
             if (applied === "applied") peerMutatedNamespaces.add(entry.namespace);
@@ -1228,16 +1663,16 @@ async function executeConvergeApply(options = {}) {
         } else {
           actualTransfers.failed += 1;
         }
-      } else {
-        actualTransfers.failed += 1;
+      } finally {
+        await closeSource?.();
       }
     } else if (transferType === "delete-local") {
       let deleted = false;
       const bufferedFiles = options.localFileBuffers?.get(entry.namespace);
       if (options.localFileBuffers) {
-        const current = bufferedFiles?.get(entry.path);
-        if (current && entry.localSha256 && createHash2("sha256").update(current).digest("hex") === entry.localSha256) {
-          bufferedFiles.delete(entry.path);
+        const current = bufferedFiles?.get(localPath);
+        if (current && entry.localSha256 && createHash3("sha256").update(current).digest("hex") === entry.localSha256) {
+          bufferedFiles.delete(localPath);
           deleted = true;
         }
       } else {
@@ -1245,10 +1680,10 @@ async function executeConvergeApply(options = {}) {
         if (rootDir && entry.localSha256) {
           try {
             const io = await createOfflineStorageIo(rootDir);
-            const filePath = path2.join(rootDir, entry.path);
-            const current = await io.readFileDigest({ root: rootDir, path: entry.path, filePath });
+            const filePath = path2.join(rootDir, localPath);
+            const current = await io.readFileDigest({ root: rootDir, path: localPath, filePath });
             if (current.sha256 === entry.localSha256) {
-              await io.deleteFile({ root: rootDir, path: entry.path, filePath });
+              await io.deleteFile({ root: rootDir, path: localPath, filePath });
               deleted = true;
             }
           } catch {
@@ -1262,19 +1697,20 @@ async function executeConvergeApply(options = {}) {
       let deleted = false;
       const bufferedFiles = options.peerFileBuffers?.get(entry.namespace);
       if (options.peerFileBuffers) {
-        const current = bufferedFiles?.get(entry.path);
-        if (current && entry.peerSha256 && createHash2("sha256").update(current).digest("hex") === entry.peerSha256) {
-          bufferedFiles.delete(entry.path);
+        const current = bufferedFiles?.get(peerPath);
+        if (current && entry.peerSha256 && createHash3("sha256").update(current).digest("hex") === entry.peerSha256) {
+          bufferedFiles.delete(peerPath);
           deleted = true;
         }
       } else if (options.peerUrl && entry.peerSha256) {
         const deletionResult = await postPeerFileDeletion(
           options.peerUrl,
           entry.namespace,
-          entry.path,
+          peerPath,
           entry.peerSha256,
           resolvedToken,
-          fetchFn
+          fetchFn,
+          timeoutMs
         );
         deleted = Boolean(deletionResult);
         if (deletionResult === "applied") peerMutatedNamespaces.add(entry.namespace);
@@ -1282,7 +1718,60 @@ async function executeConvergeApply(options = {}) {
       if (deleted) actualTransfers.conflictsResolved += 1;
       else actualTransfers.failed += 1;
     } else if (transferType === "suppress") {
-      actualTransfers.suppressed += 1;
+      let suppressed = entry.suppressSide !== void 0;
+      if (entry.suppressSide === "local" || entry.suppressSide === "both") {
+        let deletedLocal = false;
+        if (entry.localSha256 && options.localFileBuffers) {
+          const files = options.localFileBuffers.get(entry.namespace);
+          const current = files?.get(localPath);
+          if (current && createHash3("sha256").update(current).digest("hex") === entry.localSha256) {
+            files.delete(localPath);
+            deletedLocal = true;
+          }
+        } else if (entry.localSha256) {
+          const rootDir = rootMap.get(entry.namespace);
+          if (rootDir) {
+            try {
+              const io = await createOfflineStorageIo(rootDir);
+              const filePath = path2.join(rootDir, localPath);
+              const current = await io.readFileDigest({ root: rootDir, path: localPath, filePath });
+              if (current.sha256 === entry.localSha256) {
+                await io.deleteFile({ root: rootDir, path: localPath, filePath });
+                deletedLocal = true;
+              }
+            } catch {
+              deletedLocal = false;
+            }
+          }
+        }
+        suppressed &&= deletedLocal;
+      }
+      if (entry.suppressSide === "peer" || entry.suppressSide === "both") {
+        let deletedPeer = false;
+        if (entry.peerSha256 && options.peerFileBuffers) {
+          const files = options.peerFileBuffers.get(entry.namespace);
+          const current = files?.get(peerPath);
+          if (current && createHash3("sha256").update(current).digest("hex") === entry.peerSha256) {
+            files.delete(peerPath);
+            deletedPeer = true;
+          }
+        } else if (entry.peerSha256 && options.peerUrl) {
+          const result = await postPeerFileDeletion(
+            options.peerUrl,
+            entry.namespace,
+            peerPath,
+            entry.peerSha256,
+            resolvedToken,
+            fetchFn,
+            timeoutMs
+          );
+          deletedPeer = Boolean(result);
+          if (result === "applied") peerMutatedNamespaces.add(entry.namespace);
+        }
+        suppressed &&= deletedPeer;
+      }
+      if (suppressed) actualTransfers.suppressed += 1;
+      else actualTransfers.failed += 1;
     }
   }
   if (options.peerUrl && peerMutatedNamespaces.size > 0) {
@@ -1291,7 +1780,8 @@ async function executeConvergeApply(options = {}) {
       options.peerUrl,
       namespaces,
       resolvedToken,
-      fetchFn
+      fetchFn,
+      timeoutMs
     )) {
       actualTransfers.failed += 1;
     }
@@ -1310,7 +1800,7 @@ async function executeConvergeApply(options = {}) {
   };
 }
 async function updateCursorsForPlan(plan, options) {
-  const peerUrl = options.peerUrl ?? "local";
+  const peerUrl = normalizeConvergePeerUrl2(options.peerUrl ?? "local");
   let memoryDir;
   if (options.cursorDir) {
     memoryDir = options.cursorDir;
@@ -1376,7 +1866,7 @@ function formatConvergeApplyReport(result) {
   lines.push(formatConvergeReport(result.plan));
   return lines.join("\n");
 }
-async function cmdConverge(action, rest, json, config = parseConfig2({})) {
+async function cmdConverge(action, rest, json, config = parseConfig3({})) {
   if (action === "help" || action === "--help" || action === "-h" || rest.includes("--help") || rest.includes("-h")) {
     console.log(`Usage: remnic converge <plan|apply> [options]
 
@@ -1483,14 +1973,14 @@ function buildNamespacePolicyCheck(args) {
 import { WriteQuarantineStore as WriteQuarantineStore2 } from "@remnic/core/write-quarantine.js";
 
 // src/quarantine-cli.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 function renderQuarantineList(records, format) {
   if (format === "json") {
-    const summary = records.map((record) => ({
-      timestamp: record.timestamp,
-      operation: record.operation,
-      principal: record.principal,
-      attemptedNamespace: record.attemptedNamespace
+    const summary = records.map((record2) => ({
+      timestamp: record2.timestamp,
+      operation: record2.operation,
+      principal: record2.principal,
+      attemptedNamespace: record2.attemptedNamespace
     }));
     return JSON.stringify(summary, null, 2);
   }
@@ -1499,9 +1989,9 @@ function renderQuarantineList(records, format) {
   }
   if (records.length === 0) return "No quarantined writes.";
   const lines = [`Quarantined writes (${records.length}):`, ""];
-  for (const record of records) {
+  for (const record2 of records) {
     lines.push(
-      `  ${record.timestamp}  ${record.operation}  principal=${record.principal ?? "-"}  attemptedNamespace=${record.attemptedNamespace}`
+      `  ${record2.timestamp}  ${record2.operation}  principal=${record2.principal ?? "-"}  attemptedNamespace=${record2.attemptedNamespace}`
     );
   }
   return lines.join("\n");
@@ -1509,10 +1999,10 @@ function renderQuarantineList(records, format) {
 async function replayQuarantine(opts) {
   const result = { replayed: 0, failures: [], deleteFailures: [] };
   for (const entry of await opts.store.entries()) {
-    const { record } = entry;
-    const basePayload = record.payload;
-    const principal = opts.principal ?? record.principal ?? void 0;
-    const idempotencyKey = typeof basePayload.idempotencyKey === "string" && basePayload.idempotencyKey.length > 0 ? basePayload.idempotencyKey : `quarantine-replay:${basename(entry.path)}`;
+    const { record: record2 } = entry;
+    const basePayload = record2.payload;
+    const principal = opts.principal ?? record2.principal ?? void 0;
+    const idempotencyKey = typeof basePayload.idempotencyKey === "string" && basePayload.idempotencyKey.length > 0 ? basePayload.idempotencyKey : `quarantine-replay:${basename2(entry.path)}`;
     const request = {
       ...basePayload,
       namespace: opts.targetNamespace,
@@ -1521,10 +2011,10 @@ async function replayQuarantine(opts) {
       ...principal ? { authenticatedPrincipal: principal } : {}
     };
     try {
-      await opts.submit(record.operation, request);
+      await opts.submit(record2.operation, request);
     } catch (err) {
       result.failures.push({
-        operation: record.operation,
+        operation: record2.operation,
         attemptedNamespace: opts.targetNamespace,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -1582,8 +2072,8 @@ function renderReplayResult(result, targetNamespace, format) {
 }
 
 // src/quarantine-replay.ts
-import * as fs4 from "fs";
-import { EngramAccessService, Orchestrator as Orchestrator2, initLogger, parseConfig as parseConfig3, resolveRemnicConfigRecord as resolveRemnicConfigRecord2 } from "@remnic/core";
+import * as fs5 from "fs";
+import { EngramAccessService, Orchestrator as Orchestrator2, initLogger, parseConfig as parseConfig4, resolveRemnicConfigRecord as resolveRemnicConfigRecord3 } from "@remnic/core";
 import { WriteQuarantineStore } from "@remnic/core/write-quarantine.js";
 function valueFlag(args, flag) {
   const occurrences = args.filter((a) => a === flag).length;
@@ -1631,8 +2121,8 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
   let orchestrator;
   try {
     const configPath = resolveConfigPath2();
-    const raw = fs4.existsSync(configPath) ? JSON.parse(fs4.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig3(resolveRemnicConfigRecord2(raw));
+    const raw = fs5.existsSync(configPath) ? JSON.parse(fs5.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig4(resolveRemnicConfigRecord3(raw));
     orchestrator = new Orchestrator2(config);
     await orchestrator.initialize();
     await orchestrator.deferredReady;
@@ -1663,15 +2153,15 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
 }
 
 // src/offline-impression-rotation.ts
-import fs5 from "fs";
-import { parseConfig as parseConfig4, resolveRemnicConfigRecord as resolveRemnicConfigRecord3, drainPendingImpressionsForOfflineSync } from "@remnic/core";
+import fs6 from "fs";
+import { parseConfig as parseConfig5, resolveRemnicConfigRecord as resolveRemnicConfigRecord4, drainPendingImpressionsForOfflineSync } from "@remnic/core";
 import { LastRecallStore } from "@remnic/core/recall-state";
 function parseConfigQuietly(raw) {
   const originalWarn = console.warn;
   console.warn = () => {
   };
   try {
-    return parseConfig4(resolveRemnicConfigRecord3(raw));
+    return parseConfig5(resolveRemnicConfigRecord4(raw));
   } finally {
     console.warn = originalWarn;
   }
@@ -1685,7 +2175,7 @@ var OFFLINE_CONFIG_KEYS = [
 function pickOfflineConfigRecord(raw) {
   let resolved;
   try {
-    resolved = resolveRemnicConfigRecord3(raw);
+    resolved = resolveRemnicConfigRecord4(raw);
   } catch {
     resolved = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   }
@@ -1698,7 +2188,7 @@ function pickOfflineConfigRecord(raw) {
 function resolveOfflineImpressionRotation(configPath) {
   let raw;
   try {
-    raw = fs5.existsSync(configPath) ? JSON.parse(fs5.readFileSync(configPath, "utf8")) : {};
+    raw = fs6.existsSync(configPath) ? JSON.parse(fs6.readFileSync(configPath, "utf8")) : {};
   } catch {
     throw new Error(
       `cannot read recall-impression rotation from ${configPath}: config file could not be read as JSON`
@@ -1956,7 +2446,7 @@ function assertBenchModuleFreshForDevelopment() {
 }
 
 // src/daemon-service-candidates.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path5 from "path";
 var LAUNCHD_LABEL = "ai.remnic.daemon";
 var LEGACY_REMNIC_SERVER_LAUNCHD_LABEL = "ai.remnic.server";
@@ -1978,7 +2468,7 @@ function systemdUnitPaths(homeDir) {
 function anyFileExists(paths) {
   return paths.some((candidate) => {
     try {
-      return fs6.statSync(candidate).isFile();
+      return fs7.statSync(candidate).isFile();
     } catch {
       return false;
     }
@@ -1990,7 +2480,7 @@ function commandNames(command) {
 }
 function isRunnableNodeScript(filePath) {
   try {
-    const text = fs6.readFileSync(filePath, "utf8").slice(0, 4096);
+    const text = fs7.readFileSync(filePath, "utf8").slice(0, 4096);
     const firstLine = text.split(/\r?\n/, 1)[0] ?? "";
     if (/^#!.*\bnode\b/.test(firstLine)) return true;
     if (firstLine.startsWith("#!")) return false;
@@ -2003,7 +2493,7 @@ function isRunnableNodeScript(filePath) {
 function resolveShimNodeScript(filePath) {
   let text;
   try {
-    text = fs6.readFileSync(filePath, "utf8").slice(0, 16384);
+    text = fs7.readFileSync(filePath, "utf8").slice(0, 16384);
   } catch {
     return void 0;
   }
@@ -2015,8 +2505,8 @@ function resolveShimNodeScript(filePath) {
     const candidate = raw.replaceAll("${basedir}", basedir).replaceAll("$basedir", basedir).replaceAll("\\ ", " ");
     const resolved = path5.isAbsolute(candidate) ? candidate : path5.resolve(basedir, candidate);
     try {
-      if (fs6.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
-        return fs6.realpathSync(resolved);
+      if (fs7.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
+        return fs7.realpathSync(resolved);
       }
     } catch {
     }
@@ -2024,7 +2514,7 @@ function resolveShimNodeScript(filePath) {
   return void 0;
 }
 function resolveRunnableNodeScript(filePath) {
-  const realPath = fs6.realpathSync(filePath);
+  const realPath = fs7.realpathSync(filePath);
   if (isRunnableNodeScript(realPath)) return realPath;
   return resolveShimNodeScript(realPath);
 }
@@ -2034,9 +2524,9 @@ function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
     for (const name of commandNames(command)) {
       const candidate = path5.join(dir, name);
       try {
-        const stat = fs6.statSync(candidate);
+        const stat = fs7.statSync(candidate);
         if (!stat.isFile()) continue;
-        if (process.platform !== "win32") fs6.accessSync(candidate, fs6.constants.X_OK);
+        if (process.platform !== "win32") fs7.accessSync(candidate, fs7.constants.X_OK);
         const runnable = resolveRunnableNodeScript(candidate);
         if (runnable) return runnable;
       } catch {
@@ -2161,6 +2651,8 @@ var BENCH_VALUE_FLAGS = Object.freeze([
   "--memcorrect-adapter",
   "--run",
   "--memory-dir",
+  "--qmd",
+  "--collection",
   "--users",
   "--epochs",
   "--facts-per-epoch",
@@ -2342,7 +2834,7 @@ var BENCH_ACTION_FLAGS = {
     legacyEqualsPrefixes: ["--baseline=", "--report="]
   },
   attribute: {
-    value: ["--run", "--results-dir", "--memory-dir", "--threshold"],
+    value: ["--run", "--results-dir", "--memory-dir", "--threshold", "--qmd", "--collection"],
     boolean: ["--json", "--help", "-h"]
   },
   "drift-gen": {
@@ -2475,6 +2967,14 @@ function parseBenchResearchArgs(action, args) {
     throw new Error("ERROR: bench attribute requires --run <id>.");
   }
   const memoryDirRaw = readBenchOptionValue(args, "--memory-dir");
+  const qmdPathRaw = readBenchOptionValue(args, "--qmd");
+  const collection = readBenchOptionValue(args, "--collection");
+  if (action === "attribute" && Boolean(qmdPathRaw) !== Boolean(collection)) {
+    throw new Error("ERROR: --qmd <path> and --collection <name> must be provided together.");
+  }
+  if (collection !== void 0 && collection.trim().length === 0) {
+    throw new Error("ERROR: --collection requires a non-empty value.");
+  }
   let seed;
   let out;
   if (action === "drift-gen") {
@@ -2503,6 +3003,8 @@ function parseBenchResearchArgs(action, args) {
   return {
     runRef,
     memoryDir: memoryDirRaw ? path6.resolve(expandTilde(memoryDirRaw)) : void 0,
+    qmdPath: qmdPathRaw ? path6.resolve(expandTilde(qmdPathRaw)) : void 0,
+    collection,
     users: readPositiveInteger(args, "--users"),
     epochs,
     seed,
@@ -3493,7 +3995,7 @@ function finalizeBenchStatus(filePath) {
 }
 
 // src/bench-fallback.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path9 from "path";
 var FALLBACK_RESULTS_DIRNAME = "fallback-runs";
 function buildBenchRunnerArgs(parsed, benchmarkId, outputDir) {
@@ -3565,7 +4067,7 @@ function createFallbackBenchOutputDir(resultsDir, benchmarkId, pid, startedAtMs
   );
 }
 function resolveFallbackBenchResultPath(outputDir) {
-  const entries = fs7.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+  const entries = fs8.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
   if (entries.length === 0) {
     throw new Error(`Fallback benchmark runner did not write a JSON result artifact in ${outputDir}`);
   }
@@ -3573,7 +4075,7 @@ function resolveFallbackBenchResultPath(outputDir) {
 }
 
 // src/openclaw-upgrade-swap.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path10 from "path";
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -3585,7 +4087,7 @@ function createSiblingTempFilePath(targetPath, label) {
 function resolveAtomicWriteMode(targetPath, explicitMode) {
   if (explicitMode !== void 0) return explicitMode;
   try {
-    return fs8.statSync(targetPath).mode & 4095;
+    return fs9.statSync(targetPath).mode & 4095;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return 384;
@@ -3595,8 +4097,8 @@ function resolveAtomicWriteMode(targetPath, explicitMode) {
 }
 function resolveAtomicReplacementPath(targetPath) {
   try {
-    if (fs8.lstatSync(targetPath).isSymbolicLink()) {
-      return fs8.realpathSync(targetPath);
+    if (fs9.lstatSync(targetPath).isSymbolicLink()) {
+      return fs9.realpathSync(targetPath);
     }
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -3613,7 +4115,7 @@ function createSiblingSwapPath(targetDir, label) {
 function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
   if (!displacedDir) return void 0;
   try {
-    fs8.rmSync(displacedDir, { recursive: true, force: true });
+    fs9.rmSync(displacedDir, { recursive: true, force: true });
     return void 0;
   } catch (error) {
     return `Warning: ${context}, but failed to remove the displaced plugin copy at ${displacedDir}: ${describeError(error)}`;
@@ -3621,55 +4123,55 @@ function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
 }
 function atomicWriteFileSync(targetPath, data, options = {}) {
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs8.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
+  fs9.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "write");
   const mode = resolveAtomicWriteMode(resolvedTargetPath, options.mode);
   try {
     if (options.hooks?.writeTempFileSync) {
       options.hooks.writeTempFileSync(tempPath);
     } else {
-      fs8.writeFileSync(tempPath, data, { mode });
+      fs9.writeFileSync(tempPath, data, { mode });
     }
-    fs8.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs8.renameSync;
+    fs9.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs9.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs8.rmSync(tempPath, { force: true });
+    fs9.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function atomicCopyFileSync(sourcePath, targetPath, options = {}) {
-  if (!fs8.existsSync(sourcePath)) return;
+  if (!fs9.existsSync(sourcePath)) return;
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs8.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
+  fs9.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "copy");
-  const mode = fs8.statSync(sourcePath).mode & 4095;
+  const mode = fs9.statSync(sourcePath).mode & 4095;
   try {
-    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs8.copyFileSync;
+    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs9.copyFileSync;
     copyTempFileSync(sourcePath, tempPath);
-    fs8.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs8.renameSync;
+    fs9.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs9.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs8.rmSync(tempPath, { force: true });
+    fs9.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function swapDirectoryWithRollback(stagedDir, targetDir, rollbackDir) {
   let hasRollbackCopy = false;
-  fs8.mkdirSync(path10.dirname(targetDir), { recursive: true });
-  fs8.rmSync(rollbackDir, { recursive: true, force: true });
-  if (fs8.existsSync(targetDir)) {
-    fs8.renameSync(targetDir, rollbackDir);
+  fs9.mkdirSync(path10.dirname(targetDir), { recursive: true });
+  fs9.rmSync(rollbackDir, { recursive: true, force: true });
+  if (fs9.existsSync(targetDir)) {
+    fs9.renameSync(targetDir, rollbackDir);
     hasRollbackCopy = true;
   }
   try {
-    fs8.renameSync(stagedDir, targetDir);
+    fs9.renameSync(stagedDir, targetDir);
   } catch (swapError) {
-    fs8.rmSync(targetDir, { recursive: true, force: true });
-    if (hasRollbackCopy && fs8.existsSync(rollbackDir)) {
+    fs9.rmSync(targetDir, { recursive: true, force: true });
+    if (hasRollbackCopy && fs9.existsSync(rollbackDir)) {
       try {
-        fs8.renameSync(rollbackDir, targetDir);
+        fs9.renameSync(rollbackDir, targetDir);
         hasRollbackCopy = false;
       } catch (restoreError) {
         throw new AggregateError(
@@ -3684,7 +4186,7 @@ function swapDirectoryWithRollback(stagedDir, targetDir, rollbackDir) {
 }
 function cleanupRollbackDirectory(rollbackDir) {
   if (!rollbackDir) return;
-  fs8.rmSync(rollbackDir, { recursive: true, force: true });
+  fs9.rmSync(rollbackDir, { recursive: true, force: true });
 }
 function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   if (!rollbackDir) return void 0;
@@ -3696,20 +4198,20 @@ function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   }
 }
 function restoreDirectoryFromRollback(targetDir, rollbackDir) {
-  if (!fs8.existsSync(rollbackDir)) {
+  if (!fs9.existsSync(rollbackDir)) {
     throw new Error(`Rollback directory is missing: ${rollbackDir}`);
   }
-  fs8.mkdirSync(path10.dirname(targetDir), { recursive: true });
-  const displacedDir = fs8.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
+  fs9.mkdirSync(path10.dirname(targetDir), { recursive: true });
+  const displacedDir = fs9.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
   if (displacedDir) {
-    fs8.renameSync(targetDir, displacedDir);
+    fs9.renameSync(targetDir, displacedDir);
   }
   try {
-    fs8.renameSync(rollbackDir, targetDir);
+    fs9.renameSync(rollbackDir, targetDir);
   } catch (restoreError) {
-    if (displacedDir && fs8.existsSync(displacedDir)) {
+    if (displacedDir && fs9.existsSync(displacedDir)) {
       try {
-        fs8.renameSync(displacedDir, targetDir);
+        fs9.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -3728,23 +4230,23 @@ function restoreDirectoryFromRollback(targetDir, rollbackDir) {
   );
 }
 function restoreDirectoryFromBackup(targetDir, backupDir) {
-  if (!fs8.existsSync(backupDir)) {
+  if (!fs9.existsSync(backupDir)) {
     throw new Error(`Plugin backup directory is missing: ${backupDir}`);
   }
-  fs8.mkdirSync(path10.dirname(targetDir), { recursive: true });
+  fs9.mkdirSync(path10.dirname(targetDir), { recursive: true });
   const stagedDir = createSiblingSwapPath(targetDir, "backup-restore");
-  const displacedDir = fs8.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
-  fs8.cpSync(backupDir, stagedDir, { recursive: true });
+  const displacedDir = fs9.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
+  fs9.cpSync(backupDir, stagedDir, { recursive: true });
   if (displacedDir) {
-    fs8.renameSync(targetDir, displacedDir);
+    fs9.renameSync(targetDir, displacedDir);
   }
   try {
-    fs8.renameSync(stagedDir, targetDir);
+    fs9.renameSync(stagedDir, targetDir);
   } catch (restoreError) {
-    fs8.rmSync(targetDir, { recursive: true, force: true });
-    if (displacedDir && fs8.existsSync(displacedDir)) {
+    fs9.rmSync(targetDir, { recursive: true, force: true });
+    if (displacedDir && fs9.existsSync(displacedDir)) {
       try {
-        fs8.renameSync(displacedDir, targetDir);
+        fs9.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -3752,7 +4254,7 @@ function restoreDirectoryFromBackup(targetDir, backupDir) {
         );
       }
     }
-    fs8.rmSync(stagedDir, { recursive: true, force: true });
+    fs9.rmSync(stagedDir, { recursive: true, force: true });
     throw new Error(
       `Failed to restore the plugin backup into ${targetDir}. The durable backup remains preserved at ${backupDir}.`,
       { cause: restoreError }
@@ -3778,7 +4280,7 @@ function rollbackOpenclawUpgrade({
   let rollbackRestoreError;
   let pluginRestored = false;
   try {
-    if (rollbackDir && fs8.existsSync(rollbackDir)) {
+    if (rollbackDir && fs9.existsSync(rollbackDir)) {
       const cleanupWarning = restoreDirectoryFromRollback(pluginDir, rollbackDir);
       notes.push(`Restored previous plugin from rollback copy at ${rollbackDir}`);
       if (cleanupWarning) notes.push(cleanupWarning);
@@ -3788,7 +4290,7 @@ function rollbackOpenclawUpgrade({
     rollbackRestoreError = error instanceof Error ? error.message : String(error);
   }
   try {
-    if (!pluginRestored && pluginBackupDir && fs8.existsSync(pluginBackupDir)) {
+    if (!pluginRestored && pluginBackupDir && fs9.existsSync(pluginBackupDir)) {
       const cleanupWarning = restoreDirectoryFromBackup(pluginDir, pluginBackupDir);
       if (rollbackRestoreError) {
         notes.push(
@@ -3815,7 +4317,7 @@ function rollbackOpenclawUpgrade({
     notes.push("No previous plugin copy was available for automatic restore");
   }
   try {
-    if (configBackupPath && fs8.existsSync(configBackupPath)) {
+    if (configBackupPath && fs9.existsSync(configBackupPath)) {
       restoreFileFromBackup(configPath, configBackupPath);
       notes.push(`Restored OpenClaw config from backup at ${configBackupPath}`);
     }
@@ -3855,7 +4357,7 @@ Run this manually when you're ready:
 }
 
 // src/daemon-service.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path11 from "path";
 import * as childProcess from "child_process";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -3867,7 +4369,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs9.existsSync;
+  const existsSync4 = options.existsSync ?? fs10.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -3926,8 +4428,8 @@ function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync4 = options.readFileSync ?? fs9.readFileSync;
-  const unlinkSync = options.unlinkSync ?? fs9.unlinkSync;
+  const readFileSync4 = options.readFileSync ?? fs10.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs10.unlinkSync;
   const processKill = options.processKill ?? process.kill;
   const platform = options.platform ?? process.platform;
   const execFileSync3 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
@@ -4027,8 +4529,8 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs9.existsSync;
-  const readFileSync4 = options.readFileSync ?? fs9.readFileSync;
+  const existsSync4 = options.existsSync ?? fs10.existsSync;
+  const readFileSync4 = options.readFileSync ?? fs10.readFileSync;
   if (!existsSync4(plistPath)) {
     return {
       installed: false,
@@ -4262,7 +4764,7 @@ function stripConfigArgv(args) {
 }
 
 // src/import-dispatch.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import {
   runImporter,
   validateImportBatchSize,
@@ -4776,7 +5278,7 @@ async function cmdImport(rest, targetFactory, disposeTarget, ioOverrides = {}) {
   let materializedTarget;
   let materializePromise;
   const io = {
-    readFile: ioOverrides.readFile ?? (async (p) => fs10.promises.readFile(p, "utf-8")),
+    readFile: ioOverrides.readFile ?? (async (p) => fs11.promises.readFile(p, "utf-8")),
     loadAdapter: ioOverrides.loadAdapter ?? (async (name) => (await loadImporterModule(name)).adapter),
     runImporter: ioOverrides.runImporter ?? runImporter,
     getWriteTarget: async () => {
@@ -4889,7 +5391,7 @@ async function cmdCapture(rest, io) {
 }
 
 // src/import-lossless-claw-cmd.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path13 from "path";
 import {
   applyLcmSchema,
@@ -5001,15 +5503,15 @@ async function loadImportLosslessClawModule() {
 
 // src/import-lossless-claw-cmd.ts
 function assertDirectoryOrAbsent(p, label) {
-  if (fs11.existsSync(p) && !fs11.statSync(p).isDirectory()) {
+  if (fs12.existsSync(p) && !fs12.statSync(p).isDirectory()) {
     throw new Error(`${label} is not a directory: ${p}`);
   }
 }
 function assertFile(p, label) {
-  if (!fs11.existsSync(p)) {
+  if (!fs12.existsSync(p)) {
     throw new Error(`${label} does not exist: ${p}`);
   }
-  if (!fs11.statSync(p).isFile()) {
+  if (!fs12.statSync(p).isFile()) {
     throw new Error(`${label} is not a file: ${p}`);
   }
 }
@@ -5041,7 +5543,7 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     try {
       if (parsed.dryRun) {
         const lcmPath = path13.join(memoryDir, "state", "lcm.sqlite");
-        if (fs11.existsSync(lcmPath)) {
+        if (fs12.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
           destDb = mod.openInMemoryDestinationDatabase();
@@ -5179,6 +5681,8 @@ async function runBenchResearchCommand(parsed) {
         runRef: parsed.runRef,
         resultsDir: parsed.resultsDir ?? path14.join(resolveHomeDir(), ".remnic", "bench", "results"),
         memoryDir: parsed.memoryDir,
+        qmdPath: parsed.qmdPath,
+        collection: parsed.collection,
         threshold: parsed.threshold,
         json: parsed.json
       })
@@ -5242,7 +5746,9 @@ Commands:
                            subsequent local artifacts carry the kappa + warning.
   check                    Legacy latency regression gate (compatibility)
   attribute --run <id> [--results-dir <path>] [--memory-dir <path>] [--threshold <value>]
-                           Attribute operation-level benchmark failures to memory operations
+                           [--qmd <path> --collection <name>]
+                           Attribute failures from stored witnesses by default; paired QMD flags enable
+                           explicit live fallback for legacy runs without witnesses
   drift-gen [generate|validate <dir>] [--users <n>] [--epochs <n>] [--seed <n>]
                            [--out <dir>] [--facts-per-epoch <n>] [--drifting-ratio <r>]
                            [--contradicted-ratio <r>]
@@ -5349,6 +5855,8 @@ Options:
   --json                   Output JSON for \`list\`
   --run <id>               Benchmark run reference for attribute
   --memory-dir <path>      Memory directory for failure attribution
+  --qmd <path>            QMD executable for explicit legacy attribution fallback
+  --collection <name>     QMD collection paired with --qmd; never inferred or defaulted
   --users <n>              Synthetic user count for drift-gen
   --epochs <n>             Synthetic timeline epochs for drift-gen
   --facts-per-epoch <n>    Facts generated per user per epoch for drift-gen
@@ -5384,6 +5892,7 @@ Examples:
   remnic bench run --custom ./my-bench.yaml
   remnic bench procedural-ablation --out ./artifacts/procedural-ablation.json
   remnic bench attribute --run run-12345 --memory-dir ./memories
+  remnic bench attribute --run legacy-run --memory-dir ./memories --qmd /opt/qmd --collection memories
   remnic bench drift-gen generate --users 20 --epochs 10 --out ./corpus
   remnic bench drift-gen validate ./corpus
   remnic benchmark run --quick longmemeval`;
@@ -5605,7 +6114,7 @@ async function resolveAllBenchmarks() {
   if (packageBenchmarks) {
     return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
   }
-  if (!fs12.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs13.existsSync(EVAL_RUNNER_PATH)) {
     return [];
   }
   return BENCHMARK_CATALOG.filter((entry) => entry.category !== "ingestion").map((entry) => entry.id);
@@ -5653,7 +6162,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
       `Fallback benchmark runner does not support provider-backed, gateway, or thinking/timeout flags (${unsupportedOptions.join(", ")}). Build/install @remnic/bench to use those options.`
     );
   }
-  if (!fs12.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs13.existsSync(EVAL_RUNNER_PATH)) {
     console.error(
       "Benchmark runner not found. Expected eval runner at evals/run.ts or a phase-1 @remnic/bench runtime export."
     );
@@ -5663,7 +6172,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
     path15.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
     path15.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
   ];
-  const tsxCmd = tsxCandidates.find((candidate) => fs12.existsSync(candidate)) ?? "tsx";
+  const tsxCmd = tsxCandidates.find((candidate) => fs13.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
     parsed.resultsDir ?? resolveBenchOutputDir(),
     benchmarkId,
@@ -5808,9 +6317,9 @@ var PERSONAMEM_COMPLETION_MARKER = path15.join(
 );
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
-    const datasetRoot = fs12.realpathSync(datasetPath);
+    const datasetRoot = fs13.realpathSync(datasetPath);
     const candidatePath = path15.resolve(datasetRoot, relativePath);
-    const candidateRealPath = fs12.realpathSync(candidatePath);
+    const candidateRealPath = fs13.realpathSync(candidatePath);
     const relativeToRoot = path15.relative(datasetRoot, candidateRealPath);
     if (relativeToRoot.startsWith("..") || path15.isAbsolute(relativeToRoot)) {
       return null;
@@ -5869,14 +6378,14 @@ function parseCsvRows(raw) {
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
     const completionMarkerPath = path15.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
-    if (fs12.statSync(completionMarkerPath).isFile()) {
+    if (fs13.statSync(completionMarkerPath).isFile()) {
       return true;
     }
   } catch {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs12.statSync(path15.join(datasetPath, candidate)).isFile();
+      return fs13.statSync(path15.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -5885,7 +6394,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs12.readFileSync(path15.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs13.readFileSync(path15.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -5900,7 +6409,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     }
     return historyPaths.every((relativePath) => {
       const resolvedPath = resolveRealpathWithinDataset(datasetPath, relativePath);
-      return resolvedPath !== null && fs12.statSync(resolvedPath).isFile();
+      return resolvedPath !== null && fs13.statSync(resolvedPath).isFile();
     });
   } catch {
     return false;
@@ -5908,7 +6417,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs12.statSync(path15.join(datasetPath, relativePath)).isFile();
+    return fs13.statSync(path15.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
@@ -5928,10 +6437,10 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
   return candidateFilenames.some((filename) => {
     const filePath = path15.join(datasetPath, filename);
     try {
-      if (!fs12.statSync(filePath).isFile()) {
+      if (!fs13.statSync(filePath).isFile()) {
         return false;
       }
-      const raw = fs12.readFileSync(filePath, "utf8");
+      const raw = fs13.readFileSync(filePath, "utf8");
       return /"source"\s*:\s*"recsys[_-]/i.test(raw);
     } catch {
       return false;
@@ -5947,7 +6456,7 @@ function isMemoryAgentBenchDatasetComplete(datasetPath) {
 function isDatasetDownloaded(datasetPath, benchmarkId) {
   let stats;
   try {
-    stats = fs12.statSync(datasetPath);
+    stats = fs13.statSync(datasetPath);
   } catch {
     return false;
   }
@@ -5957,7 +6466,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
   if (!marker) {
     try {
-      return fs12.readdirSync(datasetPath).length > 0;
+      return fs13.readdirSync(datasetPath).length > 0;
     } catch {
       return false;
     }
@@ -5965,7 +6474,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs12.statSync(path15.join(datasetPath, name)).isFile();
+        return fs13.statSync(path15.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -5977,7 +6486,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs12.statSync(path15.join(datasetPath, name)).isFile();
+        return fs13.statSync(path15.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -5995,7 +6504,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   }
   if (marker.ext) {
     try {
-      return fs12.readdirSync(datasetPath).some(
+      return fs13.readdirSync(datasetPath).some(
         (name) => name.endsWith(marker.ext) && !marker.exclude?.includes(name)
       );
     } catch {
@@ -6007,7 +6516,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
 async function launchBenchUi(resultsDir) {
   const benchUiDir = path15.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs12.existsSync(path15.join(benchUiDir, "package.json"))) {
+  if (!fs13.existsSync(path15.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -6022,11 +6531,11 @@ async function launchBenchUi(resultsDir) {
       REMNIC_BENCH_RESULTS_DIR: resultsDir
     }
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     child.on("error", reject);
     child.on("close", (code, signal) => {
       if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
-        resolve();
+        resolve2();
         return;
       }
       reject(new Error(`bench UI exited with code ${code ?? "unknown"}`));
@@ -6045,13 +6554,13 @@ function listDownloadableBenchmarks() {
 }
 function resolveDatasetDownloadScriptPath() {
   const bundled = path15.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
-  if (fs12.existsSync(bundled)) {
+  if (fs13.existsSync(bundled)) {
     return bundled;
   }
   return path15.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs12.existsSync(path15.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs12.existsSync(path15.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs13.existsSync(path15.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs13.existsSync(path15.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -6364,8 +6873,8 @@ async function exportBenchPackageResult(parsed) {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs12.mkdirSync(path15.dirname(parsed.output), { recursive: true });
-    fs12.writeFileSync(parsed.output, rendered);
+    fs13.mkdirSync(path15.dirname(parsed.output), { recursive: true });
+    fs13.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
   }
@@ -6410,7 +6919,7 @@ async function manageBenchDatasets(parsed) {
     process.exit(1);
   }
   const scriptPath = resolveDatasetDownloadScriptPath();
-  if (!fs12.existsSync(scriptPath)) {
+  if (!fs13.existsSync(scriptPath)) {
     console.error(`ERROR: dataset download script not found: ${scriptPath}`);
     process.exit(1);
   }
@@ -6610,7 +7119,7 @@ async function calibrateBenchJudges(parsed, rawArgs) {
     );
     process.exit(1);
   }
-  const sourceResultSha256 = createHash3("sha256").update(fs12.readFileSync(latest.path)).digest("hex");
+  const sourceResultSha256 = createHash4("sha256").update(fs13.readFileSync(latest.path)).digest("hex");
   const expandedManifestPath = expandTilde(manifestPath);
   if (!bench.resolveLocalLabJudgeProviderConfig) {
     console.error(
@@ -7025,7 +7534,7 @@ function loadPinnedLoCoMoTaskSelector(parsed) {
   }
   let decoded;
   try {
-    decoded = JSON.parse(fs12.readFileSync(parsed.taskIdsFile, "utf8"));
+    decoded = JSON.parse(fs13.readFileSync(parsed.taskIdsFile, "utf8"));
   } catch (error) {
     throw new Error(
       `Unable to read --task-ids-file ${parsed.taskIdsFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -7474,7 +7983,7 @@ function attachPreparedJudgeCalibration(result, judgeCalibration) {
 function hashCalibrationProviderConfig(config) {
   const canonicalize = (value, key = "") => {
     if (typeof value === "string" && /(?:api.?key|authorization|token|secret)/i.test(key)) {
-      return { secretSha256: createHash3("sha256").update(value).digest("hex") };
+      return { secretSha256: createHash4("sha256").update(value).digest("hex") };
     }
     if (Array.isArray(value)) return value.map((item) => canonicalize(item));
     if (value && typeof value === "object") {
@@ -7485,7 +7994,7 @@ function hashCalibrationProviderConfig(config) {
     }
     return value;
   };
-  return createHash3("sha256").update(JSON.stringify(canonicalize(config))).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(canonicalize(config))).digest("hex");
 }
 function restoreOptionalEnv(key, previousValue) {
   if (previousValue === void 0) {
@@ -7697,7 +8206,7 @@ function resolveBenchReproDatasetDir(datasetDir) {
     return void 0;
   }
   try {
-    return fs12.realpathSync(datasetDir);
+    return fs13.realpathSync(datasetDir);
   } catch {
     return datasetDir;
   }
@@ -7751,13 +8260,13 @@ async function writeBenchReproManifestForPackageRun(args) {
 }
 function loadStandaloneConvergeCommandConfig() {
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  return parseConfig5(resolveRemnicConfigRecord4(raw));
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  return parseConfig6(resolveRemnicConfigRecord5(raw));
 }
 function parseConvergePluginConfig(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
   if (Object.keys(value).length === 0) return void 0;
-  return parseConfig5(resolveRemnicConfigRecord4(value));
+  return parseConfig6(resolveRemnicConfigRecord5(value));
 }
 function loadConvergeCommandConfig() {
   if (readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH")) {
@@ -7780,13 +8289,13 @@ function resolveConfigPath(cliPath) {
     path15.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs12.existsSync(candidate)) return candidate;
+    if (fs13.existsSync(candidate)) return candidate;
   }
   return path15.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
-  if (fs12.existsSync(configPath)) {
+  if (fs13.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -7796,7 +8305,7 @@ function resolveExistingBenchRemnicConfigPath(cliPath) {
 }
 function resolveExistingBenchOpenclawConfigPath(cliPath) {
   const configPath = resolveOpenclawConfigPath(cliPath);
-  if (fs12.existsSync(configPath)) {
+  if (fs13.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -7903,8 +8412,8 @@ function resolveMemoryDir() {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return normalizeMemoryDirPath(envMemoryDir);
     const configPath = resolveConfigPath();
-    const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord4(raw);
+    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord5(raw);
     if (typeof remnicCfg.memoryDir === "string" && remnicCfg.memoryDir.length > 0) {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
@@ -7912,18 +8421,18 @@ function resolveMemoryDir() {
     const standalonePath = path15.join(home, ".remnic", "memory");
     const legacyStandalonePath = path15.join(home, ".engram", "memory");
     const openclawPath = path15.join(home, ".openclaw", "workspace", "memory", "local");
-    if (fs12.existsSync(standalonePath)) return standalonePath;
-    if (fs12.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    if (fs13.existsSync(standalonePath)) return standalonePath;
+    if (fs13.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs12.existsSync(manifestPath)) {
+  if (fs13.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
         const activeMemoryDir = normalizeMemoryDirPath(active.memoryDir);
-        if (!fs12.existsSync(activeMemoryDir)) {
-          fs12.mkdirSync(activeMemoryDir, { recursive: true });
+        if (!fs13.existsSync(activeMemoryDir)) {
+          fs13.mkdirSync(activeMemoryDir, { recursive: true });
         }
         return activeMemoryDir;
       }
@@ -7969,13 +8478,13 @@ function resolveOpenclawConfigPath(cliPath) {
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
   if (envPath) return path15.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
-    if (fs12.existsSync(candidate)) return candidate;
+    if (fs13.existsSync(candidate)) return candidate;
   }
   return path15.join(resolveHomeDir(), ".openclaw", "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
-  if (!fs12.existsSync(configPath)) return {};
-  const raw = fs12.readFileSync(configPath, "utf-8");
+  if (!fs13.existsSync(configPath)) return {};
+  const raw = fs13.readFileSync(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -8074,14 +8583,14 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
 }
 function backupPathIfPresent(sourcePath, backupPath) {
-  if (!fs12.existsSync(sourcePath)) return false;
-  fs12.mkdirSync(path15.dirname(backupPath), { recursive: true });
-  fs12.cpSync(sourcePath, backupPath, { recursive: true });
+  if (!fs13.existsSync(sourcePath)) return false;
+  fs13.mkdirSync(path15.dirname(backupPath), { recursive: true });
+  fs13.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
 function assertDirectoryPathOrMissing(targetPath, label) {
-  if (!fs12.existsSync(targetPath)) return;
-  const stat = fs12.statSync(targetPath);
+  if (!fs13.existsSync(targetPath)) return;
+  const stat = fs13.statSync(targetPath);
   if (!stat.isDirectory()) {
     throw new Error(`${label} must be a directory when it already exists: ${targetPath}`);
   }
@@ -8106,7 +8615,7 @@ var PublishedOpenclawPluginInstallError = class extends Error {
   }
 };
 function installPublishedOpenclawPlugin(spec, pluginDir) {
-  const tempRoot = fs12.mkdtempSync(path15.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  const tempRoot = fs13.mkdtempSync(path15.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
   const stagedDir = `${pluginDir}.next-${process.pid}-${Date.now()}`;
   const rollbackDir = `${pluginDir}.rollback-${process.pid}-${Date.now()}`;
   let swapRollbackDir;
@@ -8122,16 +8631,16 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
       throw new Error(`npm pack ${spec} did not return a tarball name`);
     }
     const unpackDir = path15.join(tempRoot, "unpacked");
-    fs12.mkdirSync(unpackDir, { recursive: true });
+    fs13.mkdirSync(unpackDir, { recursive: true });
     childProcess2.execFileSync("tar", ["-xzf", path15.join(tempRoot, tarballName), "-C", unpackDir], {
       stdio: ["ignore", "pipe", "pipe"]
     });
     const packagedDir = path15.join(unpackDir, "package");
-    if (!fs12.existsSync(packagedDir)) {
+    if (!fs13.existsSync(packagedDir)) {
       throw new Error(`npm pack ${spec} did not contain a package/ directory`);
     }
-    fs12.rmSync(stagedDir, { recursive: true, force: true });
-    fs12.cpSync(packagedDir, stagedDir, { recursive: true });
+    fs13.rmSync(stagedDir, { recursive: true, force: true });
+    fs13.cpSync(packagedDir, stagedDir, { recursive: true });
     childProcess2.execFileSync("npm", ["install", "--omit=dev"], {
       cwd: stagedDir,
       stdio: ["ignore", "pipe", "pipe"]
@@ -8147,7 +8656,7 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
     })();
     swapRollbackDir = swapResult.rollbackDir;
     const installedPackageJsonPath = path15.join(pluginDir, "package.json");
-    const installedPackage = fs12.existsSync(installedPackageJsonPath) ? JSON.parse(fs12.readFileSync(installedPackageJsonPath, "utf8")) : {};
+    const installedPackage = fs13.existsSync(installedPackageJsonPath) ? JSON.parse(fs13.readFileSync(installedPackageJsonPath, "utf8")) : {};
     return {
       rollbackDir: swapRollbackDir,
       version: typeof installedPackage.version === "string" ? installedPackage.version : void 0
@@ -8162,8 +8671,8 @@ function installPublishedOpenclawPlugin(spec, pluginDir) {
       }
     );
   } finally {
-    fs12.rmSync(stagedDir, { recursive: true, force: true });
-    fs12.rmSync(tempRoot, { recursive: true, force: true });
+    fs13.rmSync(stagedDir, { recursive: true, force: true });
+    fs13.rmSync(tempRoot, { recursive: true, force: true });
   }
 }
 function restartOpenclawGateway() {
@@ -8182,7 +8691,7 @@ function restartOpenclawGateway() {
 }
 function cmdInit() {
   const configPath = path15.join(process.cwd(), "remnic.config.json");
-  if (fs12.existsSync(configPath)) {
+  if (fs13.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
@@ -8198,7 +8707,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs12.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs13.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
   console.log(`Created ${configPath}`);
   console.log("\nSet these environment variables:");
   console.log("  export OPENAI_API_KEY=sk-...");
@@ -8268,7 +8777,7 @@ async function cmdStatus(json) {
 }
 function oauthReadConfigRecord(configPath) {
   try {
-    const parsed = JSON.parse(fs12.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs13.readFileSync(configPath, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -8413,7 +8922,7 @@ async function oauthPromptYesNo(question) {
     return false;
   }
   process.stdout.write(`${question} [y/N] `);
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let buffer = "";
     const onData = (chunk) => {
       const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
@@ -8422,7 +8931,7 @@ async function oauthPromptYesNo(question) {
         process.stdin.removeListener("data", onData);
         process.stdin.pause();
         const answer = buffer.trim().toLowerCase();
-        resolve(answer === "y" || answer === "yes");
+        resolve2(answer === "y" || answer === "yes");
       }
     };
     process.stdin.resume();
@@ -8684,9 +9193,9 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   const service = new EngramAccessService2(orchestrator);
@@ -8855,9 +9364,9 @@ async function cmdXray(rest) {
   parseXrayCliOptions(rawQuery, options);
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
@@ -8878,9 +9387,9 @@ async function cmdXray(rest) {
 async function cmdVersions(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   if (!config.versioningEnabled) {
     console.error("Page versioning is disabled (versioningEnabled = false).");
     process.exit(1);
@@ -8994,9 +9503,9 @@ Options:
 async function cmdEnrich(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
@@ -9239,9 +9748,9 @@ Shared with:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const memoryDir = expandTilde(
     typeof memoryDirOverride === "string" && memoryDirOverride.length > 0 ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
   );
@@ -9256,9 +9765,9 @@ Shared with:
 async function cmdExtensions(action, rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const root = resolveExtensionsRoot(config);
   const noopLog = { warn: () => {
   }, debug: () => {
@@ -9307,7 +9816,7 @@ Root: ${root}`);
       const extensions = await discoverMemoryExtensions(root, warnLog);
       let entries = [];
       try {
-        entries = fs12.readdirSync(root);
+        entries = fs13.readdirSync(root);
       } catch {
         console.log(`Extensions root does not exist: ${root}`);
         process.exitCode = 0;
@@ -9318,7 +9827,7 @@ Root: ${root}`);
       for (const entry of entries) {
         const entryPath = path15.join(root, entry);
         try {
-          if (!fs12.statSync(entryPath).isDirectory()) continue;
+          if (!fs13.statSync(entryPath).isDirectory()) continue;
         } catch {
           continue;
         }
@@ -9350,9 +9859,9 @@ Root: ${root}`);
 async function cmdBriefing(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   if (!config.briefing.enabled) {
     console.error("Briefing is disabled in config (briefing.enabled = false).");
     process.exit(1);
@@ -9430,10 +9939,10 @@ async function cmdBriefing(rest) {
   if (save) {
     try {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
-      fs12.mkdirSync(saveDir, { recursive: true });
+      fs13.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
       const filePath = path15.join(saveDir, filename);
-      fs12.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
+      fs13.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
       console.error(`Saved briefing: ${filePath}`);
     } catch (err) {
       console.error(`Failed to save briefing: ${err instanceof Error ? err.message : String(err)}`);
@@ -9451,7 +9960,7 @@ async function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs12.existsSync(configPath);
+  const configExists = fs13.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   let standaloneConfig;
   let standaloneConfigError;
@@ -9459,11 +9968,11 @@ async function cmdDoctor() {
   let configuredNs = { invalid: false };
   if (configExists) {
     try {
-      const raw = JSON.parse(fs12.readFileSync(configPath, "utf8"));
-      const remnicCfg = resolveRemnicConfigRecord4(raw);
+      const raw = JSON.parse(fs13.readFileSync(configPath, "utf8"));
+      const remnicCfg = resolveRemnicConfigRecord5(raw);
       standaloneOpenaiApiKeyExplicitlyFalse = isOpenaiApiKeyDisabled(remnicCfg.openaiApiKey);
       configuredNs = readConfiguredNamespace(remnicCfg);
-      standaloneConfig = parseConfig5(remnicCfg);
+      standaloneConfig = parseConfig6(remnicCfg);
     } catch (err) {
       standaloneConfigError = err instanceof Error ? err.message : String(err);
     }
@@ -9472,10 +9981,10 @@ async function cmdDoctor() {
   try {
     memoryDir = resolveMemoryDir();
   } catch {
-    memoryDir = parseConfig5({}).memoryDir;
+    memoryDir = parseConfig6({}).memoryDir;
   }
   try {
-    fs12.mkdirSync(memoryDir, { recursive: true });
+    fs13.mkdirSync(memoryDir, { recursive: true });
     checks.push({ name: "Memory directory", ok: true, detail: memoryDir });
   } catch {
     checks.push({ name: "Memory directory", ok: false, detail: `cannot create ${memoryDir}` });
@@ -9504,7 +10013,7 @@ async function cmdDoctor() {
   });
   if (nsPolicyCheck) checks.push(nsPolicyCheck);
   const openclawConfigPath = resolveOpenclawConfigPath();
-  const openclawConfigExists = fs12.existsSync(openclawConfigPath);
+  const openclawConfigExists = fs13.existsSync(openclawConfigPath);
   let openclawConfig = {};
   let openclawConfigValid = false;
   let openclawPluginModeConfigured = false;
@@ -9512,7 +10021,7 @@ async function cmdDoctor() {
   let activeOpenclawEntryConfig = null;
   if (openclawConfigExists) {
     try {
-      const parsed = JSON.parse(fs12.readFileSync(openclawConfigPath, "utf-8"));
+      const parsed = JSON.parse(fs13.readFileSync(openclawConfigPath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         openclawConfig = parsed;
         openclawConfigValid = true;
@@ -9592,9 +10101,9 @@ async function cmdDoctor() {
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
-        if (fs12.existsSync(resolvedMemDir)) {
+        if (fs13.existsSync(resolvedMemDir)) {
           try {
-            const stat = fs12.statSync(resolvedMemDir);
+            const stat = fs13.statSync(resolvedMemDir);
             if (stat.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
@@ -9736,12 +10245,12 @@ async function cmdDoctor() {
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs12.existsSync(configPath)) {
+  if (!fs13.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs12.readFileSync(configPath, "utf8");
+  const rawConfig = fs13.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -9849,9 +10358,9 @@ async function cmdReview(action, rest) {
     const configPath = resolveConfigPath();
     let tombstonesConfig = null;
     try {
-      const rawCfg = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-      const remnicCfg = resolveRemnicConfigRecord4(rawCfg);
-      const config = parseConfig5(remnicCfg);
+      const rawCfg = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+      const remnicCfg = resolveRemnicConfigRecord5(rawCfg);
+      const config = parseConfig6(remnicCfg);
       tombstonesConfig = {
         enabled: config.tombstonesEnabled,
         semanticMatch: config.tombstonesSemanticMatch,
@@ -9937,7 +10446,7 @@ async function cmdSync(action, rest, json) {
 }
 function localOfflineSourceId(memoryDir) {
   const host = os.hostname() || "unknown-host";
-  const dirHash = createHash3("sha256").update(path15.resolve(memoryDir)).digest("hex").slice(0, 16);
+  const dirHash = createHash4("sha256").update(path15.resolve(memoryDir)).digest("hex").slice(0, 16);
   return `remnic-local:${host}:${dirHash}`;
 }
 function normalizeOfflineRemoteUrl(raw) {
@@ -10301,8 +10810,8 @@ var APPEND_TOLERANT_RUNTIME_STATE_FILES = /* @__PURE__ */ new Set([
 function isAppendTolerantOfflineRuntimeFile(relPath) {
   if (!shouldPreferIncomingOfflineRuntimeFile(relPath)) return false;
   const parts = relPath.split("/");
-  const basename2 = parts[parts.length - 1] ?? "";
-  return APPEND_TOLERANT_RUNTIME_STATE_FILES.has(basename2);
+  const basename3 = parts[parts.length - 1] ?? "";
+  return APPEND_TOLERANT_RUNTIME_STATE_FILES.has(basename3);
 }
 function offlineFileContentChunkMatchesExpected(options) {
   const { chunk, expected, offset } = options;
@@ -10537,7 +11046,7 @@ function resolveOfflineDirectHydrationPath(memoryDir, relPath) {
   }
   return target;
 }
-var OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES = OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES3;
+var OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES = OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES4;
 async function pushOfflineFileContent(args) {
   if (args.readFileChunks) {
     return pushOfflineFileContentFromChunkReader(args);
@@ -10545,7 +11054,7 @@ async function pushOfflineFileContent(args) {
   let offset = 0;
   let finalResult = null;
   let remoteSatisfiedResult = null;
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   let bytes = 0;
   while (offset < args.file.bytes || args.file.bytes === 0 && offset === 0) {
     const chunk = await readOfflineSyncFileContentChunk({
@@ -10602,11 +11111,11 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat = fs12.statSync(filePath);
+  const stat = fs13.statSync(filePath);
   if (stat.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   const chunks = args.readFileChunks({
     root: path15.resolve(args.memoryDir),
     path: args.file.path,
@@ -10869,7 +11378,7 @@ function formatMissingDecodedContentError(missing) {
 }
 async function waitForMissingOfflineContentRetry(delayMs) {
   if (delayMs <= 0) return;
-  await new Promise((resolve) => setTimeout(resolve, delayMs));
+  await new Promise((resolve2) => setTimeout(resolve2, delayMs));
 }
 async function hydrateOfflineSnapshotContent(args) {
   const snapshot = normalizeOfflineSyncSnapshot(args.snapshot);
@@ -11034,15 +11543,15 @@ function parseOfflineIntervalMs(args) {
   return parsed;
 }
 function waitForOfflineInterval(ms, setCancel) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const timer = setTimeout(() => {
       setCancel(null);
-      resolve();
+      resolve2();
     }, ms);
     setCancel(() => {
       clearTimeout(timer);
       setCancel(null);
-      resolve();
+      resolve2();
     });
   });
 }
@@ -11093,7 +11602,7 @@ function advanceOfflineBaseFilesForSuccessfulPush(options) {
   return [...next.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function runOfflineSyncOnce(options) {
-  fs12.mkdirSync(options.memoryDir, { recursive: true });
+  fs13.mkdirSync(options.memoryDir, { recursive: true });
   let activeStatePath = options.statePath;
   let priorState = await readOfflineSyncState(activeStatePath);
   let syncNamespace = options.namespace ?? priorState?.namespace;
@@ -11512,7 +12021,8 @@ async function runOfflineSyncOnce(options) {
       readFile: storageIo.readFile,
       readFileDigest: storageIo.readFileDigest,
       writeFile: storageIo.writeFile,
-      deleteFile: storageIo.deleteFile
+      deleteFile: storageIo.deleteFile,
+      recordDeletionRevision: storageIo.recordDeletionRevision
     });
   } catch (error) {
     if (!isMissingOfflineContentError(error)) {
@@ -11558,7 +12068,8 @@ async function runOfflineSyncOnce(options) {
         readFile: storageIo.readFile,
         readFileDigest: storageIo.readFileDigest,
         writeFile: storageIo.writeFile,
-        deleteFile: storageIo.deleteFile
+        deleteFile: storageIo.deleteFile,
+        recordDeletionRevision: storageIo.recordDeletionRevision
       });
     } catch (retryApplyError) {
       if (pushed || partialHydration.hydratedFiles.length > 0) {
@@ -11719,7 +12230,7 @@ Environment fallbacks:
   const configPath = resolveConfigPath();
   let config;
   try {
-    const rawConfig = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
+    const rawConfig = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
     config = parseConfigQuietly(pickOfflineConfigRecord(rawConfig));
   } catch {
     throw new Error(
@@ -11734,7 +12245,7 @@ Environment fallbacks:
   const statePath = statePathExplicit ? path15.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
   if (action === "prepare") {
     if (!remoteUrl || !token || !statePath) throw new Error("offline prepare requires remote URL and token");
-    fs12.mkdirSync(memoryDir, { recursive: true });
+    fs13.mkdirSync(memoryDir, { recursive: true });
     const remoteSnapshot = await fetchOfflineSnapshot({
       remoteUrl,
       token,
@@ -11771,7 +12282,8 @@ Environment fallbacks:
       readFile: storageIo.readFile,
       readFileDigest: storageIo.readFileDigest,
       writeFile: storageIo.writeFile,
-      deleteFile: storageIo.deleteFile
+      deleteFile: storageIo.deleteFile,
+      recordDeletionRevision: storageIo.recordDeletionRevision
     });
     const state = offlineSyncStateFromSnapshot({
       remoteId: remoteUrl,
@@ -11832,7 +12344,7 @@ Environment fallbacks:
     return;
   }
   if (action === "status") {
-    fs12.mkdirSync(memoryDir, { recursive: true });
+    fs13.mkdirSync(memoryDir, { recursive: true });
     const state = statePath ? await readOfflineSyncState(statePath) : null;
     if (state && remoteUrl && statePath) {
       assertOfflineStateMatches({
@@ -11970,7 +12482,7 @@ function cmdDedup(json) {
 function readInstalledConnectorConfig(configPath, fallback) {
   if (!configPath) return fallback;
   try {
-    const parsed = JSON.parse(fs12.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs13.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
     const { token: _token, ...config } = parsed;
     return config;
@@ -12148,7 +12660,7 @@ async function cmdConnectors(action, rest, json) {
           const pub = factory();
           const available = await pub.isHostAvailable();
           const extRoot = available ? await pub.resolveExtensionRoot() : "(host not installed)";
-          const extensionExists = available && extRoot ? fs12.existsSync(extRoot) : false;
+          const extensionExists = available && extRoot ? fs13.existsSync(extRoot) : false;
           publisherChecks.push({
             name: `Publisher: ${targetHostId}`,
             ok: !available || extensionExists,
@@ -12222,7 +12734,7 @@ async function cmdConnectors(action, rest, json) {
     let connectorsCfg;
     const configPath = resolveConfigPath();
     try {
-      const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
+      const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
       connectorsCfg = parseConfigQuietly(raw).connectors;
     } catch {
       process.stderr.write(
@@ -12298,9 +12810,9 @@ async function cmdConnectors(action, rest, json) {
     }
     initLogger2();
     const configPath = resolveConfigPath();
-    const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord4(raw);
-    const config = parseConfig5(remnicCfg);
+    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord5(raw);
+    const config = parseConfig6(remnicCfg);
     const orchestrator = new Orchestrator3(config);
     try {
       await orchestrator.initialize();
@@ -12423,9 +12935,9 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     console.error(`connectors marketplace: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
-  const rawConfig = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const pluginConfig = resolveRemnicConfigRecord4(rawConfig);
-  const config = parseConfig5(pluginConfig);
+  const rawConfig = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const pluginConfig = resolveRemnicConfigRecord5(rawConfig);
+  const config = parseConfig6(pluginConfig);
   if (subAction === "generate") {
     let outputDir;
     try {
@@ -12445,13 +12957,13 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
   } else if (subAction === "validate") {
     const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path15.join(process.cwd(), "marketplace.json");
     const resolved = path15.resolve(targetPath);
-    if (!fs12.existsSync(resolved)) {
+    if (!fs13.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs12.readFileSync(resolved, "utf8"));
+      parsed = JSON.parse(fs13.readFileSync(resolved, "utf8"));
     } catch {
       console.error(`Invalid JSON in ${resolved}`);
       process.exit(1);
@@ -12581,7 +13093,7 @@ async function cmdSpace(action, rest, json) {
       console.error("Usage: remnic space push <source> <target>");
       process.exit(1);
     }
-    const result = pushToSpace(sourceId, targetId, { force: rest.includes("--force") });
+    const result = await pushToSpace(sourceId, targetId, { force: rest.includes("--force") });
     if (json) {
       console.log(JSON.stringify(result, null, 2));
     } else {
@@ -12596,7 +13108,7 @@ async function cmdSpace(action, rest, json) {
       console.error("Usage: remnic space pull <source> <target>");
       process.exit(1);
     }
-    const result = pullFromSpace(sourceId, targetId, { force: rest.includes("--force") });
+    const result = await pullFromSpace(sourceId, targetId, { force: rest.includes("--force") });
     if (json) {
       console.log(JSON.stringify(result, null, 2));
     } else {
@@ -12620,7 +13132,7 @@ async function cmdSpace(action, rest, json) {
       console.error("Usage: remnic space promote <source> <target>");
       process.exit(1);
     }
-    const result = promoteSpace(sourceId, targetId, {
+    const result = await promoteSpace(sourceId, targetId, {
       force: rest.includes("--force"),
       forceOverwrite: rest.includes("--force-overwrite")
     });
@@ -12652,9 +13164,9 @@ async function cmdSpace(action, rest, json) {
 async function cmdLegacyBenchmark(action, rest, json) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
   const service = new EngramAccessService2(orchestrator);
   const { runBenchSuite, loadBaseline, checkRegression } = await loadBenchModule();
@@ -13055,7 +13567,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs12.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs13.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -13150,13 +13662,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs12.mkdirSync(LOGS_DIR, { recursive: true });
+  fs13.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
     const templatePath = path15.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs12.readFileSync(templatePath, "utf8");
+    const template = fs13.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs12.mkdirSync(path15.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs12.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs13.mkdirSync(path15.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs13.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
     } catch (err) {
@@ -13173,10 +13685,10 @@ function daemonInstall() {
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
     const templatePath = path15.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs12.readFileSync(templatePath, "utf8");
+    const template = fs13.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs12.mkdirSync(path15.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs12.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs13.mkdirSync(path15.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs13.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
     } catch (err) {
@@ -13212,7 +13724,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs12.unlinkSync(plistPath);
+        fs13.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -13232,7 +13744,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of SYSTEMD_UNIT_PATHS) {
       try {
-        fs12.unlinkSync(unitPath);
+        fs13.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -13299,13 +13811,13 @@ async function daemonStatus() {
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs12.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs12.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs13.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs13.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
   try {
     const configPath = resolveConfigPath();
-    const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord4(raw);
-    const config = parseConfig5(remnicCfg);
+    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord5(raw);
+    const config = parseConfig6(remnicCfg);
     const extRoot = resolveExtensionsRoot(config);
     const noopLog = { warn: () => {
     }, debug: () => {
@@ -13344,9 +13856,9 @@ function daemonStart() {
       return;
     }
   }
-  fs12.mkdirSync(PID_DIR, { recursive: true });
-  fs12.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs12.openSync(LOG_FILE, "a");
+  fs13.mkdirSync(PID_DIR, { recursive: true });
+  fs13.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs13.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -13368,7 +13880,7 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs12.writeFileSync(PID_FILE, String(child.pid));
+  fs13.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
@@ -13402,11 +13914,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs12.unlinkSync(PID_FILE);
+    fs13.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs12.unlinkSync(LEGACY_PID_FILE);
+    fs13.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -13498,7 +14010,7 @@ function cmdTokenRevoke(connector) {
 async function promptYesNo(question, defaultYes = true) {
   if (!process.stdin.isTTY) return defaultYes;
   process.stdout.write(question + " ");
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     let buf = "";
     const cleanup = () => {
       process.stdin.removeListener("data", onData);
@@ -13508,7 +14020,7 @@ async function promptYesNo(question, defaultYes = true) {
     };
     const onEnd = () => {
       cleanup();
-      resolve(defaultYes);
+      resolve2(defaultYes);
     };
     const onData = (chunk) => {
       buf += chunk.toString();
@@ -13517,11 +14029,11 @@ async function promptYesNo(question, defaultYes = true) {
         cleanup();
         const answer = buf.slice(0, nl).trim().toLowerCase();
         if (answer === "" || answer === "y" || answer === "yes") {
-          resolve(defaultYes || answer !== "");
+          resolve2(defaultYes || answer !== "");
         } else if (answer === "n" || answer === "no") {
-          resolve(false);
+          resolve2(false);
         } else {
-          resolve(defaultYes);
+          resolve2(defaultYes);
         }
       }
     };
@@ -13534,9 +14046,9 @@ async function promptYesNo(question, defaultYes = true) {
 async function cmdBinary(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   const memoryDir = resolveMemoryDir();
   const blConfig = {
     enabled: config.binaryLifecycleEnabled,
@@ -13725,7 +14237,7 @@ async function cmdOpenclawInstall(opts) {
   } else if (slotIsActiveLegacy) {
     changes.push(`  Slot left as "${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}" \u2014 re-run with --yes to activate the new entry`);
   }
-  if (!fs12.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
+  if (!fs13.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
   if (hasLegacy && migrateLegacy) {
     changes.push(`~ Legacy '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry retained (safe to remove after verifying hooks fire)`);
   }
@@ -13745,8 +14257,8 @@ async function cmdOpenclawInstall(opts) {
 Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
     return;
   }
-  if (fs12.existsSync(memoryDir)) {
-    const st = fs12.statSync(memoryDir);
+  if (fs13.existsSync(memoryDir)) {
+    const st = fs13.statSync(memoryDir);
     if (!st.isDirectory()) {
       throw new Error(
         `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
@@ -13754,12 +14266,12 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
       );
     }
   } else {
-    fs12.mkdirSync(memoryDir, { recursive: true });
+    fs13.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
   const configDir = path15.dirname(configPath);
-  if (!fs12.existsSync(configDir)) {
-    fs12.mkdirSync(configDir, { recursive: true });
+  if (!fs13.existsSync(configDir)) {
+    fs13.mkdirSync(configDir, { recursive: true });
   }
   atomicWriteFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
   console.log("\nDone! Summary of changes:");
@@ -13931,15 +14443,15 @@ async function cmdOpenclawMigrateEngram(opts) {
 }
 function createOpenclawUpgradeBackupDir() {
   const backupsRoot = path15.join(resolveHomeDir(), ".openclaw", "backups");
-  fs12.mkdirSync(backupsRoot, { recursive: true });
-  return fs12.mkdtempSync(path15.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  fs13.mkdirSync(backupsRoot, { recursive: true });
+  return fs13.mkdtempSync(path15.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord4(raw);
-  const config = parseConfig5(remnicCfg);
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord5(raw);
+  const config = parseConfig6(remnicCfg);
   if (!config.taxonomyEnabled) {
     console.error(
       "Taxonomy is disabled in config (taxonomyEnabled = false). Enable it to use taxonomy commands."
@@ -13975,8 +14487,8 @@ async function cmdTaxonomy(rest) {
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
         const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs12.mkdirSync(path15.dirname(resolverPath), { recursive: true });
-        fs12.writeFileSync(resolverPath, doc);
+        fs13.mkdirSync(path15.dirname(resolverPath), { recursive: true });
+        fs13.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
       break;
@@ -14022,7 +14534,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs12.writeFileSync(resolverPath, doc);
+        fs13.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -14053,7 +14565,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path15.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs12.writeFileSync(resolverPath, doc);
+        fs13.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -14244,12 +14756,12 @@ async function runTrainingExport(args, stdout = process.stdout) {
       `Unknown training-export format "${args.format}". ${validList}`
     );
   }
-  if (!fs12.existsSync(args.memoryDir)) {
+  if (!fs13.existsSync(args.memoryDir)) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
-  if (!fs12.statSync(args.memoryDir).isDirectory()) {
+  if (!fs13.statSync(args.memoryDir).isDirectory()) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" is not a directory. Provide the path to a memory directory, not a file.`
     );
@@ -14335,10 +14847,10 @@ async function runTrainingExport(args, stdout = process.stdout) {
   }
   const formatted = adapter.formatRecords(records);
   const outDir = path15.dirname(args.output);
-  fs12.mkdirSync(outDir, { recursive: true });
+  fs13.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
-  fs12.writeFileSync(tmpPath, formatted, "utf-8");
-  fs12.renameSync(tmpPath, args.output);
+  fs13.writeFileSync(tmpPath, formatted, "utf-8");
+  fs13.renameSync(tmpPath, args.output);
   stdout.write(
     `Exported ${records.length} records to ${args.output} (${adapter.name} format)
 `
@@ -14507,7 +15019,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs12.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs13.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -14515,12 +15027,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs12.existsSync(treeDir)) {
+        if (!fs13.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
         const indexPath = path15.join(treeDir, "INDEX.md");
-        if (!fs12.existsSync(indexPath)) {
+        if (!fs13.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -14702,9 +15214,9 @@ Other:
         let wearablesService;
         try {
           const configPath = resolveConfigPath();
-          const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord4(raw);
-          const config = parseConfig5(remnicCfg);
+          const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord5(raw);
+          const config = parseConfig6(remnicCfg);
           wearablesOrchestrator = new Orchestrator3(config);
           await wearablesOrchestrator.initialize();
           await wearablesOrchestrator.deferredReady;
@@ -14744,6 +15256,10 @@ Other:
       await runMeetingsBinaryCommand(rest);
       break;
     }
+    case "external-wiki": {
+      await runExternalWikiBinaryCommand(rest);
+      break;
+    }
     case "import": {
       if (rest.includes("--help") || rest.includes("-h") || rest.length === 0) {
         console.log(IMPORT_USAGE);
@@ -14753,9 +15269,9 @@ Other:
       const targetFactory = async () => {
         if (!orchestratorSingleton) {
           const configPath = resolveConfigPath();
-          const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord4(raw);
-          const config = parseConfig5(remnicCfg);
+          const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord5(raw);
+          const config = parseConfig6(remnicCfg);
           orchestratorSingleton = new Orchestrator3(config);
           await orchestratorSingleton.initialize();
           await orchestratorSingleton.deferredReady;
@@ -14952,6 +15468,7 @@ Usage:
     Retrospective meetings: list stored records, show one by id, or build
     (detect + fuse + store) a day's meetings from ingested audio + screen
     activity. Run "remnic meetings help" for details.
+  remnic external-wiki search <query...> [--wiki-id <id>] [--limit <1-20>] [--max-chars-per-hit <100-8000>] [--json]
 
   remnic doctor                Run diagnostics
   remnic config                Show current config
@@ -15039,8 +15556,8 @@ function waitForStreamDrain(stream) {
   if (!stream.writableNeedDrain) {
     return Promise.resolve();
   }
-  return new Promise((resolve) => {
-    stream.once("drain", resolve);
+  return new Promise((resolve2) => {
+    stream.once("drain", resolve2);
   });
 }
 function activeNonStdioHandleCount() {
@@ -15059,7 +15576,7 @@ async function armCliSuccessExitWatchdog() {
       waitForStreamDrain(process.stdout),
       waitForStreamDrain(process.stderr)
     ]),
-    new Promise((resolve) => setTimeout(resolve, CLI_OUTPUT_FLUSH_GRACE_MS))
+    new Promise((resolve2) => setTimeout(resolve2, CLI_OUTPUT_FLUSH_GRACE_MS))
   ]);
   const watchdog = setTimeout(() => {
     if (activeNonStdioHandleCount() > 0) {