@remnic/cli 9.65.8 → 9.66.1

package/dist/index.js

@@ -18,20 +18,20 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 }
 
 // src/index.ts
-import fs21 from "fs";
+import fs26 from "fs";
 import os3 from "os";
-import path18 from "path";
+import path19 from "path";
 import { createHash as createHash4 } from "crypto";
 import { writeFile as fsWriteFile } from "fs/promises";
 import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { gzipSync } from "zlib";
 import {
-  parseConfig as parseConfig12,
+  parseConfig as parseConfig17,
   isOpenaiApiKeyDisabled,
   resolveEnvVars,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord11,
-  Orchestrator as Orchestrator7,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord16,
+  Orchestrator as Orchestrator10,
   EngramAccessService as EngramAccessService2,
   initLogger as initLogger5,
   onboard,
@@ -192,12 +192,49 @@ async function runMeetingsBinaryCommand(rest) {
   }
 }
 
-// src/commands/wearables.ts
+// src/commands/timeline.ts
 import fs2 from "fs";
 import {
-  Orchestrator as Orchestrator2,
   parseConfig as parseConfig2,
   resolveRemnicConfigRecord as resolveRemnicConfigRecord2,
+  runTimelineCliCommand
+} from "@remnic/core";
+async function runTimelineBinaryCommand(rest) {
+  const timelineArgs = rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" ? ["help"] : rest;
+  try {
+    let qa = { enabled: false, maxRangeDays: 31 };
+    let timelineEnabled = false;
+    try {
+      const configPath = resolveConfigPath();
+      const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+      const config = parseConfig2(resolveRemnicConfigRecord2(raw));
+      timelineEnabled = config.activity.timeline.enabled;
+      qa = config.activity.timeline.qa;
+    } catch {
+      console.error(
+        "timeline: failed to load the Remnic config \u2014 run `remnic doctor` and check the config file for errors"
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const code = await runTimelineCliCommand(
+      { cards: null, qa, timelineEnabled },
+      timelineArgs,
+      { stdout: process.stdout, stderr: process.stderr }
+    );
+    if (code !== 0) process.exitCode = code;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/wearables.ts
+import fs3 from "fs";
+import {
+  Orchestrator as Orchestrator2,
+  parseConfig as parseConfig3,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord3,
   runWearablesCliCommand
 } from "@remnic/core";
 async function runWearablesBinaryCommand(rest) {
@@ -207,8 +244,8 @@ async function runWearablesBinaryCommand(rest) {
     let wearablesService;
     try {
       const configPath = resolveConfigPath();
-      const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
-      const config = parseConfig2(resolveRemnicConfigRecord2(raw));
+      const raw = fs3.existsSync(configPath) ? JSON.parse(fs3.readFileSync(configPath, "utf8")) : {};
+      const config = parseConfig3(resolveRemnicConfigRecord3(raw));
       wearablesOrchestrator = new Orchestrator2(config);
       await wearablesOrchestrator.initialize();
       await wearablesOrchestrator.deferredReady;
@@ -245,17 +282,17 @@ async function runWearablesBinaryCommand(rest) {
 }
 
 // src/commands/location.ts
-import fs3 from "fs";
-import { parseConfig as parseConfig3, resolveRemnicConfigRecord as resolveRemnicConfigRecord3 } from "@remnic/core";
-import { runLocationCliCommand } from "@remnic/core/location";
+import fs4 from "fs";
+import { parseConfig as parseConfig4, resolveRemnicConfigRecord as resolveRemnicConfigRecord4 } from "@remnic/core";
+import { backfillMemoryStorage, runLocationCliCommand } from "@remnic/core/location";
 async function runLocationBinaryCommand(rest) {
   const locationArgs = rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" ? ["help"] : rest;
   try {
     let config;
     try {
       const configPath = resolveConfigPath();
-      const raw = fs3.existsSync(configPath) ? JSON.parse(fs3.readFileSync(configPath, "utf8")) : {};
-      config = parseConfig3(resolveRemnicConfigRecord3(raw));
+      const raw = fs4.existsSync(configPath) ? JSON.parse(fs4.readFileSync(configPath, "utf8")) : {};
+      config = parseConfig4(resolveRemnicConfigRecord4(raw));
     } catch {
       console.error(
         "location: failed to load the Remnic config \u2014 run `remnic doctor` and check the config file for errors"
@@ -264,7 +301,11 @@ async function runLocationBinaryCommand(rest) {
       return;
     }
     const code = await runLocationCliCommand(
-      { config: config.location, memoryDir: config.memoryDir },
+      {
+        config: config.location,
+        memoryDir: config.memoryDir,
+        getMemoryStorage: () => backfillMemoryStorage(config)
+      },
       locationArgs,
       { stdout: process.stdout, stderr: process.stderr }
     );
@@ -276,16 +317,16 @@ async function runLocationBinaryCommand(rest) {
 }
 
 // src/commands/okf.ts
-import fs4 from "fs";
-import { Orchestrator as Orchestrator3, parseConfig as parseConfig4, resolveRemnicConfigRecord as resolveRemnicConfigRecord4, runOkfCliCommand } from "@remnic/core";
+import fs5 from "fs";
+import { Orchestrator as Orchestrator3, parseConfig as parseConfig5, resolveRemnicConfigRecord as resolveRemnicConfigRecord5, runOkfCliCommand } from "@remnic/core";
 async function runOkfBinaryCommand(rest) {
   const argv = rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" ? ["help"] : rest;
   let orchestrator;
   try {
     try {
       const configPath = resolveConfigPath();
-      const raw = fs4.existsSync(configPath) ? JSON.parse(fs4.readFileSync(configPath, "utf8")) : {};
-      const config2 = parseConfig4(resolveRemnicConfigRecord4(raw));
+      const raw = fs5.existsSync(configPath) ? JSON.parse(fs5.readFileSync(configPath, "utf8")) : {};
+      const config2 = parseConfig5(resolveRemnicConfigRecord5(raw));
       orchestrator = new Orchestrator3(config2);
       await orchestrator.initialize();
       await orchestrator.deferredReady;
@@ -300,7 +341,8 @@ async function runOkfBinaryCommand(rest) {
     const code = await runOkfCliCommand(argv, { stdout: process.stdout, stderr: process.stderr }, {
       memoryDir: config.memoryDir,
       conformanceEnabled: config.okf.conformanceEnabled,
-      sweepEnabled: config.okf.sweepEnabled
+      sweepEnabled: config.okf.sweepEnabled,
+      indexFilesEnabled: config.okf.indexFilesEnabled
     });
     if (code !== 0) process.exitCode = code;
   } catch (err) {
@@ -312,15 +354,249 @@ async function runOkfBinaryCommand(rest) {
   }
 }
 
+// src/commands/export-okf.ts
+import fs6 from "fs";
+import path from "path";
+import { Orchestrator as Orchestrator4, parseConfig as parseConfig6, resolveRemnicConfigRecord as resolveRemnicConfigRecord6 } from "@remnic/core";
+import { exportOkfBundle, parseIncludeStatus } from "@remnic/core/export-okf";
+function takeFlag(rest, name) {
+  const index = rest.indexOf(name);
+  if (index < 0) return void 0;
+  const value = rest[index + 1];
+  if (value === void 0 || value.startsWith("-")) {
+    throw new Error(`${name} requires a value`);
+  }
+  return value;
+}
+async function runExportOkfBinaryCommand(rest) {
+  if (rest[0] === "--help" || rest[0] === "-h" || rest.length === 0) {
+    console.log("Usage: remnic export okf --out <dir> [--force] [--include-profile] [--log]");
+    return;
+  }
+  if (rest[0] !== "okf") {
+    console.error("Usage: remnic export okf --out <dir>");
+    process.exitCode = 1;
+    return;
+  }
+  const args = rest.slice(1);
+  let orchestrator;
+  try {
+    const out = takeFlag(args, "--out");
+    if (!out) throw new Error("Missing --out");
+    const namespace = takeFlag(args, "--namespace") ?? "";
+    const configPath = resolveConfigPath();
+    const raw = fs6.existsSync(configPath) ? JSON.parse(fs6.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig6(resolveRemnicConfigRecord6(raw));
+    orchestrator = new Orchestrator4(config);
+    await orchestrator.initialize();
+    await orchestrator.deferredReady;
+    const memoryDir = namespace ? path.join(orchestrator.config.memoryDir, "namespaces", namespace) : orchestrator.config.memoryDir;
+    const result = await exportOkfBundle({
+      memoryDir,
+      outDir: out,
+      includeStatus: parseIncludeStatus(takeFlag(args, "--include-status")),
+      includeCategories: takeFlag(args, "--include-categories")?.split(","),
+      excludeTags: takeFlag(args, "--exclude-tags")?.split(","),
+      includeProfile: args.includes("--include-profile"),
+      includeWearables: args.includes("--include-wearables"),
+      includeLog: args.includes("--log"),
+      force: args.includes("--force")
+    });
+    if (result.plaintextWarning) console.log("PLAINTEXT EXPORT: the OKF bundle is unencrypted.");
+    console.log(`OKF export: ${result.exported} concepts, ${result.excluded} excluded`);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  } finally {
+    orchestrator?.abortDeferredInit();
+    await orchestrator?.destroy();
+  }
+}
+
+// src/commands/codegraph.ts
+import fs7 from "fs";
+import { Orchestrator as Orchestrator5, parseConfig as parseConfig7, resolveRemnicConfigRecord as resolveRemnicConfigRecord7 } from "@remnic/core";
+import {
+  exportCodegraphOkfBundle,
+  parseOkfCodegraphSymbolFilter
+} from "@remnic/core/export-okf-codegraph";
+function takeFlag2(rest, name) {
+  const index = rest.indexOf(name);
+  if (index < 0) return void 0;
+  const value = rest[index + 1];
+  if (value === void 0 || value.startsWith("-")) {
+    throw new Error(`${name} requires a value`);
+  }
+  return value;
+}
+async function runCodegraphBinaryCommand(rest) {
+  if (rest[0] === "--help" || rest[0] === "-h" || rest.length === 0) {
+    console.log(
+      "Usage: remnic codegraph export-okf --project <id> --out <dir> [--max-module-concepts <n>] [--symbols none|exported|all] [--force]"
+    );
+    return;
+  }
+  if (rest[0] !== "export-okf") {
+    console.error("Usage: remnic codegraph export-okf --project <id> --out <dir>");
+    process.exitCode = 1;
+    return;
+  }
+  const args = rest.slice(1);
+  let orchestrator;
+  try {
+    const project = takeFlag2(args, "--project");
+    const out = takeFlag2(args, "--out");
+    if (!project) throw new Error("Missing --project");
+    if (!out) throw new Error("Missing --out");
+    const configPath = resolveConfigPath();
+    const raw = fs7.existsSync(configPath) ? JSON.parse(fs7.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig7(resolveRemnicConfigRecord7(raw));
+    orchestrator = new Orchestrator5(config);
+    await orchestrator.initialize();
+    await orchestrator.deferredReady;
+    const maxRaw = takeFlag2(args, "--max-module-concepts");
+    const result = await exportCodegraphOkfBundle({
+      config: orchestrator.config,
+      memoryDir: orchestrator.config.memoryDir,
+      projectId: project,
+      outDir: out,
+      force: args.includes("--force"),
+      includeAdrs: !args.includes("--no-include-adrs"),
+      symbols: parseOkfCodegraphSymbolFilter(takeFlag2(args, "--symbols")),
+      ...maxRaw !== void 0 ? { maxModuleConcepts: Number(maxRaw) } : {}
+    });
+    console.log(
+      `OKF codegraph export: ${result.moduleConcepts} modules, ${result.decisions} decisions` + (result.truncated ? " (truncated)" : "")
+    );
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  } finally {
+    orchestrator?.abortDeferredInit();
+    await orchestrator?.destroy();
+  }
+}
+
+// src/commands/standup.ts
+import fs8 from "fs";
+import { Orchestrator as Orchestrator6, parseConfig as parseConfig8, resolveRemnicConfigRecord as resolveRemnicConfigRecord8 } from "@remnic/core";
+import { buildStandup, parseStandupDate, standupHelp } from "@remnic/core/standup";
+function takeFlag3(rest, name) {
+  const index = rest.indexOf(name);
+  if (index < 0) return void 0;
+  const value = rest[index + 1];
+  if (value === void 0 || value.startsWith("-")) throw new Error(`${name} requires a value`);
+  return value;
+}
+async function runStandupBinaryCommand(rest) {
+  if (rest[0] === "--help" || rest[0] === "-h") {
+    console.log(standupHelp());
+    return;
+  }
+  let orchestrator;
+  try {
+    const configPath = resolveConfigPath();
+    const raw = fs8.existsSync(configPath) ? JSON.parse(fs8.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig8(resolveRemnicConfigRecord8(raw));
+    orchestrator = new Orchestrator6(config);
+    await orchestrator.initialize();
+    await orchestrator.deferredReady;
+    const brief = buildStandup(orchestrator.config.memoryDir, parseStandupDate(takeFlag3(rest, "--date")));
+    console.log(brief.markdown);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  } finally {
+    orchestrator?.abortDeferredInit();
+    await orchestrator?.destroy();
+  }
+}
+
+// src/commands/journal.ts
+import fs9 from "fs";
+import {
+  journalPath,
+  parseConfig as parseConfig9,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord9,
+  seedJournal,
+  todayJournalDate
+} from "@remnic/core";
+function takeFlag4(rest, name) {
+  const index = rest.indexOf(name);
+  if (index < 0) return void 0;
+  const value = rest[index + 1];
+  if (value === void 0 || value.startsWith("-")) throw new Error(`${name} requires a value`);
+  return value;
+}
+function journalHelp() {
+  return `Usage: remnic journal <show|edit-path|seed> [--date YYYY-MM-DD] [--force]
+
+  show       Print the journal file for the date (default: today).
+  edit-path  Print the journal file path.
+  seed       Write the file only if it is absent. --force overwrites.
+`;
+}
+function loadMemoryDir() {
+  const configPath = resolveConfigPath();
+  const raw = fs9.existsSync(configPath) ? JSON.parse(fs9.readFileSync(configPath, "utf8")) : {};
+  return parseConfig9(resolveRemnicConfigRecord9(raw)).memoryDir;
+}
+async function runJournalBinaryCommand(rest) {
+  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" || rest[0] === "help") {
+    console.log(journalHelp());
+    return;
+  }
+  let memoryDir;
+  try {
+    memoryDir = loadMemoryDir();
+  } catch {
+    console.error(
+      "journal: failed to load the Remnic config \u2014 run `remnic doctor` and check the config file for errors"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const action = rest[0];
+    const date = takeFlag4(rest, "--date") ?? todayJournalDate();
+    const force = rest.includes("--force");
+    const filePath = journalPath(memoryDir, date);
+    if (action === "edit-path") {
+      console.log(filePath);
+      return;
+    }
+    if (action === "show") {
+      if (!fs9.existsSync(filePath)) {
+        console.error(`journal: no file at ${filePath}. Run remnic journal seed --date ${date}.`);
+        process.exitCode = 1;
+        return;
+      }
+      process.stdout.write(fs9.readFileSync(filePath, "utf8"));
+      return;
+    }
+    if (action === "seed") {
+      const result = seedJournal({ memoryDir, date, force });
+      console.log(result.wrote ? `wrote ${result.path}` : `unchanged ${result.path}`);
+      return;
+    }
+    console.error(`journal: unknown action "${action}".`);
+    console.error(journalHelp());
+    process.exitCode = 1;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  }
+}
+
 // src/commands/external-wiki.ts
-import fs5 from "fs";
-import { parseConfig as parseConfig5, resolveRemnicConfigRecord as resolveRemnicConfigRecord5, runExternalWikiCliCommand } from "@remnic/core";
+import fs10 from "fs";
+import { parseConfig as parseConfig10, resolveRemnicConfigRecord as resolveRemnicConfigRecord10, runExternalWikiCliCommand } from "@remnic/core";
 async function runExternalWikiBinaryCommand(rest) {
   let roots;
   try {
     const configPath = resolveConfigPath();
-    const raw = fs5.existsSync(configPath) ? JSON.parse(fs5.readFileSync(configPath, "utf8")) : {};
-    roots = parseConfig5(resolveRemnicConfigRecord5(raw)).externalWikis;
+    const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
+    roots = parseConfig10(resolveRemnicConfigRecord10(raw)).externalWikis;
   } catch {
     console.error(
       "external-wiki: failed to load the Remnic config - run `remnic doctor` and check the config file for errors"
@@ -341,14 +617,14 @@ async function runExternalWikiBinaryCommand(rest) {
 }
 
 // src/commands/procedural.ts
-import fs6 from "fs";
+import fs11 from "fs";
 import {
   StorageManager,
   computeProcedureStats,
   formatProcedureStatsText,
   initLogger,
-  parseConfig as parseConfig6,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord6,
+  parseConfig as parseConfig11,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord11,
   runProcedureLibraryMaintenance
 } from "@remnic/core";
 
@@ -479,8 +755,8 @@ Shared with:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs6.existsSync(configPath) ? JSON.parse(fs6.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig6(resolveRemnicConfigRecord6(raw));
+  const raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig11(resolveRemnicConfigRecord11(raw));
   const memoryDir = expandTilde(
     typeof memoryDirOverride === "string" && memoryDirOverride.length > 0 ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
   );
@@ -535,12 +811,12 @@ function formatProcedureMaintenanceText(report) {
 }
 
 // src/commands/drift.ts
-import fs7 from "fs";
+import fs12 from "fs";
 import {
-  Orchestrator as Orchestrator4,
+  Orchestrator as Orchestrator7,
   initLogger as initLogger2,
-  parseConfig as parseConfig7,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord7,
+  parseConfig as parseConfig12,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord12,
   runPreferenceDriftScan
 } from "@remnic/core";
 async function runDriftBinaryCommand(rest) {
@@ -600,13 +876,13 @@ Resolve a drifted item with the existing review surface:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs7.existsSync(configPath) ? JSON.parse(fs7.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig7(resolveRemnicConfigRecord7(raw));
+  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig12(resolveRemnicConfigRecord12(raw));
   const memoryDirOverridden = typeof memoryDirOverride === "string" && memoryDirOverride.length > 0;
   const memoryDir = expandTilde(
     memoryDirOverridden ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
   );
-  const orchestrator = new Orchestrator4(
+  const orchestrator = new Orchestrator7(
     memoryDirOverridden ? { ...config, memoryDir } : config
   );
   await orchestrator.initialize();
@@ -714,13 +990,13 @@ async function loadWecloneExportModule() {
 }
 
 // src/converge.ts
-import * as fs9 from "fs";
+import * as fs14 from "fs";
 import { createHash as createHash3 } from "crypto";
-import * as path2 from "path";
+import * as path3 from "path";
 import {
   CONVERGE_CONFLICT_POLICIES,
   DEFAULT_CONVERGE_CONFLICT_POLICY,
-  parseConfig as parseConfig8,
+  parseConfig as parseConfig13,
   buildOfflineSyncSnapshotFromBase,
   applyOfflineSyncFileContentChunk,
   isInternalRemnicStatePath as isInternalRemnicStatePath3,
@@ -746,9 +1022,9 @@ import {
 
 // src/offline-storage-io.ts
 import { createDecipheriv, createHash } from "crypto";
-import fs8 from "fs";
+import fs13 from "fs";
 import { lstat, mkdtemp, readdir, rm } from "fs/promises";
-import path from "path";
+import path2 from "path";
 import {
   OFFLINE_SYNC_FILE_CONTENT_TRANSFER_CHUNK_BYTES,
   StorageManager as StorageManager2,
@@ -775,10 +1051,10 @@ import {
 } from "@remnic/core/secure-store";
 var OFFLINE_SYNC_EXCLUSION_CONCURRENCY = 16;
 function resolveOfflineDirectHydrationPath(memoryDir, relPath) {
-  const base = path.resolve(memoryDir);
-  const target = path.resolve(base, relPath);
-  const relative = path.relative(base, target);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+  const base = path2.resolve(memoryDir);
+  const target = path2.resolve(base, relPath);
+  const relative = path2.relative(base, target);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
     throw new Error(`offline sync direct hydration path escapes memory dir: ${relPath}`);
   }
   return target;
@@ -812,13 +1088,13 @@ async function createConfiguredOfflineStorage(memoryDir, secureStoreEncryptOnWri
   return { storage, secureStoreKey, secureStoreRequired };
 }
 async function createOfflineStorageForPath(memoryDir, filePath, configured, secureStoreEncryptOnWrite) {
-  const memoryRoot = path.resolve(memoryDir);
-  const stateDir = path.dirname(filePath);
-  if (path.basename(stateDir) !== "state" || path.basename(filePath) !== "memory-lifecycle-ledger.jsonl") {
+  const memoryRoot = path2.resolve(memoryDir);
+  const stateDir = path2.dirname(filePath);
+  if (path2.basename(stateDir) !== "state" || path2.basename(filePath) !== "memory-lifecycle-ledger.jsonl") {
     throw new Error(`invalid lifecycle ledger path: ${filePath}`);
   }
-  const storageRoot = path.resolve(path.dirname(stateDir));
-  if (storageRoot !== memoryRoot && !storageRoot.startsWith(`${memoryRoot}${path.sep}`)) {
+  const storageRoot = path2.resolve(path2.dirname(stateDir));
+  if (storageRoot !== memoryRoot && !storageRoot.startsWith(`${memoryRoot}${path2.sep}`)) {
     throw new Error(`lifecycle ledger path is outside the offline memory directory: ${filePath}`);
   }
   const storage = new StorageManager2(storageRoot);
@@ -879,7 +1155,7 @@ async function cleanupOrphanedOfflineDecryptStaging(memoryDir) {
   const now = Date.now();
   for (const name of entries) {
     if (!name.startsWith(OFFLINE_DECRYPT_STAGING_DIR_PREFIX)) continue;
-    const dir = path.join(memoryDir, name);
+    const dir = path2.join(memoryDir, name);
     try {
       const info = await lstat(dir);
       if (!info.isDirectory() || info.isSymbolicLink()) continue;
@@ -908,7 +1184,7 @@ async function* readOfflineSyncFileChunks(options) {
   });
 }
 async function readFilePrefix(filePath, length) {
-  const handle = await fs8.promises.open(filePath, "r");
+  const handle = await fs13.promises.open(filePath, "r");
   try {
     const out = Buffer.alloc(length);
     const { bytesRead } = await handle.read(out, 0, length, 0);
@@ -918,7 +1194,7 @@ async function readFilePrefix(filePath, length) {
   }
 }
 async function* readPlainOfflineFileChunks(filePath, chunkSize) {
-  const stream = fs8.createReadStream(filePath, { highWaterMark: chunkSize });
+  const stream = fs13.createReadStream(filePath, { highWaterMark: chunkSize });
   for await (const chunk of stream) {
     yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
   }
@@ -947,17 +1223,17 @@ async function* readEncryptedOfflineFileChunks(options) {
   const aadCandidates = offlineFileAadCandidates(options.filePath, options.memoryDir);
   let lastError;
   for (const aad of aadCandidates) {
-    const tempDir = await mkdtemp(path.join(options.memoryDir, OFFLINE_DECRYPT_STAGING_DIR_PREFIX));
-    const tempPath = path.join(tempDir, "content");
+    const tempDir = await mkdtemp(path2.join(options.memoryDir, OFFLINE_DECRYPT_STAGING_DIR_PREFIX));
+    const tempPath = path2.join(tempDir, "content");
     try {
       const decipher = createDecipheriv("aes-256-gcm", options.key, iv, {
         authTagLength: AUTH_TAG_LENGTH
       });
       decipher.setAuthTag(authTag);
       decipher.setAAD(Buffer.concat([secureStoreEnvelopeHeaderAad(salt), aad]));
-      const output = fs8.createWriteStream(tempPath, { mode: 384 });
+      const output = fs13.createWriteStream(tempPath, { mode: 384 });
       try {
-        const stream = fs8.createReadStream(options.filePath, {
+        const stream = fs13.createReadStream(options.filePath, {
           start: MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE,
           highWaterMark: options.chunkSize
         });
@@ -992,17 +1268,17 @@ async function* readEncryptedOfflineFileChunks(options) {
 }
 function offlineFileAadCandidates(filePath, memoryDir) {
   const candidates = [filePathAad(filePath, memoryDir)];
-  const relative = path.relative(memoryDir, filePath);
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) return candidates;
-  const parts = relative.split(path.sep);
+  const relative = path2.relative(memoryDir, filePath);
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) return candidates;
+  const parts = relative.split(path2.sep);
   if (parts[0] === "namespaces" && parts.length >= 3 && parts[1]) {
-    candidates.push(filePathAad(filePath, path.join(memoryDir, "namespaces", parts[1])));
+    candidates.push(filePathAad(filePath, path2.join(memoryDir, "namespaces", parts[1])));
   }
-  const memoryParts = path.resolve(memoryDir).split(path.sep);
+  const memoryParts = path2.resolve(memoryDir).split(path2.sep);
   if (memoryParts.length >= 3 && memoryParts.at(-2) === "namespaces" && memoryParts.at(-1)) {
-    const topLevelRoot = memoryParts.slice(0, -2).join(path.sep) || path.sep;
-    const topRelative = path.relative(topLevelRoot, filePath);
-    if (topRelative && !topRelative.startsWith("..") && !path.isAbsolute(topRelative) && topRelative.split(path.sep)[0] === "namespaces" && topRelative.split(path.sep)[1] === memoryParts.at(-1)) {
+    const topLevelRoot = memoryParts.slice(0, -2).join(path2.sep) || path2.sep;
+    const topRelative = path2.relative(topLevelRoot, filePath);
+    if (topRelative && !topRelative.startsWith("..") && !path2.isAbsolute(topRelative) && topRelative.split(path2.sep)[0] === "namespaces" && topRelative.split(path2.sep)[1] === memoryParts.at(-1)) {
       candidates.push(filePathAad(filePath, topLevelRoot));
     }
   }
@@ -1567,7 +1843,7 @@ async function readLocalTombstoneEvidence(rootDir) {
   for (const relativePath of TOMBSTONE_PATHS) {
     let content;
     try {
-      content = await fs9.promises.readFile(path2.join(rootDir, relativePath), "utf-8");
+      content = await fs14.promises.readFile(path3.join(rootDir, relativePath), "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -1579,10 +1855,10 @@ async function readLocalTombstoneEvidence(rootDir) {
   return merged;
 }
 async function discoverCursorNamespaces(memoryDir, peerUrl) {
-  const cursorDir = path2.join(path2.resolve(memoryDir), ".remnic", "state", "converge-cursors");
+  const cursorDir = path3.join(path3.resolve(memoryDir), ".remnic", "state", "converge-cursors");
   let entries;
   try {
-    entries = await fs9.promises.readdir(cursorDir, { withFileTypes: true });
+    entries = await fs14.promises.readdir(cursorDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -1590,9 +1866,9 @@ async function discoverCursorNamespaces(memoryDir, peerUrl) {
   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));
+    const cursor = await readConvergeCursor(path3.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;
+    if (path3.basename(defaultConvergeCursorPath(memoryDir, peerUrl, cursor.namespace)) !== entry.name) continue;
     namespaces.add(cursor.namespace);
   }
   return [...namespaces].sort();
@@ -1658,7 +1934,7 @@ async function computeConvergePlan(options = {}) {
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig8({});
+      config = parseConfig13({});
     } catch {
     }
   }
@@ -1704,7 +1980,7 @@ async function computeConvergePlan(options = {}) {
             return await readFile3({
               root: rootInfo.rootDir,
               path: file.path,
-              filePath: path2.join(rootInfo.rootDir, file.path)
+              filePath: path3.join(rootInfo.rootDir, file.path)
             });
           } catch (error) {
             manifestReadFailed = true;
@@ -1909,7 +2185,7 @@ async function executeConvergeApply(options = {}) {
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig8({});
+      config = parseConfig13({});
     } catch {
     }
   }
@@ -2066,13 +2342,13 @@ async function executeConvergeApply(options = {}) {
         const rootDir = rootMap.get(entry.namespace);
         if (rootDir) {
           try {
-            const filePath = path2.join(rootDir, localPath);
+            const filePath = path3.join(rootDir, localPath);
             const io = await createOfflineStorageIo(rootDir);
             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 stat2 = await fs9.promises.stat(filePath);
+            const stat2 = await fs14.promises.stat(filePath);
             let chunks;
             let chunkOffset = 0;
             const resetChunks = async () => {
@@ -2163,7 +2439,7 @@ async function executeConvergeApply(options = {}) {
         if (rootDir && entry.localSha256) {
           try {
             const io = await createOfflineStorageIo(rootDir);
-            const filePath = path2.join(rootDir, localPath);
+            const filePath = path3.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 });
@@ -2216,7 +2492,7 @@ async function executeConvergeApply(options = {}) {
           if (rootDir) {
             try {
               const io = await createOfflineStorageIo(rootDir);
-              const filePath = path2.join(rootDir, localPath);
+              const filePath = path3.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 });
@@ -2349,7 +2625,7 @@ function formatConvergeApplyReport(result) {
   lines.push(formatConvergeReport(result.plan));
   return lines.join("\n");
 }
-async function cmdConverge(action, rest, json, config = parseConfig8({})) {
+async function cmdConverge(action, rest, json, config = parseConfig13({})) {
   if (action === "help" || action === "--help" || action === "-h" || rest.includes("--help") || rest.includes("-h")) {
     console.log(`Usage: remnic converge <plan|apply> [options]
 
@@ -2555,8 +2831,8 @@ function renderReplayResult(result, targetNamespace, format) {
 }
 
 // src/quarantine-replay.ts
-import * as fs10 from "fs";
-import { EngramAccessService, Orchestrator as Orchestrator5, initLogger as initLogger3, parseConfig as parseConfig9, resolveRemnicConfigRecord as resolveRemnicConfigRecord8 } from "@remnic/core";
+import * as fs15 from "fs";
+import { EngramAccessService, Orchestrator as Orchestrator8, initLogger as initLogger3, parseConfig as parseConfig14, resolveRemnicConfigRecord as resolveRemnicConfigRecord13 } from "@remnic/core";
 import { WriteQuarantineStore } from "@remnic/core/write-quarantine.js";
 function valueFlag(args, flag) {
   const occurrences = args.filter((a) => a === flag).length;
@@ -2604,9 +2880,9 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
   let orchestrator;
   try {
     const configPath = resolveConfigPath2();
-    const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig9(resolveRemnicConfigRecord8(raw));
-    orchestrator = new Orchestrator5(config);
+    const raw = fs15.existsSync(configPath) ? JSON.parse(fs15.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig14(resolveRemnicConfigRecord13(raw));
+    orchestrator = new Orchestrator8(config);
     await orchestrator.initialize();
     await orchestrator.deferredReady;
     const service = new EngramAccessService(orchestrator);
@@ -2636,15 +2912,15 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
 }
 
 // src/offline-impression-rotation.ts
-import fs11 from "fs";
-import { parseConfig as parseConfig10, resolveRemnicConfigRecord as resolveRemnicConfigRecord9, drainPendingImpressionsForOfflineSync } from "@remnic/core";
+import fs16 from "fs";
+import { parseConfig as parseConfig15, resolveRemnicConfigRecord as resolveRemnicConfigRecord14, drainPendingImpressionsForOfflineSync } from "@remnic/core";
 import { LastRecallStore } from "@remnic/core/recall-state";
 function parseConfigQuietly(raw) {
   const originalWarn = console.warn;
   console.warn = () => {
   };
   try {
-    return parseConfig10(resolveRemnicConfigRecord9(raw));
+    return parseConfig15(resolveRemnicConfigRecord14(raw));
   } finally {
     console.warn = originalWarn;
   }
@@ -2658,7 +2934,7 @@ var OFFLINE_CONFIG_KEYS = [
 function pickOfflineConfigRecord(raw) {
   let resolved;
   try {
-    resolved = resolveRemnicConfigRecord9(raw);
+    resolved = resolveRemnicConfigRecord14(raw);
   } catch {
     resolved = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   }
@@ -2671,7 +2947,7 @@ function pickOfflineConfigRecord(raw) {
 function resolveOfflineImpressionRotation(configPath) {
   let raw;
   try {
-    raw = fs11.existsSync(configPath) ? JSON.parse(fs11.readFileSync(configPath, "utf8")) : {};
+    raw = fs16.existsSync(configPath) ? JSON.parse(fs16.readFileSync(configPath, "utf8")) : {};
   } catch {
     throw new Error(
       `cannot read recall-impression rotation from ${configPath}: config file could not be read as JSON`
@@ -2707,15 +2983,15 @@ import {
   readFileSync as readFileSync2,
   statSync
 } from "fs";
-import path3 from "path";
+import path4 from "path";
 import { fileURLToPath } from "url";
 var STALE_BUILD_TOLERANCE_MS = 1e3;
 function assertLocalBenchBuildFreshForDevelopment(currentModuleUrl) {
   if (isTruthyEnv(process.env.REMNIC_BENCH_ALLOW_STALE_DIST)) {
     return;
   }
-  const currentDir = path3.dirname(fileURLToPath(currentModuleUrl));
-  const benchPackageDir = path3.resolve(currentDir, "../../bench");
+  const currentDir = path4.dirname(fileURLToPath(currentModuleUrl));
+  const benchPackageDir = path4.resolve(currentDir, "../../bench");
   const freshness = checkBenchBuildFreshness(benchPackageDir);
   if (!freshness.stale) {
     return;
@@ -2732,7 +3008,7 @@ function assertLocalBenchBuildFreshForDevelopment(currentModuleUrl) {
   );
 }
 function checkBenchBuildFreshness(benchPackageDir) {
-  const packageJsonPath = path3.join(benchPackageDir, "package.json");
+  const packageJsonPath = path4.join(benchPackageDir, "package.json");
   if (!existsSync2(packageJsonPath)) {
     return { stale: false };
   }
@@ -2745,17 +3021,17 @@ function checkBenchBuildFreshness(benchPackageDir) {
   if (packageName !== "@remnic/bench") {
     return { stale: false };
   }
-  const srcDir = path3.join(benchPackageDir, "src");
+  const srcDir = path4.join(benchPackageDir, "src");
   if (!isDirectory(srcDir)) {
     return { stale: false };
   }
   const sourceRoots = [
     srcDir,
     packageJsonPath,
-    path3.join(benchPackageDir, "tsup.config.ts"),
-    path3.join(benchPackageDir, "tsconfig.json")
+    path4.join(benchPackageDir, "tsup.config.ts"),
+    path4.join(benchPackageDir, "tsconfig.json")
   ];
-  const distPath = path3.join(benchPackageDir, "dist", "index.js");
+  const distPath = path4.join(benchPackageDir, "dist", "index.js");
   if (!existsSync2(distPath)) {
     return {
       stale: true,
@@ -2798,7 +3074,7 @@ function newestMtime(roots) {
     }
     if (stat2.isDirectory()) {
       for (const child of readdirSync(entryPath)) {
-        visit(path3.join(entryPath, child));
+        visit(path4.join(entryPath, child));
       }
       return;
     }
@@ -2831,18 +3107,18 @@ function isTruthyEnv(value) {
 
 // src/optional-bench.ts
 import { existsSync as existsSync3 } from "fs";
-import path4 from "path";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 var SPECIFIER2 = "@remnic/bench";
 var TSX_ESM_API_SPECIFIER = "tsx/esm/api";
 var cached2;
 var cachedFromLocalWorkspaceBenchSource = false;
 function resolveLocalWorkspaceBenchPaths() {
-  const currentDir = path4.dirname(fileURLToPath2(import.meta.url));
-  const benchPackageDir = path4.resolve(currentDir, "../../bench");
+  const currentDir = path5.dirname(fileURLToPath2(import.meta.url));
+  const benchPackageDir = path5.resolve(currentDir, "../../bench");
   return {
-    distEntry: path4.join(benchPackageDir, "dist", "index.js"),
-    sourceEntry: path4.join(benchPackageDir, "src", "index.ts")
+    distEntry: path5.join(benchPackageDir, "dist", "index.js"),
+    sourceEntry: path5.join(benchPackageDir, "src", "index.ts")
   };
 }
 async function tryImportLocalWorkspaceBenchSource(err) {
@@ -2929,12 +3205,12 @@ function assertBenchModuleFreshForDevelopment() {
 }
 
 // src/cmd-security.ts
-import fs12 from "fs";
+import fs17 from "fs";
 import {
-  Orchestrator as Orchestrator6,
-  parseConfig as parseConfig11,
+  Orchestrator as Orchestrator9,
+  parseConfig as parseConfig16,
   initLogger as initLogger4,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord10,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord15,
   runAuditMemoryCliCommand,
   formatAuditMemoryReport
 } from "@remnic/core";
@@ -2949,9 +3225,9 @@ async function cmdSecurity(rest) {
   }
   initLogger4();
   const configPath = resolveConfigPath();
-  const raw = fs12.existsSync(configPath) ? JSON.parse(fs12.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig11(resolveRemnicConfigRecord10(raw));
-  const orchestrator = new Orchestrator6(config);
+  const raw = fs17.existsSync(configPath) ? JSON.parse(fs17.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig16(resolveRemnicConfigRecord15(raw));
+  const orchestrator = new Orchestrator9(config);
   await orchestrator.initialize();
   try {
     const sinceFlag = rest.indexOf("--since");
@@ -2974,8 +3250,8 @@ async function cmdSecurity(rest) {
 }
 
 // src/daemon-service-candidates.ts
-import fs13 from "fs";
-import path5 from "path";
+import fs18 from "fs";
+import path6 from "path";
 var LAUNCHD_LABEL = "ai.remnic.daemon";
 var LEGACY_REMNIC_SERVER_LAUNCHD_LABEL = "ai.remnic.server";
 var LEGACY_LAUNCHD_LABEL = "ai.engram.daemon";
@@ -2988,15 +3264,15 @@ var SYSTEMD_SERVICE = "remnic.service";
 var LEGACY_SYSTEMD_SERVICE = "engram.service";
 var SYSTEMD_SERVICE_CANDIDATES = [SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE];
 function launchdPlistPaths(homeDir) {
-  return LAUNCHD_LABEL_CANDIDATES.map((label) => path5.join(homeDir, "Library", "LaunchAgents", `${label}.plist`));
+  return LAUNCHD_LABEL_CANDIDATES.map((label) => path6.join(homeDir, "Library", "LaunchAgents", `${label}.plist`));
 }
 function systemdUnitPaths(homeDir) {
-  return SYSTEMD_SERVICE_CANDIDATES.map((service) => path5.join(homeDir, ".config", "systemd", "user", service));
+  return SYSTEMD_SERVICE_CANDIDATES.map((service) => path6.join(homeDir, ".config", "systemd", "user", service));
 }
 function anyFileExists(paths) {
   return paths.some((candidate) => {
     try {
-      return fs13.statSync(candidate).isFile();
+      return fs18.statSync(candidate).isFile();
     } catch {
       return false;
     }
@@ -3008,7 +3284,7 @@ function commandNames(command) {
 }
 function isRunnableNodeScript(filePath) {
   try {
-    const text = fs13.readFileSync(filePath, "utf8").slice(0, 4096);
+    const text = fs18.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;
@@ -3021,20 +3297,20 @@ function isRunnableNodeScript(filePath) {
 function resolveShimNodeScript(filePath) {
   let text;
   try {
-    text = fs13.readFileSync(filePath, "utf8").slice(0, 16384);
+    text = fs18.readFileSync(filePath, "utf8").slice(0, 16384);
   } catch {
     return void 0;
   }
-  const basedir = path5.dirname(filePath);
+  const basedir = path6.dirname(filePath);
   const jsReferencePattern = /"([^"]+\.js)"|'([^']+\.js)'|([^\s"'`]+\.js)/g;
   for (const match of text.matchAll(jsReferencePattern)) {
     const raw = match[1] ?? match[2] ?? match[3];
     if (!raw) continue;
     const candidate = raw.replaceAll("${basedir}", basedir).replaceAll("$basedir", basedir).replaceAll("\\ ", " ");
-    const resolved = path5.isAbsolute(candidate) ? candidate : path5.resolve(basedir, candidate);
+    const resolved = path6.isAbsolute(candidate) ? candidate : path6.resolve(basedir, candidate);
     try {
-      if (fs13.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
-        return fs13.realpathSync(resolved);
+      if (fs18.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
+        return fs18.realpathSync(resolved);
       }
     } catch {
     }
@@ -3042,19 +3318,19 @@ function resolveShimNodeScript(filePath) {
   return void 0;
 }
 function resolveRunnableNodeScript(filePath) {
-  const realPath = fs13.realpathSync(filePath);
+  const realPath = fs18.realpathSync(filePath);
   if (isRunnableNodeScript(realPath)) return realPath;
   return resolveShimNodeScript(realPath);
 }
 function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
-  for (const dir of pathEnv.split(path5.delimiter)) {
+  for (const dir of pathEnv.split(path6.delimiter)) {
     if (!dir) continue;
     for (const name of commandNames(command)) {
-      const candidate = path5.join(dir, name);
+      const candidate = path6.join(dir, name);
       try {
-        const stat2 = fs13.statSync(candidate);
+        const stat2 = fs18.statSync(candidate);
         if (!stat2.isFile()) continue;
-        if (process.platform !== "win32") fs13.accessSync(candidate, fs13.constants.X_OK);
+        if (process.platform !== "win32") fs18.accessSync(candidate, fs18.constants.X_OK);
         const runnable = resolveRunnableNodeScript(candidate);
         if (runnable) return runnable;
       } catch {
@@ -3064,11 +3340,11 @@ function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
   return void 0;
 }
 function serverBinWrapperRequiredPath(candidate) {
-  const filename = path5.basename(candidate);
+  const filename = path6.basename(candidate);
   if (filename !== "remnic-server.js" && filename !== "engram-server.js") return void 0;
-  const binDir = path5.dirname(candidate);
-  if (path5.basename(binDir) !== "bin") return void 0;
-  return path5.join(path5.dirname(binDir), "dist", "index.js");
+  const binDir = path6.dirname(candidate);
+  if (path6.basename(binDir) !== "bin") return void 0;
+  return path6.join(path6.dirname(binDir), "dist", "index.js");
 }
 
 // src/service-candidates.ts
@@ -3090,7 +3366,7 @@ function firstSuccessfulCandidate(candidates, attempt) {
 }
 
 // src/bench-args.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/bench-flags.ts
 function readBenchOptionValue(argv, flag) {
@@ -3455,7 +3731,7 @@ function collectBenchmarks(argv) {
 }
 
 // src/bench-args-research.ts
-import path6 from "path";
+import path7 from "path";
 function readPositiveInteger(args, flag) {
   const raw = readBenchOptionValue(args, flag);
   if (raw === void 0) return void 0;
@@ -3501,7 +3777,7 @@ function parseBenchResearchArgs(action, args) {
     }
     const outRaw = readBenchOptionValue(args, "--out");
     if (outRaw !== void 0) {
-      out = path6.resolve(expandTilde(outRaw));
+      out = path7.resolve(expandTilde(outRaw));
     }
   }
   const epochs = readPositiveInteger(args, "--epochs");
@@ -3515,8 +3791,8 @@ function parseBenchResearchArgs(action, args) {
   }
   return {
     runRef,
-    memoryDir: memoryDirRaw ? path6.resolve(expandTilde(memoryDirRaw)) : void 0,
-    qmdPath: qmdPathRaw ? path6.resolve(expandTilde(qmdPathRaw)) : void 0,
+    memoryDir: memoryDirRaw ? path7.resolve(expandTilde(memoryDirRaw)) : void 0,
+    qmdPath: qmdPathRaw ? path7.resolve(expandTilde(qmdPathRaw)) : void 0,
     collection,
     users: readPositiveInteger(args, "--users"),
     epochs,
@@ -3736,7 +4012,7 @@ function parseBenchArgs(argv) {
   }
   validateBenchFlags(action, args);
   const driftGenPositionals = action === "drift-gen" && driftGenAction === "validate" ? collectBenchmarks(args.slice(1)) : [];
-  const driftGenDir = driftGenPositionals[0] ? path7.resolve(expandTilde(driftGenPositionals[0])) : void 0;
+  const driftGenDir = driftGenPositionals[0] ? path8.resolve(expandTilde(driftGenPositionals[0])) : void 0;
   const benchmarkArgs = action === "baseline" || action === "datasets" || action === "providers" || action === "runs" || action === "drift-gen" && (args[0] === "validate" || args[0] === "generate") ? args.slice(1) : args;
   const benchmarks = collectBenchmarks(benchmarkArgs);
   const datasetDir = readBenchOptionValue(args, "--dataset-dir") ?? readBenchOptionValue(args, "--dataset");
@@ -4286,13 +4562,13 @@ function parseBenchArgs(argv) {
     mcpUrl,
     mcpToolMap,
     mcpDemo,
-    datasetDir: datasetDir ? path7.resolve(expandTilde(datasetDir)) : void 0,
-    resultsDir: resultsDir ? path7.resolve(expandTilde(resultsDir)) : void 0,
-    baselinesDir: baselinesDir ? path7.resolve(expandTilde(baselinesDir)) : void 0,
+    datasetDir: datasetDir ? path8.resolve(expandTilde(datasetDir)) : void 0,
+    resultsDir: resultsDir ? path8.resolve(expandTilde(resultsDir)) : void 0,
+    baselinesDir: baselinesDir ? path8.resolve(expandTilde(baselinesDir)) : void 0,
     runtimeProfile,
     matrixProfiles,
-    remnicConfigPath: remnicConfigRaw ? path7.resolve(expandTilde(remnicConfigRaw)) : void 0,
-    openclawConfigPath: openclawConfigRaw ? path7.resolve(expandTilde(openclawConfigRaw)) : void 0,
+    remnicConfigPath: remnicConfigRaw ? path8.resolve(expandTilde(remnicConfigRaw)) : void 0,
+    openclawConfigPath: openclawConfigRaw ? path8.resolve(expandTilde(openclawConfigRaw)) : void 0,
     modelSource,
     gatewayAgentId,
     fastGatewayAgentId,
@@ -4315,13 +4591,13 @@ function parseBenchArgs(argv) {
     internalDisableThinking: args.includes("--internal-disable-thinking"),
     internalCodexReasoningEffort,
     threshold,
-    custom: customRaw ? path7.resolve(expandTilde(customRaw)) : void 0,
+    custom: customRaw ? path8.resolve(expandTilde(customRaw)) : void 0,
     baselineAction,
     datasetAction,
     providerAction,
     runAction,
     format,
-    output: output ? path7.resolve(expandTilde(output)) : void 0,
+    output: output ? path8.resolve(expandTilde(output)) : void 0,
     target,
     publishedName,
     publishedSeed,
@@ -4331,24 +4607,24 @@ function parseBenchArgs(argv) {
     publishedIngestConcurrency,
     publishedTaskFilter,
     memcorrectAdapter,
-    publishedOut: publishedOutRaw ? path7.resolve(expandTilde(publishedOutRaw)) : void 0,
+    publishedOut: publishedOutRaw ? path8.resolve(expandTilde(publishedOutRaw)) : void 0,
     publishedDryRun: args.includes("--dry-run"),
     requestTimeout,
     localJudgeRequestTimeout,
     frontierJudgeRequestTimeout,
-    calibrationDir: calibrationDirRaw ? path7.resolve(expandTilde(calibrationDirRaw)) : void 0,
+    calibrationDir: calibrationDirRaw ? path8.resolve(expandTilde(calibrationDirRaw)) : void 0,
     calibrationLocalConfigSha256,
     calibrationFrontierConfigSha256,
     sourceResultId,
     expectedAnswerSetSha256,
     expectedQuestionIdListSha256,
-    taskIdsFile: taskIdsFileRaw ? path7.resolve(expandTilde(taskIdsFileRaw)) : void 0,
+    taskIdsFile: taskIdsFileRaw ? path8.resolve(expandTilde(taskIdsFileRaw)) : void 0,
     expectedTaskIdListSha256,
     drainTimeout,
     // Issue #1573 PR1: surface judge-cache flags into the runner options.
     noJudgeCache: args.includes("--no-judge-cache"),
-    judgeCacheDir: judgeCacheDirRaw ? path7.resolve(expandTilde(judgeCacheDirRaw)) : void 0,
-    localLabManifestPath: localLabManifestRaw ? path7.resolve(expandTilde(localLabManifestRaw)) : void 0,
+    judgeCacheDir: judgeCacheDirRaw ? path8.resolve(expandTilde(judgeCacheDirRaw)) : void 0,
+    localLabManifestPath: localLabManifestRaw ? path8.resolve(expandTilde(localLabManifestRaw)) : void 0,
     max429WaitMs,
     disableThinking: args.includes("--disable-thinking"),
     amaBenchJudgeProtocol,
@@ -4386,9 +4662,9 @@ function assertCalibrationProvenanceMatches(binding, state, benchmarkId) {
 
 // src/bench-status.ts
 import { mkdir, readFile, readdir as readdir2, rename, writeFile } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function createBenchStatusPath(resultsDir, pid, startedAtMs = Date.now()) {
-  return path8.join(resultsDir, `bench-status-${startedAtMs}-${pid}.json`);
+  return path9.join(resultsDir, `bench-status-${startedAtMs}-${pid}.json`);
 }
 var BENCH_STATUS_FILENAME = /^bench-status-\d+-\d+\.json$/;
 var VALID_BENCH_ENTRY_STATUSES = /* @__PURE__ */ new Set(["pending", "running", "complete", "failed"]);
@@ -4401,7 +4677,7 @@ async function findLatestBenchStatusFile(resultsDir) {
   }
   const candidates = entries.filter((name) => BENCH_STATUS_FILENAME.test(name)).sort().reverse();
   for (const name of candidates) {
-    const filePath = path8.join(resultsDir, name);
+    const filePath = path9.join(resultsDir, name);
     const status = await readBenchStatus(filePath);
     if (status) {
       return filePath;
@@ -4410,7 +4686,7 @@ async function findLatestBenchStatusFile(resultsDir) {
   return null;
 }
 async function atomicWriteJSON(filePath, data) {
-  await mkdir(path8.dirname(filePath), { recursive: true });
+  await mkdir(path9.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`;
   await writeFile(tmp, JSON.stringify(data, null, 2) + "\n");
   await rename(tmp, filePath);
@@ -4527,8 +4803,8 @@ function finalizeBenchStatus(filePath) {
 }
 
 // src/bench-fallback.ts
-import fs14 from "fs";
-import path9 from "path";
+import fs19 from "fs";
+import path10 from "path";
 var FALLBACK_RESULTS_DIRNAME = "fallback-runs";
 function buildBenchRunnerArgs(parsed, benchmarkId, outputDir) {
   const args = ["--benchmark", benchmarkId];
@@ -4592,34 +4868,34 @@ function findUnsupportedFallbackBenchOptions(parsed) {
   return unsupported;
 }
 function createFallbackBenchOutputDir(resultsDir, benchmarkId, pid, startedAtMs = Date.now()) {
-  return path9.join(
+  return path10.join(
     resultsDir,
     FALLBACK_RESULTS_DIRNAME,
     `${benchmarkId}-${startedAtMs}-${pid}`
   );
 }
 function resolveFallbackBenchResultPath(outputDir) {
-  const entries = fs14.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+  const entries = fs19.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}`);
   }
-  return path9.join(outputDir, entries[0]);
+  return path10.join(outputDir, entries[0]);
 }
 
 // src/openclaw-upgrade-swap.ts
-import fs15 from "fs";
-import path10 from "path";
+import fs20 from "fs";
+import path11 from "path";
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function createSiblingTempFilePath(targetPath, label) {
   const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-  return path10.join(path10.dirname(targetPath), `.${path10.basename(targetPath)}.${label}.${nonce}.tmp`);
+  return path11.join(path11.dirname(targetPath), `.${path11.basename(targetPath)}.${label}.${nonce}.tmp`);
 }
 function resolveAtomicWriteMode(targetPath, explicitMode) {
   if (explicitMode !== void 0) return explicitMode;
   try {
-    return fs15.statSync(targetPath).mode & 4095;
+    return fs20.statSync(targetPath).mode & 4095;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return 384;
@@ -4629,8 +4905,8 @@ function resolveAtomicWriteMode(targetPath, explicitMode) {
 }
 function resolveAtomicReplacementPath(targetPath) {
   try {
-    if (fs15.lstatSync(targetPath).isSymbolicLink()) {
-      return fs15.realpathSync(targetPath);
+    if (fs20.lstatSync(targetPath).isSymbolicLink()) {
+      return fs20.realpathSync(targetPath);
     }
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -4642,12 +4918,12 @@ function resolveAtomicReplacementPath(targetPath) {
 }
 function createSiblingSwapPath(targetDir, label) {
   const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-  return path10.join(path10.dirname(targetDir), `.${path10.basename(targetDir)}.${label}.${nonce}`);
+  return path11.join(path11.dirname(targetDir), `.${path11.basename(targetDir)}.${label}.${nonce}`);
 }
 function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
   if (!displacedDir) return void 0;
   try {
-    fs15.rmSync(displacedDir, { recursive: true, force: true });
+    fs20.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)}`;
@@ -4655,43 +4931,43 @@ function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
 }
 function atomicWriteFileSync(targetPath, data, options = {}) {
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs15.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
+  fs20.mkdirSync(path11.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 {
-      fs15.writeFileSync(tempPath, data, { mode });
+      fs20.writeFileSync(tempPath, data, { mode });
     }
-    fs15.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs15.renameSync;
+    fs20.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs20.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs15.rmSync(tempPath, { force: true });
+    fs20.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function atomicCopyFileSync(sourcePath, targetPath, options = {}) {
-  if (!fs15.existsSync(sourcePath)) return;
+  if (!fs20.existsSync(sourcePath)) return;
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs15.mkdirSync(path10.dirname(resolvedTargetPath), { recursive: true });
+  fs20.mkdirSync(path11.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "copy");
-  const mode = fs15.statSync(sourcePath).mode & 4095;
+  const mode = fs20.statSync(sourcePath).mode & 4095;
   try {
-    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs15.copyFileSync;
+    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs20.copyFileSync;
     copyTempFileSync(sourcePath, tempPath);
-    fs15.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs15.renameSync;
+    fs20.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs20.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs15.rmSync(tempPath, { force: true });
+    fs20.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function cleanupRollbackDirectory(rollbackDir) {
   if (!rollbackDir) return;
-  fs15.rmSync(rollbackDir, { recursive: true, force: true });
+  fs20.rmSync(rollbackDir, { recursive: true, force: true });
 }
 function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   if (!rollbackDir) return void 0;
@@ -4703,20 +4979,20 @@ function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   }
 }
 function restoreDirectoryFromRollback(targetDir, rollbackDir) {
-  if (!fs15.existsSync(rollbackDir)) {
+  if (!fs20.existsSync(rollbackDir)) {
     throw new Error(`Rollback directory is missing: ${rollbackDir}`);
   }
-  fs15.mkdirSync(path10.dirname(targetDir), { recursive: true });
-  const displacedDir = fs15.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
+  fs20.mkdirSync(path11.dirname(targetDir), { recursive: true });
+  const displacedDir = fs20.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
   if (displacedDir) {
-    fs15.renameSync(targetDir, displacedDir);
+    fs20.renameSync(targetDir, displacedDir);
   }
   try {
-    fs15.renameSync(rollbackDir, targetDir);
+    fs20.renameSync(rollbackDir, targetDir);
   } catch (restoreError) {
-    if (displacedDir && fs15.existsSync(displacedDir)) {
+    if (displacedDir && fs20.existsSync(displacedDir)) {
       try {
-        fs15.renameSync(displacedDir, targetDir);
+        fs20.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -4732,23 +5008,23 @@ function restoreDirectoryFromRollback(targetDir, rollbackDir) {
   return cleanupDisplacedDirectoryBestEffort(displacedDir, `restored the previous plugin copy into ${targetDir}`);
 }
 function restoreDirectoryFromBackup(targetDir, backupDir) {
-  if (!fs15.existsSync(backupDir)) {
+  if (!fs20.existsSync(backupDir)) {
     throw new Error(`Plugin backup directory is missing: ${backupDir}`);
   }
-  fs15.mkdirSync(path10.dirname(targetDir), { recursive: true });
+  fs20.mkdirSync(path11.dirname(targetDir), { recursive: true });
   const stagedDir = createSiblingSwapPath(targetDir, "backup-restore");
-  const displacedDir = fs15.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
-  fs15.cpSync(backupDir, stagedDir, { recursive: true });
+  const displacedDir = fs20.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
+  fs20.cpSync(backupDir, stagedDir, { recursive: true });
   if (displacedDir) {
-    fs15.renameSync(targetDir, displacedDir);
+    fs20.renameSync(targetDir, displacedDir);
   }
   try {
-    fs15.renameSync(stagedDir, targetDir);
+    fs20.renameSync(stagedDir, targetDir);
   } catch (restoreError) {
-    fs15.rmSync(targetDir, { recursive: true, force: true });
-    if (displacedDir && fs15.existsSync(displacedDir)) {
+    fs20.rmSync(targetDir, { recursive: true, force: true });
+    if (displacedDir && fs20.existsSync(displacedDir)) {
       try {
-        fs15.renameSync(displacedDir, targetDir);
+        fs20.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -4756,7 +5032,7 @@ function restoreDirectoryFromBackup(targetDir, backupDir) {
         );
       }
     }
-    fs15.rmSync(stagedDir, { recursive: true, force: true });
+    fs20.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 }
@@ -4781,7 +5057,7 @@ function rollbackOpenclawUpgrade({
   let configRemovalAttempted = false;
   let pluginRestored = false;
   try {
-    if (rollbackDir && fs15.existsSync(rollbackDir)) {
+    if (rollbackDir && fs20.existsSync(rollbackDir)) {
       const cleanupWarning = restoreDirectoryFromRollback(pluginDir, rollbackDir);
       notes.push(`Restored previous plugin from rollback copy at ${rollbackDir}`);
       if (cleanupWarning) notes.push(cleanupWarning);
@@ -4791,7 +5067,7 @@ function rollbackOpenclawUpgrade({
     rollbackRestoreError = error instanceof Error ? error.message : String(error);
   }
   try {
-    if (!pluginRestored && pluginBackupDir && fs15.existsSync(pluginBackupDir)) {
+    if (!pluginRestored && pluginBackupDir && fs20.existsSync(pluginBackupDir)) {
       const cleanupWarning = restoreDirectoryFromBackup(pluginDir, pluginBackupDir);
       if (rollbackRestoreError) {
         notes.push(`Rollback copy restore failed; restored previous plugin from durable backup at ${pluginBackupDir}`);
@@ -4816,12 +5092,12 @@ function rollbackOpenclawUpgrade({
     notes.push("No previous plugin copy was available for automatic restore");
   }
   try {
-    if (configBackupPath && fs15.existsSync(configBackupPath)) {
+    if (configBackupPath && fs20.existsSync(configBackupPath)) {
       restoreFileFromBackup(configPath, configBackupPath);
       notes.push(`Restored OpenClaw config from backup at ${configBackupPath}`);
-    } else if (removeConfigIfUnbacked && fs15.existsSync(configPath)) {
+    } else if (removeConfigIfUnbacked && fs20.existsSync(configPath)) {
       configRemovalAttempted = true;
-      fs15.rmSync(configPath, { force: true });
+      fs20.rmSync(configPath, { force: true });
       notes.push("Removed OpenClaw config created during the failed upgrade");
     }
   } catch (error) {
@@ -4874,9 +5150,9 @@ Run this manually when you're ready:
 
 // src/openclaw-managed-upgrade-loader.ts
 import { execFileSync } from "child_process";
-import fs16 from "fs";
+import fs21 from "fs";
 import os from "os";
-import path11 from "path";
+import path12 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
 var MANAGED_UPGRADE_SPECIFIER = "@remnic/plugin-openclaw/managed-upgrade";
 var OPENCLAW_PLUGIN_PACKAGE = "@remnic/plugin-openclaw";
@@ -4948,9 +5224,9 @@ function buildOpenclawManagedUpgradePackageSpec(version = "latest") {
   return `${OPENCLAW_PLUGIN_PACKAGE}@${version}`;
 }
 function readCliAdapterRange() {
-  const moduleDir = path11.dirname(fileURLToPath3(import.meta.url));
-  const manifestPath = path11.resolve(moduleDir, "../package.json");
-  const manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf8"));
+  const moduleDir = path12.dirname(fileURLToPath3(import.meta.url));
+  const manifestPath = path12.resolve(moduleDir, "../package.json");
+  const manifest = JSON.parse(fs21.readFileSync(manifestPath, "utf8"));
   if (manifest.name !== "@remnic/cli") {
     throw new Error(`Invalid @remnic/cli package manifest at ${manifestPath}.`);
   }
@@ -4994,7 +5270,7 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
     const adapterMissing = isSpecifierNotFoundError(error, OPENCLAW_PLUGIN_PACKAGE) || isSpecifierNotFoundError(error, MANAGED_UPGRADE_SPECIFIER) || isManagedUpgradeSubpathMissing(error);
     if (!adapterMissing) throw error;
   }
-  const temporaryRoot = fs16.mkdtempSync(path11.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  const temporaryRoot = fs21.mkdtempSync(path12.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
   try {
     const toolingPackageSpec = `${OPENCLAW_PLUGIN_PACKAGE}@${readCliAdapterRange()}`;
     const installArgs = [
@@ -5008,13 +5284,13 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
       toolingPackageSpec
     ];
     (hooks.runNpmInstall ?? runNpmInstall)(installArgs);
-    const resolverPath = path11.join(temporaryRoot, "load-managed-upgrade.mjs");
-    fs16.writeFileSync(resolverPath, `export * from ${JSON.stringify(MANAGED_UPGRADE_SPECIFIER)};
+    const resolverPath = path12.join(temporaryRoot, "load-managed-upgrade.mjs");
+    fs21.writeFileSync(resolverPath, `export * from ${JSON.stringify(MANAGED_UPGRADE_SPECIFIER)};
 `, "utf8");
     return await importModule(pathToFileURL2(resolverPath).href);
   } finally {
     try {
-      fs16.rmSync(temporaryRoot, { recursive: true, force: true });
+      fs21.rmSync(temporaryRoot, { recursive: true, force: true });
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       console.warn(`Could not remove temporary managed upgrade project at ${temporaryRoot}: ${detail}`);
@@ -5023,13 +5299,13 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
 }
 
 // src/remote-daemon.ts
-import fs17 from "fs";
+import fs22 from "fs";
 function readCompatEnv(primary, legacy) {
   return process.env[primary] ?? process.env[legacy];
 }
 function readRemnicConfigRecord(configPath) {
   try {
-    const parsed = JSON.parse(fs17.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs22.readFileSync(configPath, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -5258,11 +5534,11 @@ async function remoteRecallXray(daemon, request) {
 }
 
 // src/daemon-service.ts
-import fs18 from "fs";
-import path12 from "path";
+import fs23 from "fs";
+import path13 from "path";
 import * as childProcess from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
-var thisModuleDir = path12.dirname(fileURLToPath4(import.meta.url));
+var thisModuleDir = path13.dirname(fileURLToPath4(import.meta.url));
 function launchdLoadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["load", "-w", plistPath], { stdio: "pipe" });
 }
@@ -5270,7 +5546,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs18.existsSync;
+  const existsSync4 = options.existsSync ?? fs23.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -5284,8 +5560,8 @@ function resolveServerBinDetails(options = {}) {
     });
   } catch {
   }
-  const workspaceServerBin = path12.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
-  const workspaceDistIndex = path12.resolve(moduleDir, "../../remnic-server/dist/index.js");
+  const workspaceServerBin = path13.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
+  const workspaceDistIndex = path13.resolve(moduleDir, "../../remnic-server/dist/index.js");
   candidates.push(
     {
       path: workspaceServerBin,
@@ -5306,11 +5582,11 @@ function resolveServerBinDetails(options = {}) {
     });
   }
   candidates.push({
-    path: path12.resolve(moduleDir, "../../remnic-server/src/index.ts"),
+    path: path13.resolve(moduleDir, "../../remnic-server/src/index.ts"),
     source: "workspace-source"
   });
   const selected = candidates.find((candidate) => isCandidateReady(candidate, existsSync4)) ?? candidates.find((candidate) => existsSync4(candidate.path)) ?? candidates[0] ?? {
-    path: path12.resolve(moduleDir, "../../remnic-server/dist/index.js"),
+    path: path13.resolve(moduleDir, "../../remnic-server/dist/index.js"),
     source: "workspace-dist"
   };
   const exists = existsSync4(selected.path);
@@ -5329,8 +5605,8 @@ function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync4 = options.readFileSync ?? fs18.readFileSync;
-  const unlinkSync = options.unlinkSync ?? fs18.unlinkSync;
+  const readFileSync4 = options.readFileSync ?? fs23.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs23.unlinkSync;
   const processKill = options.processKill ?? process.kill;
   const platform = options.platform ?? process.platform;
   const execFileSync4 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
@@ -5365,7 +5641,7 @@ function readVerifiedDaemonPid(options) {
 }
 function doesProcessCommandLookLikeRemnicDaemon(command, expectedServerBin) {
   const normalizedCommand = command.trim();
-  const normalizedExpected = path12.resolve(expandTilde(expectedServerBin));
+  const normalizedExpected = path13.resolve(expandTilde(expectedServerBin));
   return normalizedCommand.includes(normalizedExpected) || /(?:^|\s|[/\\])(?:remnic-server|engram-server)(?:\.js)?(?:\s|$)/.test(normalizedCommand) || /@remnic[/\\]server[/\\]/.test(normalizedCommand) || /packages[/\\]remnic-server[/\\](?:bin[/\\]remnic-server\.js|dist[/\\]index\.js|src[/\\]index\.ts)/.test(normalizedCommand);
 }
 function parseDaemonPid(raw) {
@@ -5430,8 +5706,8 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs18.existsSync;
-  const readFileSync4 = options.readFileSync ?? fs18.readFileSync;
+  const existsSync4 = options.existsSync ?? fs23.existsSync;
+  const readFileSync4 = options.readFileSync ?? fs23.readFileSync;
   if (!existsSync4(plistPath)) {
     return {
       installed: false,
@@ -5470,7 +5746,7 @@ function inspectLaunchdPlist(plistPath, options = {}) {
     };
   }
   const expandedServerArg = expandTilde(serverArg);
-  if (!path12.isAbsolute(expandedServerArg)) {
+  if (!path13.isAbsolute(expandedServerArg)) {
     return {
       installed: true,
       ok: false,
@@ -5542,8 +5818,8 @@ function normalizeResolvedPath(resolved) {
   return resolved;
 }
 function packageServerBinFromEntry(packageEntry) {
-  if (path12.basename(packageEntry) === "index.js" && path12.basename(path12.dirname(packageEntry)) === "dist") {
-    return path12.join(path12.dirname(path12.dirname(packageEntry)), "bin", "remnic-server.js");
+  if (path13.basename(packageEntry) === "index.js" && path13.basename(path13.dirname(packageEntry)) === "dist") {
+    return path13.join(path13.dirname(path13.dirname(packageEntry)), "bin", "remnic-server.js");
   }
   return packageEntry;
 }
@@ -5609,7 +5885,7 @@ function stripConfigArgv(args) {
 }
 
 // src/import-dispatch.ts
-import fs19 from "fs";
+import fs24 from "fs";
 import {
   runImporter,
   validateImportBatchSize,
@@ -5618,7 +5894,7 @@ import {
 
 // src/import-bundle-detect.ts
 import { lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import path13 from "path";
+import path14 from "path";
 function detectBundleEntries(bundleDir, options = {}) {
   const readdir3 = options.readdirImpl ?? defaultReaddir;
   const readFileImpl = options.readFileImpl ?? defaultReadFile;
@@ -5649,7 +5925,7 @@ function detectBundleEntries(bundleDir, options = {}) {
   for (const filePath of roots) {
     if (seenFiles.has(filePath)) continue;
     seenFiles.add(filePath);
-    const name = path13.basename(filePath);
+    const name = path14.basename(filePath);
     const match = classifyFile(name, filePath, readFileImpl);
     if (match) entries.push(match);
   }
@@ -5687,7 +5963,7 @@ function collectCandidatePaths(root, readdir3, isDirectory2, isRegularFile) {
       return;
     }
     for (const entry of entries) {
-      const full = path13.join(dir, entry);
+      const full = path14.join(dir, entry);
       if (isDirectory2(full)) {
         walk(full, depth + 1);
       } else if (isRegularFile(full)) {
@@ -5766,7 +6042,8 @@ var SUPPORTED_IMPORTERS = [
   "claude",
   "gemini",
   "mem0",
-  "supermemory"
+  "supermemory",
+  "okf"
 ];
 function isSupportedImporterName(value) {
   return SUPPORTED_IMPORTERS.includes(value);
@@ -5824,16 +6101,16 @@ Or add it to a project:
 }
 
 // src/import-dispatch.ts
-var IMPORT_USAGE = `remnic import \u2014 Bring memory from ChatGPT, Claude, Gemini, Mem0, or Supermemory (issue #568)
+var IMPORT_USAGE = `remnic import \u2014 Bring memory from ChatGPT, Claude, Gemini, Mem0, Supermemory, or OKF
 
 Usage:
   remnic import --adapter <name> --file <path> [options]
+  remnic import okf <dir> [options]
 
 Required:
   --adapter <name>            One of: ${SUPPORTED_IMPORTERS.join(" | ")}
-  --file <path>               Path to a text/JSON source export. ZIP archives
-                              are not accepted by this single-file path yet. May be
-                              omitted for API-only adapters (mem0).
+  --file <path>               Path to a text/JSON source export, or an OKF directory.
+                              Archives must be unpacked first.
 
 Options:
   --dry-run                   Parse and transform only; do not write memories.
@@ -5849,20 +6126,17 @@ Bulk mode (slice 7):
                               mem0 exports inside <dir> and run each
                               matching adapter. Replaces --adapter/--file.
 
-Slice 1 ships infrastructure only. Adapter packages
-(@remnic/import-chatgpt, @remnic/import-claude, @remnic/import-gemini,
-@remnic/import-mem0, @remnic/import-supermemory) land in follow-up slices.
-Install whichever you need:
+Install the adapter you need:
 
   npm install -g @remnic/import-chatgpt
-  npm install -g @remnic/import-claude
-  npm install -g @remnic/import-gemini
-  npm install -g @remnic/import-mem0
-  npm install -g @remnic/import-supermemory
+  npm install -g @remnic/import-okf
 `;
 function parseImportArgs(rest) {
   const args = [...rest];
-  const adapter = takeValue(args, "--adapter");
+  let adapter = takeValue(args, "--adapter");
+  if (!adapter && args[0] && !args[0].startsWith("--") && isSupportedImporterName(args[0])) {
+    adapter = args.shift();
+  }
   if (!adapter) {
     throw new Error(
       `--adapter <name> is required. Valid values: ${SUPPORTED_IMPORTERS.join(", ")}`
@@ -5874,7 +6148,7 @@ function parseImportArgs(rest) {
     );
   }
   const fileRaw = takeOptionalValue(args, "--file");
-  const file = fileRaw !== void 0 ? expandTilde(fileRaw) : void 0;
+  let file = fileRaw !== void 0 ? expandTilde(fileRaw) : void 0;
   const batchSizeRaw = takeOptionalValue(args, "--batch-size");
   let batchSize;
   if (batchSizeRaw !== void 0) {
@@ -5899,6 +6173,9 @@ function parseImportArgs(rest) {
   }
   const dryRun = consumeFlag(args, "--dry-run");
   const includeConversations = consumeFlag(args, "--include-conversations");
+  if (file === void 0 && args[0] && !args[0].startsWith("--")) {
+    file = expandTilde(args.shift());
+  }
   rejectLeftoverImportArgs(args, "remnic import");
   return {
     adapter,
@@ -5923,14 +6200,19 @@ function rejectLeftoverImportArgs(args, command) {
   }
 }
 async function runImportCommand(args, io) {
-  if (args.file && isZipFilePath(args.file)) {
+  if (args.file && (isZipFilePath(args.file) || /\.(tgz|tar\.gz)$/i.test(args.file))) {
     throw new Error(
-      `ZIP imports are not supported by --file yet: '${args.file}'. Extract the archive first or use --all-from-bundle for supported bundle layouts.`
+      `unpack first: archive imports are not supported ('${args.file}'). Extract the archive, then pass the directory.`
     );
   }
   const adapter = await io.loadAdapter(args.adapter);
   let input;
-  if (args.file) {
+  if (args.adapter === "okf") {
+    if (!args.file) {
+      throw new Error("OKF import requires a directory path (remnic import okf <dir>)");
+    }
+    input = args.file;
+  } else if (args.file) {
     try {
       input = await io.readFile(args.file);
     } catch (err) {
@@ -6123,7 +6405,7 @@ async function cmdImport(rest, targetFactory, disposeTarget, ioOverrides = {}) {
   let materializedTarget;
   let materializePromise;
   const io = {
-    readFile: ioOverrides.readFile ?? (async (p) => fs19.promises.readFile(p, "utf-8")),
+    readFile: ioOverrides.readFile ?? (async (p) => fs24.promises.readFile(p, "utf-8")),
     loadAdapter: ioOverrides.loadAdapter ?? (async (name) => (await loadImporterModule(name)).adapter),
     runImporter: ioOverrides.runImporter ?? runImporter,
     getWriteTarget: async () => {
@@ -6236,8 +6518,8 @@ async function cmdCapture(rest, io) {
 }
 
 // src/import-lossless-claw-cmd.ts
-import fs20 from "fs";
-import path14 from "path";
+import fs25 from "fs";
+import path15 from "path";
 import {
   applyLcmSchema,
   ensureLcmStateDir,
@@ -6348,15 +6630,15 @@ async function loadImportLosslessClawModule() {
 
 // src/import-lossless-claw-cmd.ts
 function assertDirectoryOrAbsent(p, label) {
-  if (fs20.existsSync(p) && !fs20.statSync(p).isDirectory()) {
+  if (fs25.existsSync(p) && !fs25.statSync(p).isDirectory()) {
     throw new Error(`${label} is not a directory: ${p}`);
   }
 }
 function assertFile(p, label) {
-  if (!fs20.existsSync(p)) {
+  if (!fs25.existsSync(p)) {
     throw new Error(`${label} does not exist: ${p}`);
   }
-  if (!fs20.statSync(p).isFile()) {
+  if (!fs25.statSync(p).isFile()) {
     throw new Error(`${label} is not a file: ${p}`);
   }
 }
@@ -6387,8 +6669,8 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     let destDb;
     try {
       if (parsed.dryRun) {
-        const lcmPath = path14.join(memoryDir, "state", "lcm.sqlite");
-        if (fs20.existsSync(lcmPath)) {
+        const lcmPath = path15.join(memoryDir, "state", "lcm.sqlite");
+        if (fs25.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
           destDb = mod.openInMemoryDestinationDatabase();
@@ -6509,7 +6791,7 @@ function printBenchComparisonSummary(comparison, baseline, candidate) {
 // src/bench-coding-commands.ts
 import { lstat as lstat2, readFile as readFile2, realpath, stat } from "fs/promises";
 import os2 from "os";
-import path15 from "path";
+import path16 from "path";
 var UINT32_MAX = 4294967295;
 var FROZEN_GENERATOR_SEED = 81;
 var FROZEN_TASK_COUNT = 30;
@@ -6519,7 +6801,7 @@ var FROZEN_MAX_STEPS = 12;
 var FROZEN_MAX_TOOL_CALLS = 8;
 var FROZEN_MAX_OUTPUT_CHARS = 16384;
 var MAX_OUTPUT_BYTES = 16384;
-var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path15.join(
+var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path16.join(
   resolveHomeDir(),
   ".remnic",
   "bench",
@@ -6853,7 +7135,7 @@ function parseBenchCodingArgs(args) {
   throw new Error(`unknown bench coding subcommand ${args[0]}`);
 }
 function normalizeCommandPaths(command) {
-  const resolve2 = (value) => path15.resolve(expandTilde(value));
+  const resolve2 = (value) => path16.resolve(expandTilde(value));
   if (command.kind === "repo-generate") {
     return { ...command, outputDir: resolve2(command.outputDir) };
   }
@@ -6884,23 +7166,23 @@ function normalizeCommandPaths(command) {
   return command;
 }
 async function canonicalProspectivePath(value) {
-  let candidate = path15.resolve(value);
+  let candidate = path16.resolve(value);
   const missingSegments = [];
   while (true) {
     try {
-      return path15.join(await realpath(candidate), ...missingSegments.reverse());
+      return path16.join(await realpath(candidate), ...missingSegments.reverse());
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
-      const parent = path15.dirname(candidate);
+      const parent = path16.dirname(candidate);
       if (parent === candidate) throw error;
-      missingSegments.push(path15.basename(candidate));
+      missingSegments.push(path16.basename(candidate));
       candidate = parent;
     }
   }
 }
 function isSameOrDescendant(candidate, root) {
-  const relative = path15.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path15.sep}`) && !path15.isAbsolute(relative);
+  const relative = path16.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path16.sep}`) && !path16.isAbsolute(relative);
 }
 async function pathExists(value) {
   try {
@@ -6919,7 +7201,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
       const configured = process.env[variable]?.trim();
       if (!configured) continue;
       const memoryRoot = await canonicalProspectivePath(
-        path15.resolve(expandTilde(configured))
+        path16.resolve(expandTilde(configured))
       );
       if (isSameOrDescendant(canonicalOutput, memoryRoot)) {
         throw new Error(refusal);
@@ -6927,10 +7209,10 @@ async function assertSafeBenchmarkOutput(outputDir) {
     }
     let candidate = canonicalOutput;
     while (true) {
-      const hasProfile = await pathExists(path15.join(candidate, "profile.md"));
-      const hasMemoryData = await pathExists(path15.join(candidate, "facts")) || await pathExists(path15.join(candidate, "entities")) || await pathExists(path15.join(candidate, "state"));
+      const hasProfile = await pathExists(path16.join(candidate, "profile.md"));
+      const hasMemoryData = await pathExists(path16.join(candidate, "facts")) || await pathExists(path16.join(candidate, "entities")) || await pathExists(path16.join(candidate, "state"));
       if (hasProfile && hasMemoryData) throw new Error(refusal);
-      const parent = path15.dirname(candidate);
+      const parent = path16.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -6942,7 +7224,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
 async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
   try {
     const parsed = JSON.parse(
-      await readFile2(path15.join(runDir, "run.json"), "utf8")
+      await readFile2(path16.join(runDir, "run.json"), "utf8")
     );
     if (parsed.schemaVersion !== 1 || typeof parsed.runId !== "string" || parsed.runId.length === 0 || typeof parsed.suiteVersion !== "string" || !parsed.suiteVersion.startsWith("h6-failure-gate-v1-")) {
       throw new Error("invalid H6 metadata");
@@ -7001,7 +7283,7 @@ async function runRepoVerification(command, bench) {
   if (command.directory === void 0) {
     dataset = await requireFunction(bench, "loadCommittedH6BenchmarkDataset")();
   } else {
-    const serialized = await readFile2(path15.join(command.directory, "dataset.json"), "utf8").catch(
+    const serialized = await readFile2(path16.join(command.directory, "dataset.json"), "utf8").catch(
       () => void 0
     );
     if (serialized === void 0) {
@@ -7129,8 +7411,8 @@ async function cmdBenchCoding(args) {
 }
 
 // src/bench-security-commands.ts
-import path16 from "path";
-var DEFAULT_OUTPUT_DIR = path16.join(
+import path17 from "path";
+var DEFAULT_OUTPUT_DIR = path17.join(
   resolveHomeDir(),
   ".remnic",
   "bench",
@@ -7279,7 +7561,7 @@ ${BENCH_SECURITY_USAGE}`);
 }
 
 // src/bench-research-commands.ts
-import path17 from "path";
+import path18 from "path";
 function emit(result) {
   if (result.output) {
     console.log(result.output);
@@ -7297,7 +7579,7 @@ async function runBenchResearchCommand(parsed) {
     emit(
       await runAttributeCliCommand({
         runRef: parsed.runRef,
-        resultsDir: parsed.resultsDir ?? path17.join(resolveHomeDir(), ".remnic", "bench", "results"),
+        resultsDir: parsed.resultsDir ?? path18.join(resolveHomeDir(), ".remnic", "bench", "results"),
         memoryDir: parsed.memoryDir,
         qmdPath: parsed.qmdPath,
         collection: parsed.collection,
@@ -7567,15 +7849,15 @@ registerPublisher("hermes", () => new HermesMemoryExtensionPublisher());
 registerPublisher("pi", () => new LazyPluginPiPublisher("pi", (mod) => mod.PiMemoryExtensionPublisher));
 registerPublisher("omp", () => new LazyPluginPiPublisher("omp", (mod) => mod.OmpMemoryExtensionPublisher));
 registerPublisher("prime-agent", () => new LazyPluginPiPublisher("prime-agent", (mod) => mod.PrimeAgentMemoryExtensionPublisher));
-var PID_DIR = path18.join(resolveHomeDir(), ".remnic");
-var LEGACY_PID_DIR = path18.join(resolveHomeDir(), ".engram");
-var PID_FILE = path18.join(PID_DIR, "server.pid");
-var LEGACY_PID_FILE = path18.join(LEGACY_PID_DIR, "server.pid");
-var LOG_FILE = path18.join(PID_DIR, "server.log");
-var LEGACY_LOG_FILE = path18.join(LEGACY_PID_DIR, "server.log");
-var CLI_MODULE_DIR = path18.dirname(fileURLToPath5(import.meta.url));
-var CLI_REPO_ROOT = path18.resolve(CLI_MODULE_DIR, "../../..");
-var EVAL_RUNNER_PATH = path18.join(CLI_REPO_ROOT, "evals", "run.ts");
+var PID_DIR = path19.join(resolveHomeDir(), ".remnic");
+var LEGACY_PID_DIR = path19.join(resolveHomeDir(), ".engram");
+var PID_FILE = path19.join(PID_DIR, "server.pid");
+var LEGACY_PID_FILE = path19.join(LEGACY_PID_DIR, "server.pid");
+var LOG_FILE = path19.join(PID_DIR, "server.log");
+var LEGACY_LOG_FILE = path19.join(LEGACY_PID_DIR, "server.log");
+var CLI_MODULE_DIR = path19.dirname(fileURLToPath5(import.meta.url));
+var CLI_REPO_ROOT = path19.resolve(CLI_MODULE_DIR, "../../..");
+var EVAL_RUNNER_PATH = path19.join(CLI_REPO_ROOT, "evals", "run.ts");
 var OPENCLAW_GATEWAY_LABEL = "ai.openclaw.gateway";
 var CLI_SUCCESS_EXIT_GRACE_MS = 5e3;
 var CLI_OUTPUT_FLUSH_GRACE_MS = 250;
@@ -7740,7 +8022,7 @@ async function resolveAllBenchmarks() {
   if (packageBenchmarks) {
     return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
   }
-  if (!fs21.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs26.existsSync(EVAL_RUNNER_PATH)) {
     return [];
   }
   return BENCHMARK_CATALOG.filter((entry) => entry.category !== "ingestion").map((entry) => entry.id);
@@ -7788,17 +8070,17 @@ 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 (!fs21.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs26.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."
     );
     process.exit(1);
   }
   const tsxCandidates = [
-    path18.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
-    path18.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
+    path19.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
+    path19.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
   ];
-  const tsxCmd = tsxCandidates.find((candidate) => fs21.existsSync(candidate)) ?? "tsx";
+  const tsxCmd = tsxCandidates.find((candidate) => fs26.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
     parsed.resultsDir ?? resolveBenchOutputDir(),
     benchmarkId,
@@ -7815,7 +8097,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
   return resolveFallbackBenchResultPath(fallbackOutputDir);
 }
 function resolveBenchOutputDir() {
-  return path18.join(resolveHomeDir(), ".remnic", "bench", "results");
+  return path19.join(resolveHomeDir(), ".remnic", "bench", "results");
 }
 var DOWNLOADABLE_BENCHMARK_DATASETS = [
   "ama-bench",
@@ -7860,8 +8142,8 @@ var MEMORY_AGENT_BENCH_SPLIT_FILENAMES = [
 ];
 var MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES = [
   "entity2id.json",
-  path18.join("processed_data", "Recsys_Redial", "entity2id.json"),
-  path18.join("Recsys_Redial", "entity2id.json")
+  path19.join("processed_data", "Recsys_Redial", "entity2id.json"),
+  path19.join("Recsys_Redial", "entity2id.json")
 ];
 var DOWNLOADED_DATASET_MARKERS = {
   "ama-bench": { anyOf: ["open_end_qa_set.jsonl"] },
@@ -7936,18 +8218,18 @@ var PERSONAMEM_DATASET_FILE_CANDIDATES = [
   "benchmark/benchmark.csv",
   "benchmark.csv"
 ];
-var PERSONAMEM_COMPLETION_MARKER = path18.join(
+var PERSONAMEM_COMPLETION_MARKER = path19.join(
   "data",
   "chat_history_32k",
   ".download-complete"
 );
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
-    const datasetRoot = fs21.realpathSync(datasetPath);
-    const candidatePath = path18.resolve(datasetRoot, relativePath);
-    const candidateRealPath = fs21.realpathSync(candidatePath);
-    const relativeToRoot = path18.relative(datasetRoot, candidateRealPath);
-    if (relativeToRoot.startsWith("..") || path18.isAbsolute(relativeToRoot)) {
+    const datasetRoot = fs26.realpathSync(datasetPath);
+    const candidatePath = path19.resolve(datasetRoot, relativePath);
+    const candidateRealPath = fs26.realpathSync(candidatePath);
+    const relativeToRoot = path19.relative(datasetRoot, candidateRealPath);
+    if (relativeToRoot.startsWith("..") || path19.isAbsolute(relativeToRoot)) {
       return null;
     }
     return candidateRealPath;
@@ -8003,15 +8285,15 @@ function parseCsvRows(raw) {
 }
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
-    const completionMarkerPath = path18.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
-    if (fs21.statSync(completionMarkerPath).isFile()) {
+    const completionMarkerPath = path19.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
+    if (fs26.statSync(completionMarkerPath).isFile()) {
       return true;
     }
   } catch {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs21.statSync(path18.join(datasetPath, candidate)).isFile();
+      return fs26.statSync(path19.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -8020,7 +8302,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs21.readFileSync(path18.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs26.readFileSync(path19.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -8035,7 +8317,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     }
     return historyPaths.every((relativePath) => {
       const resolvedPath = resolveRealpathWithinDataset(datasetPath, relativePath);
-      return resolvedPath !== null && fs21.statSync(resolvedPath).isFile();
+      return resolvedPath !== null && fs26.statSync(resolvedPath).isFile();
     });
   } catch {
     return false;
@@ -8043,14 +8325,14 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs21.statSync(path18.join(datasetPath, relativePath)).isFile();
+    return fs26.statSync(path19.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
 }
 function hasMemoryAgentBenchEntityMapping(datasetPath) {
-  const absoluteDatasetPath = path18.resolve(datasetPath);
-  const roots = [absoluteDatasetPath, path18.dirname(absoluteDatasetPath)];
+  const absoluteDatasetPath = path19.resolve(datasetPath);
+  const roots = [absoluteDatasetPath, path19.dirname(absoluteDatasetPath)];
   return hasDatasetFile(absoluteDatasetPath, "entity2id.json") || roots.some(
     (root) => MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES.filter((relativePath) => relativePath !== "entity2id.json").some((relativePath) => hasDatasetFile(root, relativePath))
   );
@@ -8061,12 +8343,12 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
     ...MEMORY_AGENT_BENCH_SPLIT_FILENAMES
   ];
   return candidateFilenames.some((filename) => {
-    const filePath = path18.join(datasetPath, filename);
+    const filePath = path19.join(datasetPath, filename);
     try {
-      if (!fs21.statSync(filePath).isFile()) {
+      if (!fs26.statSync(filePath).isFile()) {
         return false;
       }
-      const raw = fs21.readFileSync(filePath, "utf8");
+      const raw = fs26.readFileSync(filePath, "utf8");
       return /"source"\s*:\s*"recsys[_-]/i.test(raw);
     } catch {
       return false;
@@ -8082,7 +8364,7 @@ function isMemoryAgentBenchDatasetComplete(datasetPath) {
 function isDatasetDownloaded(datasetPath, benchmarkId) {
   let stats;
   try {
-    stats = fs21.statSync(datasetPath);
+    stats = fs26.statSync(datasetPath);
   } catch {
     return false;
   }
@@ -8092,7 +8374,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
   if (!marker) {
     try {
-      return fs21.readdirSync(datasetPath).length > 0;
+      return fs26.readdirSync(datasetPath).length > 0;
     } catch {
       return false;
     }
@@ -8100,7 +8382,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs21.statSync(path18.join(datasetPath, name)).isFile();
+        return fs26.statSync(path19.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -8112,7 +8394,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs21.statSync(path18.join(datasetPath, name)).isFile();
+        return fs26.statSync(path19.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -8130,7 +8412,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   }
   if (marker.ext) {
     try {
-      return fs21.readdirSync(datasetPath).some(
+      return fs26.readdirSync(datasetPath).some(
         (name) => name.endsWith(marker.ext) && !marker.exclude?.includes(name)
       );
     } catch {
@@ -8140,9 +8422,9 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   return false;
 }
 async function launchBenchUi(resultsDir) {
-  const benchUiDir = path18.join(CLI_REPO_ROOT, "packages", "bench-ui");
+  const benchUiDir = path19.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs21.existsSync(path18.join(benchUiDir, "package.json"))) {
+  if (!fs26.existsSync(path19.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -8169,24 +8451,24 @@ async function launchBenchUi(resultsDir) {
   });
 }
 function resolveRepoDatasetRoot() {
-  const repoCandidate = path18.join(CLI_REPO_ROOT, "evals", "datasets");
+  const repoCandidate = path19.join(CLI_REPO_ROOT, "evals", "datasets");
   if (isRepoCheckout()) {
     return repoCandidate;
   }
-  return path18.join(resolveHomeDir(), ".remnic", "bench", "datasets");
+  return path19.join(resolveHomeDir(), ".remnic", "bench", "datasets");
 }
 function listDownloadableBenchmarks() {
   return [...DOWNLOADABLE_BENCHMARK_DATASETS];
 }
 function resolveDatasetDownloadScriptPath() {
-  const bundled = path18.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
-  if (fs21.existsSync(bundled)) {
+  const bundled = path19.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
+  if (fs26.existsSync(bundled)) {
     return bundled;
   }
-  return path18.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
+  return path19.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs21.existsSync(path18.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs21.existsSync(path18.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs26.existsSync(path19.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs26.existsSync(path19.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -8237,7 +8519,7 @@ function resolveBenchDatasetDir(benchmarkId, quick, datasetDirOverride) {
   if (quick) {
     return void 0;
   }
-  const datasetDir = path18.join(resolveRepoDatasetRoot(), benchmarkId);
+  const datasetDir = path19.join(resolveRepoDatasetRoot(), benchmarkId);
   if (isDatasetDownloaded(datasetDir, benchmarkId)) {
     return datasetDir;
   }
@@ -8494,13 +8776,13 @@ async function exportBenchPackageResult(parsed) {
     process.exit(1);
   }
   const result = await loadBenchmarkResult(summary.path);
-  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path18.dirname(summary.path), result.meta.id) : void 0;
+  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path19.dirname(summary.path), result.meta.id) : void 0;
   const rendered = renderBenchmarkResultExport(result, parsed.format, {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs21.mkdirSync(path18.dirname(parsed.output), { recursive: true });
-    fs21.writeFileSync(parsed.output, rendered);
+    fs26.mkdirSync(path19.dirname(parsed.output), { recursive: true });
+    fs26.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
   }
@@ -8517,7 +8799,7 @@ async function manageBenchDatasets(parsed) {
       process.exit(1);
     }
     const status = supported.map((benchmarkId) => {
-      const datasetPath = path18.join(datasetRoot, benchmarkId);
+      const datasetPath = path19.join(datasetRoot, benchmarkId);
       return {
         benchmark: benchmarkId,
         downloaded: isDatasetDownloaded(datasetPath, benchmarkId),
@@ -8545,7 +8827,7 @@ async function manageBenchDatasets(parsed) {
     process.exit(1);
   }
   const scriptPath = resolveDatasetDownloadScriptPath();
-  if (!fs21.existsSync(scriptPath)) {
+  if (!fs26.existsSync(scriptPath)) {
     console.error(`ERROR: dataset download script not found: ${scriptPath}`);
     process.exit(1);
   }
@@ -8555,7 +8837,7 @@ async function manageBenchDatasets(parsed) {
     runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, parsed.json === true);
     downloaded.push({
       benchmark: benchmarkId,
-      path: path18.join(datasetRoot, benchmarkId)
+      path: path19.join(datasetRoot, benchmarkId)
     });
   }
   if (parsed.json) {
@@ -8694,10 +8976,10 @@ async function calibrateBenchJudges(parsed, rawArgs) {
   }
   const bench = await loadBenchModule();
   const resultsDir = expandTilde(
-    parsed.resultsDir ?? path18.join(resolveHomeDir(), ".remnic", "bench", "results")
+    parsed.resultsDir ?? path19.join(resolveHomeDir(), ".remnic", "bench", "results")
   );
   const calibrationDir = expandTilde(
-    parsed.calibrationDir ?? path18.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    parsed.calibrationDir ?? path19.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const stored = await bench.listBenchmarkResults(resultsDir);
   const allForBenchmark = stored.filter((entry) => entry.benchmark === benchmarkId);
@@ -8745,7 +9027,7 @@ async function calibrateBenchJudges(parsed, rawArgs) {
     );
     process.exit(1);
   }
-  const sourceResultSha256 = createHash4("sha256").update(fs21.readFileSync(latest.path)).digest("hex");
+  const sourceResultSha256 = createHash4("sha256").update(fs26.readFileSync(latest.path)).digest("hex");
   const expandedManifestPath = expandTilde(manifestPath);
   if (!bench.resolveLocalLabJudgeProviderConfig) {
     console.error(
@@ -9160,7 +9442,7 @@ function loadPinnedLoCoMoTaskSelector(parsed) {
   }
   let decoded;
   try {
-    decoded = JSON.parse(fs21.readFileSync(parsed.taskIdsFile, "utf8"));
+    decoded = JSON.parse(fs26.readFileSync(parsed.taskIdsFile, "utf8"));
   } catch (error) {
     throw new Error(
       `Unable to read --task-ids-file ${parsed.taskIdsFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -9257,7 +9539,7 @@ async function loadPublishedPromotionHelpers() {
   return {
     async promoteArtifactsToPublished(args) {
       const { mkdirSync, readFileSync: readFileSync4, writeFileSync } = await import("fs");
-      const path19 = await import("path");
+      const path20 = await import("path");
       mkdirSync(args.publishedOutDir, { recursive: true });
       if (args.artifactPaths.length === 0) {
         console.warn(
@@ -9274,13 +9556,13 @@ async function loadPublishedPromotionHelpers() {
         const modelSlug = args.model.replace(/[^a-zA-Z0-9_.-]/g, "-");
         const rawProfile = parsedObj.config?.runtimeProfile;
         const profileSlug = typeof rawProfile === "string" && rawProfile.length > 0 ? `-${rawProfile.replace(/[^a-zA-Z0-9_.-]/g, "-")}` : "";
-        const target = path19.join(
+        const target = path20.join(
           args.publishedOutDir,
           `${today}-${args.benchmarkId}-${modelSlug}${profileSlug}-${gitShaShort}.json`
         );
         writeFileSync(target, raw, "utf8");
         console.log(
-          `[bench published] Promoted ${path19.basename(artifactPath)} \u2192 ${target}`
+          `[bench published] Promoted ${path20.basename(artifactPath)} \u2192 ${target}`
         );
       }
       void benchModule;
@@ -9387,7 +9669,7 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
   const previousCodexDiagnosticsDir = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV];
   const previousCodexDiagnosticsMode = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_MODE_ENV];
   if (!previousCodexDiagnosticsDir) {
-    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path18.join(
+    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path19.join(
       outputDir,
       "codex-cli-diagnostics"
     );
@@ -9537,7 +9819,7 @@ async function preparePersistedJudgeCalibrationAttachment(benchModule, benchmark
     );
   }
   const calibrationDir = expandTilde(
-    calibrationBinding.calibrationDir ?? path18.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    calibrationBinding.calibrationDir ?? path19.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const state = await benchModule.loadJudgeCalibrationState?.(benchmarkId, calibrationDir);
   if (!state) {
@@ -9835,7 +10117,7 @@ function resolveBenchReproDatasetDir(datasetDir) {
     return void 0;
   }
   try {
-    return fs21.realpathSync(datasetDir);
+    return fs26.realpathSync(datasetDir);
   } catch {
     return datasetDir;
   }
@@ -9889,13 +10171,13 @@ async function writeBenchReproManifestForPackageRun(args) {
 }
 function loadStandaloneConvergeCommandConfig() {
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  return parseConfig12(resolveRemnicConfigRecord11(raw));
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  return parseConfig17(resolveRemnicConfigRecord16(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 parseConfig12(resolveRemnicConfigRecord11(value));
+  return parseConfig17(resolveRemnicConfigRecord16(value));
 }
 function loadConvergeCommandConfig() {
   if (readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH")) {
@@ -9908,23 +10190,23 @@ function loadConvergeCommandConfig() {
   return loadStandaloneConvergeCommandConfig();
 }
 function resolveConfigPath(cliPath) {
-  if (cliPath) return path18.resolve(expandTilde(cliPath));
+  if (cliPath) return path19.resolve(expandTilde(cliPath));
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
-  if (envPath) return path18.resolve(expandTilde(envPath));
+  if (envPath) return path19.resolve(expandTilde(envPath));
   const candidates = [
-    path18.join(process.cwd(), "remnic.config.json"),
-    path18.join(process.cwd(), "engram.config.json"),
-    path18.join(resolveHomeDir(), ".config", "remnic", "config.json"),
-    path18.join(resolveHomeDir(), ".config", "engram", "config.json")
+    path19.join(process.cwd(), "remnic.config.json"),
+    path19.join(process.cwd(), "engram.config.json"),
+    path19.join(resolveHomeDir(), ".config", "remnic", "config.json"),
+    path19.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs21.existsSync(candidate)) return candidate;
+    if (fs26.existsSync(candidate)) return candidate;
   }
-  return path18.join(resolveHomeDir(), ".config", "remnic", "config.json");
+  return path19.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
-  if (fs21.existsSync(configPath)) {
+  if (fs26.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -9934,7 +10216,7 @@ function resolveExistingBenchRemnicConfigPath(cliPath) {
 }
 function resolveExistingBenchOpenclawConfigPath(cliPath) {
   const configPath = resolveOpenclawConfigPath(cliPath);
-  if (fs21.existsSync(configPath)) {
+  if (fs26.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -10034,34 +10316,34 @@ async function resolvePackageBenchRuntime(benchModule, parsed, runtimeProfile) {
   );
 }
 function normalizeMemoryDirPath(memoryDir) {
-  return path18.resolve(expandTilde(memoryDir));
+  return path19.resolve(expandTilde(memoryDir));
 }
 function resolveMemoryDir() {
   const configMemoryDir = (() => {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return normalizeMemoryDirPath(envMemoryDir);
     const configPath = resolveConfigPath();
-    const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord11(raw);
+    const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
     if (typeof remnicCfg.memoryDir === "string" && remnicCfg.memoryDir.length > 0) {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
     const home = resolveHomeDir();
-    const standalonePath = path18.join(home, ".remnic", "memory");
-    const legacyStandalonePath = path18.join(home, ".engram", "memory");
-    const openclawPath = path18.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
-    if (fs21.existsSync(standalonePath)) return standalonePath;
-    if (fs21.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    const standalonePath = path19.join(home, ".remnic", "memory");
+    const legacyStandalonePath = path19.join(home, ".engram", "memory");
+    const openclawPath = path19.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+    if (fs26.existsSync(standalonePath)) return standalonePath;
+    if (fs26.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs21.existsSync(manifestPath)) {
+  if (fs26.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
         const activeMemoryDir = normalizeMemoryDirPath(active.memoryDir);
-        if (!fs21.existsSync(activeMemoryDir)) {
-          fs21.mkdirSync(activeMemoryDir, { recursive: true });
+        if (!fs26.existsSync(activeMemoryDir)) {
+          fs26.mkdirSync(activeMemoryDir, { recursive: true });
         }
         return activeMemoryDir;
       }
@@ -10098,25 +10380,25 @@ function resolveFlagStrict(args, flag) {
 var REMNIC_OPENCLAW_LEGACY_PLUGIN_ID = "openclaw-engram";
 function resolveOpenclawStateDir() {
   const configuredStateDir = process.env.OPENCLAW_STATE_DIR?.trim();
-  return configuredStateDir ? path18.resolve(expandTilde(configuredStateDir)) : path18.join(resolveHomeDir(), ".openclaw");
+  return configuredStateDir ? path19.resolve(expandTilde(configuredStateDir)) : path19.join(resolveHomeDir(), ".openclaw");
 }
 var DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR = [
   process.env.OPENCLAW_CONFIG_PATH,
   process.env.OPENCLAW_ENGRAM_CONFIG_PATH,
-  path18.join(resolveOpenclawStateDir(), "openclaw.json")
+  path19.join(resolveOpenclawStateDir(), "openclaw.json")
 ].filter(Boolean);
 function resolveOpenclawConfigPath(cliPath) {
-  if (cliPath) return path18.resolve(expandTilde(cliPath));
+  if (cliPath) return path19.resolve(expandTilde(cliPath));
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
-  if (envPath) return path18.resolve(expandTilde(envPath));
+  if (envPath) return path19.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
-    if (fs21.existsSync(candidate)) return candidate;
+    if (fs26.existsSync(candidate)) return candidate;
   }
-  return path18.join(resolveOpenclawStateDir(), "openclaw.json");
+  return path19.join(resolveOpenclawStateDir(), "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
-  if (!fs21.existsSync(configPath)) return {};
-  const raw = fs21.readFileSync(configPath, "utf-8");
+  if (!fs26.existsSync(configPath)) return {};
+  const raw = fs26.readFileSync(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -10171,10 +10453,10 @@ function buildRemnicOpenclawHooksPolicy(legacyHooks, existingHooks) {
 function resolveOpenclawInstallMemoryDir(args) {
   const existingMemoryDir = (typeof args.existingNewEntryConfig.memoryDir === "string" ? args.existingNewEntryConfig.memoryDir : void 0) || (args.migrateLegacy && typeof args.legacyConfigToMerge.memoryDir === "string" ? args.legacyConfigToMerge.memoryDir : void 0);
   if (args.requestedMemoryDir) {
-    return path18.resolve(expandTilde(args.requestedMemoryDir));
+    return path19.resolve(expandTilde(args.requestedMemoryDir));
   }
   if (existingMemoryDir) {
-    return path18.resolve(expandTilde(existingMemoryDir));
+    return path19.resolve(expandTilde(existingMemoryDir));
   }
   return args.fallbackMemoryDir;
 }
@@ -10192,21 +10474,21 @@ function resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir) {
     if (!config || typeof config !== "object" || Array.isArray(config)) continue;
     const memoryDir = config.memoryDir;
     if (typeof memoryDir === "string" && memoryDir.trim().length > 0) {
-      return path18.resolve(expandTilde(memoryDir));
+      return path19.resolve(expandTilde(memoryDir));
     }
   }
   return fallbackMemoryDir;
 }
 function resolveOpenclawPluginDir(cliPath) {
-  if (cliPath) return path18.resolve(expandTilde(cliPath));
+  if (cliPath) return path19.resolve(expandTilde(cliPath));
   return resolveOpenclawManagedPluginDir();
 }
 function resolveOpenclawManagedPluginDir() {
-  return path18.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  return path19.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
 }
 function resolveOpenclawLegacyPluginDir(cliPath) {
-  if (cliPath) return path18.resolve(expandTilde(cliPath));
-  return path18.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
+  if (cliPath) return path19.resolve(expandTilde(cliPath));
+  return path19.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
 }
 function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   const yyyy = now.getFullYear().toString();
@@ -10218,9 +10500,9 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
 }
 function backupPathIfPresent(sourcePath, backupPath) {
-  if (!fs21.existsSync(sourcePath)) return false;
-  fs21.mkdirSync(path18.dirname(backupPath), { recursive: true });
-  fs21.cpSync(sourcePath, backupPath, { recursive: true });
+  if (!fs26.existsSync(sourcePath)) return false;
+  fs26.mkdirSync(path19.dirname(backupPath), { recursive: true });
+  fs26.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
 function restartOpenclawGateway() {
@@ -10238,15 +10520,15 @@ function restartOpenclawGateway() {
   });
 }
 function cmdInit() {
-  const configPath = path18.join(process.cwd(), "remnic.config.json");
-  if (fs21.existsSync(configPath)) {
+  const configPath = path19.join(process.cwd(), "remnic.config.json");
+  if (fs26.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
   const template = {
     remnic: {
       openaiApiKey: "${OPENAI_API_KEY}",
-      memoryDir: path18.join(process.cwd(), ".remnic", "memory"),
+      memoryDir: path19.join(process.cwd(), ".remnic", "memory"),
       memoryOsPreset: "balanced"
     },
     server: {
@@ -10255,7 +10537,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs21.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs26.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-...");
@@ -10308,7 +10590,7 @@ async function cmdStatus(json) {
   console.log(`Remnic server: running${pid ? ` (pid ${pid})` : ""}`);
   await printHealthCheck(resolveDaemonBaseUrl(resolveConfigPath()), resolveStatusProbeToken());
 }
-async function oauthFetch(method, path19, token, body) {
+async function oauthFetch(method, path20, token, body) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 5e3);
   try {
@@ -10327,7 +10609,7 @@ async function oauthFetch(method, path19, token, body) {
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const response = await fetch(`${resolveDaemonBaseUrl(resolveConfigPath())}${path19}`, init);
+    const response = await fetch(`${resolveDaemonBaseUrl(resolveConfigPath())}${path20}`, init);
     if (response.status === 401) {
       throw new Error(
         "operator token rejected by remnic-server (HTTP 401). Update `server.authToken` or `REMNIC_AUTH_TOKEN` to match the running daemon."
@@ -10677,10 +10959,10 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
-  const orchestrator = new Orchestrator7(config);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
+  const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   const service = new EngramAccessService2(orchestrator);
   const recallRequest = buildQueryRecallRequest(queryText);
@@ -10857,10 +11139,10 @@ async function cmdXray(rest) {
   }
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
-  const orchestrator = new Orchestrator7(config);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
+  const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const service = new EngramAccessService2(orchestrator);
@@ -10890,8 +11172,8 @@ async function runWhoKnowsCommand(rest, io) {
 async function withLocalService(fn) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const orchestrator = new Orchestrator7(parseConfig12(resolveRemnicConfigRecord11(raw)));
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const orchestrator = new Orchestrator10(parseConfig17(resolveRemnicConfigRecord16(raw)));
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const service = new EngramAccessService2(orchestrator);
@@ -10923,9 +11205,9 @@ async function cmdPromotionCandidates(rest) {
 async function cmdVersions(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   if (!config.versioningEnabled) {
     console.error("Page versioning is disabled (versioningEnabled = false).");
     process.exit(1);
@@ -10945,7 +11227,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions list <page-path>");
         process.exit(1);
       }
-      const absPath = path18.resolve(pagePath);
+      const absPath = path19.resolve(pagePath);
       const history = await listVersions(absPath, versioningConfig, memDir);
       if (json) {
         console.log(JSON.stringify(history, null, 2));
@@ -10970,7 +11252,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions show <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path18.resolve(pagePath);
+      const absPath = path19.resolve(pagePath);
       try {
         const content = await getVersion(absPath, versionId, versioningConfig, memDir);
         console.log(content);
@@ -10988,7 +11270,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions diff <page-path> <v1> <v2>");
         process.exit(1);
       }
-      const absPath = path18.resolve(pagePath);
+      const absPath = path19.resolve(pagePath);
       try {
         const diffOutput = await diffVersions(absPath, v1, v2, versioningConfig, memDir);
         console.log(diffOutput);
@@ -11005,7 +11287,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions revert <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path18.resolve(pagePath);
+      const absPath = path19.resolve(pagePath);
       try {
         const version = await revertToVersion(absPath, versionId, versioningConfig, void 0, memDir);
         if (json) {
@@ -11039,13 +11321,13 @@ Options:
 async function cmdEnrich(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
-    const auditDir2 = path18.join(memoryDir2, "enrichment");
+    const auditDir2 = path19.join(memoryDir2, "enrichment");
     const sinceFlag = resolveFlag(rest.slice(1), "--since");
     const entries = await readAuditLog(auditDir2, sinceFlag ?? void 0);
     if (entries.length === 0) {
@@ -11069,7 +11351,7 @@ async function cmdEnrich(rest) {
     pipelineConfig2.providers = [
       { id: "web-search", enabled: true, costTier: "cheap" }
     ];
-    const orchestrator2 = new Orchestrator7(config);
+    const orchestrator2 = new Orchestrator10(config);
     await orchestrator2.initialize();
     await orchestrator2.deferredReady;
     const searchBackend2 = orchestrator2.qmd;
@@ -11105,7 +11387,7 @@ Registered providers:`);
     console.error("Usage: remnic enrich <entity-name> | --all | --dry-run | audit | providers");
     process.exit(1);
   }
-  const orchestrator = new Orchestrator7(config);
+  const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const storage = await orchestrator.getStorage(config.defaultNamespace);
@@ -11170,7 +11452,7 @@ Registered providers:`);
     return;
   }
   const memoryDir = expandTilde(config.memoryDir);
-  const auditDir = path18.join(memoryDir, "enrichment");
+  const auditDir = path19.join(memoryDir, "enrichment");
   let totalPersisted = 0;
   for (const result of results) {
     for (const candidate of result.acceptedCandidates) {
@@ -11233,9 +11515,9 @@ Registered providers:`);
 async function cmdExtensions(action, rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const root = resolveExtensionsRoot(config);
   const noopLog = { warn: () => {
   }, debug: () => {
@@ -11284,7 +11566,7 @@ Root: ${root}`);
       const extensions = await discoverMemoryExtensions(root, warnLog);
       let entries = [];
       try {
-        entries = fs21.readdirSync(root);
+        entries = fs26.readdirSync(root);
       } catch {
         console.log(`Extensions root does not exist: ${root}`);
         process.exitCode = 0;
@@ -11293,9 +11575,9 @@ Root: ${root}`);
       const validNames = new Set(extensions.map((e) => e.name));
       let errors = 0;
       for (const entry of entries) {
-        const entryPath = path18.join(root, entry);
+        const entryPath = path19.join(root, entry);
         try {
-          if (!fs21.statSync(entryPath).isDirectory()) continue;
+          if (!fs26.statSync(entryPath).isDirectory()) continue;
         } catch {
           continue;
         }
@@ -11327,9 +11609,9 @@ Root: ${root}`);
 async function cmdBriefing(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   if (!config.briefing.enabled) {
     console.error("Briefing is disabled in config (briefing.enabled = false).");
     process.exit(1);
@@ -11382,7 +11664,7 @@ async function cmdBriefing(rest) {
     process.exit(1);
   }
   const format = effectiveFormatFlag === "json" ? "json" : effectiveFormatFlag === "markdown" ? "markdown" : config.briefing.defaultFormat;
-  const orchestrator = new Orchestrator7(config);
+  const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   const storage = await orchestrator.getStorage(config.defaultNamespace);
   const calendarSource = config.briefing.calendarSource ? new FileCalendarSource(config.briefing.calendarSource) : void 0;
@@ -11407,10 +11689,10 @@ async function cmdBriefing(rest) {
   if (save) {
     try {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
-      fs21.mkdirSync(saveDir, { recursive: true });
+      fs26.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
-      const filePath = path18.join(saveDir, filename);
-      fs21.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
+      const filePath = path19.join(saveDir, filename);
+      fs26.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)}`);
@@ -11428,7 +11710,7 @@ async function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs21.existsSync(configPath);
+  const configExists = fs26.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   let standaloneConfig;
   let standaloneConfigError;
@@ -11436,11 +11718,11 @@ async function cmdDoctor() {
   let configuredNs = { invalid: false };
   if (configExists) {
     try {
-      const raw = JSON.parse(fs21.readFileSync(configPath, "utf8"));
-      const remnicCfg = resolveRemnicConfigRecord11(raw);
+      const raw = JSON.parse(fs26.readFileSync(configPath, "utf8"));
+      const remnicCfg = resolveRemnicConfigRecord16(raw);
       standaloneOpenaiApiKeyExplicitlyFalse = isOpenaiApiKeyDisabled(remnicCfg.openaiApiKey);
       configuredNs = readConfiguredNamespace(remnicCfg);
-      standaloneConfig = parseConfig12(remnicCfg);
+      standaloneConfig = parseConfig17(remnicCfg);
     } catch (err) {
       standaloneConfigError = err instanceof Error ? err.message : String(err);
     }
@@ -11449,10 +11731,10 @@ async function cmdDoctor() {
   try {
     memoryDir = resolveMemoryDir();
   } catch {
-    memoryDir = parseConfig12({}).memoryDir;
+    memoryDir = parseConfig17({}).memoryDir;
   }
   try {
-    fs21.mkdirSync(memoryDir, { recursive: true });
+    fs26.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}` });
@@ -11481,7 +11763,7 @@ async function cmdDoctor() {
   });
   if (nsPolicyCheck) checks.push(nsPolicyCheck);
   const openclawConfigPath = resolveOpenclawConfigPath();
-  const openclawConfigExists = fs21.existsSync(openclawConfigPath);
+  const openclawConfigExists = fs26.existsSync(openclawConfigPath);
   let openclawConfig = {};
   let openclawConfigValid = false;
   let openclawPluginModeConfigured = false;
@@ -11489,7 +11771,7 @@ async function cmdDoctor() {
   let activeOpenclawEntryConfig = null;
   if (openclawConfigExists) {
     try {
-      const parsed = JSON.parse(fs21.readFileSync(openclawConfigPath, "utf-8"));
+      const parsed = JSON.parse(fs26.readFileSync(openclawConfigPath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         openclawConfig = parsed;
         openclawConfigValid = true;
@@ -11565,13 +11847,13 @@ async function cmdDoctor() {
       const rawMemoryDir = entryConfig?.memoryDir;
       const configuredMemoryDir = typeof rawMemoryDir === "string" ? rawMemoryDir : void 0;
       if (configuredMemoryDir) {
-        const resolvedMemDir = path18.resolve(expandTilde(configuredMemoryDir));
+        const resolvedMemDir = path19.resolve(expandTilde(configuredMemoryDir));
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
-        if (fs21.existsSync(resolvedMemDir)) {
+        if (fs26.existsSync(resolvedMemDir)) {
           try {
-            const stat2 = fs21.statSync(resolvedMemDir);
+            const stat2 = fs26.statSync(resolvedMemDir);
             if (stat2.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
@@ -11726,12 +12008,12 @@ async function cmdDoctor() {
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs21.existsSync(configPath)) {
+  if (!fs26.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs21.readFileSync(configPath, "utf8");
+  const rawConfig = fs26.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -11778,7 +12060,7 @@ async function cmdMigrate(json, rollback) {
   console.log(`  Rollback: ${result.rollbackCommand}`);
 }
 function cmdOnboard(dirPath, json) {
-  const directory = path18.resolve(dirPath || process.cwd());
+  const directory = path19.resolve(dirPath || process.cwd());
   const result = onboard({ directory });
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -11797,7 +12079,7 @@ Suggested namespace: ${result.plan.suggestedNamespace}`);
 async function cmdCurate(targetPath, json) {
   const memoryDir = resolveMemoryDir();
   const result = await curate({
-    targetPath: path18.resolve(targetPath),
+    targetPath: path19.resolve(targetPath),
     memoryDir,
     source: "curation",
     checkDuplicates: true,
@@ -11839,9 +12121,9 @@ async function cmdReview(action, rest) {
     const configPath = resolveConfigPath();
     let tombstonesConfig = null;
     try {
-      const rawCfg = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-      const remnicCfg = resolveRemnicConfigRecord11(rawCfg);
-      const config = parseConfig12(remnicCfg);
+      const rawCfg = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+      const remnicCfg = resolveRemnicConfigRecord16(rawCfg);
+      const config = parseConfig17(remnicCfg);
       tombstonesConfig = {
         enabled: config.tombstonesEnabled,
         semanticMatch: config.tombstonesSemanticMatch,
@@ -11927,7 +12209,7 @@ async function cmdSync(action, rest, json) {
 }
 function localOfflineSourceId(memoryDir) {
   const host = os3.hostname() || "unknown-host";
-  const dirHash = createHash4("sha256").update(path18.resolve(memoryDir)).digest("hex").slice(0, 16);
+  const dirHash = createHash4("sha256").update(path19.resolve(memoryDir)).digest("hex").slice(0, 16);
   return `remnic-local:${host}:${dirHash}`;
 }
 function normalizeOfflineRemoteUrl(raw) {
@@ -12325,10 +12607,10 @@ var OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX = 3;
 var OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS = 250;
 var OfflineRemoteFileChangedError = class extends Error {
   path;
-  constructor(path19) {
-    super(`remote file changed while fetching offline content: ${path19}`);
+  constructor(path20) {
+    super(`remote file changed while fetching offline content: ${path20}`);
     this.name = "OfflineRemoteFileChangedError";
-    this.path = path19;
+    this.path = path20;
   }
 };
 function isOfflineRemoteFileChangedError(error) {
@@ -12583,13 +12865,13 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat2 = fs21.statSync(filePath);
+  const stat2 = fs26.statSync(filePath);
   if (stat2.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
   const hash = createHash4("sha256");
   const chunks = args.readFileChunks({
-    root: path18.resolve(args.memoryDir),
+    root: path19.resolve(args.memoryDir),
     path: args.file.path,
     filePath,
     chunkSize: OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES
@@ -13074,7 +13356,7 @@ function advanceOfflineBaseFilesForSuccessfulPush(options) {
   return [...next.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function runOfflineSyncOnce(options) {
-  fs21.mkdirSync(options.memoryDir, { recursive: true });
+  fs26.mkdirSync(options.memoryDir, { recursive: true });
   let activeStatePath = options.statePath;
   let priorState = await readOfflineSyncState(activeStatePath);
   let syncNamespace = options.namespace ?? priorState?.namespace;
@@ -13699,7 +13981,7 @@ Environment fallbacks:
   REMNIC_OFFLINE_REMOTE_URL, REMNIC_OFFLINE_TOKEN, REMNIC_AUTH_TOKEN`);
     return;
   }
-  const memoryDir = path18.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
+  const memoryDir = path19.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
   const namespace = resolveRequiredValueFlag(rest, "--namespace");
   const includeTranscripts = !hasFlag(rest, "--no-transcripts");
   const stateOverride = resolveRequiredValueFlag(rest, "--state");
@@ -13707,7 +13989,7 @@ Environment fallbacks:
   const configPath = resolveConfigPath();
   let config;
   try {
-    const rawConfig = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
+    const rawConfig = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
     config = parseConfigQuietly(pickOfflineConfigRecord(rawConfig));
   } catch {
     throw new Error(
@@ -13719,10 +14001,10 @@ Environment fallbacks:
   const needsRemote = action === "prepare" || action === "sync" || action === "watch";
   const remoteUrl = needsRemote ? resolveOfflineRemoteUrl(rest) : resolveOptionalOfflineRemoteUrl(rest);
   const token = needsRemote ? resolveOfflineToken(rest) : void 0;
-  const statePath = statePathExplicit ? path18.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
+  const statePath = statePathExplicit ? path19.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");
-    fs21.mkdirSync(memoryDir, { recursive: true });
+    fs26.mkdirSync(memoryDir, { recursive: true });
     const remoteSnapshot = await fetchOfflineSnapshot({
       remoteUrl,
       token,
@@ -13821,7 +14103,7 @@ Environment fallbacks:
     return;
   }
   if (action === "status") {
-    fs21.mkdirSync(memoryDir, { recursive: true });
+    fs26.mkdirSync(memoryDir, { recursive: true });
     const state = statePath ? await readOfflineSyncState(statePath) : null;
     if (state && remoteUrl && statePath) {
       assertOfflineStateMatches({
@@ -13901,11 +14183,11 @@ Environment fallbacks:
           failures: result.largeFilePushFailures
         });
         largeFileFailureCounts = advanced.counts;
-        for (const path19 of advanced.newlySkipped) {
-          if (skippedLargeFiles.has(path19)) continue;
-          skippedLargeFiles.add(path19);
+        for (const path20 of advanced.newlySkipped) {
+          if (skippedLargeFiles.has(path20)) continue;
+          skippedLargeFiles.add(path20);
           console.warn(
-            `offline sync: permanently skipping ${path19} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+            `offline sync: permanently skipping ${path20} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
           );
         }
         const pulled = result.pull ? result.pull.upserted + result.pull.deleted : 0;
@@ -13920,11 +14202,11 @@ Environment fallbacks:
             failures: error.failures
           });
           largeFileFailureCounts = advanced.counts;
-          for (const path19 of advanced.newlySkipped) {
-            if (skippedLargeFiles.has(path19)) continue;
-            skippedLargeFiles.add(path19);
+          for (const path20 of advanced.newlySkipped) {
+            if (skippedLargeFiles.has(path20)) continue;
+            skippedLargeFiles.add(path20);
             console.warn(
-              `offline sync: permanently skipping ${path19} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+              `offline sync: permanently skipping ${path20} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
             );
           }
         }
@@ -13959,7 +14241,7 @@ function cmdDedup(json) {
 function readInstalledConnectorConfig(configPath, fallback) {
   if (!configPath) return fallback;
   try {
-    const parsed = JSON.parse(fs21.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs26.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
     const { token: _token, ...config } = parsed;
     return config;
@@ -14065,7 +14347,7 @@ async function cmdConnectors(action, rest, json) {
             const connectorDaemonUrl = typeof effectiveConnectorConfig.remnicDaemonUrl === "string" && effectiveConnectorConfig.remnicDaemonUrl.trim().length > 0 ? effectiveConnectorConfig.remnicDaemonUrl.trim() : void 0;
             const pubResult = await pub.publish({
               config: { memoryDir, namespace: connectorNamespace, daemonUrl: connectorDaemonUrl },
-              skillsRoot: path18.join(memoryDir, "skills"),
+              skillsRoot: path19.join(memoryDir, "skills"),
               rollbackTokenEntry: preInstallTokenEntry,
               log: { info: console.log, warn: console.warn, error: console.error }
             });
@@ -14137,7 +14419,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 ? fs21.existsSync(extRoot) : false;
+          const extensionExists = available && extRoot ? fs26.existsSync(extRoot) : false;
           publisherChecks.push({
             name: `Publisher: ${targetHostId}`,
             ok: !available || extensionExists,
@@ -14211,7 +14493,7 @@ async function cmdConnectors(action, rest, json) {
     let connectorsCfg;
     const configPath = resolveConfigPath();
     try {
-      const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
+      const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
       connectorsCfg = parseConfigQuietly(raw).connectors;
     } catch {
       process.stderr.write(
@@ -14287,10 +14569,10 @@ async function cmdConnectors(action, rest, json) {
     }
     initLogger5();
     const configPath = resolveConfigPath();
-    const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord11(raw);
-    const config = parseConfig12(remnicCfg);
-    const orchestrator = new Orchestrator7(config);
+    const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
+    const config = parseConfig17(remnicCfg);
+    const orchestrator = new Orchestrator10(config);
     try {
       await orchestrator.initialize();
       await orchestrator.deferredReady;
@@ -14412,9 +14694,9 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     console.error(`connectors marketplace: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
-  const rawConfig = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const pluginConfig = resolveRemnicConfigRecord11(rawConfig);
-  const config = parseConfig12(pluginConfig);
+  const rawConfig = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const pluginConfig = resolveRemnicConfigRecord16(rawConfig);
+  const config = parseConfig17(pluginConfig);
   if (subAction === "generate") {
     let outputDir;
     try {
@@ -14425,22 +14707,22 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     }
     const manifest = generateMarketplaceManifest();
     await writeMarketplaceManifest(outputDir, manifest);
-    const outPath = path18.join(outputDir, "marketplace.json");
+    const outPath = path19.join(outputDir, "marketplace.json");
     if (json) {
       console.log(JSON.stringify({ status: "generated", path: outPath }, null, 2));
     } else {
       console.log(`Generated marketplace.json at ${outPath}`);
     }
   } else if (subAction === "validate") {
-    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path18.join(process.cwd(), "marketplace.json");
-    const resolved = path18.resolve(targetPath);
-    if (!fs21.existsSync(resolved)) {
+    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path19.join(process.cwd(), "marketplace.json");
+    const resolved = path19.resolve(targetPath);
+    if (!fs26.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs21.readFileSync(resolved, "utf8"));
+      parsed = JSON.parse(fs26.readFileSync(resolved, "utf8"));
     } catch {
       console.error(`Invalid JSON in ${resolved}`);
       process.exit(1);
@@ -14643,10 +14925,10 @@ async function cmdSpace(action, rest, json) {
 async function cmdLegacyBenchmark(action, rest, json) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
-  const orchestrator = new Orchestrator7(config);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
+  const orchestrator = new Orchestrator10(config);
   const service = new EngramAccessService2(orchestrator);
   const { runBenchSuite, loadBaseline, checkRegression } = await loadBenchModule();
   const benchConfig = {
@@ -14845,7 +15127,7 @@ async function cmdBench(rest) {
     }
     const completeCount = prevStatus.benchmarks.filter((b) => b.status === "complete").length;
     const failedCount = prevStatus.benchmarks.filter((b) => b.status === "failed").length;
-    printBenchStatusLine(parsed.json, `Resuming from: ${path18.basename(latestStatusPath)}`);
+    printBenchStatusLine(parsed.json, `Resuming from: ${path19.basename(latestStatusPath)}`);
     printBenchStatusLine(parsed.json, `  Previous run: ${prevStatus.startedAt}`);
     printBenchStatusLine(parsed.json, `  Benchmarks: ${prevStatus.benchmarks.length} total, ${completeCount} complete, ${failedCount} failed`);
     const before = selectedBenchmarks.length;
@@ -15013,9 +15295,9 @@ Options:
     );
     process.exit(1);
   } else {
-    fixturePath = path18.resolve(expandTilde(fixturePathRaw));
+    fixturePath = path19.resolve(expandTilde(fixturePathRaw));
   }
-  const outPath = path18.resolve(expandTilde(outPathRaw));
+  const outPath = path19.resolve(expandTilde(outPathRaw));
   const benchModule = await loadBenchModule();
   const runner = benchModule.runProceduralAblationCli;
   if (typeof runner !== "function") {
@@ -15034,7 +15316,7 @@ Options:
   );
   console.log(`wrote ${outPath}`);
 }
-var LOGS_DIR = path18.join(PID_DIR, "logs");
+var LOGS_DIR = path19.join(PID_DIR, "logs");
 var LAUNCHD_PLIST_PATHS = launchdPlistPaths(resolveHomeDir());
 var [LAUNCHD_PLIST_PATH] = LAUNCHD_PLIST_PATHS;
 var SYSTEMD_UNIT_PATHS = systemdUnitPaths(resolveHomeDir());
@@ -15048,7 +15330,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs21.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs26.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -15111,7 +15393,7 @@ function selectLaunchdInspection(openclawPluginModeConfigured) {
   for (const plistPath of LAUNCHD_PLIST_PATHS.slice(1)) {
     const legacy = inspectLaunchdPlist(plistPath);
     if (!legacy.installed) continue;
-    const label = path18.basename(plistPath, ".plist");
+    const label = path19.basename(plistPath, ".plist");
     return legacy.ok ? {
       ...legacy,
       warn: true,
@@ -15143,13 +15425,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs21.mkdirSync(LOGS_DIR, { recursive: true });
+  fs26.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
-    const templatePath = path18.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs21.readFileSync(templatePath, "utf8");
+    const templatePath = path19.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
+    const template = fs26.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs21.mkdirSync(path18.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs21.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs26.mkdirSync(path19.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs26.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
     } catch (err) {
@@ -15165,11 +15447,11 @@ function daemonInstall() {
     console.log(`  RunAtLoad: true, KeepAlive: true`);
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
-    const templatePath = path18.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs21.readFileSync(templatePath, "utf8");
+    const templatePath = path19.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
+    const template = fs26.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs21.mkdirSync(path18.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs21.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs26.mkdirSync(path19.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs26.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
     } catch (err) {
@@ -15205,7 +15487,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs21.unlinkSync(plistPath);
+        fs26.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -15225,7 +15507,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of SYSTEMD_UNIT_PATHS) {
       try {
-        fs21.unlinkSync(unitPath);
+        fs26.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -15292,13 +15574,13 @@ async function daemonStatus() {
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs21.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs21.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs26.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs26.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
   try {
     const configPath = resolveConfigPath();
-    const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord11(raw);
-    const config = parseConfig12(remnicCfg);
+    const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
+    const config = parseConfig17(remnicCfg);
     const extRoot = resolveExtensionsRoot(config);
     const noopLog = { warn: () => {
     }, debug: () => {
@@ -15337,9 +15619,9 @@ function daemonStart() {
       return;
     }
   }
-  fs21.mkdirSync(PID_DIR, { recursive: true });
-  fs21.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs21.openSync(LOG_FILE, "a");
+  fs26.mkdirSync(PID_DIR, { recursive: true });
+  fs26.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs26.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -15361,7 +15643,7 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs21.writeFileSync(PID_FILE, String(child.pid));
+  fs26.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
@@ -15395,11 +15677,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs21.unlinkSync(PID_FILE);
+    fs26.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs21.unlinkSync(LEGACY_PID_FILE);
+    fs26.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -15527,9 +15809,9 @@ async function promptYesNo(question, defaultYes = true) {
 async function cmdBinary(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const memoryDir = resolveMemoryDir();
   const blConfig = {
     enabled: config.binaryLifecycleEnabled,
@@ -15647,7 +15929,7 @@ Clean complete: cleaned=${result.cleaned}`
 }
 async function cmdOpenclawInstall(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
-  const fallbackMemoryDir = path18.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+  const fallbackMemoryDir = path19.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   console.log(`OpenClaw config: ${configPath}`);
   const existingConfig = readOpenclawConfig(configPath);
   const { plugins, entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
@@ -15718,7 +16000,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 (!fs21.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
+  if (!fs26.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)`);
   }
@@ -15738,8 +16020,8 @@ async function cmdOpenclawInstall(opts) {
 Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
     return;
   }
-  if (fs21.existsSync(memoryDir)) {
-    const st = fs21.statSync(memoryDir);
+  if (fs26.existsSync(memoryDir)) {
+    const st = fs26.statSync(memoryDir);
     if (!st.isDirectory()) {
       throw new Error(
         `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
@@ -15747,12 +16029,12 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
       );
     }
   } else {
-    fs21.mkdirSync(memoryDir, { recursive: true });
+    fs26.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
-  const configDir = path18.dirname(configPath);
-  if (!fs21.existsSync(configDir)) {
-    fs21.mkdirSync(configDir, { recursive: true });
+  const configDir = path19.dirname(configPath);
+  if (!fs26.existsSync(configDir)) {
+    fs26.mkdirSync(configDir, { recursive: true });
   }
   atomicWriteFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
   console.log("\nDone! Summary of changes:");
@@ -15779,12 +16061,12 @@ async function cmdOpenclawUpgrade(opts) {
   const pluginDir = resolveOpenclawPluginDir(opts.pluginDir);
   const managedTargetDir = resolveOpenclawManagedPluginDir();
   const legacyPluginDirForBackup = opts.legacyPluginDirForBackup ? resolveOpenclawLegacyPluginDir(opts.legacyPluginDirForBackup) : void 0;
-  const fallbackMemoryDir = path18.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+  const fallbackMemoryDir = path19.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   const packageSpec = buildOpenclawManagedUpgradePackageSpec(opts.version);
-  const configExistedBefore = fs21.existsSync(configPath);
+  const configExistedBefore = fs26.existsSync(configPath);
   const existingConfig = readOpenclawConfig(configPath);
   const { entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
-  const preservedMemoryDir = opts.memoryDir ? path18.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
+  const preservedMemoryDir = opts.memoryDir ? path19.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
   console.log(`OpenClaw config: ${configPath}`);
   console.log(`Plugin dir:      ${pluginDir}`);
   if (legacyPluginDirForBackup) {
@@ -15792,7 +16074,7 @@ async function cmdOpenclawUpgrade(opts) {
   }
   console.log(`Memory dir:      ${preservedMemoryDir}`);
   console.log(`Package spec:    ${packageSpec}`);
-  console.log(`Backup root:     ${path18.join(resolveOpenclawStateDir(), "backups")}`);
+  console.log(`Backup root:     ${path19.join(resolveOpenclawStateDir(), "backups")}`);
   const plannedActions = [
     `backup openclaw.json and the existing ${REMNIC_OPENCLAW_PLUGIN_ID} extension`,
     ...legacyPluginDirForBackup ? [`backup the existing ${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID} extension without modifying it`] : [],
@@ -15830,9 +16112,9 @@ async function cmdOpenclawUpgrade(opts) {
     assertDirectoryPathOrMissing(legacyPluginDirForBackup, "Legacy OpenClaw plugin dir");
   }
   const backupDir = createOpenclawUpgradeBackupDir();
-  const configBackupPath = path18.join(backupDir, "openclaw.json");
-  const pluginBackupDir = path18.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
-  const legacyPluginBackupDir = legacyPluginDirForBackup ? path18.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
+  const configBackupPath = path19.join(backupDir, "openclaw.json");
+  const pluginBackupDir = path19.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  const legacyPluginBackupDir = legacyPluginDirForBackup ? path19.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
   const backupNotes = [];
   if (backupPathIfPresent(configPath, configBackupPath)) {
     backupNotes.push(`+ Backed up config to ${configBackupPath}`);
@@ -15882,7 +16164,7 @@ async function cmdOpenclawUpgrade(opts) {
     const managedRollbackDir = publishedInstallError ? publishedInstallError.managedRollbackDir : installResult?.managedRollbackDir;
     const managedRollbackTargetDir = publishedInstallError?.managedRollbackTargetDir ?? installResult?.managedRollbackTargetDir ?? managedTargetDir;
     const requiresHostManagedRestore = publishedInstallError?.requiresHostManagedRestore ?? installResult?.requiresHostManagedRestore ?? false;
-    const managedRollbackSharesPluginDir = managedRollbackDir && path18.resolve(managedRollbackTargetDir) === path18.resolve(pluginDir);
+    const managedRollbackSharesPluginDir = managedRollbackDir && path19.resolve(managedRollbackTargetDir) === path19.resolve(pluginDir);
     const pluginRollbackDir = managedRollbackSharesPluginDir ? requiresHostManagedRestore ? rollbackDir : rollbackDir ?? managedRollbackDir : rollbackDir;
     const shouldRestorePlugin = Boolean(
       installResult && !requiresHostManagedRestore || pluginRollbackDir || publishedInstallError?.shouldRestoreBackup
@@ -15939,7 +16221,7 @@ async function cmdOpenclawUpgrade(opts) {
       rollbackErrors.push(error);
     }
     if (pendingConfigRestoreError) rollbackErrors.push(pendingConfigRestoreError);
-    if (managedRollbackDir && path18.resolve(managedRollbackTargetDir) !== path18.resolve(pluginDir) && !requiresHostManagedRestore) {
+    if (managedRollbackDir && path19.resolve(managedRollbackTargetDir) !== path19.resolve(pluginDir) && !requiresHostManagedRestore) {
       try {
         rollbackNotes.push(
           ...rollbackOpenclawUpgrade({
@@ -16005,16 +16287,16 @@ async function cmdOpenclawMigrateEngram(opts) {
   console.log("  - Re-apply any local source patches to the new package only after verifying the published build.");
 }
 function createOpenclawUpgradeBackupDir() {
-  const backupsRoot = path18.join(resolveOpenclawStateDir(), "backups");
-  fs21.mkdirSync(backupsRoot, { recursive: true });
-  return fs21.mkdtempSync(path18.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  const backupsRoot = path19.join(resolveOpenclawStateDir(), "backups");
+  fs26.mkdirSync(backupsRoot, { recursive: true });
+  return fs26.mkdtempSync(path19.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord11(raw);
-  const config = parseConfig12(remnicCfg);
+  const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   if (!config.taxonomyEnabled) {
     console.error(
       "Taxonomy is disabled in config (taxonomyEnabled = false). Enable it to use taxonomy commands."
@@ -16049,9 +16331,9 @@ async function cmdTaxonomy(rest) {
       const doc = generateResolverDocument(taxonomy);
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
-        const resolverPath = path18.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs21.mkdirSync(path18.dirname(resolverPath), { recursive: true });
-        fs21.writeFileSync(resolverPath, doc);
+        const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs26.mkdirSync(path19.dirname(resolverPath), { recursive: true });
+        fs26.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
       break;
@@ -16096,8 +16378,8 @@ async function cmdTaxonomy(rest) {
       console.log(`Added category "${id}" (${name}).`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path18.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs21.writeFileSync(resolverPath, doc);
+        const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs26.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -16127,8 +16409,8 @@ async function cmdTaxonomy(rest) {
       console.log(`Removed category "${id}".`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path18.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs21.writeFileSync(resolverPath, doc);
+        const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs26.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -16319,12 +16601,12 @@ async function runTrainingExport(args, stdout = process.stdout) {
       `Unknown training-export format "${args.format}". ${validList}`
     );
   }
-  if (!fs21.existsSync(args.memoryDir)) {
+  if (!fs26.existsSync(args.memoryDir)) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
-  if (!fs21.statSync(args.memoryDir).isDirectory()) {
+  if (!fs26.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.`
     );
@@ -16409,11 +16691,11 @@ async function runTrainingExport(args, stdout = process.stdout) {
     );
   }
   const formatted = adapter.formatRecords(records);
-  const outDir = path18.dirname(args.output);
-  fs21.mkdirSync(outDir, { recursive: true });
+  const outDir = path19.dirname(args.output);
+  fs26.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
-  fs21.writeFileSync(tmpPath, formatted, "utf-8");
-  fs21.renameSync(tmpPath, args.output);
+  fs26.writeFileSync(tmpPath, formatted, "utf-8");
+  fs26.renameSync(tmpPath, args.output);
   stdout.write(
     `Exported ${records.length} records to ${args.output} (${adapter.name} format)
 `
@@ -16526,7 +16808,7 @@ async function main(argv = process.argv.slice(2)) {
     case "tree": {
       const subAction = rest[0];
       const json = rest.includes("--json");
-      const outputDir = resolveFlag(rest, "--output") ?? path18.join(process.cwd(), ".remnic", "context-tree");
+      const outputDir = resolveFlag(rest, "--output") ?? path19.join(process.cwd(), ".remnic", "context-tree");
       const categoriesFlag = resolveFlag(rest, "--categories");
       const categories = categoriesFlag ? categoriesFlag.split(",") : void 0;
       const maxPerCategoryRaw = resolveFlag(rest, "--max-per-category");
@@ -16591,7 +16873,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs21.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs26.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -16599,12 +16881,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs21.existsSync(treeDir)) {
+        if (!fs26.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
-        const indexPath = path18.join(treeDir, "INDEX.md");
-        if (!fs21.existsSync(indexPath)) {
+        const indexPath = path19.join(treeDir, "INDEX.md");
+        if (!fs26.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -16791,12 +17073,28 @@ Other:
       await runMeetingsBinaryCommand(rest);
       break;
     }
+    case "timeline": {
+      await runTimelineBinaryCommand(rest);
+      break;
+    }
     case "location":
       await runLocationBinaryCommand(rest);
       break;
     case "okf":
       await runOkfBinaryCommand(rest);
       break;
+    case "export":
+      await runExportOkfBinaryCommand(rest);
+      break;
+    case "standup":
+      await runStandupBinaryCommand(rest);
+      break;
+    case "journal":
+      await runJournalBinaryCommand(rest);
+      break;
+    case "codegraph":
+      await runCodegraphBinaryCommand(rest);
+      break;
     case "external-wiki": {
       await runExternalWikiBinaryCommand(rest);
       break;
@@ -16810,10 +17108,10 @@ Other:
       const targetFactory = async () => {
         if (!orchestratorSingleton) {
           const configPath = resolveConfigPath();
-          const raw = fs21.existsSync(configPath) ? JSON.parse(fs21.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord11(raw);
-          const config = parseConfig12(remnicCfg);
-          orchestratorSingleton = new Orchestrator7(config);
+          const raw = fs26.existsSync(configPath) ? JSON.parse(fs26.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord16(raw);
+          const config = parseConfig17(remnicCfg);
+          orchestratorSingleton = new Orchestrator10(config);
           await orchestratorSingleton.initialize();
           await orchestratorSingleton.deferredReady;
         }
@@ -17014,6 +17312,10 @@ Usage:
   remnic okf <lint|sweep> [--json]
     OKF v0.1 conformance: lint reports missing frontmatter/type findings,
     sweep backfills missing type values (okf.sweepEnabled).
+  remnic export okf --out <dir>
+    Write a portable OKF v0.1 knowledge bundle (plaintext interchange).
+  remnic standup [--date YYYY-MM-DD]
+    Deterministic yesterday/today/blockers brief plus an activity grid.
   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