@remnic/cli 9.50.0 → 9.50.3

package/dist/index.js

@@ -18,12 +18,12 @@ async function persistEnrichmentCandidate(storage, entityName, candidate) {
 }
 
 // src/index.ts
-import fs13 from "fs";
-import os2 from "os";
-import path16 from "path";
+import fs14 from "fs";
+import os3 from "os";
+import path17 from "path";
 import { createHash as createHash4 } from "crypto";
 import * as childProcess2 from "child_process";
-import { fileURLToPath as fileURLToPath4 } from "url";
+import { fileURLToPath as fileURLToPath5 } from "url";
 import { gzipSync } from "zlib";
 import {
   parseConfig as parseConfig6,
@@ -138,7 +138,7 @@ import {
   OPERATION_NAMES,
   validateCapabilitiesForMint
 } from "@remnic/core";
-import { resolveRemnicPluginEntry } from "@remnic/core/plugin-id.js";
+import { PLUGIN_ID as REMNIC_OPENCLAW_PLUGIN_ID, resolveRemnicPluginEntry } from "@remnic/core/plugin-id.js";
 
 // src/commands/meetings.ts
 import fs from "fs";
@@ -4157,33 +4157,6 @@ function atomicCopyFileSync(sourcePath, targetPath, options = {}) {
     throw error;
   }
 }
-function swapDirectoryWithRollback(stagedDir, targetDir, rollbackDir) {
-  let hasRollbackCopy = false;
-  fs9.mkdirSync(path10.dirname(targetDir), { recursive: true });
-  fs9.rmSync(rollbackDir, { recursive: true, force: true });
-  if (fs9.existsSync(targetDir)) {
-    fs9.renameSync(targetDir, rollbackDir);
-    hasRollbackCopy = true;
-  }
-  try {
-    fs9.renameSync(stagedDir, targetDir);
-  } catch (swapError) {
-    fs9.rmSync(targetDir, { recursive: true, force: true });
-    if (hasRollbackCopy && fs9.existsSync(rollbackDir)) {
-      try {
-        fs9.renameSync(rollbackDir, targetDir);
-        hasRollbackCopy = false;
-      } catch (restoreError) {
-        throw new AggregateError(
-          [swapError, restoreError],
-          `Failed to stage upgraded plugin and failed to restore the previous plugin copy. The last known-good plugin remains preserved at ${rollbackDir}.`
-        );
-      }
-    }
-    throw swapError;
-  }
-  return { rollbackDir: hasRollbackCopy ? rollbackDir : void 0 };
-}
 function cleanupRollbackDirectory(rollbackDir) {
   if (!rollbackDir) return;
   fs9.rmSync(rollbackDir, { recursive: true, force: true });
@@ -4224,10 +4197,7 @@ function restoreDirectoryFromRollback(targetDir, rollbackDir) {
       { cause: restoreError }
     );
   }
