@remnic/cli 9.66.0 → 9.66.2

package/dist/index.js

@@ -18,7 +18,7 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 }
 
 // src/index.ts
-import fs24 from "fs";
+import fs28 from "fs";
 import os3 from "os";
 import path19 from "path";
 import { createHash as createHash4 } from "crypto";
@@ -27,10 +27,10 @@ import * as childProcess2 from "child_process";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { gzipSync } from "zlib";
 import {
-  parseConfig as parseConfig15,
+  parseConfig as parseConfig17,
   isOpenaiApiKeyDisabled,
   resolveEnvVars,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord14,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord16,
   Orchestrator as Orchestrator10,
   EngramAccessService as EngramAccessService2,
   initLogger as initLogger5,
@@ -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,8 +282,8 @@ async function runWearablesBinaryCommand(rest) {
 }
 
 // src/commands/location.ts
-import fs3 from "fs";
-import { parseConfig as parseConfig3, resolveRemnicConfigRecord as resolveRemnicConfigRecord3 } from "@remnic/core";
+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;
@@ -254,8 +291,8 @@ async function runLocationBinaryCommand(rest) {
     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"
@@ -280,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;
@@ -318,9 +355,9 @@ async function runOkfBinaryCommand(rest) {
 }
 
 // src/commands/export-okf.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path from "path";
-import { Orchestrator as Orchestrator4, parseConfig as parseConfig5, resolveRemnicConfigRecord as resolveRemnicConfigRecord5 } from "@remnic/core";
+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);
@@ -348,8 +385,8 @@ async function runExportOkfBinaryCommand(rest) {
     if (!out) throw new Error("Missing --out");
     const namespace = takeFlag(args, "--namespace") ?? "";
     const configPath = resolveConfigPath();
-    const raw = fs5.existsSync(configPath) ? JSON.parse(fs5.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig5(resolveRemnicConfigRecord5(raw));
+    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;
@@ -377,8 +414,8 @@ async function runExportOkfBinaryCommand(rest) {
 }
 
 // src/commands/codegraph.ts
-import fs6 from "fs";
-import { Orchestrator as Orchestrator5, parseConfig as parseConfig6, resolveRemnicConfigRecord as resolveRemnicConfigRecord6 } from "@remnic/core";
+import fs7 from "fs";
+import { Orchestrator as Orchestrator5, parseConfig as parseConfig7, resolveRemnicConfigRecord as resolveRemnicConfigRecord7 } from "@remnic/core";
 import {
   exportCodegraphOkfBundle,
   parseOkfCodegraphSymbolFilter
@@ -412,8 +449,8 @@ async function runCodegraphBinaryCommand(rest) {
     if (!project) throw new Error("Missing --project");
     if (!out) throw new Error("Missing --out");
     const configPath = resolveConfigPath();
-    const raw = fs6.existsSync(configPath) ? JSON.parse(fs6.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig6(resolveRemnicConfigRecord6(raw));
+    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;
@@ -441,8 +478,8 @@ async function runCodegraphBinaryCommand(rest) {
 }
 
 // src/commands/standup.ts
-import fs7 from "fs";
-import { Orchestrator as Orchestrator6, parseConfig as parseConfig7, resolveRemnicConfigRecord as resolveRemnicConfigRecord7 } from "@remnic/core";
+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);
@@ -459,8 +496,8 @@ async function runStandupBinaryCommand(rest) {
   let orchestrator;
   try {
     const configPath = resolveConfigPath();
-    const raw = fs7.existsSync(configPath) ? JSON.parse(fs7.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig7(resolveRemnicConfigRecord7(raw));
+    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;
@@ -475,45 +512,85 @@ async function runStandupBinaryCommand(rest) {
   }
 }
 
-// src/commands/external-wiki.ts
-import fs8 from "fs";
-import { parseConfig as parseConfig8, resolveRemnicConfigRecord as resolveRemnicConfigRecord8, runExternalWikiCliCommand } from "@remnic/core";
-async function runExternalWikiBinaryCommand(rest) {
-  let roots;
+// 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 {
-    const configPath = resolveConfigPath();
-    const raw = fs8.existsSync(configPath) ? JSON.parse(fs8.readFileSync(configPath, "utf8")) : {};
-    roots = parseConfig8(resolveRemnicConfigRecord8(raw)).externalWikis;
+    memoryDir = loadMemoryDir();
   } catch {
     console.error(
-      "external-wiki: failed to load the Remnic config - run `remnic doctor` and check the config file for errors"
+      "journal: failed to load the Remnic config \u2014 run `remnic doctor` and check the config file for errors"
     );
     process.exitCode = 1;
     return;
   }
   try {
-    const code = await runExternalWikiCliCommand(roots, rest, {
-      stdout: process.stdout,
-      stderr: process.stderr
-    });
-    if (code !== 0) process.exitCode = code;
-  } catch {
-    console.error("external-wiki: search failed");
+    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/procedural.ts
-import fs9 from "fs";
-import {
-  StorageManager,
-  computeProcedureStats,
-  formatProcedureStatsText,
-  initLogger,
-  parseConfig as parseConfig9,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord9,
-  runProcedureLibraryMaintenance
-} from "@remnic/core";
+// src/commands/journal-vault.ts
+import fs10 from "fs";
+import { readVaultJournal } from "@remnic/core";
 
 // src/cli-args.ts
 function resolveFlag(args, flag) {
@@ -571,6 +648,236 @@ function parseTaxonomyResolveArgs(args, booleanFlags = TAXONOMY_RESOLVE_BOOLEAN_
   return { textParts, values, booleans };
 }
 
+// src/commands/journal-vault.ts
+var defaultIo = {
+  stdout: (line) => {
+    process.stdout.write(`${line}
+`);
+  },
+  stderr: (line) => {
+    process.stderr.write(`${line}
+`);
+  }
+};
+function journalVaultHelp() {
+  return `Usage: remnic journal-vault show --file <path> --section <heading>
+
+  show  Print the stripped journal section. Missing file or heading prints exists:false.
+`;
+}
+function runJournalVaultCommand(rest, io = defaultIo) {
+  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" || rest[0] === "help") {
+    io.stdout(journalVaultHelp().trimEnd());
+    return 0;
+  }
+  if (rest[0] !== "show") {
+    io.stderr(`journal-vault: unknown action "${rest[0]}".`);
+    io.stderr(journalVaultHelp().trimEnd());
+    return 1;
+  }
+  const filePath = resolveFlag(rest, "--file");
+  const section = resolveFlag(rest, "--section");
+  if (filePath === void 0 || section === void 0) {
+    io.stderr("journal-vault: show requires --file <path> and --section <heading>");
+    return 1;
+  }
+  let fileText = null;
+  try {
+    fileText = fs10.readFileSync(filePath, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      io.stderr(err instanceof Error ? err.message : String(err));
+      return 1;
+    }
+  }
+  const result = readVaultJournal({ fileText, journalSection: section });
+  if (!result.ok) {
+    io.stderr(`journal-vault: duplicate heading at lines ${result.lines.join(", ")}`);
+    return 1;
+  }
+  if (!result.exists) {
+    io.stdout("exists:false");
+    return 0;
+  }
+  io.stdout(result.text);
+  return 0;
+}
+async function runJournalVaultBinaryCommand(rest) {
+  const code = runJournalVaultCommand(rest);
+  if (code !== 0) process.exitCode = code;
+}
+
+// src/commands/activity-privacy.ts
+import { parseFlexibleIsoTimestamp, shouldRetain } from "@remnic/core";
+var defaultIo2 = {
+  stdout: (line) => {
+    process.stdout.write(`${line}
+`);
+  },
+  stderr: (line) => {
+    process.stderr.write(`${line}
+`);
+  }
+};
+function activityPrivacyHelp() {
+  return `Usage: remnic activity-privacy retain --captured <iso> --now <iso> --days <n> [--enabled <true|false>]
+
+  retain  Print retain=true or retain=false. --days 0 keeps forever.
+`;
+}
+function parseEnabled(rest, io) {
+  const raw = resolveFlag(rest, "--enabled");
+  if (raw === void 0) {
+    if (hasFlag(rest, "--enabled")) {
+      io.stderr("activity-privacy: --enabled requires true or false");
+      return void 0;
+    }
+    return true;
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  io.stderr("activity-privacy: --enabled must be true or false");
+  return void 0;
+}
+function runActivityPrivacyCommand(rest, io = defaultIo2) {
+  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" || rest[0] === "help") {
+    io.stdout(activityPrivacyHelp().trimEnd());
+    return 0;
+  }
+  if (rest[0] !== "retain") {
+    io.stderr(`activity-privacy: unknown action "${rest[0]}".`);
+    io.stderr(activityPrivacyHelp().trimEnd());
+    return 1;
+  }
+  const capturedRaw = resolveFlag(rest, "--captured");
+  const nowRaw = resolveFlag(rest, "--now");
+  const daysRaw = resolveFlag(rest, "--days");
+  if (capturedRaw === void 0 || nowRaw === void 0 || daysRaw === void 0) {
+    io.stderr("activity-privacy: retain requires --captured <iso>, --now <iso>, and --days <n>");
+    return 1;
+  }
+  const capturedAtMs = parseFlexibleIsoTimestamp(capturedRaw);
+  const nowMs = parseFlexibleIsoTimestamp(nowRaw);
+  if (capturedAtMs === null || nowMs === null) {
+    io.stderr("activity-privacy: --captured and --now must be ISO timestamps");
+    return 1;
+  }
+  const days = Number(daysRaw);
+  if (!Number.isInteger(days) || days < 0) {
+    io.stderr("activity-privacy: --days must be a non-negative integer");
+    return 1;
+  }
+  const enabled = parseEnabled(rest, io);
+  if (enabled === void 0) return 1;
+  io.stdout(`retain=${shouldRetain(capturedAtMs, nowMs, days, enabled)}`);
+  return 0;
+}
+async function runActivityPrivacyBinaryCommand(rest) {
+  const code = runActivityPrivacyCommand(rest);
+  if (code !== 0) process.exitCode = code;
+}
+
+// src/commands/vault-publish.ts
+import fs11 from "fs";
+import { applyManagedRegion } from "@remnic/core";
+var defaultIo3 = {
+  stdout: (line) => {
+    process.stdout.write(`${line}
+`);
+  },
+  stderr: (line) => {
+    process.stderr.write(`${line}
+`);
+  }
+};
+function vaultPublishHelp() {
+  return `Usage: remnic vault-publish apply --file <path> --name <region> --content <text>
+
+  apply  Replace the marked region. Missing markers print no_marker.
+`;
+}
+function runVaultPublishCommand(rest, io = defaultIo3) {
+  if (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h" || rest[0] === "help") {
+    io.stdout(vaultPublishHelp().trimEnd());
+    return 0;
+  }
+  if (rest[0] !== "apply") {
+    io.stderr(`vault-publish: unknown action "${rest[0]}".`);
+    io.stderr(vaultPublishHelp().trimEnd());
+    return 1;
+  }
+  const filePath = resolveFlag(rest, "--file");
+  const name = resolveFlag(rest, "--name");
+  const content = resolveFlag(rest, "--content");
+  if (filePath === void 0 || name === void 0 || content === void 0) {
+    io.stderr("vault-publish: apply requires --file <path>, --name <region>, and --content <text>");
+    return 1;
+  }
+  let fileText;
+  try {
+    fileText = fs11.readFileSync(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      io.stderr("missing_file");
+      return 1;
+    }
+    io.stderr(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  const applied = applyManagedRegion(fileText, { strategy: "markers", name, content });
+  if (!applied.ok) {
+    io.stderr(applied.reason);
+    return 1;
+  }
+  if (applied.text !== fileText) fs11.writeFileSync(filePath, applied.text);
+  io.stdout("ok");
+  return 0;
+}
+async function runVaultPublishBinaryCommand(rest) {
+  const code = runVaultPublishCommand(rest);
+  if (code !== 0) process.exitCode = code;
+}
+
+// src/commands/external-wiki.ts
+import fs12 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 = fs12.existsSync(configPath) ? JSON.parse(fs12.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"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const code = await runExternalWikiCliCommand(roots, rest, {
+      stdout: process.stdout,
+      stderr: process.stderr
+    });
+    if (code !== 0) process.exitCode = code;
+  } catch {
+    console.error("external-wiki: search failed");
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/procedural.ts
+import fs13 from "fs";
+import {
+  StorageManager,
+  computeProcedureStats,
+  formatProcedureStatsText,
+  initLogger,
+  parseConfig as parseConfig11,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord11,
+  runProcedureLibraryMaintenance
+} from "@remnic/core";
+
 // src/path-utils.ts
 function resolveHomeDir() {
   return process.env.HOME ?? process.env.USERPROFILE ?? "~";
@@ -642,8 +949,8 @@ Shared with:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs9.existsSync(configPath) ? JSON.parse(fs9.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig9(resolveRemnicConfigRecord9(raw));
+  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig11(resolveRemnicConfigRecord11(raw));
   const memoryDir = expandTilde(
     typeof memoryDirOverride === "string" && memoryDirOverride.length > 0 ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
   );
@@ -698,12 +1005,12 @@ function formatProcedureMaintenanceText(report) {
 }
 
 // src/commands/drift.ts
-import fs10 from "fs";
+import fs14 from "fs";
 import {
   Orchestrator as Orchestrator7,
   initLogger as initLogger2,
-  parseConfig as parseConfig10,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord10,
+  parseConfig as parseConfig12,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord12,
   runPreferenceDriftScan
 } from "@remnic/core";
 async function runDriftBinaryCommand(rest) {
@@ -763,8 +1070,8 @@ Resolve a drifted item with the existing review surface:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs10.existsSync(configPath) ? JSON.parse(fs10.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig10(resolveRemnicConfigRecord10(raw));
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig12(resolveRemnicConfigRecord12(raw));
   const memoryDirOverridden = typeof memoryDirOverride === "string" && memoryDirOverride.length > 0;
   const memoryDir = expandTilde(
     memoryDirOverridden ? memoryDirOverride : config.memoryDir ?? resolveMemoryDir()
@@ -827,6 +1134,104 @@ function formatPreferenceDriftText(report) {
   return lines.join("\n") + "\n";
 }
 
+// src/commands/recall-navigate.ts
+import {
+  expandRecallNode,
+  traverseRecallLink
+} from "@remnic/core";
+var RECALL_NAV_UNAVAILABLE_TAG = "[unavailable] budget_off";
+function recallNavigateHelp() {
+  return `Usage: remnic recall <expand|traverse> --node <json> [--budget <n>] [--type <linkType>]
+
+  expand    Re-render one node at the next disclosure level
+  traverse  Follow typed links from a node
+
+  --budget 0 turns navigation off and prints ${RECALL_NAV_UNAVAILABLE_TAG}
+  --type    required for traverse: supports, contradicts, elaborates, supersedes, causes
+`;
+}
+function takeFlag5(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 parseBudget(rest) {
+  if (!rest.includes("--budget")) return 1;
+  const raw = takeFlag5(rest, "--budget");
+  const budget = Number(raw);
+  if (!Number.isFinite(budget)) {
+    throw new Error(`--budget must be a number (got ${JSON.stringify(raw)})`);
+  }
+  return budget;
+}
+function parseNode(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error("--node must be JSON");
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("--node must be a JSON object");
+  }
+  const node = value;
+  if (typeof node.id !== "string" || node.id.length === 0) {
+    throw new Error("--node.id must be a non-empty string");
+  }
+  if (typeof node.disclosure !== "string") {
+    throw new Error("--node.disclosure is required");
+  }
+  return node;
+}
+function emitUnavailable(io) {
+  io.stdout(RECALL_NAV_UNAVAILABLE_TAG);
+  return 0;
+}
+function runRecallNavigate(rest, io) {
+  const action = rest[0];
+  if (rest.length === 0 || action === "--help" || action === "-h" || action === "help") {
+    io.stdout(recallNavigateHelp());
+    return 0;
+  }
+  try {
+    const budget = parseBudget(rest);
+    const nodeRaw = takeFlag5(rest, "--node");
+    if (nodeRaw === void 0) throw new Error("--node is required");
+    const node = parseNode(nodeRaw);
+    if (action === "expand") {
+      const result = expandRecallNode(node, { budget });
+      if (result.status === "unavailable") return emitUnavailable(io);
+      io.stdout(JSON.stringify(result));
+      return 0;
+    }
+    if (action === "traverse") {
+      const linkType = takeFlag5(rest, "--type");
+      if (linkType === void 0) throw new Error("traverse requires --type");
+      const result = traverseRecallLink(node, linkType, { budget });
+      if (result.status === "unavailable") return emitUnavailable(io);
+      io.stdout(JSON.stringify(result));
+      return 0;
+    }
+    io.stderr(`recall: unknown action "${action}".`);
+    io.stderr(recallNavigateHelp());
+    return 1;
+  } catch (err) {
+    io.stderr(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function runRecallNavigateCommand(rest) {
+  const code = runRecallNavigate(rest, {
+    stdout: (line) => console.log(line),
+    stderr: (line) => console.error(line)
+  });
+  if (code !== 0) process.exitCode = code;
+}
+
 // src/optional-module-loader.ts
 function isSpecifierNotFoundError(err, specifier) {
   if (!err || typeof err !== "object") {
@@ -877,13 +1282,13 @@ async function loadWecloneExportModule() {
 }
 
 // src/converge.ts
-import * as fs12 from "fs";
+import * as fs16 from "fs";
 import { createHash as createHash3 } from "crypto";
 import * as path3 from "path";
 import {
   CONVERGE_CONFLICT_POLICIES,
   DEFAULT_CONVERGE_CONFLICT_POLICY,
-  parseConfig as parseConfig11,
+  parseConfig as parseConfig13,
   buildOfflineSyncSnapshotFromBase,
   applyOfflineSyncFileContentChunk,
   isInternalRemnicStatePath as isInternalRemnicStatePath3,
@@ -909,7 +1314,7 @@ import {
 
 // src/offline-storage-io.ts
 import { createDecipheriv, createHash } from "crypto";
-import fs11 from "fs";
+import fs15 from "fs";
 import { lstat, mkdtemp, readdir, rm } from "fs/promises";
 import path2 from "path";
 import {
@@ -1071,7 +1476,7 @@ async function* readOfflineSyncFileChunks(options) {
   });
 }
 async function readFilePrefix(filePath, length) {
-  const handle = await fs11.promises.open(filePath, "r");
+  const handle = await fs15.promises.open(filePath, "r");
   try {
     const out = Buffer.alloc(length);
     const { bytesRead } = await handle.read(out, 0, length, 0);
@@ -1081,7 +1486,7 @@ async function readFilePrefix(filePath, length) {
   }
 }
 async function* readPlainOfflineFileChunks(filePath, chunkSize) {
-  const stream = fs11.createReadStream(filePath, { highWaterMark: chunkSize });
+  const stream = fs15.createReadStream(filePath, { highWaterMark: chunkSize });
   for await (const chunk of stream) {
     yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
   }
@@ -1118,9 +1523,9 @@ async function* readEncryptedOfflineFileChunks(options) {
       });
       decipher.setAuthTag(authTag);
       decipher.setAAD(Buffer.concat([secureStoreEnvelopeHeaderAad(salt), aad]));
-      const output = fs11.createWriteStream(tempPath, { mode: 384 });
+      const output = fs15.createWriteStream(tempPath, { mode: 384 });
       try {
-        const stream = fs11.createReadStream(options.filePath, {
+        const stream = fs15.createReadStream(options.filePath, {
           start: MAGIC_HEADER_SIZE + ENVELOPE_HEADER_SIZE,
           highWaterMark: options.chunkSize
         });
@@ -1730,7 +2135,7 @@ async function readLocalTombstoneEvidence(rootDir) {
   for (const relativePath of TOMBSTONE_PATHS) {
     let content;
     try {
-      content = await fs12.promises.readFile(path3.join(rootDir, relativePath), "utf-8");
+      content = await fs16.promises.readFile(path3.join(rootDir, relativePath), "utf-8");
     } catch (error) {
       if (error.code === "ENOENT") continue;
       throw error;
@@ -1745,7 +2150,7 @@ async function discoverCursorNamespaces(memoryDir, peerUrl) {
   const cursorDir = path3.join(path3.resolve(memoryDir), ".remnic", "state", "converge-cursors");
   let entries;
   try {
-    entries = await fs12.promises.readdir(cursorDir, { withFileTypes: true });
+    entries = await fs16.promises.readdir(cursorDir, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -1821,7 +2226,7 @@ async function computeConvergePlan(options = {}) {
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig11({});
+      config = parseConfig13({});
     } catch {
     }
   }
@@ -2072,7 +2477,7 @@ async function executeConvergeApply(options = {}) {
   let config = options.config;
   if (!config) {
     try {
-      config = parseConfig11({});
+      config = parseConfig13({});
     } catch {
     }
   }
@@ -2235,7 +2640,7 @@ async function executeConvergeApply(options = {}) {
             if (current.sha256 !== entry.localSha256) {
               throw new Error(`local file changed during push: ${localPath}`);
             }
-            const stat2 = await fs12.promises.stat(filePath);
+            const stat2 = await fs16.promises.stat(filePath);
             let chunks;
             let chunkOffset = 0;
             const resetChunks = async () => {
@@ -2512,7 +2917,7 @@ function formatConvergeApplyReport(result) {
   lines.push(formatConvergeReport(result.plan));
   return lines.join("\n");
 }
-async function cmdConverge(action, rest, json, config = parseConfig11({})) {
+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]
 
@@ -2718,8 +3123,8 @@ function renderReplayResult(result, targetNamespace, format) {
 }
 
 // src/quarantine-replay.ts
-import * as fs13 from "fs";
-import { EngramAccessService, Orchestrator as Orchestrator8, initLogger as initLogger3, parseConfig as parseConfig12, resolveRemnicConfigRecord as resolveRemnicConfigRecord11 } from "@remnic/core";
+import * as fs17 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;
@@ -2767,8 +3172,8 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
   let orchestrator;
   try {
     const configPath = resolveConfigPath2();
-    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
-    const config = parseConfig12(resolveRemnicConfigRecord11(raw));
+    const raw = fs17.existsSync(configPath) ? JSON.parse(fs17.readFileSync(configPath, "utf8")) : {};
+    const config = parseConfig14(resolveRemnicConfigRecord13(raw));
     orchestrator = new Orchestrator8(config);
     await orchestrator.initialize();
     await orchestrator.deferredReady;
@@ -2799,15 +3204,15 @@ async function runQuarantineReplay(rest, format, resolveConfigPath2) {
 }
 
 // src/offline-impression-rotation.ts
-import fs14 from "fs";
-import { parseConfig as parseConfig13, resolveRemnicConfigRecord as resolveRemnicConfigRecord12, drainPendingImpressionsForOfflineSync } from "@remnic/core";
+import fs18 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 parseConfig13(resolveRemnicConfigRecord12(raw));
+    return parseConfig15(resolveRemnicConfigRecord14(raw));
   } finally {
     console.warn = originalWarn;
   }
@@ -2821,7 +3226,7 @@ var OFFLINE_CONFIG_KEYS = [
 function pickOfflineConfigRecord(raw) {
   let resolved;
   try {
-    resolved = resolveRemnicConfigRecord12(raw);
+    resolved = resolveRemnicConfigRecord14(raw);
   } catch {
     resolved = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
   }
@@ -2834,7 +3239,7 @@ function pickOfflineConfigRecord(raw) {
 function resolveOfflineImpressionRotation(configPath) {
   let raw;
   try {
-    raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
+    raw = fs18.existsSync(configPath) ? JSON.parse(fs18.readFileSync(configPath, "utf8")) : {};
   } catch {
     throw new Error(
       `cannot read recall-impression rotation from ${configPath}: config file could not be read as JSON`
@@ -3092,12 +3497,12 @@ function assertBenchModuleFreshForDevelopment() {
 }
 
 // src/cmd-security.ts
-import fs15 from "fs";
+import fs19 from "fs";
 import {
   Orchestrator as Orchestrator9,
-  parseConfig as parseConfig14,
+  parseConfig as parseConfig16,
   initLogger as initLogger4,
-  resolveRemnicConfigRecord as resolveRemnicConfigRecord13,
+  resolveRemnicConfigRecord as resolveRemnicConfigRecord15,
   runAuditMemoryCliCommand,
   formatAuditMemoryReport
 } from "@remnic/core";
@@ -3112,8 +3517,8 @@ async function cmdSecurity(rest) {
   }
   initLogger4();
   const configPath = resolveConfigPath();
-  const raw = fs15.existsSync(configPath) ? JSON.parse(fs15.readFileSync(configPath, "utf8")) : {};
-  const config = parseConfig14(resolveRemnicConfigRecord13(raw));
+  const raw = fs19.existsSync(configPath) ? JSON.parse(fs19.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig16(resolveRemnicConfigRecord15(raw));
   const orchestrator = new Orchestrator9(config);
   await orchestrator.initialize();
   try {
@@ -3137,7 +3542,7 @@ async function cmdSecurity(rest) {
 }
 
 // src/daemon-service-candidates.ts
-import fs16 from "fs";
+import fs20 from "fs";
 import path6 from "path";
 var LAUNCHD_LABEL = "ai.remnic.daemon";
 var LEGACY_REMNIC_SERVER_LAUNCHD_LABEL = "ai.remnic.server";
@@ -3159,7 +3564,7 @@ function systemdUnitPaths(homeDir) {
 function anyFileExists(paths) {
   return paths.some((candidate) => {
     try {
-      return fs16.statSync(candidate).isFile();
+      return fs20.statSync(candidate).isFile();
     } catch {
       return false;
     }
@@ -3171,7 +3576,7 @@ function commandNames(command) {
 }
 function isRunnableNodeScript(filePath) {
   try {
-    const text = fs16.readFileSync(filePath, "utf8").slice(0, 4096);
+    const text = fs20.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;
@@ -3184,7 +3589,7 @@ function isRunnableNodeScript(filePath) {
 function resolveShimNodeScript(filePath) {
   let text;
   try {
-    text = fs16.readFileSync(filePath, "utf8").slice(0, 16384);
+    text = fs20.readFileSync(filePath, "utf8").slice(0, 16384);
   } catch {
     return void 0;
   }
@@ -3196,8 +3601,8 @@ function resolveShimNodeScript(filePath) {
     const candidate = raw.replaceAll("${basedir}", basedir).replaceAll("$basedir", basedir).replaceAll("\\ ", " ");
     const resolved = path6.isAbsolute(candidate) ? candidate : path6.resolve(basedir, candidate);
     try {
-      if (fs16.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
-        return fs16.realpathSync(resolved);
+      if (fs20.statSync(resolved).isFile() && isRunnableNodeScript(resolved)) {
+        return fs20.realpathSync(resolved);
       }
     } catch {
     }
@@ -3205,7 +3610,7 @@ function resolveShimNodeScript(filePath) {
   return void 0;
 }
 function resolveRunnableNodeScript(filePath) {
-  const realPath = fs16.realpathSync(filePath);
+  const realPath = fs20.realpathSync(filePath);
   if (isRunnableNodeScript(realPath)) return realPath;
   return resolveShimNodeScript(realPath);
 }
@@ -3215,9 +3620,9 @@ function findCommandOnPath(command, pathEnv = process.env.PATH ?? "") {
     for (const name of commandNames(command)) {
       const candidate = path6.join(dir, name);
       try {
-        const stat2 = fs16.statSync(candidate);
+        const stat2 = fs20.statSync(candidate);
         if (!stat2.isFile()) continue;
-        if (process.platform !== "win32") fs16.accessSync(candidate, fs16.constants.X_OK);
+        if (process.platform !== "win32") fs20.accessSync(candidate, fs20.constants.X_OK);
         const runnable = resolveRunnableNodeScript(candidate);
         if (runnable) return runnable;
       } catch {
@@ -4690,7 +5095,7 @@ function finalizeBenchStatus(filePath) {
 }
 
 // src/bench-fallback.ts
-import fs17 from "fs";
+import fs21 from "fs";
 import path10 from "path";
 var FALLBACK_RESULTS_DIRNAME = "fallback-runs";
 function buildBenchRunnerArgs(parsed, benchmarkId, outputDir) {
@@ -4762,7 +5167,7 @@ function createFallbackBenchOutputDir(resultsDir, benchmarkId, pid, startedAtMs
   );
 }
 function resolveFallbackBenchResultPath(outputDir) {
-  const entries = fs17.readdirSync(outputDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort();
+  const entries = fs21.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}`);
   }
@@ -4770,7 +5175,7 @@ function resolveFallbackBenchResultPath(outputDir) {
 }
 
 // src/openclaw-upgrade-swap.ts
-import fs18 from "fs";
+import fs22 from "fs";
 import path11 from "path";
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -4782,7 +5187,7 @@ function createSiblingTempFilePath(targetPath, label) {
 function resolveAtomicWriteMode(targetPath, explicitMode) {
   if (explicitMode !== void 0) return explicitMode;
   try {
-    return fs18.statSync(targetPath).mode & 4095;
+    return fs22.statSync(targetPath).mode & 4095;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return 384;
@@ -4792,8 +5197,8 @@ function resolveAtomicWriteMode(targetPath, explicitMode) {
 }
 function resolveAtomicReplacementPath(targetPath) {
   try {
-    if (fs18.lstatSync(targetPath).isSymbolicLink()) {
-      return fs18.realpathSync(targetPath);
+    if (fs22.lstatSync(targetPath).isSymbolicLink()) {
+      return fs22.realpathSync(targetPath);
     }
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -4810,7 +5215,7 @@ function createSiblingSwapPath(targetDir, label) {
 function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
   if (!displacedDir) return void 0;
   try {
-    fs18.rmSync(displacedDir, { recursive: true, force: true });
+    fs22.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)}`;
@@ -4818,43 +5223,43 @@ function cleanupDisplacedDirectoryBestEffort(displacedDir, context) {
 }
 function atomicWriteFileSync(targetPath, data, options = {}) {
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs18.mkdirSync(path11.dirname(resolvedTargetPath), { recursive: true });
+  fs22.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 {
-      fs18.writeFileSync(tempPath, data, { mode });
+      fs22.writeFileSync(tempPath, data, { mode });
     }
-    fs18.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs18.renameSync;
+    fs22.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs22.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs18.rmSync(tempPath, { force: true });
+    fs22.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function atomicCopyFileSync(sourcePath, targetPath, options = {}) {
-  if (!fs18.existsSync(sourcePath)) return;
+  if (!fs22.existsSync(sourcePath)) return;
   const resolvedTargetPath = resolveAtomicReplacementPath(targetPath);
-  fs18.mkdirSync(path11.dirname(resolvedTargetPath), { recursive: true });
+  fs22.mkdirSync(path11.dirname(resolvedTargetPath), { recursive: true });
   const tempPath = createSiblingTempFilePath(resolvedTargetPath, "copy");
-  const mode = fs18.statSync(sourcePath).mode & 4095;
+  const mode = fs22.statSync(sourcePath).mode & 4095;
   try {
-    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs18.copyFileSync;
+    const copyTempFileSync = options.hooks?.copyTempFileSync ?? fs22.copyFileSync;
     copyTempFileSync(sourcePath, tempPath);
-    fs18.chmodSync(tempPath, mode);
-    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs18.renameSync;
+    fs22.chmodSync(tempPath, mode);
+    const renameTempFileSync = options.hooks?.renameTempFileSync ?? fs22.renameSync;
     renameTempFileSync(tempPath, resolvedTargetPath);
   } catch (error) {
-    fs18.rmSync(tempPath, { force: true });
+    fs22.rmSync(tempPath, { force: true });
     throw error;
   }
 }
 function cleanupRollbackDirectory(rollbackDir) {
   if (!rollbackDir) return;
-  fs18.rmSync(rollbackDir, { recursive: true, force: true });
+  fs22.rmSync(rollbackDir, { recursive: true, force: true });
 }
 function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   if (!rollbackDir) return void 0;
@@ -4866,20 +5271,20 @@ function cleanupRollbackDirectoryBestEffort(rollbackDir) {
   }
 }
 function restoreDirectoryFromRollback(targetDir, rollbackDir) {
-  if (!fs18.existsSync(rollbackDir)) {
+  if (!fs22.existsSync(rollbackDir)) {
     throw new Error(`Rollback directory is missing: ${rollbackDir}`);
   }
-  fs18.mkdirSync(path11.dirname(targetDir), { recursive: true });
-  const displacedDir = fs18.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
+  fs22.mkdirSync(path11.dirname(targetDir), { recursive: true });
+  const displacedDir = fs22.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "rollback-restore") : void 0;
   if (displacedDir) {
-    fs18.renameSync(targetDir, displacedDir);
+    fs22.renameSync(targetDir, displacedDir);
   }
   try {
-    fs18.renameSync(rollbackDir, targetDir);
+    fs22.renameSync(rollbackDir, targetDir);
   } catch (restoreError) {
-    if (displacedDir && fs18.existsSync(displacedDir)) {
+    if (displacedDir && fs22.existsSync(displacedDir)) {
       try {
-        fs18.renameSync(displacedDir, targetDir);
+        fs22.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -4895,23 +5300,23 @@ function restoreDirectoryFromRollback(targetDir, rollbackDir) {
   return cleanupDisplacedDirectoryBestEffort(displacedDir, `restored the previous plugin copy into ${targetDir}`);
 }
 function restoreDirectoryFromBackup(targetDir, backupDir) {
-  if (!fs18.existsSync(backupDir)) {
+  if (!fs22.existsSync(backupDir)) {
     throw new Error(`Plugin backup directory is missing: ${backupDir}`);
   }
-  fs18.mkdirSync(path11.dirname(targetDir), { recursive: true });
+  fs22.mkdirSync(path11.dirname(targetDir), { recursive: true });
   const stagedDir = createSiblingSwapPath(targetDir, "backup-restore");
-  const displacedDir = fs18.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
-  fs18.cpSync(backupDir, stagedDir, { recursive: true });
+  const displacedDir = fs22.existsSync(targetDir) ? createSiblingSwapPath(targetDir, "pre-backup-restore") : void 0;
+  fs22.cpSync(backupDir, stagedDir, { recursive: true });
   if (displacedDir) {
-    fs18.renameSync(targetDir, displacedDir);
+    fs22.renameSync(targetDir, displacedDir);
   }
   try {
-    fs18.renameSync(stagedDir, targetDir);
+    fs22.renameSync(stagedDir, targetDir);
   } catch (restoreError) {
-    fs18.rmSync(targetDir, { recursive: true, force: true });
-    if (displacedDir && fs18.existsSync(displacedDir)) {
+    fs22.rmSync(targetDir, { recursive: true, force: true });
+    if (displacedDir && fs22.existsSync(displacedDir)) {
       try {
-        fs18.renameSync(displacedDir, targetDir);
+        fs22.renameSync(displacedDir, targetDir);
       } catch (revertError) {
         throw new AggregateError(
           [restoreError, revertError],
@@ -4919,7 +5324,7 @@ function restoreDirectoryFromBackup(targetDir, backupDir) {
         );
       }
     }
-    fs18.rmSync(stagedDir, { recursive: true, force: true });
+    fs22.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 }
@@ -4944,7 +5349,7 @@ function rollbackOpenclawUpgrade({
   let configRemovalAttempted = false;
   let pluginRestored = false;
   try {
-    if (rollbackDir && fs18.existsSync(rollbackDir)) {
+    if (rollbackDir && fs22.existsSync(rollbackDir)) {
       const cleanupWarning = restoreDirectoryFromRollback(pluginDir, rollbackDir);
       notes.push(`Restored previous plugin from rollback copy at ${rollbackDir}`);
       if (cleanupWarning) notes.push(cleanupWarning);
@@ -4954,7 +5359,7 @@ function rollbackOpenclawUpgrade({
     rollbackRestoreError = error instanceof Error ? error.message : String(error);
   }
   try {
-    if (!pluginRestored && pluginBackupDir && fs18.existsSync(pluginBackupDir)) {
+    if (!pluginRestored && pluginBackupDir && fs22.existsSync(pluginBackupDir)) {
       const cleanupWarning = restoreDirectoryFromBackup(pluginDir, pluginBackupDir);
       if (rollbackRestoreError) {
         notes.push(`Rollback copy restore failed; restored previous plugin from durable backup at ${pluginBackupDir}`);
@@ -4979,12 +5384,12 @@ function rollbackOpenclawUpgrade({
     notes.push("No previous plugin copy was available for automatic restore");
   }
   try {
-    if (configBackupPath && fs18.existsSync(configBackupPath)) {
+    if (configBackupPath && fs22.existsSync(configBackupPath)) {
       restoreFileFromBackup(configPath, configBackupPath);
       notes.push(`Restored OpenClaw config from backup at ${configBackupPath}`);
-    } else if (removeConfigIfUnbacked && fs18.existsSync(configPath)) {
+    } else if (removeConfigIfUnbacked && fs22.existsSync(configPath)) {
       configRemovalAttempted = true;
-      fs18.rmSync(configPath, { force: true });
+      fs22.rmSync(configPath, { force: true });
       notes.push("Removed OpenClaw config created during the failed upgrade");
     }
   } catch (error) {
@@ -5037,7 +5442,7 @@ Run this manually when you're ready:
 
 // src/openclaw-managed-upgrade-loader.ts
 import { execFileSync } from "child_process";
-import fs19 from "fs";
+import fs23 from "fs";
 import os from "os";
 import path12 from "path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
@@ -5113,7 +5518,7 @@ function buildOpenclawManagedUpgradePackageSpec(version = "latest") {
 function readCliAdapterRange() {
   const moduleDir = path12.dirname(fileURLToPath3(import.meta.url));
   const manifestPath = path12.resolve(moduleDir, "../package.json");
-  const manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf8"));
+  const manifest = JSON.parse(fs23.readFileSync(manifestPath, "utf8"));
   if (manifest.name !== "@remnic/cli") {
     throw new Error(`Invalid @remnic/cli package manifest at ${manifestPath}.`);
   }
@@ -5157,7 +5562,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 = fs19.mkdtempSync(path12.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  const temporaryRoot = fs23.mkdtempSync(path12.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
   try {
     const toolingPackageSpec = `${OPENCLAW_PLUGIN_PACKAGE}@${readCliAdapterRange()}`;
     const installArgs = [
@@ -5172,12 +5577,12 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
     ];
     (hooks.runNpmInstall ?? runNpmInstall)(installArgs);
     const resolverPath = path12.join(temporaryRoot, "load-managed-upgrade.mjs");
-    fs19.writeFileSync(resolverPath, `export * from ${JSON.stringify(MANAGED_UPGRADE_SPECIFIER)};
+    fs23.writeFileSync(resolverPath, `export * from ${JSON.stringify(MANAGED_UPGRADE_SPECIFIER)};
 `, "utf8");
     return await importModule(pathToFileURL2(resolverPath).href);
   } finally {
     try {
-      fs19.rmSync(temporaryRoot, { recursive: true, force: true });
+      fs23.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}`);
@@ -5186,13 +5591,13 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
 }
 
 // src/remote-daemon.ts
-import fs20 from "fs";
+import fs24 from "fs";
 function readCompatEnv(primary, legacy) {
   return process.env[primary] ?? process.env[legacy];
 }
 function readRemnicConfigRecord(configPath) {
   try {
-    const parsed = JSON.parse(fs20.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs24.readFileSync(configPath, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -5421,7 +5826,7 @@ async function remoteRecallXray(daemon, request) {
 }
 
 // src/daemon-service.ts
-import fs21 from "fs";
+import fs25 from "fs";
 import path13 from "path";
 import * as childProcess from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -5433,7 +5838,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs21.existsSync;
+  const existsSync4 = options.existsSync ?? fs25.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -5492,8 +5897,8 @@ function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync4 = options.readFileSync ?? fs21.readFileSync;
-  const unlinkSync = options.unlinkSync ?? fs21.unlinkSync;
+  const readFileSync4 = options.readFileSync ?? fs25.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs25.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));
@@ -5593,8 +5998,8 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs21.existsSync;
-  const readFileSync4 = options.readFileSync ?? fs21.readFileSync;
+  const existsSync4 = options.existsSync ?? fs25.existsSync;
+  const readFileSync4 = options.readFileSync ?? fs25.readFileSync;
   if (!existsSync4(plistPath)) {
     return {
       installed: false,
@@ -5772,7 +6177,7 @@ function stripConfigArgv(args) {
 }
 
 // src/import-dispatch.ts
-import fs22 from "fs";
+import fs26 from "fs";
 import {
   runImporter,
   validateImportBatchSize,
@@ -6292,7 +6697,7 @@ async function cmdImport(rest, targetFactory, disposeTarget, ioOverrides = {}) {
   let materializedTarget;
   let materializePromise;
   const io = {
-    readFile: ioOverrides.readFile ?? (async (p) => fs22.promises.readFile(p, "utf-8")),
+    readFile: ioOverrides.readFile ?? (async (p) => fs26.promises.readFile(p, "utf-8")),
     loadAdapter: ioOverrides.loadAdapter ?? (async (name) => (await loadImporterModule(name)).adapter),
     runImporter: ioOverrides.runImporter ?? runImporter,
     getWriteTarget: async () => {
@@ -6405,7 +6810,7 @@ async function cmdCapture(rest, io) {
 }
 
 // src/import-lossless-claw-cmd.ts
-import fs23 from "fs";
+import fs27 from "fs";
 import path15 from "path";
 import {
   applyLcmSchema,
@@ -6517,15 +6922,15 @@ async function loadImportLosslessClawModule() {
 
 // src/import-lossless-claw-cmd.ts
 function assertDirectoryOrAbsent(p, label) {
-  if (fs23.existsSync(p) && !fs23.statSync(p).isDirectory()) {
+  if (fs27.existsSync(p) && !fs27.statSync(p).isDirectory()) {
     throw new Error(`${label} is not a directory: ${p}`);
   }
 }
 function assertFile(p, label) {
-  if (!fs23.existsSync(p)) {
+  if (!fs27.existsSync(p)) {
     throw new Error(`${label} does not exist: ${p}`);
   }
-  if (!fs23.statSync(p).isFile()) {
+  if (!fs27.statSync(p).isFile()) {
     throw new Error(`${label} is not a file: ${p}`);
   }
 }
@@ -6557,7 +6962,7 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     try {
       if (parsed.dryRun) {
         const lcmPath = path15.join(memoryDir, "state", "lcm.sqlite");
-        if (fs23.existsSync(lcmPath)) {
+        if (fs27.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
           destDb = mod.openInMemoryDestinationDatabase();
@@ -7909,7 +8314,7 @@ async function resolveAllBenchmarks() {
   if (packageBenchmarks) {
     return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
   }
-  if (!fs24.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs28.existsSync(EVAL_RUNNER_PATH)) {
     return [];
   }
   return BENCHMARK_CATALOG.filter((entry) => entry.category !== "ingestion").map((entry) => entry.id);
@@ -7957,7 +8362,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
       `Fallback benchmark runner does not support provider-backed, gateway, or thinking/timeout flags (${unsupportedOptions.join(", ")}). Build/install @remnic/bench to use those options.`
     );
   }
-  if (!fs24.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs28.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."
     );
@@ -7967,7 +8372,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
     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) => fs24.existsSync(candidate)) ?? "tsx";
+  const tsxCmd = tsxCandidates.find((candidate) => fs28.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
     parsed.resultsDir ?? resolveBenchOutputDir(),
     benchmarkId,
@@ -8112,9 +8517,9 @@ var PERSONAMEM_COMPLETION_MARKER = path19.join(
 );
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
-    const datasetRoot = fs24.realpathSync(datasetPath);
+    const datasetRoot = fs28.realpathSync(datasetPath);
     const candidatePath = path19.resolve(datasetRoot, relativePath);
-    const candidateRealPath = fs24.realpathSync(candidatePath);
+    const candidateRealPath = fs28.realpathSync(candidatePath);
     const relativeToRoot = path19.relative(datasetRoot, candidateRealPath);
     if (relativeToRoot.startsWith("..") || path19.isAbsolute(relativeToRoot)) {
       return null;
@@ -8173,14 +8578,14 @@ function parseCsvRows(raw) {
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
     const completionMarkerPath = path19.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
-    if (fs24.statSync(completionMarkerPath).isFile()) {
+    if (fs28.statSync(completionMarkerPath).isFile()) {
       return true;
     }
   } catch {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs24.statSync(path19.join(datasetPath, candidate)).isFile();
+      return fs28.statSync(path19.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -8189,7 +8594,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs24.readFileSync(path19.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs28.readFileSync(path19.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -8204,7 +8609,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     }
     return historyPaths.every((relativePath) => {
       const resolvedPath = resolveRealpathWithinDataset(datasetPath, relativePath);
-      return resolvedPath !== null && fs24.statSync(resolvedPath).isFile();
+      return resolvedPath !== null && fs28.statSync(resolvedPath).isFile();
     });
   } catch {
     return false;
@@ -8212,7 +8617,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs24.statSync(path19.join(datasetPath, relativePath)).isFile();
+    return fs28.statSync(path19.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
@@ -8232,10 +8637,10 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
   return candidateFilenames.some((filename) => {
     const filePath = path19.join(datasetPath, filename);
     try {
-      if (!fs24.statSync(filePath).isFile()) {
+      if (!fs28.statSync(filePath).isFile()) {
         return false;
       }
-      const raw = fs24.readFileSync(filePath, "utf8");
+      const raw = fs28.readFileSync(filePath, "utf8");
       return /"source"\s*:\s*"recsys[_-]/i.test(raw);
     } catch {
       return false;
@@ -8251,7 +8656,7 @@ function isMemoryAgentBenchDatasetComplete(datasetPath) {
 function isDatasetDownloaded(datasetPath, benchmarkId) {
   let stats;
   try {
-    stats = fs24.statSync(datasetPath);
+    stats = fs28.statSync(datasetPath);
   } catch {
     return false;
   }
@@ -8261,7 +8666,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
   if (!marker) {
     try {
-      return fs24.readdirSync(datasetPath).length > 0;
+      return fs28.readdirSync(datasetPath).length > 0;
     } catch {
       return false;
     }
@@ -8269,7 +8674,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs24.statSync(path19.join(datasetPath, name)).isFile();
+        return fs28.statSync(path19.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -8281,7 +8686,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs24.statSync(path19.join(datasetPath, name)).isFile();
+        return fs28.statSync(path19.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -8299,7 +8704,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   }
   if (marker.ext) {
     try {
-      return fs24.readdirSync(datasetPath).some(
+      return fs28.readdirSync(datasetPath).some(
         (name) => name.endsWith(marker.ext) && !marker.exclude?.includes(name)
       );
     } catch {
@@ -8311,7 +8716,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
 async function launchBenchUi(resultsDir) {
   const benchUiDir = path19.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs24.existsSync(path19.join(benchUiDir, "package.json"))) {
+  if (!fs28.existsSync(path19.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -8349,13 +8754,13 @@ function listDownloadableBenchmarks() {
 }
 function resolveDatasetDownloadScriptPath() {
   const bundled = path19.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
-  if (fs24.existsSync(bundled)) {
+  if (fs28.existsSync(bundled)) {
     return bundled;
   }
   return path19.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs24.existsSync(path19.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs24.existsSync(path19.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs28.existsSync(path19.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs28.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";
@@ -8668,8 +9073,8 @@ async function exportBenchPackageResult(parsed) {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs24.mkdirSync(path19.dirname(parsed.output), { recursive: true });
-    fs24.writeFileSync(parsed.output, rendered);
+    fs28.mkdirSync(path19.dirname(parsed.output), { recursive: true });
+    fs28.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
   }
@@ -8714,7 +9119,7 @@ async function manageBenchDatasets(parsed) {
     process.exit(1);
   }
   const scriptPath = resolveDatasetDownloadScriptPath();
-  if (!fs24.existsSync(scriptPath)) {
+  if (!fs28.existsSync(scriptPath)) {
     console.error(`ERROR: dataset download script not found: ${scriptPath}`);
     process.exit(1);
   }
@@ -8914,7 +9319,7 @@ async function calibrateBenchJudges(parsed, rawArgs) {
     );
     process.exit(1);
   }
-  const sourceResultSha256 = createHash4("sha256").update(fs24.readFileSync(latest.path)).digest("hex");
+  const sourceResultSha256 = createHash4("sha256").update(fs28.readFileSync(latest.path)).digest("hex");
   const expandedManifestPath = expandTilde(manifestPath);
   if (!bench.resolveLocalLabJudgeProviderConfig) {
     console.error(
@@ -9329,7 +9734,7 @@ function loadPinnedLoCoMoTaskSelector(parsed) {
   }
   let decoded;
   try {
-    decoded = JSON.parse(fs24.readFileSync(parsed.taskIdsFile, "utf8"));
+    decoded = JSON.parse(fs28.readFileSync(parsed.taskIdsFile, "utf8"));
   } catch (error) {
     throw new Error(
       `Unable to read --task-ids-file ${parsed.taskIdsFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -10004,7 +10409,7 @@ function resolveBenchReproDatasetDir(datasetDir) {
     return void 0;
   }
   try {
-    return fs24.realpathSync(datasetDir);
+    return fs28.realpathSync(datasetDir);
   } catch {
     return datasetDir;
   }
@@ -10058,13 +10463,13 @@ async function writeBenchReproManifestForPackageRun(args) {
 }
 function loadStandaloneConvergeCommandConfig() {
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  return parseConfig15(resolveRemnicConfigRecord14(raw));
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.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 parseConfig15(resolveRemnicConfigRecord14(value));
+  return parseConfig17(resolveRemnicConfigRecord16(value));
 }
 function loadConvergeCommandConfig() {
   if (readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH")) {
@@ -10087,13 +10492,13 @@ function resolveConfigPath(cliPath) {
     path19.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs24.existsSync(candidate)) return candidate;
+    if (fs28.existsSync(candidate)) return candidate;
   }
   return path19.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
-  if (fs24.existsSync(configPath)) {
+  if (fs28.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -10103,7 +10508,7 @@ function resolveExistingBenchRemnicConfigPath(cliPath) {
 }
 function resolveExistingBenchOpenclawConfigPath(cliPath) {
   const configPath = resolveOpenclawConfigPath(cliPath);
-  if (fs24.existsSync(configPath)) {
+  if (fs28.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -10210,8 +10615,8 @@ function resolveMemoryDir() {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return normalizeMemoryDirPath(envMemoryDir);
     const configPath = resolveConfigPath();
-    const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord14(raw);
+    const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
     if (typeof remnicCfg.memoryDir === "string" && remnicCfg.memoryDir.length > 0) {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
@@ -10219,18 +10624,18 @@ function resolveMemoryDir() {
     const standalonePath = path19.join(home, ".remnic", "memory");
     const legacyStandalonePath = path19.join(home, ".engram", "memory");
     const openclawPath = path19.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
-    if (fs24.existsSync(standalonePath)) return standalonePath;
-    if (fs24.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    if (fs28.existsSync(standalonePath)) return standalonePath;
+    if (fs28.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs24.existsSync(manifestPath)) {
+  if (fs28.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
         const activeMemoryDir = normalizeMemoryDirPath(active.memoryDir);
-        if (!fs24.existsSync(activeMemoryDir)) {
-          fs24.mkdirSync(activeMemoryDir, { recursive: true });
+        if (!fs28.existsSync(activeMemoryDir)) {
+          fs28.mkdirSync(activeMemoryDir, { recursive: true });
         }
         return activeMemoryDir;
       }
@@ -10279,13 +10684,13 @@ function resolveOpenclawConfigPath(cliPath) {
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
   if (envPath) return path19.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
-    if (fs24.existsSync(candidate)) return candidate;
+    if (fs28.existsSync(candidate)) return candidate;
   }
   return path19.join(resolveOpenclawStateDir(), "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
-  if (!fs24.existsSync(configPath)) return {};
-  const raw = fs24.readFileSync(configPath, "utf-8");
+  if (!fs28.existsSync(configPath)) return {};
+  const raw = fs28.readFileSync(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -10387,9 +10792,9 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
 }
 function backupPathIfPresent(sourcePath, backupPath) {
-  if (!fs24.existsSync(sourcePath)) return false;
-  fs24.mkdirSync(path19.dirname(backupPath), { recursive: true });
-  fs24.cpSync(sourcePath, backupPath, { recursive: true });
+  if (!fs28.existsSync(sourcePath)) return false;
+  fs28.mkdirSync(path19.dirname(backupPath), { recursive: true });
+  fs28.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
 function restartOpenclawGateway() {
@@ -10408,7 +10813,7 @@ function restartOpenclawGateway() {
 }
 function cmdInit() {
   const configPath = path19.join(process.cwd(), "remnic.config.json");
-  if (fs24.existsSync(configPath)) {
+  if (fs28.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
@@ -10424,7 +10829,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs24.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs28.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-...");
@@ -10846,9 +11251,9 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   const service = new EngramAccessService2(orchestrator);
@@ -11026,9 +11431,9 @@ async function cmdXray(rest) {
   }
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const orchestrator = new Orchestrator10(config);
   await orchestrator.initialize();
   await orchestrator.deferredReady;
@@ -11059,8 +11464,8 @@ async function runWhoKnowsCommand(rest, io) {
 async function withLocalService(fn) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const orchestrator = new Orchestrator10(parseConfig15(resolveRemnicConfigRecord14(raw)));
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const orchestrator = new Orchestrator10(parseConfig17(resolveRemnicConfigRecord16(raw)));
   await orchestrator.initialize();
   await orchestrator.deferredReady;
   const service = new EngramAccessService2(orchestrator);
@@ -11092,9 +11497,9 @@ async function cmdPromotionCandidates(rest) {
 async function cmdVersions(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.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);
@@ -11208,9 +11613,9 @@ Options:
 async function cmdEnrich(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
@@ -11402,9 +11807,9 @@ Registered providers:`);
 async function cmdExtensions(action, rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const root = resolveExtensionsRoot(config);
   const noopLog = { warn: () => {
   }, debug: () => {
@@ -11453,7 +11858,7 @@ Root: ${root}`);
       const extensions = await discoverMemoryExtensions(root, warnLog);
       let entries = [];
       try {
-        entries = fs24.readdirSync(root);
+        entries = fs28.readdirSync(root);
       } catch {
         console.log(`Extensions root does not exist: ${root}`);
         process.exitCode = 0;
@@ -11464,7 +11869,7 @@ Root: ${root}`);
       for (const entry of entries) {
         const entryPath = path19.join(root, entry);
         try {
-          if (!fs24.statSync(entryPath).isDirectory()) continue;
+          if (!fs28.statSync(entryPath).isDirectory()) continue;
         } catch {
           continue;
         }
@@ -11496,9 +11901,9 @@ Root: ${root}`);
 async function cmdBriefing(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.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);
@@ -11576,10 +11981,10 @@ async function cmdBriefing(rest) {
   if (save) {
     try {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
-      fs24.mkdirSync(saveDir, { recursive: true });
+      fs28.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
       const filePath = path19.join(saveDir, filename);
-      fs24.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
+      fs28.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)}`);
@@ -11597,7 +12002,7 @@ async function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs24.existsSync(configPath);
+  const configExists = fs28.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   let standaloneConfig;
   let standaloneConfigError;
@@ -11605,11 +12010,11 @@ async function cmdDoctor() {
   let configuredNs = { invalid: false };
   if (configExists) {
     try {
-      const raw = JSON.parse(fs24.readFileSync(configPath, "utf8"));
-      const remnicCfg = resolveRemnicConfigRecord14(raw);
+      const raw = JSON.parse(fs28.readFileSync(configPath, "utf8"));
+      const remnicCfg = resolveRemnicConfigRecord16(raw);
       standaloneOpenaiApiKeyExplicitlyFalse = isOpenaiApiKeyDisabled(remnicCfg.openaiApiKey);
       configuredNs = readConfiguredNamespace(remnicCfg);
-      standaloneConfig = parseConfig15(remnicCfg);
+      standaloneConfig = parseConfig17(remnicCfg);
     } catch (err) {
       standaloneConfigError = err instanceof Error ? err.message : String(err);
     }
@@ -11618,10 +12023,10 @@ async function cmdDoctor() {
   try {
     memoryDir = resolveMemoryDir();
   } catch {
-    memoryDir = parseConfig15({}).memoryDir;
+    memoryDir = parseConfig17({}).memoryDir;
   }
   try {
-    fs24.mkdirSync(memoryDir, { recursive: true });
+    fs28.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}` });
@@ -11650,7 +12055,7 @@ async function cmdDoctor() {
   });
   if (nsPolicyCheck) checks.push(nsPolicyCheck);
   const openclawConfigPath = resolveOpenclawConfigPath();
-  const openclawConfigExists = fs24.existsSync(openclawConfigPath);
+  const openclawConfigExists = fs28.existsSync(openclawConfigPath);
   let openclawConfig = {};
   let openclawConfigValid = false;
   let openclawPluginModeConfigured = false;
@@ -11658,7 +12063,7 @@ async function cmdDoctor() {
   let activeOpenclawEntryConfig = null;
   if (openclawConfigExists) {
     try {
-      const parsed = JSON.parse(fs24.readFileSync(openclawConfigPath, "utf-8"));
+      const parsed = JSON.parse(fs28.readFileSync(openclawConfigPath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         openclawConfig = parsed;
         openclawConfigValid = true;
@@ -11738,9 +12143,9 @@ async function cmdDoctor() {
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
-        if (fs24.existsSync(resolvedMemDir)) {
+        if (fs28.existsSync(resolvedMemDir)) {
           try {
-            const stat2 = fs24.statSync(resolvedMemDir);
+            const stat2 = fs28.statSync(resolvedMemDir);
             if (stat2.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
@@ -11895,12 +12300,12 @@ async function cmdDoctor() {
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs24.existsSync(configPath)) {
+  if (!fs28.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs24.readFileSync(configPath, "utf8");
+  const rawConfig = fs28.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -12008,9 +12413,9 @@ async function cmdReview(action, rest) {
     const configPath = resolveConfigPath();
     let tombstonesConfig = null;
     try {
-      const rawCfg = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-      const remnicCfg = resolveRemnicConfigRecord14(rawCfg);
-      const config = parseConfig15(remnicCfg);
+      const rawCfg = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+      const remnicCfg = resolveRemnicConfigRecord16(rawCfg);
+      const config = parseConfig17(remnicCfg);
       tombstonesConfig = {
         enabled: config.tombstonesEnabled,
         semanticMatch: config.tombstonesSemanticMatch,
@@ -12752,7 +13157,7 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat2 = fs24.statSync(filePath);
+  const stat2 = fs28.statSync(filePath);
   if (stat2.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
@@ -13243,7 +13648,7 @@ function advanceOfflineBaseFilesForSuccessfulPush(options) {
   return [...next.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function runOfflineSyncOnce(options) {
-  fs24.mkdirSync(options.memoryDir, { recursive: true });
+  fs28.mkdirSync(options.memoryDir, { recursive: true });
   let activeStatePath = options.statePath;
   let priorState = await readOfflineSyncState(activeStatePath);
   let syncNamespace = options.namespace ?? priorState?.namespace;
@@ -13876,7 +14281,7 @@ Environment fallbacks:
   const configPath = resolveConfigPath();
   let config;
   try {
-    const rawConfig = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
+    const rawConfig = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
     config = parseConfigQuietly(pickOfflineConfigRecord(rawConfig));
   } catch {
     throw new Error(
@@ -13891,7 +14296,7 @@ Environment fallbacks:
   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");
-    fs24.mkdirSync(memoryDir, { recursive: true });
+    fs28.mkdirSync(memoryDir, { recursive: true });
     const remoteSnapshot = await fetchOfflineSnapshot({
       remoteUrl,
       token,
@@ -13990,7 +14395,7 @@ Environment fallbacks:
     return;
   }
   if (action === "status") {
-    fs24.mkdirSync(memoryDir, { recursive: true });
+    fs28.mkdirSync(memoryDir, { recursive: true });
     const state = statePath ? await readOfflineSyncState(statePath) : null;
     if (state && remoteUrl && statePath) {
       assertOfflineStateMatches({
@@ -14128,7 +14533,7 @@ function cmdDedup(json) {
 function readInstalledConnectorConfig(configPath, fallback) {
   if (!configPath) return fallback;
   try {
-    const parsed = JSON.parse(fs24.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs28.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
     const { token: _token, ...config } = parsed;
     return config;
@@ -14306,7 +14711,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 ? fs24.existsSync(extRoot) : false;
+          const extensionExists = available && extRoot ? fs28.existsSync(extRoot) : false;
           publisherChecks.push({
             name: `Publisher: ${targetHostId}`,
             ok: !available || extensionExists,
@@ -14380,7 +14785,7 @@ async function cmdConnectors(action, rest, json) {
     let connectorsCfg;
     const configPath = resolveConfigPath();
     try {
-      const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
+      const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
       connectorsCfg = parseConfigQuietly(raw).connectors;
     } catch {
       process.stderr.write(
@@ -14456,9 +14861,9 @@ async function cmdConnectors(action, rest, json) {
     }
     initLogger5();
     const configPath = resolveConfigPath();
-    const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord14(raw);
-    const config = parseConfig15(remnicCfg);
+    const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
+    const config = parseConfig17(remnicCfg);
     const orchestrator = new Orchestrator10(config);
     try {
       await orchestrator.initialize();
@@ -14581,9 +14986,9 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     console.error(`connectors marketplace: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
-  const rawConfig = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const pluginConfig = resolveRemnicConfigRecord14(rawConfig);
-  const config = parseConfig15(pluginConfig);
+  const rawConfig = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const pluginConfig = resolveRemnicConfigRecord16(rawConfig);
+  const config = parseConfig17(pluginConfig);
   if (subAction === "generate") {
     let outputDir;
     try {
@@ -14603,13 +15008,13 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
   } else if (subAction === "validate") {
     const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path19.join(process.cwd(), "marketplace.json");
     const resolved = path19.resolve(targetPath);
-    if (!fs24.existsSync(resolved)) {
+    if (!fs28.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs24.readFileSync(resolved, "utf8"));
+      parsed = JSON.parse(fs28.readFileSync(resolved, "utf8"));
     } catch {
       console.error(`Invalid JSON in ${resolved}`);
       process.exit(1);
@@ -14812,9 +15217,9 @@ async function cmdSpace(action, rest, json) {
 async function cmdLegacyBenchmark(action, rest, json) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.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();
@@ -15217,7 +15622,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs24.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs28.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -15312,13 +15717,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs24.mkdirSync(LOGS_DIR, { recursive: true });
+  fs28.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
     const templatePath = path19.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs24.readFileSync(templatePath, "utf8");
+    const template = fs28.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs24.mkdirSync(path19.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs24.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs28.mkdirSync(path19.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs28.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
     } catch (err) {
@@ -15335,10 +15740,10 @@ function daemonInstall() {
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
     const templatePath = path19.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs24.readFileSync(templatePath, "utf8");
+    const template = fs28.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs24.mkdirSync(path19.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs24.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs28.mkdirSync(path19.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs28.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
     } catch (err) {
@@ -15374,7 +15779,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs24.unlinkSync(plistPath);
+        fs28.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -15394,7 +15799,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of SYSTEMD_UNIT_PATHS) {
       try {
-        fs24.unlinkSync(unitPath);
+        fs28.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -15461,13 +15866,13 @@ async function daemonStatus() {
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs24.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs24.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs28.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs28.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
   try {
     const configPath = resolveConfigPath();
-    const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-    const remnicCfg = resolveRemnicConfigRecord14(raw);
-    const config = parseConfig15(remnicCfg);
+    const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = resolveRemnicConfigRecord16(raw);
+    const config = parseConfig17(remnicCfg);
     const extRoot = resolveExtensionsRoot(config);
     const noopLog = { warn: () => {
     }, debug: () => {
@@ -15506,9 +15911,9 @@ function daemonStart() {
       return;
     }
   }
-  fs24.mkdirSync(PID_DIR, { recursive: true });
-  fs24.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs24.openSync(LOG_FILE, "a");
+  fs28.mkdirSync(PID_DIR, { recursive: true });
+  fs28.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs28.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -15530,7 +15935,7 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs24.writeFileSync(PID_FILE, String(child.pid));
+  fs28.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
@@ -15564,11 +15969,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs24.unlinkSync(PID_FILE);
+    fs28.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs24.unlinkSync(LEGACY_PID_FILE);
+    fs28.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -15696,9 +16101,9 @@ async function promptYesNo(question, defaultYes = true) {
 async function cmdBinary(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = resolveRemnicConfigRecord16(raw);
+  const config = parseConfig17(remnicCfg);
   const memoryDir = resolveMemoryDir();
   const blConfig = {
     enabled: config.binaryLifecycleEnabled,
@@ -15887,7 +16292,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 (!fs24.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
+  if (!fs28.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)`);
   }
@@ -15907,8 +16312,8 @@ async function cmdOpenclawInstall(opts) {
 Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
     return;
   }
-  if (fs24.existsSync(memoryDir)) {
-    const st = fs24.statSync(memoryDir);
+  if (fs28.existsSync(memoryDir)) {
+    const st = fs28.statSync(memoryDir);
     if (!st.isDirectory()) {
       throw new Error(
         `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
@@ -15916,12 +16321,12 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
       );
     }
   } else {
-    fs24.mkdirSync(memoryDir, { recursive: true });
+    fs28.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
   const configDir = path19.dirname(configPath);
-  if (!fs24.existsSync(configDir)) {
-    fs24.mkdirSync(configDir, { recursive: true });
+  if (!fs28.existsSync(configDir)) {
+    fs28.mkdirSync(configDir, { recursive: true });
   }
   atomicWriteFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
   console.log("\nDone! Summary of changes:");
@@ -15950,7 +16355,7 @@ async function cmdOpenclawUpgrade(opts) {
   const legacyPluginDirForBackup = opts.legacyPluginDirForBackup ? resolveOpenclawLegacyPluginDir(opts.legacyPluginDirForBackup) : void 0;
   const fallbackMemoryDir = path19.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   const packageSpec = buildOpenclawManagedUpgradePackageSpec(opts.version);
-  const configExistedBefore = fs24.existsSync(configPath);
+  const configExistedBefore = fs28.existsSync(configPath);
   const existingConfig = readOpenclawConfig(configPath);
   const { entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
   const preservedMemoryDir = opts.memoryDir ? path19.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
@@ -16175,15 +16580,15 @@ async function cmdOpenclawMigrateEngram(opts) {
 }
 function createOpenclawUpgradeBackupDir() {
   const backupsRoot = path19.join(resolveOpenclawStateDir(), "backups");
-  fs24.mkdirSync(backupsRoot, { recursive: true });
-  return fs24.mkdtempSync(path19.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  fs28.mkdirSync(backupsRoot, { recursive: true });
+  return fs28.mkdtempSync(path19.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger5();
   const configPath = resolveConfigPath();
-  const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-  const remnicCfg = resolveRemnicConfigRecord14(raw);
-  const config = parseConfig15(remnicCfg);
+  const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.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."
@@ -16219,8 +16624,8 @@ async function cmdTaxonomy(rest) {
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
         const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs24.mkdirSync(path19.dirname(resolverPath), { recursive: true });
-        fs24.writeFileSync(resolverPath, doc);
+        fs28.mkdirSync(path19.dirname(resolverPath), { recursive: true });
+        fs28.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
       break;
@@ -16266,7 +16671,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs24.writeFileSync(resolverPath, doc);
+        fs28.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -16297,7 +16702,7 @@ async function cmdTaxonomy(rest) {
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
         const resolverPath = path19.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs24.writeFileSync(resolverPath, doc);
+        fs28.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -16488,12 +16893,12 @@ async function runTrainingExport(args, stdout = process.stdout) {
       `Unknown training-export format "${args.format}". ${validList}`
     );
   }
-  if (!fs24.existsSync(args.memoryDir)) {
+  if (!fs28.existsSync(args.memoryDir)) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
-  if (!fs24.statSync(args.memoryDir).isDirectory()) {
+  if (!fs28.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.`
     );
@@ -16579,10 +16984,10 @@ async function runTrainingExport(args, stdout = process.stdout) {
   }
   const formatted = adapter.formatRecords(records);
   const outDir = path19.dirname(args.output);
-  fs24.mkdirSync(outDir, { recursive: true });
+  fs28.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
-  fs24.writeFileSync(tmpPath, formatted, "utf-8");
-  fs24.renameSync(tmpPath, args.output);
+  fs28.writeFileSync(tmpPath, formatted, "utf-8");
+  fs28.renameSync(tmpPath, args.output);
   stdout.write(
     `Exported ${records.length} records to ${args.output} (${adapter.name} format)
 `
@@ -16625,6 +17030,9 @@ async function main(argv = process.argv.slice(2)) {
       await cmdQuery(queryText, json, explain);
       break;
     }
+    case "recall":
+      await runRecallNavigateCommand(rest);
+      break;
     case "action-confidence":
       await cmdActionConfidence(rest);
       break;
@@ -16760,7 +17168,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs24.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs28.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -16768,12 +17176,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs24.existsSync(treeDir)) {
+        if (!fs28.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
         const indexPath = path19.join(treeDir, "INDEX.md");
-        if (!fs24.existsSync(indexPath)) {
+        if (!fs28.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -16960,6 +17368,10 @@ Other:
       await runMeetingsBinaryCommand(rest);
       break;
     }
+    case "timeline": {
+      await runTimelineBinaryCommand(rest);
+      break;
+    }
     case "location":
       await runLocationBinaryCommand(rest);
       break;
@@ -16972,6 +17384,18 @@ Other:
     case "standup":
       await runStandupBinaryCommand(rest);
       break;
+    case "journal":
+      await runJournalBinaryCommand(rest);
+      break;
+    case "journal-vault":
+      await runJournalVaultBinaryCommand(rest);
+      break;
+    case "activity-privacy":
+      await runActivityPrivacyBinaryCommand(rest);
+      break;
+    case "vault-publish":
+      await runVaultPublishBinaryCommand(rest);
+      break;
     case "codegraph":
       await runCodegraphBinaryCommand(rest);
       break;
@@ -16988,9 +17412,9 @@ Other:
       const targetFactory = async () => {
         if (!orchestratorSingleton) {
           const configPath = resolveConfigPath();
-          const raw = fs24.existsSync(configPath) ? JSON.parse(fs24.readFileSync(configPath, "utf8")) : {};
-          const remnicCfg = resolveRemnicConfigRecord14(raw);
-          const config = parseConfig15(remnicCfg);
+          const raw = fs28.existsSync(configPath) ? JSON.parse(fs28.readFileSync(configPath, "utf8")) : {};
+          const remnicCfg = resolveRemnicConfigRecord16(raw);
+          const config = parseConfig17(remnicCfg);
           orchestratorSingleton = new Orchestrator10(config);
           await orchestratorSingleton.initialize();
           await orchestratorSingleton.deferredReady;