-  return cleanupDisplacedDirectoryBestEffort(
-    displacedDir,
-    `restored the previous plugin copy into ${targetDir}`
-  );
+  return cleanupDisplacedDirectoryBestEffort(displacedDir, `restored the previous plugin copy into ${targetDir}`);
 }
 function restoreDirectoryFromBackup(targetDir, backupDir) {
   if (!fs9.existsSync(backupDir)) {
@@ -4260,10 +4230,7 @@ function restoreDirectoryFromBackup(targetDir, backupDir) {
       { cause: restoreError }
     );
   }
-  return cleanupDisplacedDirectoryBestEffort(
-    displacedDir,
-    `restored the plugin backup into ${targetDir}`
-  );
+  return cleanupDisplacedDirectoryBestEffort(displacedDir, `restored the plugin backup into ${targetDir}`);
 }
 function restoreFileFromBackup(targetPath, backupPath) {
   atomicCopyFileSync(backupPath, targetPath);
@@ -4273,11 +4240,13 @@ function rollbackOpenclawUpgrade({
   configPath,
   pluginBackupDir,
   pluginDir,
-  rollbackDir
+  rollbackDir,
+  removeConfigIfUnbacked
 }) {
   const notes = [];
   const errors = [];
   let rollbackRestoreError;
+  let configRemovalAttempted = false;
   let pluginRestored = false;
   try {
     if (rollbackDir && fs9.existsSync(rollbackDir)) {
@@ -4293,9 +4262,7 @@ function rollbackOpenclawUpgrade({
     if (!pluginRestored && pluginBackupDir && fs9.existsSync(pluginBackupDir)) {
       const cleanupWarning = restoreDirectoryFromBackup(pluginDir, pluginBackupDir);
       if (rollbackRestoreError) {
-        notes.push(
-          `Rollback copy restore failed; restored previous plugin from durable backup at ${pluginBackupDir}`
-        );
+        notes.push(`Rollback copy restore failed; restored previous plugin from durable backup at ${pluginBackupDir}`);
       } else {
         notes.push(`Restored previous plugin from backup at ${pluginBackupDir}`);
       }
@@ -4320,10 +4287,14 @@ function rollbackOpenclawUpgrade({
     if (configBackupPath && fs9.existsSync(configBackupPath)) {
       restoreFileFromBackup(configPath, configBackupPath);
       notes.push(`Restored OpenClaw config from backup at ${configBackupPath}`);
+    } else if (removeConfigIfUnbacked && fs9.existsSync(configPath)) {
+      configRemovalAttempted = true;
+      fs9.rmSync(configPath, { force: true });
+      notes.push("Removed OpenClaw config created during the failed upgrade");
     }
   } catch (error) {
     errors.push(
-      `Failed to restore OpenClaw config from backup at ${configBackupPath}: ${error instanceof Error ? error.message : String(error)}`
+      configRemovalAttempted || !configBackupPath ? `Failed to remove OpenClaw config created during the failed upgrade: ${error instanceof Error ? error.message : String(error)}` : `Failed to restore OpenClaw config from backup at ${configBackupPath}: ${error instanceof Error ? error.message : String(error)}`
     );
   }
   if (errors.length > 0) {
@@ -4331,6 +4302,19 @@ function rollbackOpenclawUpgrade({
   }
   return notes;
 }
+function restoreOpenclawConfigWithRetry(options) {
+  try {
+    rollbackOpenclawUpgrade(options);
+    return void 0;
+  } catch (initialRestoreError) {
+    try {
+      rollbackOpenclawUpgrade(options);
+      return "Restored OpenClaw config after a transient rollback failure";
+    } catch (retryRestoreError) {
+      throw new AggregateError([initialRestoreError, retryRestoreError], "OpenClaw config restore failed twice.");
+    }
+  }
+}
 function createOpenclawUpgradeRollbackFailure(options) {
   const { failurePhase, installError, rollbackError } = options;
   return new AggregateError(
@@ -4356,12 +4340,162 @@ Run this manually when you're ready:
   }
 }
 
-// src/daemon-service.ts
+// src/openclaw-managed-upgrade-loader.ts
+import { execFileSync } from "child_process";
 import fs10 from "fs";
+import os from "os";
 import path11 from "path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "url";
+var MANAGED_UPGRADE_SPECIFIER = "@remnic/plugin-openclaw/managed-upgrade";
+var OPENCLAW_PLUGIN_PACKAGE = "@remnic/plugin-openclaw";
+var NPM_INSTALL_TIMEOUT_MS = 12e4;
+var DIST_TAG_SELECTOR = /^[A-Za-z][0-9A-Za-z._-]*$/;
+var CARET_SEMVER_RANGE_SELECTOR = /^\^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
+function semanticVersionCoreLength(selector) {
+  let cursor = selector.startsWith("v") ? 1 : 0;
+  for (let part = 0; part < 3; part += 1) {
+    const partStart = cursor;
+    while (cursor < selector.length) {
+      const code = selector.charCodeAt(cursor);
+      if (code < 48 || code > 57) break;
+      cursor += 1;
+    }
+    if (cursor === partStart || cursor - partStart > 1 && selector.charCodeAt(partStart) === 48) return -1;
+    if (part < 2) {
+      if (selector.charCodeAt(cursor) !== 46) return -1;
+      cursor += 1;
+    }
+  }
+  return cursor;
+}
+function areSemverIdentifiersValid(value, start, end, rejectLeadingZeroes) {
+  if (start >= end) return false;
+  let identifierStart = start;
+  let numeric = true;
+  for (let cursor = start; cursor <= end; cursor += 1) {
+    const code = value.charCodeAt(cursor);
+    if (cursor === end || code === 46) {
+      if (cursor === identifierStart) return false;
+      if (rejectLeadingZeroes && numeric && cursor - identifierStart > 1 && value.charCodeAt(identifierStart) === 48) {
+        return false;
+      }
+      identifierStart = cursor + 1;
+      numeric = true;
+      continue;
+    }
+    const alphanumeric = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+    if (!alphanumeric && code !== 45) return false;
+    if (code < 48 || code > 57) numeric = false;
+  }
+  return true;
+}
+function isExactSemverSelector(selector) {
+  const coreLength = semanticVersionCoreLength(selector);
+  if (coreLength < 0) return false;
+  if (coreLength === selector.length) return true;
+  const suffixMarker = selector[coreLength];
+  if (suffixMarker === "-") {
+    const plusIndex = selector.indexOf("+", coreLength + 1);
+    const prereleaseEnd = plusIndex < 0 ? selector.length : plusIndex;
+    if (!areSemverIdentifiersValid(selector, coreLength + 1, prereleaseEnd, true)) return false;
+    return plusIndex < 0 || areSemverIdentifiersValid(selector, plusIndex + 1, selector.length, false);
+  }
+  return suffixMarker === "+" && areSemverIdentifiersValid(selector, coreLength + 1, selector.length, false);
+}
+function assertRegistrySelector(selector) {
+  const lowerSelector = selector.toLowerCase();
+  const archiveSelector = lowerSelector.endsWith(".tgz") || lowerSelector.endsWith(".tar.gz");
+  if (!isExactSemverSelector(selector) && !DIST_TAG_SELECTOR.test(selector) || archiveSelector) {
+    throw new Error(
+      `Invalid OpenClaw plugin version ${JSON.stringify(selector)}. Use an exact semantic version or npm dist-tag.`
+    );
+  }
+}
+function buildOpenclawManagedUpgradePackageSpec(version = "latest") {
+  assertRegistrySelector(version);
+  return `${OPENCLAW_PLUGIN_PACKAGE}@${version}`;
+}
+function readCliAdapterRange() {
+  const moduleDir = path11.dirname(fileURLToPath3(import.meta.url));
+  const manifestPath = path11.resolve(moduleDir, "../package.json");
+  const manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf8"));
+  if (manifest.name !== "@remnic/cli") {
+    throw new Error(`Invalid @remnic/cli package manifest at ${manifestPath}.`);
+  }
+  const peerDependencies = manifest.peerDependencies && typeof manifest.peerDependencies === "object" && !Array.isArray(manifest.peerDependencies) ? manifest.peerDependencies : {};
+  const adapterRange = peerDependencies[OPENCLAW_PLUGIN_PACKAGE];
+  if (typeof adapterRange !== "string" || !CARET_SEMVER_RANGE_SELECTOR.test(adapterRange)) {
+    throw new Error(
+      `Invalid ${OPENCLAW_PLUGIN_PACKAGE} peer dependency ${JSON.stringify(adapterRange)} in ${manifestPath}.`
+    );
+  }
+  return adapterRange;
+}
+function assertOpenclawManagedUpgradePackageSpec(packageSpec) {
+  const prefix = `${OPENCLAW_PLUGIN_PACKAGE}@`;
+  if (!packageSpec.startsWith(prefix)) {
+    throw new Error(`Invalid OpenClaw plugin package spec ${JSON.stringify(packageSpec)}.`);
+  }
+  assertRegistrySelector(packageSpec.slice(prefix.length));
+}
+function runNpmInstall(args) {
+  execFileSync("npm", args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: NPM_INSTALL_TIMEOUT_MS
+  });
+}
+function isManagedUpgradeSubpathMissing(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return false;
+  if (error.code !== "ERR_PACKAGE_PATH_NOT_EXPORTED" || !("message" in error)) return false;
+  if (typeof error.message !== "string") return false;
+  const namesManagedUpgradeSubpath = error.message.includes("'./managed-upgrade'") || error.message.includes('"./managed-upgrade"');
+  const namesOpenclawAdapter = /[/\\]@remnic[/\\]plugin-openclaw[/\\]package\.json(?:\s|$)/.test(error.message);
+  return namesManagedUpgradeSubpath && namesOpenclawAdapter;
+}
+async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
+  assertOpenclawManagedUpgradePackageSpec(packageSpec);
+  const importModule = hooks.importModule ?? ((specifier) => import(specifier));
+  try {
+    return await importModule(MANAGED_UPGRADE_SPECIFIER);
+  } catch (error) {
+    const adapterMissing = isSpecifierNotFoundError(error, OPENCLAW_PLUGIN_PACKAGE) || isSpecifierNotFoundError(error, MANAGED_UPGRADE_SPECIFIER) || isManagedUpgradeSubpathMissing(error);
+    if (!adapterMissing) throw error;
+  }
+  const temporaryRoot = fs10.mkdtempSync(path11.join(os.tmpdir(), "remnic-openclaw-upgrade-"));
+  try {
+    const toolingPackageSpec = `${OPENCLAW_PLUGIN_PACKAGE}@${readCliAdapterRange()}`;
+    const installArgs = [
+      "install",
+      "--ignore-scripts",
+      "--no-save",
+      "--omit=peer",
+      "--fund=false",
+      "--prefix",
+      temporaryRoot,
+      toolingPackageSpec
+    ];
+    (hooks.runNpmInstall ?? runNpmInstall)(installArgs);
+    const resolverPath = path11.join(temporaryRoot, "load-managed-upgrade.mjs");
+    fs10.writeFileSync(resolverPath, `export * from ${JSON.stringify(MANAGED_UPGRADE_SPECIFIER)};
+`, "utf8");
+    return await importModule(pathToFileURL2(resolverPath).href);
+  } finally {
+    try {
+      fs10.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}`);
+    }
+  }
+}
+
+// src/daemon-service.ts
+import fs11 from "fs";
+import path12 from "path";
 import * as childProcess from "child_process";
-import { fileURLToPath as fileURLToPath3 } from "url";
-var thisModuleDir = path11.dirname(fileURLToPath3(import.meta.url));
+import { fileURLToPath as fileURLToPath4 } from "url";
+var thisModuleDir = path12.dirname(fileURLToPath4(import.meta.url));
 function launchdLoadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["load", "-w", plistPath], { stdio: "pipe" });
 }
@@ -4369,7 +4503,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs10.existsSync;
+  const existsSync4 = options.existsSync ?? fs11.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -4383,8 +4517,8 @@ function resolveServerBinDetails(options = {}) {
     });
   } catch {
   }
-  const workspaceServerBin = path11.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
-  const workspaceDistIndex = path11.resolve(moduleDir, "../../remnic-server/dist/index.js");
+  const workspaceServerBin = path12.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
+  const workspaceDistIndex = path12.resolve(moduleDir, "../../remnic-server/dist/index.js");
   candidates.push(
     {
       path: workspaceServerBin,
@@ -4405,11 +4539,11 @@ function resolveServerBinDetails(options = {}) {
     });
   }
   candidates.push({
-    path: path11.resolve(moduleDir, "../../remnic-server/src/index.ts"),
+    path: path12.resolve(moduleDir, "../../remnic-server/src/index.ts"),
     source: "workspace-source"
   });
   const selected = candidates.find((candidate) => isCandidateReady(candidate, existsSync4)) ?? candidates.find((candidate) => existsSync4(candidate.path)) ?? candidates[0] ?? {
-    path: path11.resolve(moduleDir, "../../remnic-server/dist/index.js"),
+    path: path12.resolve(moduleDir, "../../remnic-server/dist/index.js"),
     source: "workspace-dist"
   };
   const exists = existsSync4(selected.path);
@@ -4428,11 +4562,11 @@ function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync4 = options.readFileSync ?? fs10.readFileSync;
-  const unlinkSync = options.unlinkSync ?? fs10.unlinkSync;
+  const readFileSync4 = options.readFileSync ?? fs11.readFileSync;
+  const unlinkSync = options.unlinkSync ?? fs11.unlinkSync;
   const processKill = options.processKill ?? process.kill;
   const platform = options.platform ?? process.platform;
-  const execFileSync3 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
+  const execFileSync4 = options.execFileSync ?? ((command, args, execOptions) => childProcess.execFileSync(command, args, execOptions));
   for (const file of options.pidFiles) {
     let pid;
     try {
@@ -4450,7 +4584,7 @@ function readVerifiedDaemonPid(options) {
       removePidFileBestEffort(file, unlinkSync);
       continue;
     }
-    const command = readProcessCommand(pid, execFileSync3, platform);
+    const command = readProcessCommand(pid, execFileSync4, platform);
     if (command === void 0) {
       removePidFileBestEffort(file, unlinkSync);
       continue;
@@ -4464,7 +4598,7 @@ function readVerifiedDaemonPid(options) {
 }
 function doesProcessCommandLookLikeRemnicDaemon(command, expectedServerBin) {
   const normalizedCommand = command.trim();
-  const normalizedExpected = path11.resolve(expandTilde(expectedServerBin));
+  const normalizedExpected = path12.resolve(expandTilde(expectedServerBin));
   return normalizedCommand.includes(normalizedExpected) || /(?:^|\s|[/\\])(?:remnic-server|engram-server)(?:\.js)?(?:\s|$)/.test(normalizedCommand) || /@remnic[/\\]server[/\\]/.test(normalizedCommand) || /packages[/\\]remnic-server[/\\](?:bin[/\\]remnic-server\.js|dist[/\\]index\.js|src[/\\]index\.ts)/.test(normalizedCommand);
 }
 function parseDaemonPid(raw) {
@@ -4473,15 +4607,15 @@ function parseDaemonPid(raw) {
   const pid = Number(trimmed);
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
-function readProcessCommand(pid, execFileSync3, platform) {
+function readProcessCommand(pid, execFileSync4, platform) {
   if (platform === "win32") {
-    return readWindowsProcessCommand(pid, execFileSync3);
+    return readWindowsProcessCommand(pid, execFileSync4);
   }
-  return readPosixProcessCommand(pid, execFileSync3);
+  return readPosixProcessCommand(pid, execFileSync4);
 }
-function readPosixProcessCommand(pid, execFileSync3) {
+function readPosixProcessCommand(pid, execFileSync4) {
   try {
-    return execFileSync3("ps", ["-p", String(pid), "-o", "command="], {
+    return execFileSync4("ps", ["-p", String(pid), "-o", "command="], {
       encoding: "utf8",
       stdio: "pipe"
     });
@@ -4489,11 +4623,11 @@ function readPosixProcessCommand(pid, execFileSync3) {
     return void 0;
   }
 }
-function readWindowsProcessCommand(pid, execFileSync3) {
+function readWindowsProcessCommand(pid, execFileSync4) {
   const powerShellCommand = `$process = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($null -ne $process) { $process.CommandLine }`;
   for (const command of ["powershell.exe", "powershell", "pwsh"]) {
     try {
-      const output = execFileSync3(
+      const output = execFileSync4(
         command,
         ["-NoProfile", "-NonInteractive", "-Command", powerShellCommand],
         {
@@ -4508,7 +4642,7 @@ function readWindowsProcessCommand(pid, execFileSync3) {
     }
   }
   try {
-    const output = execFileSync3(
+    const output = execFileSync4(
       "wmic",
       ["process", "where", ["processid", String(pid)].join("="), "get", "CommandLine", "/value"],
       {
@@ -4529,8 +4663,8 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs10.existsSync;
-  const readFileSync4 = options.readFileSync ?? fs10.readFileSync;
+  const existsSync4 = options.existsSync ?? fs11.existsSync;
+  const readFileSync4 = options.readFileSync ?? fs11.readFileSync;
   if (!existsSync4(plistPath)) {
     return {
       installed: false,
@@ -4569,7 +4703,7 @@ function inspectLaunchdPlist(plistPath, options = {}) {
     };
   }
   const expandedServerArg = expandTilde(serverArg);
-  if (!path11.isAbsolute(expandedServerArg)) {
+  if (!path12.isAbsolute(expandedServerArg)) {
     return {
       installed: true,
       ok: false,
@@ -4637,12 +4771,12 @@ function resolveImportSpecifier(specifier) {
   return resolver.call(import.meta, specifier);
 }
 function normalizeResolvedPath(resolved) {
-  if (resolved.startsWith("file:")) return fileURLToPath3(resolved);
+  if (resolved.startsWith("file:")) return fileURLToPath4(resolved);
   return resolved;
 }
 function packageServerBinFromEntry(packageEntry) {
-  if (path11.basename(packageEntry) === "index.js" && path11.basename(path11.dirname(packageEntry)) === "dist") {
-    return path11.join(path11.dirname(path11.dirname(packageEntry)), "bin", "remnic-server.js");
+  if (path12.basename(packageEntry) === "index.js" && path12.basename(path12.dirname(packageEntry)) === "dist") {
+    return path12.join(path12.dirname(path12.dirname(packageEntry)), "bin", "remnic-server.js");
   }
   return packageEntry;
 }
@@ -4764,7 +4898,7 @@ function stripConfigArgv(args) {
 }
 
 // src/import-dispatch.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import {
   runImporter,
   validateImportBatchSize,
@@ -4773,7 +4907,7 @@ import {
 
 // src/import-bundle-detect.ts
 import { lstatSync as lstatSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import path12 from "path";
+import path13 from "path";
 function detectBundleEntries(bundleDir, options = {}) {
   const readdir3 = options.readdirImpl ?? defaultReaddir;
   const readFileImpl = options.readFileImpl ?? defaultReadFile;
@@ -4804,7 +4938,7 @@ function detectBundleEntries(bundleDir, options = {}) {
   for (const filePath of roots) {
     if (seenFiles.has(filePath)) continue;
     seenFiles.add(filePath);
-    const name = path12.basename(filePath);
+    const name = path13.basename(filePath);
     const match = classifyFile(name, filePath, readFileImpl);
     if (match) entries.push(match);
   }
@@ -4842,7 +4976,7 @@ function collectCandidatePaths(root, readdir3, isDirectory2, isRegularFile) {
       return;
     }
     for (const entry of entries) {
-      const full = path12.join(dir, entry);
+      const full = path13.join(dir, entry);
       if (isDirectory2(full)) {
         walk(full, depth + 1);
       } else if (isRegularFile(full)) {
@@ -5278,7 +5412,7 @@ async function cmdImport(rest, targetFactory, disposeTarget, ioOverrides = {}) {
   let materializedTarget;
   let materializePromise;
   const io = {
-    readFile: ioOverrides.readFile ?? (async (p) => fs11.promises.readFile(p, "utf-8")),
+    readFile: ioOverrides.readFile ?? (async (p) => fs12.promises.readFile(p, "utf-8")),
     loadAdapter: ioOverrides.loadAdapter ?? (async (name) => (await loadImporterModule(name)).adapter),
     runImporter: ioOverrides.runImporter ?? runImporter,
     getWriteTarget: async () => {
@@ -5391,8 +5525,8 @@ async function cmdCapture(rest, io) {
 }
 
 // src/import-lossless-claw-cmd.ts
-import fs12 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path14 from "path";
 import {
   applyLcmSchema,
   ensureLcmStateDir,
@@ -5503,15 +5637,15 @@ async function loadImportLosslessClawModule() {
 
 // src/import-lossless-claw-cmd.ts
 function assertDirectoryOrAbsent(p, label) {
-  if (fs12.existsSync(p) && !fs12.statSync(p).isDirectory()) {
+  if (fs13.existsSync(p) && !fs13.statSync(p).isDirectory()) {
     throw new Error(`${label} is not a directory: ${p}`);
   }
 }
 function assertFile(p, label) {
-  if (!fs12.existsSync(p)) {
+  if (!fs13.existsSync(p)) {
     throw new Error(`${label} does not exist: ${p}`);
   }
-  if (!fs12.statSync(p).isFile()) {
+  if (!fs13.statSync(p).isFile()) {
     throw new Error(`${label} is not a file: ${p}`);
   }
 }
@@ -5542,8 +5676,8 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     let destDb;
     try {
       if (parsed.dryRun) {
-        const lcmPath = path13.join(memoryDir, "state", "lcm.sqlite");
-        if (fs12.existsSync(lcmPath)) {
+        const lcmPath = path14.join(memoryDir, "state", "lcm.sqlite");
+        if (fs13.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
           destDb = mod.openInMemoryDestinationDatabase();
@@ -5662,8 +5796,8 @@ function printBenchComparisonSummary(comparison, baseline, candidate) {
 
 // src/bench-coding-commands.ts
 import { lstat as lstat2, readFile as readFile2, realpath, stat } from "fs/promises";
-import os from "os";
-import path14 from "path";
+import os2 from "os";
+import path15 from "path";
 var UINT32_MAX = 4294967295;
 var FROZEN_GENERATOR_SEED = 81;
 var FROZEN_TASK_COUNT = 30;
@@ -5673,7 +5807,7 @@ var FROZEN_MAX_STEPS = 12;
 var FROZEN_MAX_TOOL_CALLS = 8;
 var FROZEN_MAX_OUTPUT_CHARS = 16384;
 var MAX_OUTPUT_BYTES = 16384;
-var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path14.join(
+var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path15.join(
   resolveHomeDir(),
   ".remnic",
   "bench",
@@ -6007,7 +6141,7 @@ function parseBenchCodingArgs(args) {
   throw new Error(`unknown bench coding subcommand ${args[0]}`);
 }
 function normalizeCommandPaths(command) {
-  const resolve2 = (value) => path14.resolve(expandTilde(value));
+  const resolve2 = (value) => path15.resolve(expandTilde(value));
   if (command.kind === "repo-generate") {
     return { ...command, outputDir: resolve2(command.outputDir) };
   }
@@ -6038,23 +6172,23 @@ function normalizeCommandPaths(command) {
   return command;
 }
 async function canonicalProspectivePath(value) {
-  let candidate = path14.resolve(value);
+  let candidate = path15.resolve(value);
   const missingSegments = [];
   while (true) {
     try {
-      return path14.join(await realpath(candidate), ...missingSegments.reverse());
+      return path15.join(await realpath(candidate), ...missingSegments.reverse());
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
-      const parent = path14.dirname(candidate);
+      const parent = path15.dirname(candidate);
       if (parent === candidate) throw error;
-      missingSegments.push(path14.basename(candidate));
+      missingSegments.push(path15.basename(candidate));
       candidate = parent;
     }
   }
 }
 function isSameOrDescendant(candidate, root) {
-  const relative = path14.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative);
+  const relative = path15.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path15.sep}`) && !path15.isAbsolute(relative);
 }
 async function pathExists(value) {
   try {
@@ -6073,7 +6207,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
       const configured = process.env[variable]?.trim();
       if (!configured) continue;
       const memoryRoot = await canonicalProspectivePath(
-        path14.resolve(expandTilde(configured))
+        path15.resolve(expandTilde(configured))
       );
       if (isSameOrDescendant(canonicalOutput, memoryRoot)) {
         throw new Error(refusal);
@@ -6081,10 +6215,10 @@ async function assertSafeBenchmarkOutput(outputDir) {
     }
     let candidate = canonicalOutput;
     while (true) {
-      const hasProfile = await pathExists(path14.join(candidate, "profile.md"));
-      const hasMemoryData = await pathExists(path14.join(candidate, "facts")) || await pathExists(path14.join(candidate, "entities")) || await pathExists(path14.join(candidate, "state"));
+      const hasProfile = await pathExists(path15.join(candidate, "profile.md"));
+      const hasMemoryData = await pathExists(path15.join(candidate, "facts")) || await pathExists(path15.join(candidate, "entities")) || await pathExists(path15.join(candidate, "state"));
       if (hasProfile && hasMemoryData) throw new Error(refusal);
-      const parent = path14.dirname(candidate);
+      const parent = path15.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -6096,7 +6230,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
 async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
   try {
     const parsed = JSON.parse(
-      await readFile2(path14.join(runDir, "run.json"), "utf8")
+      await readFile2(path15.join(runDir, "run.json"), "utf8")
     );
     if (parsed.schemaVersion !== 1 || typeof parsed.runId !== "string" || parsed.runId.length === 0 || typeof parsed.suiteVersion !== "string" || !parsed.suiteVersion.startsWith("h6-failure-gate-v1-")) {
       throw new Error("invalid H6 metadata");
@@ -6106,7 +6240,7 @@ async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
   }
 }
 function sanitizeOutput(output) {
-  const home = os.homedir();
+  const home = os2.homedir();
   const safe = home.length > 1 ? output.replaceAll(home, "~") : output;
   if (Buffer.byteLength(safe, "utf8") <= MAX_OUTPUT_BYTES) return safe.trimEnd();
   const bounded = Buffer.from(safe, "utf8").subarray(0, MAX_OUTPUT_BYTES - 32).toString("utf8");
@@ -6155,7 +6289,7 @@ async function runRepoVerification(command, bench) {
   if (command.directory === void 0) {
     dataset = await requireFunction(bench, "loadCommittedH6BenchmarkDataset")();
   } else {
-    const serialized = await readFile2(path14.join(command.directory, "dataset.json"), "utf8").catch(
+    const serialized = await readFile2(path15.join(command.directory, "dataset.json"), "utf8").catch(
       () => void 0
     );
     if (serialized === void 0) {
@@ -6283,7 +6417,7 @@ async function cmdBenchCoding(args) {
 }
 
 // src/bench-research-commands.ts
-import path15 from "path";
+import path16 from "path";
 function emit(result) {
   if (result.output) {
     console.log(result.output);
@@ -6301,7 +6435,7 @@ async function runBenchResearchCommand(parsed) {
     emit(
       await runAttributeCliCommand({
         runRef: parsed.runRef,
-        resultsDir: parsed.resultsDir ?? path15.join(resolveHomeDir(), ".remnic", "bench", "results"),
+        resultsDir: parsed.resultsDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "results"),
         memoryDir: parsed.memoryDir,
         qmdPath: parsed.qmdPath,
         collection: parsed.collection,
@@ -6570,15 +6704,15 @@ registerPublisher("omp", () => new LazyPluginPiPublisher("omp", (mod) => mod.Omp
 function readCompatEnv(primary, legacy) {
   return process.env[primary] ?? process.env[legacy];
 }
-var PID_DIR = path16.join(resolveHomeDir(), ".remnic");
-var LEGACY_PID_DIR = path16.join(resolveHomeDir(), ".engram");
-var PID_FILE = path16.join(PID_DIR, "server.pid");
-var LEGACY_PID_FILE = path16.join(LEGACY_PID_DIR, "server.pid");
-var LOG_FILE = path16.join(PID_DIR, "server.log");
-var LEGACY_LOG_FILE = path16.join(LEGACY_PID_DIR, "server.log");
-var CLI_MODULE_DIR = path16.dirname(fileURLToPath4(import.meta.url));
-var CLI_REPO_ROOT = path16.resolve(CLI_MODULE_DIR, "../../..");
-var EVAL_RUNNER_PATH = path16.join(CLI_REPO_ROOT, "evals", "run.ts");
+var PID_DIR = path17.join(resolveHomeDir(), ".remnic");
+var LEGACY_PID_DIR = path17.join(resolveHomeDir(), ".engram");
+var PID_FILE = path17.join(PID_DIR, "server.pid");
+var LEGACY_PID_FILE = path17.join(LEGACY_PID_DIR, "server.pid");
+var LOG_FILE = path17.join(PID_DIR, "server.log");
+var LEGACY_LOG_FILE = path17.join(LEGACY_PID_DIR, "server.log");
+var CLI_MODULE_DIR = path17.dirname(fileURLToPath5(import.meta.url));
+var CLI_REPO_ROOT = path17.resolve(CLI_MODULE_DIR, "../../..");
+var EVAL_RUNNER_PATH = path17.join(CLI_REPO_ROOT, "evals", "run.ts");
 var OPENCLAW_GATEWAY_LABEL = "ai.openclaw.gateway";
 var CLI_SUCCESS_EXIT_GRACE_MS = 5e3;
 var CLI_OUTPUT_FLUSH_GRACE_MS = 250;
@@ -6743,7 +6877,7 @@ async function resolveAllBenchmarks() {
   if (packageBenchmarks) {
     return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
   }
-  if (!fs13.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs14.existsSync(EVAL_RUNNER_PATH)) {
     return [];
   }
   return BENCHMARK_CATALOG.filter((entry) => entry.category !== "ingestion").map((entry) => entry.id);
@@ -6791,17 +6925,17 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
       `Fallback benchmark runner does not support provider-backed, gateway, or thinking/timeout flags (${unsupportedOptions.join(", ")}). Build/install @remnic/bench to use those options.`
     );
   }
-  if (!fs13.existsSync(EVAL_RUNNER_PATH)) {
+  if (!fs14.existsSync(EVAL_RUNNER_PATH)) {
     console.error(
       "Benchmark runner not found. Expected eval runner at evals/run.ts or a phase-1 @remnic/bench runtime export."
     );
     process.exit(1);
   }
   const tsxCandidates = [
-    path16.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
-    path16.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
+    path17.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
+    path17.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
   ];
-  const tsxCmd = tsxCandidates.find((candidate) => fs13.existsSync(candidate)) ?? "tsx";
+  const tsxCmd = tsxCandidates.find((candidate) => fs14.existsSync(candidate)) ?? "tsx";
   const fallbackOutputDir = createFallbackBenchOutputDir(
     parsed.resultsDir ?? resolveBenchOutputDir(),
     benchmarkId,
@@ -6818,7 +6952,7 @@ async function runBenchViaFallback(parsed, benchmarkId, runtimeProfile) {
   return resolveFallbackBenchResultPath(fallbackOutputDir);
 }
 function resolveBenchOutputDir() {
-  return path16.join(resolveHomeDir(), ".remnic", "bench", "results");
+  return path17.join(resolveHomeDir(), ".remnic", "bench", "results");
 }
 var DOWNLOADABLE_BENCHMARK_DATASETS = [
   "ama-bench",
@@ -6863,8 +6997,8 @@ var MEMORY_AGENT_BENCH_SPLIT_FILENAMES = [
 ];
 var MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES = [
   "entity2id.json",
-  path16.join("processed_data", "Recsys_Redial", "entity2id.json"),
-  path16.join("Recsys_Redial", "entity2id.json")
+  path17.join("processed_data", "Recsys_Redial", "entity2id.json"),
+  path17.join("Recsys_Redial", "entity2id.json")
 ];
 var DOWNLOADED_DATASET_MARKERS = {
   "ama-bench": { anyOf: ["open_end_qa_set.jsonl"] },
@@ -6939,18 +7073,18 @@ var PERSONAMEM_DATASET_FILE_CANDIDATES = [
   "benchmark/benchmark.csv",
   "benchmark.csv"
 ];
-var PERSONAMEM_COMPLETION_MARKER = path16.join(
+var PERSONAMEM_COMPLETION_MARKER = path17.join(
   "data",
   "chat_history_32k",
   ".download-complete"
 );
 function resolveRealpathWithinDataset(datasetPath, relativePath) {
   try {
-    const datasetRoot = fs13.realpathSync(datasetPath);
-    const candidatePath = path16.resolve(datasetRoot, relativePath);
-    const candidateRealPath = fs13.realpathSync(candidatePath);
-    const relativeToRoot = path16.relative(datasetRoot, candidateRealPath);
-    if (relativeToRoot.startsWith("..") || path16.isAbsolute(relativeToRoot)) {
+    const datasetRoot = fs14.realpathSync(datasetPath);
+    const candidatePath = path17.resolve(datasetRoot, relativePath);
+    const candidateRealPath = fs14.realpathSync(candidatePath);
+    const relativeToRoot = path17.relative(datasetRoot, candidateRealPath);
+    if (relativeToRoot.startsWith("..") || path17.isAbsolute(relativeToRoot)) {
       return null;
     }
     return candidateRealPath;
@@ -7006,15 +7140,15 @@ function parseCsvRows(raw) {
 }
 function isPersonaMemDatasetComplete(datasetPath) {
   try {
-    const completionMarkerPath = path16.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
-    if (fs13.statSync(completionMarkerPath).isFile()) {
+    const completionMarkerPath = path17.join(datasetPath, PERSONAMEM_COMPLETION_MARKER);
+    if (fs14.statSync(completionMarkerPath).isFile()) {
       return true;
     }
   } catch {
   }
   const datasetFile = PERSONAMEM_DATASET_FILE_CANDIDATES.find((candidate) => {
     try {
-      return fs13.statSync(path16.join(datasetPath, candidate)).isFile();
+      return fs14.statSync(path17.join(datasetPath, candidate)).isFile();
     } catch {
       return false;
     }
@@ -7023,7 +7157,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     return false;
   }
   try {
-    const rows = parseCsvRows(fs13.readFileSync(path16.join(datasetPath, datasetFile), "utf8"));
+    const rows = parseCsvRows(fs14.readFileSync(path17.join(datasetPath, datasetFile), "utf8"));
     if (rows.length < 2) {
       return false;
     }
@@ -7038,7 +7172,7 @@ function isPersonaMemDatasetComplete(datasetPath) {
     }
     return historyPaths.every((relativePath) => {
       const resolvedPath = resolveRealpathWithinDataset(datasetPath, relativePath);
-      return resolvedPath !== null && fs13.statSync(resolvedPath).isFile();
+      return resolvedPath !== null && fs14.statSync(resolvedPath).isFile();
     });
   } catch {
     return false;
@@ -7046,14 +7180,14 @@ function isPersonaMemDatasetComplete(datasetPath) {
 }
 function hasDatasetFile(datasetPath, relativePath) {
   try {
-    return fs13.statSync(path16.join(datasetPath, relativePath)).isFile();
+    return fs14.statSync(path17.join(datasetPath, relativePath)).isFile();
   } catch {
     return false;
   }
 }
 function hasMemoryAgentBenchEntityMapping(datasetPath) {
-  const absoluteDatasetPath = path16.resolve(datasetPath);
-  const roots = [absoluteDatasetPath, path16.dirname(absoluteDatasetPath)];
+  const absoluteDatasetPath = path17.resolve(datasetPath);
+  const roots = [absoluteDatasetPath, path17.dirname(absoluteDatasetPath)];
   return hasDatasetFile(absoluteDatasetPath, "entity2id.json") || roots.some(
     (root) => MEMORY_AGENT_BENCH_ENTITY_MAPPING_CANDIDATES.filter((relativePath) => relativePath !== "entity2id.json").some((relativePath) => hasDatasetFile(root, relativePath))
   );
@@ -7064,12 +7198,12 @@ function memoryAgentBenchDatasetHasRecSysSamples(datasetPath) {
     ...MEMORY_AGENT_BENCH_SPLIT_FILENAMES
   ];
   return candidateFilenames.some((filename) => {
-    const filePath = path16.join(datasetPath, filename);
+    const filePath = path17.join(datasetPath, filename);
     try {
-      if (!fs13.statSync(filePath).isFile()) {
+      if (!fs14.statSync(filePath).isFile()) {
         return false;
       }
-      const raw = fs13.readFileSync(filePath, "utf8");
+      const raw = fs14.readFileSync(filePath, "utf8");
       return /"source"\s*:\s*"recsys[_-]/i.test(raw);
     } catch {
       return false;
@@ -7085,7 +7219,7 @@ function isMemoryAgentBenchDatasetComplete(datasetPath) {
 function isDatasetDownloaded(datasetPath, benchmarkId) {
   let stats;
   try {
-    stats = fs13.statSync(datasetPath);
+    stats = fs14.statSync(datasetPath);
   } catch {
     return false;
   }
@@ -7095,7 +7229,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
   if (!marker) {
     try {
-      return fs13.readdirSync(datasetPath).length > 0;
+      return fs14.readdirSync(datasetPath).length > 0;
     } catch {
       return false;
     }
@@ -7103,7 +7237,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.allOf) {
     const hasAllRequiredFiles = marker.allOf.every((name) => {
       try {
-        return fs13.statSync(path16.join(datasetPath, name)).isFile();
+        return fs14.statSync(path17.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -7115,7 +7249,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   if (marker.anyOf) {
     const hasMarkerFile = marker.anyOf.some((name) => {
       try {
-        return fs13.statSync(path16.join(datasetPath, name)).isFile();
+        return fs14.statSync(path17.join(datasetPath, name)).isFile();
       } catch {
         return false;
       }
@@ -7133,7 +7267,7 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   }
   if (marker.ext) {
     try {
-      return fs13.readdirSync(datasetPath).some(
+      return fs14.readdirSync(datasetPath).some(
         (name) => name.endsWith(marker.ext) && !marker.exclude?.includes(name)
       );
     } catch {
@@ -7143,9 +7277,9 @@ function isDatasetDownloaded(datasetPath, benchmarkId) {
   return false;
 }
 async function launchBenchUi(resultsDir) {
-  const benchUiDir = path16.join(CLI_REPO_ROOT, "packages", "bench-ui");
+  const benchUiDir = path17.join(CLI_REPO_ROOT, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs13.existsSync(path16.join(benchUiDir, "package.json"))) {
+  if (!fs14.existsSync(path17.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -7172,24 +7306,24 @@ async function launchBenchUi(resultsDir) {
   });
 }
 function resolveRepoDatasetRoot() {
-  const repoCandidate = path16.join(CLI_REPO_ROOT, "evals", "datasets");
+  const repoCandidate = path17.join(CLI_REPO_ROOT, "evals", "datasets");
   if (isRepoCheckout()) {
     return repoCandidate;
   }
-  return path16.join(resolveHomeDir(), ".remnic", "bench", "datasets");
+  return path17.join(resolveHomeDir(), ".remnic", "bench", "datasets");
 }
 function listDownloadableBenchmarks() {
   return [...DOWNLOADABLE_BENCHMARK_DATASETS];
 }
 function resolveDatasetDownloadScriptPath() {
-  const bundled = path16.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
-  if (fs13.existsSync(bundled)) {
+  const bundled = path17.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
+  if (fs14.existsSync(bundled)) {
     return bundled;
   }
-  return path16.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
+  return path17.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
 }
 function isRepoCheckout() {
-  return fs13.existsSync(path16.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs13.existsSync(path16.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+  return fs14.existsSync(path17.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs14.existsSync(path17.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -7240,7 +7374,7 @@ function resolveBenchDatasetDir(benchmarkId, quick, datasetDirOverride) {
   if (quick) {
     return void 0;
   }
-  const datasetDir = path16.join(resolveRepoDatasetRoot(), benchmarkId);
+  const datasetDir = path17.join(resolveRepoDatasetRoot(), benchmarkId);
   if (isDatasetDownloaded(datasetDir, benchmarkId)) {
     return datasetDir;
   }
@@ -7497,13 +7631,13 @@ async function exportBenchPackageResult(parsed) {
     process.exit(1);
   }
   const result = await loadBenchmarkResult(summary.path);
-  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path16.dirname(summary.path), result.meta.id) : void 0;
+  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path17.dirname(summary.path), result.meta.id) : void 0;
   const rendered = renderBenchmarkResultExport(result, parsed.format, {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs13.mkdirSync(path16.dirname(parsed.output), { recursive: true });
-    fs13.writeFileSync(parsed.output, rendered);
+    fs14.mkdirSync(path17.dirname(parsed.output), { recursive: true });
+    fs14.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
   }
@@ -7520,7 +7654,7 @@ async function manageBenchDatasets(parsed) {
       process.exit(1);
     }
     const status = supported.map((benchmarkId) => {
-      const datasetPath = path16.join(datasetRoot, benchmarkId);
+      const datasetPath = path17.join(datasetRoot, benchmarkId);
       return {
         benchmark: benchmarkId,
         downloaded: isDatasetDownloaded(datasetPath, benchmarkId),
@@ -7548,7 +7682,7 @@ async function manageBenchDatasets(parsed) {
     process.exit(1);
   }
   const scriptPath = resolveDatasetDownloadScriptPath();
-  if (!fs13.existsSync(scriptPath)) {
+  if (!fs14.existsSync(scriptPath)) {
     console.error(`ERROR: dataset download script not found: ${scriptPath}`);
     process.exit(1);
   }
@@ -7558,7 +7692,7 @@ async function manageBenchDatasets(parsed) {
     runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, parsed.json === true);
     downloaded.push({
       benchmark: benchmarkId,
-      path: path16.join(datasetRoot, benchmarkId)
+      path: path17.join(datasetRoot, benchmarkId)
     });
   }
   if (parsed.json) {
@@ -7697,10 +7831,10 @@ async function calibrateBenchJudges(parsed, rawArgs) {
   }
   const bench = await loadBenchModule();
   const resultsDir = expandTilde(
-    parsed.resultsDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "results")
+    parsed.resultsDir ?? path17.join(resolveHomeDir(), ".remnic", "bench", "results")
   );
   const calibrationDir = expandTilde(
-    parsed.calibrationDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    parsed.calibrationDir ?? path17.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const stored = await bench.listBenchmarkResults(resultsDir);
   const allForBenchmark = stored.filter((entry) => entry.benchmark === benchmarkId);
@@ -7748,7 +7882,7 @@ async function calibrateBenchJudges(parsed, rawArgs) {
     );
     process.exit(1);
   }
-  const sourceResultSha256 = createHash4("sha256").update(fs13.readFileSync(latest.path)).digest("hex");
+  const sourceResultSha256 = createHash4("sha256").update(fs14.readFileSync(latest.path)).digest("hex");
   const expandedManifestPath = expandTilde(manifestPath);
   if (!bench.resolveLocalLabJudgeProviderConfig) {
     console.error(
@@ -8163,7 +8297,7 @@ function loadPinnedLoCoMoTaskSelector(parsed) {
   }
   let decoded;
   try {
-    decoded = JSON.parse(fs13.readFileSync(parsed.taskIdsFile, "utf8"));
+    decoded = JSON.parse(fs14.readFileSync(parsed.taskIdsFile, "utf8"));
   } catch (error) {
     throw new Error(
       `Unable to read --task-ids-file ${parsed.taskIdsFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -8260,7 +8394,7 @@ async function loadPublishedPromotionHelpers() {
   return {
     async promoteArtifactsToPublished(args) {
       const { mkdirSync, readFileSync: readFileSync4, writeFileSync } = await import("fs");
-      const path17 = await import("path");
+      const path18 = await import("path");
       mkdirSync(args.publishedOutDir, { recursive: true });
       if (args.artifactPaths.length === 0) {
         console.warn(
@@ -8277,13 +8411,13 @@ async function loadPublishedPromotionHelpers() {
         const modelSlug = args.model.replace(/[^a-zA-Z0-9_.-]/g, "-");
         const rawProfile = parsedObj.config?.runtimeProfile;
         const profileSlug = typeof rawProfile === "string" && rawProfile.length > 0 ? `-${rawProfile.replace(/[^a-zA-Z0-9_.-]/g, "-")}` : "";
-        const target = path17.join(
+        const target = path18.join(
           args.publishedOutDir,
           `${today}-${args.benchmarkId}-${modelSlug}${profileSlug}-${gitShaShort}.json`
         );
         writeFileSync(target, raw, "utf8");
         console.log(
-          `[bench published] Promoted ${path17.basename(artifactPath)} \u2192 ${target}`
+          `[bench published] Promoted ${path18.basename(artifactPath)} \u2192 ${target}`
         );
       }
       void benchModule;
@@ -8390,7 +8524,7 @@ async function runBenchViaPackage(parsed, benchmarkId, runtimeProfile, benchStat
   const previousCodexDiagnosticsDir = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV];
   const previousCodexDiagnosticsMode = process.env[CODEX_CLI_BENCH_DIAGNOSTICS_MODE_ENV];
   if (!previousCodexDiagnosticsDir) {
-    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path16.join(
+    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path17.join(
       outputDir,
       "codex-cli-diagnostics"
     );
@@ -8538,7 +8672,7 @@ async function preparePersistedJudgeCalibrationAttachment(benchModule, benchmark
     );
   }
   const calibrationDir = expandTilde(
-    calibrationBinding.calibrationDir ?? path16.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    calibrationBinding.calibrationDir ?? path17.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const state = await benchModule.loadJudgeCalibrationState?.(benchmarkId, calibrationDir);
   if (!state) {
@@ -8835,7 +8969,7 @@ function resolveBenchReproDatasetDir(datasetDir) {
     return void 0;
   }
   try {
-    return fs13.realpathSync(datasetDir);
+    return fs14.realpathSync(datasetDir);
   } catch {
     return datasetDir;
   }
@@ -8889,7 +9023,7 @@ async function writeBenchReproManifestForPackageRun(args) {
 }
 function loadStandaloneConvergeCommandConfig() {
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   return parseConfig6(resolveRemnicConfigRecord5(raw));
 }
 function parseConvergePluginConfig(value) {
@@ -8908,23 +9042,23 @@ function loadConvergeCommandConfig() {
   return loadStandaloneConvergeCommandConfig();
 }
 function resolveConfigPath(cliPath) {
-  if (cliPath) return path16.resolve(expandTilde(cliPath));
+  if (cliPath) return path17.resolve(expandTilde(cliPath));
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
-  if (envPath) return path16.resolve(expandTilde(envPath));
+  if (envPath) return path17.resolve(expandTilde(envPath));
   const candidates = [
-    path16.join(process.cwd(), "remnic.config.json"),
-    path16.join(process.cwd(), "engram.config.json"),
-    path16.join(resolveHomeDir(), ".config", "remnic", "config.json"),
-    path16.join(resolveHomeDir(), ".config", "engram", "config.json")
+    path17.join(process.cwd(), "remnic.config.json"),
+    path17.join(process.cwd(), "engram.config.json"),
+    path17.join(resolveHomeDir(), ".config", "remnic", "config.json"),
+    path17.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs13.existsSync(candidate)) return candidate;
+    if (fs14.existsSync(candidate)) return candidate;
   }
-  return path16.join(resolveHomeDir(), ".config", "remnic", "config.json");
+  return path17.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
 function resolveExistingBenchRemnicConfigPath(cliPath) {
   const configPath = resolveConfigPath(cliPath);
-  if (fs13.existsSync(configPath)) {
+  if (fs14.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -8934,7 +9068,7 @@ function resolveExistingBenchRemnicConfigPath(cliPath) {
 }
 function resolveExistingBenchOpenclawConfigPath(cliPath) {
   const configPath = resolveOpenclawConfigPath(cliPath);
-  if (fs13.existsSync(configPath)) {
+  if (fs14.existsSync(configPath)) {
     return configPath;
   }
   if (cliPath) {
@@ -9034,34 +9168,34 @@ async function resolvePackageBenchRuntime(benchModule, parsed, runtimeProfile) {
   );
 }
 function normalizeMemoryDirPath(memoryDir) {
-  return path16.resolve(expandTilde(memoryDir));
+  return path17.resolve(expandTilde(memoryDir));
 }
 function resolveMemoryDir() {
   const configMemoryDir = (() => {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return normalizeMemoryDirPath(envMemoryDir);
     const configPath = resolveConfigPath();
-    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
     const remnicCfg = resolveRemnicConfigRecord5(raw);
     if (typeof remnicCfg.memoryDir === "string" && remnicCfg.memoryDir.length > 0) {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
     const home = resolveHomeDir();
-    const standalonePath = path16.join(home, ".remnic", "memory");
-    const legacyStandalonePath = path16.join(home, ".engram", "memory");
-    const openclawPath = path16.join(home, ".openclaw", "workspace", "memory", "local");
-    if (fs13.existsSync(standalonePath)) return standalonePath;
-    if (fs13.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    const standalonePath = path17.join(home, ".remnic", "memory");
+    const legacyStandalonePath = path17.join(home, ".engram", "memory");
+    const openclawPath = path17.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+    if (fs14.existsSync(standalonePath)) return standalonePath;
+    if (fs14.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs13.existsSync(manifestPath)) {
+  if (fs14.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
         const activeMemoryDir = normalizeMemoryDirPath(active.memoryDir);
-        if (!fs13.existsSync(activeMemoryDir)) {
-          fs13.mkdirSync(activeMemoryDir, { recursive: true });
+        if (!fs14.existsSync(activeMemoryDir)) {
+          fs14.mkdirSync(activeMemoryDir, { recursive: true });
         }
         return activeMemoryDir;
       }
@@ -9095,25 +9229,28 @@ function resolveFlagStrict(args, flag) {
   }
   return value;
 }
-var REMNIC_OPENCLAW_PLUGIN_ID = "openclaw-remnic";
 var REMNIC_OPENCLAW_LEGACY_PLUGIN_ID = "openclaw-engram";
+function resolveOpenclawStateDir() {
+  const configuredStateDir = process.env.OPENCLAW_STATE_DIR?.trim();
+  return configuredStateDir ? path17.resolve(expandTilde(configuredStateDir)) : path17.join(resolveHomeDir(), ".openclaw");
+}
 var DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR = [
   process.env.OPENCLAW_CONFIG_PATH,
   process.env.OPENCLAW_ENGRAM_CONFIG_PATH,
-  path16.join(resolveHomeDir(), ".openclaw", "openclaw.json")
+  path17.join(resolveOpenclawStateDir(), "openclaw.json")
 ].filter(Boolean);
 function resolveOpenclawConfigPath(cliPath) {
-  if (cliPath) return path16.resolve(expandTilde(cliPath));
+  if (cliPath) return path17.resolve(expandTilde(cliPath));
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
-  if (envPath) return path16.resolve(expandTilde(envPath));
+  if (envPath) return path17.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
-    if (fs13.existsSync(candidate)) return candidate;
+    if (fs14.existsSync(candidate)) return candidate;
   }
-  return path16.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+  return path17.join(resolveOpenclawStateDir(), "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
-  if (!fs13.existsSync(configPath)) return {};
-  const raw = fs13.readFileSync(configPath, "utf-8");
+  if (!fs14.existsSync(configPath)) return {};
+  const raw = fs14.readFileSync(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -9168,10 +9305,10 @@ function buildRemnicOpenclawHooksPolicy(legacyHooks, existingHooks) {
 function resolveOpenclawInstallMemoryDir(args) {
   const existingMemoryDir = (typeof args.existingNewEntryConfig.memoryDir === "string" ? args.existingNewEntryConfig.memoryDir : void 0) || (args.migrateLegacy && typeof args.legacyConfigToMerge.memoryDir === "string" ? args.legacyConfigToMerge.memoryDir : void 0);
   if (args.requestedMemoryDir) {
-    return path16.resolve(expandTilde(args.requestedMemoryDir));
+    return path17.resolve(expandTilde(args.requestedMemoryDir));
   }
   if (existingMemoryDir) {
-    return path16.resolve(expandTilde(existingMemoryDir));
+    return path17.resolve(expandTilde(existingMemoryDir));
   }
   return args.fallbackMemoryDir;
 }
@@ -9189,18 +9326,21 @@ function resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir) {
     if (!config || typeof config !== "object" || Array.isArray(config)) continue;
     const memoryDir = config.memoryDir;
     if (typeof memoryDir === "string" && memoryDir.trim().length > 0) {
-      return path16.resolve(expandTilde(memoryDir));
+      return path17.resolve(expandTilde(memoryDir));
     }
   }
   return fallbackMemoryDir;
 }
 function resolveOpenclawPluginDir(cliPath) {
-  if (cliPath) return path16.resolve(expandTilde(cliPath));
-  return path16.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  if (cliPath) return path17.resolve(expandTilde(cliPath));
+  return resolveOpenclawManagedPluginDir();
+}
+function resolveOpenclawManagedPluginDir() {
+  return path17.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
 }
 function resolveOpenclawLegacyPluginDir(cliPath) {
-  if (cliPath) return path16.resolve(expandTilde(cliPath));
-  return path16.join(resolveHomeDir(), ".openclaw", "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
+  if (cliPath) return path17.resolve(expandTilde(cliPath));
+  return path17.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
 }
 function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   const yyyy = now.getFullYear().toString();
@@ -9212,98 +9352,11 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   return `${yyyy}${mm}${dd}-${hh}${min}${ss}`;
 }
 function backupPathIfPresent(sourcePath, backupPath) {
-  if (!fs13.existsSync(sourcePath)) return false;
-  fs13.mkdirSync(path16.dirname(backupPath), { recursive: true });
-  fs13.cpSync(sourcePath, backupPath, { recursive: true });
+  if (!fs14.existsSync(sourcePath)) return false;
+  fs14.mkdirSync(path17.dirname(backupPath), { recursive: true });
+  fs14.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
-function assertDirectoryPathOrMissing(targetPath, label) {
-  if (!fs13.existsSync(targetPath)) return;
-  const stat2 = fs13.statSync(targetPath);
-  if (!stat2.isDirectory()) {
-    throw new Error(`${label} must be a directory when it already exists: ${targetPath}`);
-  }
-}
-function describeErrorWithCause(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (!(error instanceof Error) || !("cause" in error)) return message;
-  const cause = error.cause;
-  if (cause === void 0 || cause === null) return message;
-  const causeText = cause instanceof Error ? cause.message : String(cause);
-  if (!causeText || causeText === message) return message;
-  return `${message} Cause: ${causeText}`;
-}
-var PublishedOpenclawPluginInstallError = class extends Error {
-  rollbackDir;
-  shouldRestoreBackup;
-  constructor(message, options = {}) {
-    super(message, options);
-    this.name = "PublishedOpenclawPluginInstallError";
-    this.rollbackDir = options.rollbackDir;
-    this.shouldRestoreBackup = options.shouldRestoreBackup ?? false;
-  }
-};
-function installPublishedOpenclawPlugin(spec, pluginDir) {
-  const tempRoot = fs13.mkdtempSync(path16.join(os2.tmpdir(), "remnic-openclaw-upgrade-"));
-  const stagedDir = `${pluginDir}.next-${process.pid}-${Date.now()}`;
-  const rollbackDir = `${pluginDir}.rollback-${process.pid}-${Date.now()}`;
-  let swapRollbackDir;
-  let shouldRestoreBackup = false;
-  try {
-    const packOutput = childProcess2.execFileSync("npm", ["pack", spec], {
-      cwd: tempRoot,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const tarballName = packOutput.trim().split(/\r?\n/).map((line) => line.trim()).filter(Boolean).at(-1);
-    if (!tarballName) {
-      throw new Error(`npm pack ${spec} did not return a tarball name`);
-    }
-    const unpackDir = path16.join(tempRoot, "unpacked");
-    fs13.mkdirSync(unpackDir, { recursive: true });
-    childProcess2.execFileSync("tar", ["-xzf", path16.join(tempRoot, tarballName), "-C", unpackDir], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const packagedDir = path16.join(unpackDir, "package");
-    if (!fs13.existsSync(packagedDir)) {
-      throw new Error(`npm pack ${spec} did not contain a package/ directory`);
-    }
-    fs13.rmSync(stagedDir, { recursive: true, force: true });
-    fs13.cpSync(packagedDir, stagedDir, { recursive: true });
-    childProcess2.execFileSync("npm", ["install", "--omit=dev"], {
-      cwd: stagedDir,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    assertDirectoryPathOrMissing(pluginDir, "OpenClaw plugin dir");
-    const swapResult = (() => {
-      try {
-        return swapDirectoryWithRollback(stagedDir, pluginDir, rollbackDir);
-      } catch (swapError) {
-        shouldRestoreBackup = swapError instanceof AggregateError;
-        throw swapError;
-      }
-    })();
-    swapRollbackDir = swapResult.rollbackDir;
-    const installedPackageJsonPath = path16.join(pluginDir, "package.json");
-    const installedPackage = fs13.existsSync(installedPackageJsonPath) ? JSON.parse(fs13.readFileSync(installedPackageJsonPath, "utf8")) : {};
-    return {
-      rollbackDir: swapRollbackDir,
-      version: typeof installedPackage.version === "string" ? installedPackage.version : void 0
-    };
-  } catch (error) {
-    throw new PublishedOpenclawPluginInstallError(
-      `Failed to install published OpenClaw plugin from ${spec}.`,
-      {
-        cause: error,
-        rollbackDir: swapRollbackDir,
-        shouldRestoreBackup
-      }
-    );
-  } finally {
-    fs13.rmSync(stagedDir, { recursive: true, force: true });
-    fs13.rmSync(tempRoot, { recursive: true, force: true });
-  }
-}
 function restartOpenclawGateway() {
   if (process.platform !== "darwin") {
     throw new Error(
@@ -9319,15 +9372,15 @@ function restartOpenclawGateway() {
   });
 }
 function cmdInit() {
-  const configPath = path16.join(process.cwd(), "remnic.config.json");
-  if (fs13.existsSync(configPath)) {
+  const configPath = path17.join(process.cwd(), "remnic.config.json");
+  if (fs14.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
   const template = {
     remnic: {
       openaiApiKey: "${OPENAI_API_KEY}",
-      memoryDir: path16.join(process.cwd(), ".remnic", "memory"),
+      memoryDir: path17.join(process.cwd(), ".remnic", "memory"),
       memoryOsPreset: "balanced"
     },
     server: {
@@ -9336,7 +9389,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs13.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs14.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-...");
@@ -9406,7 +9459,7 @@ async function cmdStatus(json) {
 }
 function oauthReadConfigRecord(configPath) {
   try {
-    const parsed = JSON.parse(fs13.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs14.readFileSync(configPath, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -9464,7 +9517,7 @@ function oauthResolveOperatorToken() {
   }
   return void 0;
 }
-async function oauthFetch(method, path17, token, body) {
+async function oauthFetch(method, path18, token, body) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 5e3);
   try {
@@ -9483,7 +9536,7 @@ async function oauthFetch(method, path17, token, body) {
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const response = await fetch(`${oauthResolveBaseUrl()}${path17}`, init);
+    const response = await fetch(`${oauthResolveBaseUrl()}${path18}`, init);
     if (response.status === 401) {
       throw new Error(
         "operator token rejected by remnic-server (HTTP 401). Update `server.authToken` or `REMNIC_AUTH_TOKEN` to match the running daemon."
@@ -9822,7 +9875,7 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
@@ -9993,7 +10046,7 @@ async function cmdXray(rest) {
   parseXrayCliOptions(rawQuery, options);
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
@@ -10016,7 +10069,7 @@ async function cmdXray(rest) {
 async function cmdVersions(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   if (!config.versioningEnabled) {
@@ -10038,7 +10091,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions list <page-path>");
         process.exit(1);
       }
-      const absPath = path16.resolve(pagePath);
+      const absPath = path17.resolve(pagePath);
       const history = await listVersions(absPath, versioningConfig, memDir);
       if (json) {
         console.log(JSON.stringify(history, null, 2));
@@ -10063,7 +10116,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions show <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path16.resolve(pagePath);
+      const absPath = path17.resolve(pagePath);
       try {
         const content = await getVersion(absPath, versionId, versioningConfig, memDir);
         console.log(content);
@@ -10081,7 +10134,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions diff <page-path> <v1> <v2>");
         process.exit(1);
       }
-      const absPath = path16.resolve(pagePath);
+      const absPath = path17.resolve(pagePath);
       try {
         const diffOutput = await diffVersions(absPath, v1, v2, versioningConfig, memDir);
         console.log(diffOutput);
@@ -10098,7 +10151,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions revert <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path16.resolve(pagePath);
+      const absPath = path17.resolve(pagePath);
       try {
         const version = await revertToVersion(absPath, versionId, versioningConfig, void 0, memDir);
         if (json) {
@@ -10132,13 +10185,13 @@ Options:
 async function cmdEnrich(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
-    const auditDir2 = path16.join(memoryDir2, "enrichment");
+    const auditDir2 = path17.join(memoryDir2, "enrichment");
     const sinceFlag = resolveFlag(rest.slice(1), "--since");
     const entries = await readAuditLog(auditDir2, sinceFlag ?? void 0);
     if (entries.length === 0) {
@@ -10263,7 +10316,7 @@ Registered providers:`);
     return;
   }
   const memoryDir = expandTilde(config.memoryDir);
-  const auditDir = path16.join(memoryDir, "enrichment");
+  const auditDir = path17.join(memoryDir, "enrichment");
   let totalPersisted = 0;
   for (const result of results) {
     for (const candidate of result.acceptedCandidates) {
@@ -10377,7 +10430,7 @@ Shared with:
     process.exit(1);
   }
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const memoryDir = expandTilde(
@@ -10394,7 +10447,7 @@ Shared with:
 async function cmdExtensions(action, rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const root = resolveExtensionsRoot(config);
@@ -10445,7 +10498,7 @@ Root: ${root}`);
       const extensions = await discoverMemoryExtensions(root, warnLog);
       let entries = [];
       try {
-        entries = fs13.readdirSync(root);
+        entries = fs14.readdirSync(root);
       } catch {
         console.log(`Extensions root does not exist: ${root}`);
         process.exitCode = 0;
@@ -10454,9 +10507,9 @@ Root: ${root}`);
       const validNames = new Set(extensions.map((e) => e.name));
       let errors = 0;
       for (const entry of entries) {
-        const entryPath = path16.join(root, entry);
+        const entryPath = path17.join(root, entry);
         try {
-          if (!fs13.statSync(entryPath).isDirectory()) continue;
+          if (!fs14.statSync(entryPath).isDirectory()) continue;
         } catch {
           continue;
         }
@@ -10488,7 +10541,7 @@ Root: ${root}`);
 async function cmdBriefing(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   if (!config.briefing.enabled) {
@@ -10568,10 +10621,10 @@ async function cmdBriefing(rest) {
   if (save) {
     try {
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
-      fs13.mkdirSync(saveDir, { recursive: true });
+      fs14.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
-      const filePath = path16.join(saveDir, filename);
-      fs13.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
+      const filePath = path17.join(saveDir, filename);
+      fs14.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)}`);
@@ -10589,7 +10642,7 @@ async function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs13.existsSync(configPath);
+  const configExists = fs14.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   let standaloneConfig;
   let standaloneConfigError;
@@ -10597,7 +10650,7 @@ async function cmdDoctor() {
   let configuredNs = { invalid: false };
   if (configExists) {
     try {
-      const raw = JSON.parse(fs13.readFileSync(configPath, "utf8"));
+      const raw = JSON.parse(fs14.readFileSync(configPath, "utf8"));
       const remnicCfg = resolveRemnicConfigRecord5(raw);
       standaloneOpenaiApiKeyExplicitlyFalse = isOpenaiApiKeyDisabled(remnicCfg.openaiApiKey);
       configuredNs = readConfiguredNamespace(remnicCfg);
@@ -10613,7 +10666,7 @@ async function cmdDoctor() {
     memoryDir = parseConfig6({}).memoryDir;
   }
   try {
-    fs13.mkdirSync(memoryDir, { recursive: true });
+    fs14.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}` });
@@ -10642,7 +10695,7 @@ async function cmdDoctor() {
   });
   if (nsPolicyCheck) checks.push(nsPolicyCheck);
   const openclawConfigPath = resolveOpenclawConfigPath();
-  const openclawConfigExists = fs13.existsSync(openclawConfigPath);
+  const openclawConfigExists = fs14.existsSync(openclawConfigPath);
   let openclawConfig = {};
   let openclawConfigValid = false;
   let openclawPluginModeConfigured = false;
@@ -10650,7 +10703,7 @@ async function cmdDoctor() {
   let activeOpenclawEntryConfig = null;
   if (openclawConfigExists) {
     try {
-      const parsed = JSON.parse(fs13.readFileSync(openclawConfigPath, "utf-8"));
+      const parsed = JSON.parse(fs14.readFileSync(openclawConfigPath, "utf-8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         openclawConfig = parsed;
         openclawConfigValid = true;
@@ -10726,13 +10779,13 @@ async function cmdDoctor() {
       const rawMemoryDir = entryConfig?.memoryDir;
       const configuredMemoryDir = typeof rawMemoryDir === "string" ? rawMemoryDir : void 0;
       if (configuredMemoryDir) {
-        const resolvedMemDir = path16.resolve(expandTilde(configuredMemoryDir));
+        const resolvedMemDir = path17.resolve(expandTilde(configuredMemoryDir));
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
-        if (fs13.existsSync(resolvedMemDir)) {
+        if (fs14.existsSync(resolvedMemDir)) {
           try {
-            const stat2 = fs13.statSync(resolvedMemDir);
+            const stat2 = fs14.statSync(resolvedMemDir);
             if (stat2.isDirectory()) {
               memDirOk = true;
               memDirDetail = resolvedMemDir;
@@ -10874,12 +10927,12 @@ async function cmdDoctor() {
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs13.existsSync(configPath)) {
+  if (!fs14.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs13.readFileSync(configPath, "utf8");
+  const rawConfig = fs14.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -10926,7 +10979,7 @@ async function cmdMigrate(json, rollback) {
   console.log(`  Rollback: ${result.rollbackCommand}`);
 }
 function cmdOnboard(dirPath, json) {
-  const directory = path16.resolve(dirPath || process.cwd());
+  const directory = path17.resolve(dirPath || process.cwd());
   const result = onboard({ directory });
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -10945,7 +10998,7 @@ Suggested namespace: ${result.plan.suggestedNamespace}`);
 async function cmdCurate(targetPath, json) {
   const memoryDir = resolveMemoryDir();
   const result = await curate({
-    targetPath: path16.resolve(targetPath),
+    targetPath: path17.resolve(targetPath),
     memoryDir,
     source: "curation",
     checkDuplicates: true,
@@ -10987,7 +11040,7 @@ async function cmdReview(action, rest) {
     const configPath = resolveConfigPath();
     let tombstonesConfig = null;
     try {
-      const rawCfg = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+      const rawCfg = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
       const remnicCfg = resolveRemnicConfigRecord5(rawCfg);
       const config = parseConfig6(remnicCfg);
       tombstonesConfig = {
@@ -11074,8 +11127,8 @@ async function cmdSync(action, rest, json) {
   }
 }
 function localOfflineSourceId(memoryDir) {
-  const host = os2.hostname() || "unknown-host";
-  const dirHash = createHash4("sha256").update(path16.resolve(memoryDir)).digest("hex").slice(0, 16);
+  const host = os3.hostname() || "unknown-host";
+  const dirHash = createHash4("sha256").update(path17.resolve(memoryDir)).digest("hex").slice(0, 16);
   return `remnic-local:${host}:${dirHash}`;
 }
 function normalizeOfflineRemoteUrl(raw) {
@@ -11473,10 +11526,10 @@ var OFFLINE_SYNC_CONTENT_MISSING_RETRY_MAX = 3;
 var OFFLINE_SYNC_CONTENT_MISSING_RETRY_DELAY_MS = 250;
 var OfflineRemoteFileChangedError = class extends Error {
   path;
-  constructor(path17) {
-    super(`remote file changed while fetching offline content: ${path17}`);
+  constructor(path18) {
+    super(`remote file changed while fetching offline content: ${path18}`);
     this.name = "OfflineRemoteFileChangedError";
-    this.path = path17;
+    this.path = path18;
   }
 };
 function isOfflineRemoteFileChangedError(error) {
@@ -11667,10 +11720,10 @@ function offlineDirectPushFiles(options) {
   }).sort((left, right) => right.bytes - left.bytes || left.path.localeCompare(right.path));
 }
 function resolveOfflineDirectHydrationPath(memoryDir, relPath) {
-  const base = path16.resolve(memoryDir);
-  const target = path16.resolve(base, relPath);
-  const relative = path16.relative(base, target);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path16.sep}`) || path16.isAbsolute(relative)) {
+  const base = path17.resolve(memoryDir);
+  const target = path17.resolve(base, relPath);
+  const relative = path17.relative(base, target);
+  if (relative === "" || relative === ".." || relative.startsWith(`..${path17.sep}`) || path17.isAbsolute(relative)) {
     throw new Error(`offline sync direct hydration path escapes memory dir: ${relPath}`);
   }
   return target;
@@ -11740,13 +11793,13 @@ async function pushOfflineFileContent(args) {
 }
 async function pushOfflineFileContentFromChunkReader(args) {
   const filePath = resolveOfflineDirectHydrationPath(args.memoryDir, args.file.path);
-  const stat2 = fs13.statSync(filePath);
+  const stat2 = fs14.statSync(filePath);
   if (stat2.mtimeMs !== args.file.mtimeMs) {
     throw new Error(`local file changed while pushing offline content: ${args.file.path}`);
   }
   const hash = createHash4("sha256");
   const chunks = args.readFileChunks({
-    root: path16.resolve(args.memoryDir),
+    root: path17.resolve(args.memoryDir),
     path: args.file.path,
     filePath,
     chunkSize: OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES
@@ -12231,7 +12284,7 @@ function advanceOfflineBaseFilesForSuccessfulPush(options) {
   return [...next.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function runOfflineSyncOnce(options) {
-  fs13.mkdirSync(options.memoryDir, { recursive: true });
+  fs14.mkdirSync(options.memoryDir, { recursive: true });
   let activeStatePath = options.statePath;
   let priorState = await readOfflineSyncState(activeStatePath);
   let syncNamespace = options.namespace ?? priorState?.namespace;
@@ -12851,7 +12904,7 @@ Environment fallbacks:
   REMNIC_OFFLINE_REMOTE_URL, REMNIC_OFFLINE_TOKEN, REMNIC_AUTH_TOKEN`);
     return;
   }
-  const memoryDir = path16.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
+  const memoryDir = path17.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
   const namespace = resolveRequiredValueFlag(rest, "--namespace");
   const includeTranscripts = !hasFlag(rest, "--no-transcripts");
   const stateOverride = resolveRequiredValueFlag(rest, "--state");
@@ -12859,7 +12912,7 @@ Environment fallbacks:
   const configPath = resolveConfigPath();
   let config;
   try {
-    const rawConfig = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const rawConfig = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
     config = parseConfigQuietly(pickOfflineConfigRecord(rawConfig));
   } catch {
     throw new Error(
@@ -12871,10 +12924,10 @@ Environment fallbacks:
   const needsRemote = action === "prepare" || action === "sync" || action === "watch";
   const remoteUrl = needsRemote ? resolveOfflineRemoteUrl(rest) : resolveOptionalOfflineRemoteUrl(rest);
   const token = needsRemote ? resolveOfflineToken(rest) : void 0;
-  const statePath = statePathExplicit ? path16.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
+  const statePath = statePathExplicit ? path17.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");
-    fs13.mkdirSync(memoryDir, { recursive: true });
+    fs14.mkdirSync(memoryDir, { recursive: true });
     const remoteSnapshot = await fetchOfflineSnapshot({
       remoteUrl,
       token,
@@ -12973,7 +13026,7 @@ Environment fallbacks:
     return;
   }
   if (action === "status") {
-    fs13.mkdirSync(memoryDir, { recursive: true });
+    fs14.mkdirSync(memoryDir, { recursive: true });
     const state = statePath ? await readOfflineSyncState(statePath) : null;
     if (state && remoteUrl && statePath) {
       assertOfflineStateMatches({
@@ -13053,11 +13106,11 @@ Environment fallbacks:
           failures: result.largeFilePushFailures
         });
         largeFileFailureCounts = advanced.counts;
-        for (const path17 of advanced.newlySkipped) {
-          if (skippedLargeFiles.has(path17)) continue;
-          skippedLargeFiles.add(path17);
+        for (const path18 of advanced.newlySkipped) {
+          if (skippedLargeFiles.has(path18)) continue;
+          skippedLargeFiles.add(path18);
           console.warn(
-            `offline sync: permanently skipping ${path17} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+            `offline sync: permanently skipping ${path18} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
           );
         }
         const pulled = result.pull ? result.pull.upserted + result.pull.deleted : 0;
@@ -13072,11 +13125,11 @@ Environment fallbacks:
             failures: error.failures
           });
           largeFileFailureCounts = advanced.counts;
-          for (const path17 of advanced.newlySkipped) {
-            if (skippedLargeFiles.has(path17)) continue;
-            skippedLargeFiles.add(path17);
+          for (const path18 of advanced.newlySkipped) {
+            if (skippedLargeFiles.has(path18)) continue;
+            skippedLargeFiles.add(path18);
             console.warn(
-              `offline sync: permanently skipping ${path17} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
+              `offline sync: permanently skipping ${path18} after ${OFFLINE_LARGE_FILE_SKIP_AFTER_FAILURES} failed large-file pushes for this watcher process (see issue #1786; use --exclude or offlineSyncExcludes to silence permanently)`
             );
           }
         }
@@ -13111,7 +13164,7 @@ function cmdDedup(json) {
 function readInstalledConnectorConfig(configPath, fallback) {
   if (!configPath) return fallback;
   try {
-    const parsed = JSON.parse(fs13.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs14.readFileSync(configPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return fallback;
     const { token: _token, ...config } = parsed;
     return config;
@@ -13217,7 +13270,7 @@ async function cmdConnectors(action, rest, json) {
             const connectorDaemonUrl = typeof effectiveConnectorConfig.remnicDaemonUrl === "string" && effectiveConnectorConfig.remnicDaemonUrl.trim().length > 0 ? effectiveConnectorConfig.remnicDaemonUrl.trim() : void 0;
             const pubResult = await pub.publish({
               config: { memoryDir, namespace: connectorNamespace, daemonUrl: connectorDaemonUrl },
-              skillsRoot: path16.join(memoryDir, "skills"),
+              skillsRoot: path17.join(memoryDir, "skills"),
               rollbackTokenEntry: preInstallTokenEntry,
               log: { info: console.log, warn: console.warn, error: console.error }
             });
@@ -13289,7 +13342,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 ? fs13.existsSync(extRoot) : false;
+          const extensionExists = available && extRoot ? fs14.existsSync(extRoot) : false;
           publisherChecks.push({
             name: `Publisher: ${targetHostId}`,
             ok: !available || extensionExists,
@@ -13363,7 +13416,7 @@ async function cmdConnectors(action, rest, json) {
     let connectorsCfg;
     const configPath = resolveConfigPath();
     try {
-      const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+      const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
       connectorsCfg = parseConfigQuietly(raw).connectors;
     } catch {
       process.stderr.write(
@@ -13439,7 +13492,7 @@ async function cmdConnectors(action, rest, json) {
     }
     initLogger2();
     const configPath = resolveConfigPath();
-    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
     const remnicCfg = resolveRemnicConfigRecord5(raw);
     const config = parseConfig6(remnicCfg);
     const orchestrator = new Orchestrator3(config);
@@ -13564,7 +13617,7 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     console.error(`connectors marketplace: ${err instanceof Error ? err.message : String(err)}`);
     process.exit(1);
   }
-  const rawConfig = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const rawConfig = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const pluginConfig = resolveRemnicConfigRecord5(rawConfig);
   const config = parseConfig6(pluginConfig);
   if (subAction === "generate") {
@@ -13577,22 +13630,22 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     }
     const manifest = generateMarketplaceManifest();
     await writeMarketplaceManifest(outputDir, manifest);
-    const outPath = path16.join(outputDir, "marketplace.json");
+    const outPath = path17.join(outputDir, "marketplace.json");
     if (json) {
       console.log(JSON.stringify({ status: "generated", path: outPath }, null, 2));
     } else {
       console.log(`Generated marketplace.json at ${outPath}`);
     }
   } else if (subAction === "validate") {
-    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path16.join(process.cwd(), "marketplace.json");
-    const resolved = path16.resolve(targetPath);
-    if (!fs13.existsSync(resolved)) {
+    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path17.join(process.cwd(), "marketplace.json");
+    const resolved = path17.resolve(targetPath);
+    if (!fs14.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(fs13.readFileSync(resolved, "utf8"));
+      parsed = JSON.parse(fs14.readFileSync(resolved, "utf8"));
     } catch {
       console.error(`Invalid JSON in ${resolved}`);
       process.exit(1);
@@ -13793,7 +13846,7 @@ async function cmdSpace(action, rest, json) {
 async function cmdLegacyBenchmark(action, rest, json) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const orchestrator = new Orchestrator3(config);
@@ -13994,7 +14047,7 @@ async function cmdBench(rest) {
     }
     const completeCount = prevStatus.benchmarks.filter((b) => b.status === "complete").length;
     const failedCount = prevStatus.benchmarks.filter((b) => b.status === "failed").length;
-    printBenchStatusLine(parsed.json, `Resuming from: ${path16.basename(latestStatusPath)}`);
+    printBenchStatusLine(parsed.json, `Resuming from: ${path17.basename(latestStatusPath)}`);
     printBenchStatusLine(parsed.json, `  Previous run: ${prevStatus.startedAt}`);
     printBenchStatusLine(parsed.json, `  Benchmarks: ${prevStatus.benchmarks.length} total, ${completeCount} complete, ${failedCount} failed`);
     const before = selectedBenchmarks.length;
@@ -14162,9 +14215,9 @@ Options:
     );
     process.exit(1);
   } else {
-    fixturePath = path16.resolve(expandTilde(fixturePathRaw));
+    fixturePath = path17.resolve(expandTilde(fixturePathRaw));
   }
-  const outPath = path16.resolve(expandTilde(outPathRaw));
+  const outPath = path17.resolve(expandTilde(outPathRaw));
   const benchModule = await loadBenchModule();
   const runner = benchModule.runProceduralAblationCli;
   if (typeof runner !== "function") {
@@ -14183,7 +14236,7 @@ Options:
   );
   console.log(`wrote ${outPath}`);
 }
-var LOGS_DIR = path16.join(PID_DIR, "logs");
+var LOGS_DIR = path17.join(PID_DIR, "logs");
 var LAUNCHD_PLIST_PATHS = launchdPlistPaths(resolveHomeDir());
 var [LAUNCHD_PLIST_PATH] = LAUNCHD_PLIST_PATHS;
 var SYSTEMD_UNIT_PATHS = systemdUnitPaths(resolveHomeDir());
@@ -14197,7 +14250,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs13.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs14.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -14260,7 +14313,7 @@ function selectLaunchdInspection(openclawPluginModeConfigured) {
   for (const plistPath of LAUNCHD_PLIST_PATHS.slice(1)) {
     const legacy = inspectLaunchdPlist(plistPath);
     if (!legacy.installed) continue;
-    const label = path16.basename(plistPath, ".plist");
+    const label = path17.basename(plistPath, ".plist");
     return legacy.ok ? {
       ...legacy,
       warn: true,
@@ -14292,13 +14345,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs13.mkdirSync(LOGS_DIR, { recursive: true });
+  fs14.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
-    const templatePath = path16.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs13.readFileSync(templatePath, "utf8");
+    const templatePath = path17.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
+    const template = fs14.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs13.mkdirSync(path16.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs13.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs14.mkdirSync(path17.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs14.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
     } catch (err) {
@@ -14314,11 +14367,11 @@ function daemonInstall() {
     console.log(`  RunAtLoad: true, KeepAlive: true`);
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
-    const templatePath = path16.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs13.readFileSync(templatePath, "utf8");
+    const templatePath = path17.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
+    const template = fs14.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs13.mkdirSync(path16.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs13.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs14.mkdirSync(path17.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs14.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
     } catch (err) {
@@ -14354,7 +14407,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs13.unlinkSync(plistPath);
+        fs14.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -14374,7 +14427,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of SYSTEMD_UNIT_PATHS) {
       try {
-        fs13.unlinkSync(unitPath);
+        fs14.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -14441,11 +14494,11 @@ async function daemonStatus() {
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs13.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs13.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs14.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs14.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
   try {
     const configPath = resolveConfigPath();
-    const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+    const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
     const remnicCfg = resolveRemnicConfigRecord5(raw);
     const config = parseConfig6(remnicCfg);
     const extRoot = resolveExtensionsRoot(config);
@@ -14486,9 +14539,9 @@ function daemonStart() {
       return;
     }
   }
-  fs13.mkdirSync(PID_DIR, { recursive: true });
-  fs13.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs13.openSync(LOG_FILE, "a");
+  fs14.mkdirSync(PID_DIR, { recursive: true });
+  fs14.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs14.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -14510,7 +14563,7 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs13.writeFileSync(PID_FILE, String(child.pid));
+  fs14.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
@@ -14544,11 +14597,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs13.unlinkSync(PID_FILE);
+    fs14.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs13.unlinkSync(LEGACY_PID_FILE);
+    fs14.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -14676,7 +14729,7 @@ async function promptYesNo(question, defaultYes = true) {
 async function cmdBinary(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   const memoryDir = resolveMemoryDir();
@@ -14796,7 +14849,7 @@ Clean complete: cleaned=${result.cleaned}`
 }
 async function cmdOpenclawInstall(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
-  const fallbackMemoryDir = path16.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+  const fallbackMemoryDir = path17.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   console.log(`OpenClaw config: ${configPath}`);
   const existingConfig = readOpenclawConfig(configPath);
   const { plugins, entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
@@ -14867,7 +14920,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 (!fs13.existsSync(memoryDir)) changes.push(`+ Will create memory directory: ${memoryDir}`);
+  if (!fs14.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)`);
   }
@@ -14887,8 +14940,8 @@ async function cmdOpenclawInstall(opts) {
 Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
     return;
   }
-  if (fs13.existsSync(memoryDir)) {
-    const st = fs13.statSync(memoryDir);
+  if (fs14.existsSync(memoryDir)) {
+    const st = fs14.statSync(memoryDir);
     if (!st.isDirectory()) {
       throw new Error(
         `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
@@ -14896,12 +14949,12 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
       );
     }
   } else {
-    fs13.mkdirSync(memoryDir, { recursive: true });
+    fs14.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
-  const configDir = path16.dirname(configPath);
-  if (!fs13.existsSync(configDir)) {
-    fs13.mkdirSync(configDir, { recursive: true });
+  const configDir = path17.dirname(configPath);
+  if (!fs14.existsSync(configDir)) {
+    fs14.mkdirSync(configDir, { recursive: true });
   }
   atomicWriteFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
   console.log("\nDone! Summary of changes:");
@@ -14926,16 +14979,14 @@ Note: The legacy '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry has been kept along
 async function cmdOpenclawUpgrade(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
   const pluginDir = resolveOpenclawPluginDir(opts.pluginDir);
+  const managedTargetDir = resolveOpenclawManagedPluginDir();
   const legacyPluginDirForBackup = opts.legacyPluginDirForBackup ? resolveOpenclawLegacyPluginDir(opts.legacyPluginDirForBackup) : void 0;
-  const fallbackMemoryDir = path16.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
-  const packageSpec = `@remnic/plugin-openclaw@${opts.version ?? "latest"}`;
+  const fallbackMemoryDir = path17.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+  const packageSpec = buildOpenclawManagedUpgradePackageSpec(opts.version);
+  const configExistedBefore = fs14.existsSync(configPath);
   const existingConfig = readOpenclawConfig(configPath);
   const { entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
-  const preservedMemoryDir = opts.memoryDir ? path16.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
-  assertDirectoryPathOrMissing(pluginDir, "OpenClaw plugin dir");
-  if (legacyPluginDirForBackup) {
-    assertDirectoryPathOrMissing(legacyPluginDirForBackup, "Legacy OpenClaw plugin dir");
-  }
+  const preservedMemoryDir = opts.memoryDir ? path17.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
   console.log(`OpenClaw config: ${configPath}`);
   console.log(`Plugin dir:      ${pluginDir}`);
   if (legacyPluginDirForBackup) {
@@ -14943,11 +14994,12 @@ async function cmdOpenclawUpgrade(opts) {
   }
   console.log(`Memory dir:      ${preservedMemoryDir}`);
   console.log(`Package spec:    ${packageSpec}`);
-  console.log(`Backup root:     ${path16.join(resolveHomeDir(), ".openclaw", "backups")}`);
+  console.log(`Backup root:     ${path17.join(resolveOpenclawStateDir(), "backups")}`);
   const plannedActions = [
     `backup openclaw.json and the existing ${REMNIC_OPENCLAW_PLUGIN_ID} extension`,
     ...legacyPluginDirForBackup ? [`backup the existing ${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID} extension without modifying it`] : [],
-    `npm pack ${packageSpec} and stage a clean plugin copy before swap`,
+    `install ${packageSpec} through OpenClaw's managed plugin project`,
+    `remove the old unmanaged extension and verify OpenClaw can load the managed plugin`,
     `re-run remnic openclaw install with the preserved memory dir`,
     opts.restartGateway ? "restart the OpenClaw gateway with launchctl kickstart" : "leave gateway restart to the operator (--no-restart)"
   ];
@@ -14968,10 +15020,21 @@ async function cmdOpenclawUpgrade(opts) {
       return;
     }
   }
+  const {
+    assertDirectoryPathOrMissing,
+    describeErrorWithCause,
+    installPublishedOpenclawPlugin,
+    PublishedOpenclawPluginInstallError
+  } = await loadOpenclawManagedUpgradeModule(packageSpec);
+  assertDirectoryPathOrMissing(pluginDir, "OpenClaw plugin dir");
+  assertDirectoryPathOrMissing(managedTargetDir, "Managed OpenClaw plugin dir");
+  if (legacyPluginDirForBackup) {
+    assertDirectoryPathOrMissing(legacyPluginDirForBackup, "Legacy OpenClaw plugin dir");
+  }
   const backupDir = createOpenclawUpgradeBackupDir();
-  const configBackupPath = path16.join(backupDir, "openclaw.json");
-  const pluginBackupDir = path16.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
-  const legacyPluginBackupDir = legacyPluginDirForBackup ? path16.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
+  const configBackupPath = path17.join(backupDir, "openclaw.json");
+  const pluginBackupDir = path17.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  const legacyPluginBackupDir = legacyPluginDirForBackup ? path17.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
   const backupNotes = [];
   if (backupPathIfPresent(configPath, configBackupPath)) {
     backupNotes.push(`+ Backed up config to ${configBackupPath}`);
@@ -14990,9 +15053,23 @@ async function cmdOpenclawUpgrade(opts) {
       backupNotes.push(`  No existing legacy plugin dir found at ${legacyPluginDirForBackup}; nothing to preserve`);
     }
   }
+  const runOpenclawCommand = (args, { timeoutMs }) => childProcess2.execFileSync("openclaw", [...args], {
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      OPENCLAW_CONFIG_PATH: configPath
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: timeoutMs
+  });
   let installResult;
   try {
-    installResult = installPublishedOpenclawPlugin(packageSpec, pluginDir);
+    installResult = installPublishedOpenclawPlugin(
+      packageSpec,
+      pluginDir,
+      managedTargetDir,
+      runOpenclawCommand
+    );
     await cmdOpenclawInstall({
       yes: true,
       dryRun: false,
@@ -15004,25 +15081,81 @@ async function cmdOpenclawUpgrade(opts) {
     const installErrorText = describeErrorWithCause(installError);
     const publishedInstallError = installError instanceof PublishedOpenclawPluginInstallError ? installError : void 0;
     const rollbackDir = publishedInstallError ? publishedInstallError.rollbackDir : installResult?.rollbackDir;
-    const shouldRestorePlugin = Boolean(installResult || rollbackDir || publishedInstallError?.shouldRestoreBackup);
-    const shouldRestoreConfig = Boolean(installResult);
-    const shouldRollback = shouldRestorePlugin || shouldRestoreConfig;
+    const managedRollbackDir = publishedInstallError ? publishedInstallError.managedRollbackDir : installResult?.managedRollbackDir;
+    const managedRollbackTargetDir = publishedInstallError?.managedRollbackTargetDir ?? installResult?.managedRollbackTargetDir ?? managedTargetDir;
+    const requiresHostManagedRestore = publishedInstallError?.requiresHostManagedRestore ?? installResult?.requiresHostManagedRestore ?? false;
+    const managedRollbackSharesPluginDir = managedRollbackDir && path17.resolve(managedRollbackTargetDir) === path17.resolve(pluginDir);
+    const pluginRollbackDir = managedRollbackSharesPluginDir ? requiresHostManagedRestore ? rollbackDir : rollbackDir ?? managedRollbackDir : rollbackDir;
+    const shouldRestorePlugin = Boolean(
+      installResult && !requiresHostManagedRestore || pluginRollbackDir || publishedInstallError?.shouldRestoreBackup
+    );
+    const shouldRestoreConfig = Boolean(installResult || publishedInstallError?.shouldRestoreConfig);
+    const shouldRollback = shouldRestorePlugin || shouldRestoreConfig || Boolean(managedRollbackDir);
     if (!shouldRollback) {
-      throw new Error(
-        `OpenClaw upgrade failed while ${failurePhase}. Original failure: ${installErrorText}.`,
-        { cause: installError }
-      );
+      throw new Error(`OpenClaw upgrade failed while ${failurePhase}. Original failure: ${installErrorText}.`, {
+        cause: installError
+      });
+    }
+    const rollbackErrors = [];
+    let pendingConfigRestoreError;
+    let usedLocalManagedRestore = Boolean(publishedInstallError?.managedRestoreNote);
+    const rollbackNotes = publishedInstallError?.managedRestoreNote ? [publishedInstallError.managedRestoreNote] : [];
+    if (installResult && shouldRestoreConfig) {
+      try {
+        const configRestoreNote = restoreOpenclawConfigWithRetry({
+          configBackupPath,
+          configPath,
+          pluginDir,
+          removeConfigIfUnbacked: !configExistedBefore
+        });
+        if (configRestoreNote) rollbackNotes.push(configRestoreNote);
+      } catch (error) {
+        pendingConfigRestoreError = error;
+      }
+    }
+    if (installResult) {
+      try {
+        const managedRestoreNote = installResult.rollbackManagedInstall();
+        if (managedRestoreNote) {
+          usedLocalManagedRestore = true;
+          rollbackNotes.push(managedRestoreNote);
+        }
+      } catch (error) {
+        rollbackErrors.push(error);
+      }
     }
-    let rollbackNotes;
+    const finalRestoresConfig = shouldRestoreConfig && !usedLocalManagedRestore;
     try {
-      rollbackNotes = rollbackOpenclawUpgrade({
-        configBackupPath: shouldRestoreConfig ? configBackupPath : void 0,
-        configPath,
-        pluginBackupDir: shouldRestorePlugin ? pluginBackupDir : void 0,
-        pluginDir,
-        rollbackDir
-      });
-    } catch (rollbackError) {
+      rollbackNotes.push(
+        ...rollbackOpenclawUpgrade({
+          configBackupPath: finalRestoresConfig ? configBackupPath : void 0,
+          configPath,
+          pluginBackupDir: shouldRestorePlugin ? pluginBackupDir : void 0,
+          pluginDir,
+          rollbackDir: pluginRollbackDir,
+          removeConfigIfUnbacked: finalRestoresConfig && !configExistedBefore
+        })
+      );
+      if (finalRestoresConfig) pendingConfigRestoreError = void 0;
+    } catch (error) {
+      rollbackErrors.push(error);
+    }
+    if (pendingConfigRestoreError) rollbackErrors.push(pendingConfigRestoreError);
+    if (managedRollbackDir && path17.resolve(managedRollbackTargetDir) !== path17.resolve(pluginDir) && !requiresHostManagedRestore) {
+      try {
+        rollbackNotes.push(
+          ...rollbackOpenclawUpgrade({
+            configPath,
+            pluginDir: managedRollbackTargetDir,
+            rollbackDir: managedRollbackDir
+          })
+        );
+      } catch (error) {
+        rollbackErrors.push(error);
+      }
+    }
+    if (rollbackErrors.length > 0) {
+      const rollbackError = rollbackErrors.length > 1 ? new AggregateError(rollbackErrors, "One or more managed, file, or config rollback steps failed.") : rollbackErrors[0];
       throw createOpenclawUpgradeRollbackFailure({
         failurePhase,
         installError,
@@ -15034,18 +15167,20 @@ async function cmdOpenclawUpgrade(opts) {
       { cause: installError }
     );
   }
-  const rollbackCleanupWarning = cleanupRollbackDirectoryBestEffort(
-    installResult?.rollbackDir
-  );
+  const rollbackCleanupWarning = cleanupRollbackDirectoryBestEffort(installResult?.rollbackDir);
+  const managedRollbackCleanupWarning = cleanupRollbackDirectoryBestEffort(installResult?.managedRollbackDir);
   console.log("\nUpgrade backups:");
   for (const note of backupNotes) console.log(`  ${note}`);
   console.log(
     `
-Installed published plugin from npm pack ${packageSpec}${installResult.version ? ` (version ${installResult.version})` : ""}.`
+Installed published plugin through OpenClaw from ${packageSpec}${installResult?.version ? ` (version ${installResult?.version})` : ""}.`
   );
   if (rollbackCleanupWarning) {
     console.warn(rollbackCleanupWarning);
   }
+  if (managedRollbackCleanupWarning) {
+    console.warn(managedRollbackCleanupWarning);
+  }
   if (opts.restartGateway) {
     const restartResult = runBestEffortGatewayRestart(restartOpenclawGateway, OPENCLAW_GATEWAY_LABEL);
     console.log(restartResult.message);
@@ -15072,14 +15207,14 @@ async function cmdOpenclawMigrateEngram(opts) {
   console.log("  - Re-apply any local source patches to the new package only after verifying the published build.");
 }
 function createOpenclawUpgradeBackupDir() {
-  const backupsRoot = path16.join(resolveHomeDir(), ".openclaw", "backups");
-  fs13.mkdirSync(backupsRoot, { recursive: true });
-  return fs13.mkdtempSync(path16.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  const backupsRoot = path17.join(resolveOpenclawStateDir(), "backups");
+  fs14.mkdirSync(backupsRoot, { recursive: true });
+  return fs14.mkdtempSync(path17.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger2();
   const configPath = resolveConfigPath();
-  const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+  const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = resolveRemnicConfigRecord5(raw);
   const config = parseConfig6(remnicCfg);
   if (!config.taxonomyEnabled) {
@@ -15116,9 +15251,9 @@ async function cmdTaxonomy(rest) {
       const doc = generateResolverDocument(taxonomy);
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
-        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs13.mkdirSync(path16.dirname(resolverPath), { recursive: true });
-        fs13.writeFileSync(resolverPath, doc);
+        const resolverPath = path17.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs14.mkdirSync(path17.dirname(resolverPath), { recursive: true });
+        fs14.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
       break;
@@ -15163,8 +15298,8 @@ async function cmdTaxonomy(rest) {
       console.log(`Added category "${id}" (${name}).`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs13.writeFileSync(resolverPath, doc);
+        const resolverPath = path17.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs14.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -15194,8 +15329,8 @@ async function cmdTaxonomy(rest) {
       console.log(`Removed category "${id}".`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path16.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs13.writeFileSync(resolverPath, doc);
+        const resolverPath = path17.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs14.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
       break;
@@ -15386,12 +15521,12 @@ async function runTrainingExport(args, stdout = process.stdout) {
       `Unknown training-export format "${args.format}". ${validList}`
     );
   }
-  if (!fs13.existsSync(args.memoryDir)) {
+  if (!fs14.existsSync(args.memoryDir)) {
     throw new Error(
       `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
     );
   }
-  if (!fs13.statSync(args.memoryDir).isDirectory()) {
+  if (!fs14.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.`
     );
@@ -15476,11 +15611,11 @@ async function runTrainingExport(args, stdout = process.stdout) {
     );
   }
   const formatted = adapter.formatRecords(records);
-  const outDir = path16.dirname(args.output);
-  fs13.mkdirSync(outDir, { recursive: true });
+  const outDir = path17.dirname(args.output);
+  fs14.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
-  fs13.writeFileSync(tmpPath, formatted, "utf-8");
-  fs13.renameSync(tmpPath, args.output);
+  fs14.writeFileSync(tmpPath, formatted, "utf-8");
+  fs14.renameSync(tmpPath, args.output);
   stdout.write(
     `Exported ${records.length} records to ${args.output} (${adapter.name} format)
 `
@@ -15584,7 +15719,7 @@ async function main(argv = process.argv.slice(2)) {
     case "tree": {
       const subAction = rest[0];
       const json = rest.includes("--json");
-      const outputDir = resolveFlag(rest, "--output") ?? path16.join(process.cwd(), ".remnic", "context-tree");
+      const outputDir = resolveFlag(rest, "--output") ?? path17.join(process.cwd(), ".remnic", "context-tree");
       const categoriesFlag = resolveFlag(rest, "--categories");
       const categories = categoriesFlag ? categoriesFlag.split(",") : void 0;
       const maxPerCategoryRaw = resolveFlag(rest, "--max-per-category");
@@ -15649,7 +15784,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs13.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs14.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -15657,12 +15792,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs13.existsSync(treeDir)) {
+        if (!fs14.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
-        const indexPath = path16.join(treeDir, "INDEX.md");
-        if (!fs13.existsSync(indexPath)) {
+        const indexPath = path17.join(treeDir, "INDEX.md");
+        if (!fs14.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -15844,7 +15979,7 @@ Other:
         let wearablesService;
         try {
           const configPath = resolveConfigPath();
-          const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+          const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
           const remnicCfg = resolveRemnicConfigRecord5(raw);
           const config = parseConfig6(remnicCfg);
           wearablesOrchestrator = new Orchestrator3(config);
@@ -15899,7 +16034,7 @@ Other:
       const targetFactory = async () => {
         if (!orchestratorSingleton) {
           const configPath = resolveConfigPath();
-          const raw = fs13.existsSync(configPath) ? JSON.parse(fs13.readFileSync(configPath, "utf8")) : {};
+          const raw = fs14.existsSync(configPath) ? JSON.parse(fs14.readFileSync(configPath, "utf8")) : {};
           const remnicCfg = resolveRemnicConfigRecord5(raw);
           const config = parseConfig6(remnicCfg);
           orchestratorSingleton = new Orchestrator3(config);
@@ -16061,15 +16196,15 @@ Run 'remnic capsule <subcommand> --help' for subcommand details.`);
              @remnic/plugin-openclaw while backing up the legacy extension.
 
              Sets plugins.entries["${REMNIC_OPENCLAW_PLUGIN_ID}"] and plugins.slots.memory
-             in ~/.openclaw/openclaw.json (or $OPENCLAW_CONFIG_PATH).
+             in $OPENCLAW_STATE_DIR/openclaw.json, ~/.openclaw/openclaw.json, or $OPENCLAW_CONFIG_PATH.
 
 Options:
   --yes / -y / --force    Skip interactive prompts, assume Y
   --dry-run               Print resulting config diff without writing
-  --memory-dir <path>     Override default memory dir (~/.openclaw/workspace/memory/local)
+  --memory-dir <path>     Override the OpenClaw state-root memory dir
   --config <path>         Override OpenClaw config path
   --version <tag>         Upgrade @remnic/plugin-openclaw from a specific npm tag/version
-  --plugin-dir <path>     Override OpenClaw extension dir (~/.openclaw/extensions/openclaw-remnic)
+  --plugin-dir <path>     Override the OpenClaw state-root extension dir
   --legacy-plugin-dir <path>
                           Override legacy extension dir backed up by migrate-engram
   --no-restart            Skip the final launchctl kickstart after upgrade`);