@remnic/cli 9.69.56 → 9.69.57

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/enrichment-persist.ts
 import { composeSalvagedEnvelope } from "@remnic/core/salvage-envelope";
 async function persistEnrichmentCandidate(storage, entityName, candidate) {
@@ -480,8 +487,8 @@ function resetLegacyDatasetWarningState() {
 
 // src/index.ts
 import fs32 from "fs";
-import os3 from "os";
-import path22 from "path";
+import os4 from "os";
+import path23 from "path";
 import { createHash as createHash6 } from "crypto";
 import { writeFile as fsWriteFile } from "fs/promises";
 import * as childProcess2 from "child_process";
@@ -569,6 +576,8 @@ import {
   StorageManager as StorageManager4,
   parseXrayCliOptions,
   renderXray,
+  parseWhyCliOptions,
+  renderRecallWhy,
   extractWhoKnowsRawArgs,
   parseWhoKnowsCliOptions,
   renderWhoKnows,
@@ -3296,13 +3305,13 @@ async function planLocalNamespaceCensus(args) {
     citationTemplate: args.citationTemplate,
     cachedFiles: identityCache.size > 0 ? [...identityCache.values()] : priorFiles,
     readFile: async (file) => {
-      const readFile4 = io.readFile;
-      if (!readFile4) {
+      const readFile5 = io.readFile;
+      if (!readFile5) {
         manifestReadFailed = true;
         throw new Error("offline storage cannot read reconciliation manifest files");
       }
       try {
-        return await readFile4({
+        return await readFile5({
           root: rootDir,
           path: file.path,
           filePath: path6.join(rootDir, file.path)
@@ -7684,6 +7693,355 @@ async function loadOpenclawManagedUpgradeModule(packageSpec, hooks = {}) {
   }
 }
 
+// src/report.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, writeFileSync } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import os2 from "os";
+import path16 from "path";
+var REPORT_ALLOWED_CONFIG_FIELDS = Object.freeze([
+  "qmdEnabled",
+  "qmdAutoEmbedEnabled",
+  "qmdDaemonEnabled",
+  "qmdColdTierEnabled",
+  "qmdTierMigrationEnabled",
+  "qmdTierAutoBackfillEnabled",
+  "qmdMaintenanceEnabled",
+  "debug",
+  "identityEnabled",
+  "injectQuestions",
+  "consolidateEveryN",
+  "maxMemoryTokens",
+  "commitmentDecayDays"
+]);
+var SIZE_BUCKETS = Object.freeze([
+  { label: "< 1 KB", max: 1024 },
+  { label: "1 KB \u2013 10 KB", max: 10 * 1024 },
+  { label: "10 KB \u2013 100 KB", max: 100 * 1024 },
+  { label: "100 KB \u2013 1 MB", max: 1024 * 1024 },
+  { label: "1 MB \u2013 10 MB", max: 10 * 1024 * 1024 },
+  { label: "10 MB \u2013 100 MB", max: 100 * 1024 * 1024 },
+  { label: "100 MB \u2013 1 GB", max: 1024 * 1024 * 1024 },
+  { label: "> 1 GB", max: Infinity }
+]);
+function sizeBucket(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) return SIZE_BUCKETS[0].label;
+  for (const bucket of SIZE_BUCKETS) {
+    if (bytes <= bucket.max) return bucket.label;
+  }
+  return SIZE_BUCKETS[SIZE_BUCKETS.length - 1].label;
+}
+function sizeOfStore(dir) {
+  try {
+    const { execSync: execSync2 } = __require("child_process");
+    const output = execSync2(`du -sb "${dir}" 2>/dev/null || echo 0`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const match = output.match(/^(\d+)/);
+    return match ? Number(match[1]) : 0;
+  } catch {
+    return 0;
+  }
+}
+function countMemories(dir) {
+  try {
+    let count = 0;
+    const walk = (d) => {
+      for (const entry of readdirSync2(d)) {
+        const full = path16.join(d, entry);
+        const st = statSync2(full);
+        if (st.isDirectory()) walk(full);
+        else if (entry.endsWith(".md")) count++;
+      }
+    };
+    walk(dir);
+    return count;
+  } catch {
+    return 0;
+  }
+}
+function findConfigPath() {
+  const candidates = [
+    path16.join(os2.homedir(), ".config", "remnic", "config.json"),
+    path16.join(os2.homedir(), ".config", "openclaw", "openclaw.json"),
+    path16.join(os2.homedir(), ".openclaw", "config.json")
+  ];
+  for (const p of candidates) {
+    if (existsSync4(p)) return p;
+  }
+  return void 0;
+}
+function findMemoryDir(configPath) {
+  if (configPath) {
+    try {
+      const raw = JSON.parse(readFileSync4(configPath, "utf-8"));
+      const cfg = raw?.plugins?.["remnic"] ?? raw?.plugins?.["openclaw-engram"] ?? {};
+      if (typeof cfg.memoryDir === "string") return cfg.memoryDir;
+    } catch {
+    }
+  }
+  return path16.join(os2.homedir(), ".remnic", "memory");
+}
+function extractConfigShape(rawConfig) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(rawConfig)) {
+    if (!Object.hasOwn(rawConfig, key)) continue;
+    if (!REPORT_ALLOWED_CONFIG_FIELDS.includes(key)) continue;
+    const value = rawConfig[key];
+    if (typeof value === "boolean" || typeof value === "number") {
+      result[key] = value;
+    } else if (typeof value === "string" && ["alpha", "beta", "stable"].includes(value)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function runDoctorChecks() {
+  const checks = [];
+  const nodeMajor = Number.parseInt(process.version.slice(1).split(".")[0], 10);
+  checks.push({ name: "Node.js version", ok: nodeMajor >= 22 });
+  const configPath = findConfigPath();
+  checks.push({ name: "Config file", ok: configPath !== void 0 });
+  const memoryDir = findMemoryDir(configPath);
+  try {
+    mkdirSync(memoryDir, { recursive: true });
+    checks.push({ name: "Memory directory", ok: true });
+  } catch {
+    checks.push({ name: "Memory directory", ok: false });
+  }
+  const openclawPath = path16.join(os2.homedir(), ".config", "openclaw", "openclaw.json");
+  checks.push({ name: "OpenClaw config file", ok: existsSync4(openclawPath) });
+  return checks;
+}
+var PUBLIC_BENCHMARK_IDS = Object.freeze([
+  "ama-bench",
+  "memory-arena",
+  "amemgym",
+  "longmemeval",
+  "locomo",
+  "beam",
+  "personamem",
+  "membench",
+  "memoryagentbench",
+  "taxonomy-accuracy",
+  "extraction-judge-calibration",
+  "extraction-span-mode",
+  "enrichment-fidelity",
+  "entity-consolidation",
+  "page-versioning",
+  "retrieval-personalization",
+  "retrieval-temporal",
+  "retrieval-direct-answer",
+  "retrieval-graph",
+  "retrieval-reasoning-trace",
+  "coding-recall",
+  "procedural-recall",
+  "say-once",
+  "ingestion-entity-recall",
+  "ingestion-schema-completeness",
+  "ingestion-backlink-f1",
+  "ingestion-setup-friction",
+  "ingestion-citation-accuracy",
+  "assistant-morning-brief",
+  "assistant-meeting-prep",
+  "assistant-next-best-action",
+  "assistant-synthesis",
+  "buffer-surprise-trigger",
+  "contradiction-detection",
+  "retention-aged-dataset",
+  "memcorrect-v1",
+  "bounded-memory-contracts",
+  "staged-memory-synthetic-v1"
+]);
+var PUBLIC_METRIC_KEYS = Object.freeze([
+  "recall",
+  "precision",
+  "f1",
+  "exact_match",
+  "category_match",
+  "keyword_overlap",
+  "high_confidence",
+  "latencyMs",
+  "tokens",
+  "cost",
+  "qrel_at_1",
+  "qrel_at_3",
+  "qrel_at_5",
+  "qrel_at_10",
+  "bleu",
+  "rouge",
+  "support",
+  "completeness"
+]);
+var METRIC_KEY_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+function summarizeBenchScorecard(raw) {
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const summary = {};
+  const rawId = readBenchmarkId(raw);
+  if (rawId !== void 0) {
+    summary.benchmarkId = PUBLIC_BENCHMARK_IDS.includes(rawId) ? rawId : "custom";
+  }
+  const tasks = readNested(raw, "results", "tasks") ?? readOwn(raw, "tasks");
+  if (Array.isArray(tasks)) summary.taskCount = tasks.length;
+  const aggregates = readNested(raw, "results", "aggregates") ?? readOwn(raw, "scores");
+  const scores = extractNumericScores(aggregates);
+  if (scores !== void 0) summary.scores = scores;
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function readOwn(source, key) {
+  return Object.hasOwn(source, key) ? source[key] : void 0;
+}
+function readNested(source, ...path24) {
+  let current = source;
+  for (const key of path24) {
+    if (typeof current !== "object" || current === null) return void 0;
+    if (!Object.hasOwn(current, key)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function readBenchmarkId(raw) {
+  const metaId = readNested(raw, "meta", "benchmark");
+  if (typeof metaId === "string" && metaId.length > 0) return metaId;
+  const bench = readOwn(raw, "benchmark");
+  if (typeof bench === "object" && bench !== null) {
+    const id = readOwn(bench, "id");
+    if (typeof id === "string" && id.length > 0) return id;
+  }
+  return void 0;
+}
+function extractNumericScores(source) {
+  if (typeof source !== "object" || source === null) return void 0;
+  const scores = {};
+  for (const key of Object.getOwnPropertyNames(source)) {
+    if (!Object.hasOwn(source, key)) continue;
+    if (!PUBLIC_METRIC_KEYS.includes(key)) continue;
+    if (!METRIC_KEY_PATTERN.test(key)) continue;
+    const value = readOwn(source, key);
+    if (typeof value === "number" && Number.isFinite(value)) {
+      scores[key] = value;
+      continue;
+    }
+    if (typeof value === "object" && value !== null) {
+      const mean = readOwn(value, "mean");
+      if (typeof mean === "number" && Number.isFinite(mean)) scores[key] = mean;
+    }
+  }
+  return Object.keys(scores).length > 0 ? scores : void 0;
+}
+async function buildReport(options = {}) {
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const platform = { os: os2.platform(), arch: os2.arch(), node: process.version };
+  let remnicVersion = "unknown";
+  try {
+    const pkgPath = __require.resolve("@remnic/core/package.json");
+    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    remnicVersion = pkg.version ?? "unknown";
+  } catch {
+  }
+  const doctor = runDoctorChecks();
+  let configShape = {};
+  try {
+    const configPath = findConfigPath();
+    if (configPath) {
+      const raw = JSON.parse(readFileSync4(configPath, "utf-8"));
+      const remnicCfg = raw?.plugins?.["remnic"] ?? raw?.plugins?.["openclaw-engram"] ?? {};
+      configShape = extractConfigShape(remnicCfg);
+    }
+  } catch {
+  }
+  const memoryDir = findMemoryDir(findConfigPath());
+  const totalMemories = countMemories(memoryDir);
+  const storeBytes = sizeOfStore(memoryDir);
+  const sizeBucketLabel = sizeBucket(storeBytes);
+  let benchScorecard;
+  if (options.includeBench) {
+    const scorecardPath = path16.join(os2.homedir(), ".remnic", "reports", "bench-scorecard.json");
+    try {
+      const raw = JSON.parse(await readFile3(scorecardPath, "utf-8"));
+      benchScorecard = summarizeBenchScorecard(raw);
+    } catch {
+    }
+  }
+  return {
+    schemaVersion: "1",
+    generatedAt,
+    platform,
+    remnicVersion,
+    doctor,
+    configShape,
+    storeScale: { totalMemories, sizeBucket: sizeBucketLabel },
+    ...benchScorecard !== void 0 ? { benchScorecard } : {}
+  };
+}
+function renderReportMarkdown(report) {
+  const lines = [
+    "## Remnic Diagnostic Report",
+    "",
+    `Generated: ${report.generatedAt}`,
+    `Version: ${report.remnicVersion}`,
+    `Platform: ${report.platform.os} ${report.platform.arch} (Node ${report.platform.node})`,
+    "",
+    "### Doctor Checks",
+    "",
+    "| Check | Status |",
+    "| --- | --- |"
+  ];
+  for (const check of report.doctor) {
+    lines.push(`| ${check.name} | ${check.ok ? "Pass" : "Fail"} |`);
+  }
+  lines.push("", "### Config Shape (allow-list only)", "");
+  const keys = Object.getOwnPropertyNames(report.configShape).sort();
+  lines.push("| Field | Value |");
+  lines.push("| --- | --- |");
+  for (const key of keys) {
+    lines.push(`| ${key} | ${JSON.stringify(report.configShape[key])} |`);
+  }
+  lines.push("", "### Store Scale", "");
+  lines.push("| Metric | Value |");
+  lines.push("| --- | --- |");
+  lines.push(`| Total memories | ${report.storeScale.totalMemories} |`);
+  lines.push(`| Store size | ${report.storeScale.sizeBucket} |`);
+  if (report.benchScorecard !== void 0) {
+    lines.push("", "### Bench Scorecard", "");
+    lines.push("```json");
+    lines.push(JSON.stringify(report.benchScorecard, null, 2));
+    lines.push("```");
+  }
+  lines.push("", "---", "", "**Privacy:** This report contains only the fields listed above.");
+  lines.push("No secrets, paths, hostnames, or personal data are included.");
+  lines.push("", "To file an issue, paste the above into a new GitHub issue at:");
+  lines.push("https://github.com/joshuaswarren/remnic/issues/new");
+  return lines.join("\n");
+}
+function renderReportJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+async function cmdReport(options = {}) {
+  const reportDir = path16.join(os2.homedir(), ".remnic", "reports");
+  mkdirSync(reportDir, { recursive: true });
+  const report = await buildReport({ includeBench: options.includeBench });
+  const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "");
+  const mdPath = path16.join(reportDir, `report-${dateStr}.md`);
+  const jsonPath = path16.join(reportDir, `report-${dateStr}.json`);
+  const md = renderReportMarkdown(report);
+  const json = renderReportJson(report);
+  writeFileSync(mdPath, md, "utf-8");
+  writeFileSync(jsonPath, json, "utf-8");
+  if (options.json) {
+    console.log(json);
+  } else {
+    console.log(md);
+  }
+  console.log(`
+Report saved to:
+  ${mdPath}
+  ${jsonPath}`);
+  console.log("\nTo file an issue, run:");
+  console.log(`  gh issue create --title "Remnic diagnostic report ${dateStr}" --body-file "${mdPath}"`);
+  console.log("\nOr paste the report at: https://github.com/joshuaswarren/remnic/issues/new");
+}
+
 // src/remote-daemon.ts
 import fs28 from "fs";
 import { readCompatEnv } from "@remnic/core";
@@ -7936,13 +8294,58 @@ async function remoteRecallXray(daemon, request) {
   }
   return { snapshotFound: false };
 }
+async function remoteRecallWhy(daemon, request) {
+  const params = new URLSearchParams({ q: request.query });
+  if (request.expect !== void 0 && request.expect.length > 0) {
+    params.set("expect", request.expect);
+  }
+  if (request.namespace !== void 0 && request.namespace.length > 0) {
+    params.set("namespace", request.namespace);
+  }
+  if (request.sessionKey !== void 0 && request.sessionKey.length > 0) {
+    params.set("session", request.sessionKey);
+  }
+  let response;
+  try {
+    response = await daemonFetch(
+      daemon.baseUrl,
+      `engram/v1/recall/why?${params.toString()}`,
+      daemon.token,
+      1e4
+    );
+  } catch (err) {
+    if (isTransportError(err)) throw unreachableError(daemon.baseUrl);
+    throw err;
+  }
+  if (response.status === 401) {
+    throw new Error(
+      `token rejected by remnic-server at ${daemon.baseUrl} (HTTP 401). Update server.authToken or REMNIC_AUTH_TOKEN to match the remote daemon.`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(`remnic-server returned HTTP ${response.status} ${response.statusText}`);
+  }
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw new Error("remnic-server returned a non-JSON response");
+  }
+  if (payload !== null && typeof payload === "object" && !Array.isArray(payload)) {
+    const record2 = payload;
+    if (record2.reportFound === true && record2.report !== null && typeof record2.report === "object") {
+      return { reportFound: true, report: record2.report };
+    }
+  }
+  return { reportFound: false };
+}
 
 // src/daemon-service.ts
 import fs29 from "fs";
-import path16 from "path";
+import path17 from "path";
 import * as childProcess from "child_process";
 import { fileURLToPath as fileURLToPath5 } from "url";
-var thisModuleDir = path16.dirname(fileURLToPath5(import.meta.url));
+var thisModuleDir = path17.dirname(fileURLToPath5(import.meta.url));
 function launchdLoadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["load", "-w", plistPath], { stdio: "pipe" });
 }
@@ -7950,7 +8353,7 @@ function launchdUnloadPlist(plistPath, processApi = childProcess) {
   processApi.execFileSync("launchctl", ["unload", plistPath], { stdio: "pipe" });
 }
 function resolveServerBinDetails(options = {}) {
-  const existsSync4 = options.existsSync ?? fs29.existsSync;
+  const existsSync5 = options.existsSync ?? fs29.existsSync;
   const findCommandOnPath2 = options.findCommandOnPath ?? findCommandOnPath;
   const moduleDir = options.moduleDir ?? thisModuleDir;
   const packageResolve = options.packageResolve ?? resolveImportSpecifier;
@@ -7964,8 +8367,8 @@ function resolveServerBinDetails(options = {}) {
     });
   } catch {
   }
-  const workspaceServerBin = path16.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
-  const workspaceDistIndex = path16.resolve(moduleDir, "../../remnic-server/dist/index.js");
+  const workspaceServerBin = path17.resolve(moduleDir, "../../remnic-server/bin/remnic-server.js");
+  const workspaceDistIndex = path17.resolve(moduleDir, "../../remnic-server/dist/index.js");
   candidates.push(
     {
       path: workspaceServerBin,
@@ -7986,15 +8389,15 @@ function resolveServerBinDetails(options = {}) {
     });
   }
   candidates.push({
-    path: path16.resolve(moduleDir, "../../remnic-server/src/index.ts"),
+    path: path17.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: path16.resolve(moduleDir, "../../remnic-server/dist/index.js"),
+  const selected = candidates.find((candidate) => isCandidateReady(candidate, existsSync5)) ?? candidates.find((candidate) => existsSync5(candidate.path)) ?? candidates[0] ?? {
+    path: path17.resolve(moduleDir, "../../remnic-server/dist/index.js"),
     source: "workspace-dist"
   };
-  const exists = existsSync4(selected.path);
-  const requiredExists = selected.requiredPath ? existsSync4(selected.requiredPath) : true;
+  const exists = existsSync5(selected.path);
+  const requiredExists = selected.requiredPath ? existsSync5(selected.requiredPath) : true;
   const { requiredPath: _requiredPath, ...publicSelected } = selected;
   return {
     ...publicSelected,
@@ -8002,14 +8405,14 @@ function resolveServerBinDetails(options = {}) {
     loadableByNode: exists && requiredExists && !selected.path.endsWith(".ts")
   };
 }
-function isCandidateReady(candidate, existsSync4) {
-  return existsSync4(candidate.path) && (candidate.requiredPath ? existsSync4(candidate.requiredPath) : true);
+function isCandidateReady(candidate, existsSync5) {
+  return existsSync5(candidate.path) && (candidate.requiredPath ? existsSync5(candidate.requiredPath) : true);
 }
 function resolveServerBin(options = {}) {
   return resolveServerBinDetails(options).path;
 }
 function readVerifiedDaemonPid(options) {
-  const readFileSync5 = options.readFileSync ?? fs29.readFileSync;
+  const readFileSync6 = options.readFileSync ?? fs29.readFileSync;
   const unlinkSync = options.unlinkSync ?? fs29.unlinkSync;
   const processKill = options.processKill ?? process.kill;
   const platform = options.platform ?? process.platform;
@@ -8017,7 +8420,7 @@ function readVerifiedDaemonPid(options) {
   for (const file of options.pidFiles) {
     let pid;
     try {
-      pid = parseDaemonPid(readFileSync5(file, "utf8"));
+      pid = parseDaemonPid(readFileSync6(file, "utf8"));
     } catch {
       continue;
     }
@@ -8045,7 +8448,7 @@ function readVerifiedDaemonPid(options) {
 }
 function doesProcessCommandLookLikeRemnicDaemon(command, expectedServerBin) {
   const normalizedCommand = command.trim();
-  const normalizedExpected = path16.resolve(expandTilde(expectedServerBin));
+  const normalizedExpected = path17.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) {
@@ -8110,9 +8513,9 @@ function removePidFileBestEffort(file, unlinkSync) {
   }
 }
 function inspectLaunchdPlist(plistPath, options = {}) {
-  const existsSync4 = options.existsSync ?? fs29.existsSync;
-  const readFileSync5 = options.readFileSync ?? fs29.readFileSync;
-  if (!existsSync4(plistPath)) {
+  const existsSync5 = options.existsSync ?? fs29.existsSync;
+  const readFileSync6 = options.readFileSync ?? fs29.readFileSync;
+  if (!existsSync5(plistPath)) {
     return {
       installed: false,
       ok: true,
@@ -8122,7 +8525,7 @@ function inspectLaunchdPlist(plistPath, options = {}) {
   }
   let content;
   try {
-    content = readFileSync5(plistPath, "utf8");
+    content = readFileSync6(plistPath, "utf8");
   } catch {
     return {
       installed: true,
@@ -8150,7 +8553,7 @@ function inspectLaunchdPlist(plistPath, options = {}) {
     };
   }
   const expandedServerArg = expandTilde(serverArg);
-  if (!path16.isAbsolute(expandedServerArg)) {
+  if (!path17.isAbsolute(expandedServerArg)) {
     return {
       installed: true,
       ok: false,
@@ -8158,7 +8561,7 @@ function inspectLaunchdPlist(plistPath, options = {}) {
       remediation: "Run `remnic daemon install` so launchd uses an absolute Remnic server path."
     };
   }
-  if (!existsSync4(expandedServerArg)) {
+  if (!existsSync5(expandedServerArg)) {
     return {
       installed: true,
       ok: false,
@@ -8222,8 +8625,8 @@ function normalizeResolvedPath(resolved) {
   return resolved;
 }
 function packageServerBinFromEntry(packageEntry) {
-  if (path16.basename(packageEntry) === "index.js" && path16.basename(path16.dirname(packageEntry)) === "dist") {
-    return path16.join(path16.dirname(path16.dirname(packageEntry)), "bin", "remnic-server.js");
+  if (path17.basename(packageEntry) === "index.js" && path17.basename(path17.dirname(packageEntry)) === "dist") {
+    return path17.join(path17.dirname(path17.dirname(packageEntry)), "bin", "remnic-server.js");
   }
   return packageEntry;
 }
@@ -8297,8 +8700,8 @@ import {
 } from "@remnic/core";
 
 // src/import-bundle-detect.ts
-import { lstatSync as lstatSync3, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import path17 from "path";
+import { lstatSync as lstatSync3, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
+import path18 from "path";
 function detectBundleEntries(bundleDir, options = {}) {
   const readdir4 = options.readdirImpl ?? defaultReaddir;
   const readFileImpl = options.readFileImpl ?? defaultReadFile;
@@ -8329,7 +8732,7 @@ function detectBundleEntries(bundleDir, options = {}) {
   for (const filePath of roots) {
     if (seenFiles.has(filePath)) continue;
     seenFiles.add(filePath);
-    const name = path17.basename(filePath);
+    const name = path18.basename(filePath);
     const match = classifyFile(name, filePath, readFileImpl);
     if (match) entries.push(match);
   }
@@ -8367,7 +8770,7 @@ function collectCandidatePaths(root, readdir4, isDirectory2, isRegularFile) {
       return;
     }
     for (const entry of entries) {
-      const full = path17.join(dir, entry);
+      const full = path18.join(dir, entry);
       if (isDirectory2(full)) {
         walk(full, depth + 1);
       } else if (isRegularFile(full)) {
@@ -8416,10 +8819,10 @@ function disambiguateConversations(filePath, readFileImpl) {
   return "chatgpt";
 }
 function defaultReaddir(dir) {
-  return readdirSync2(dir);
+  return readdirSync3(dir);
 }
 function defaultReadFile(p) {
-  return readFileSync4(p, "utf-8");
+  return readFileSync5(p, "utf-8");
 }
 function defaultIsDirectory(p) {
   try {
@@ -8923,7 +9326,7 @@ async function cmdCapture(rest, io) {
 
 // src/import-lossless-claw-cmd.ts
 import fs31 from "fs";
-import path18 from "path";
+import path19 from "path";
 import {
   applyLcmSchema,
   ensureLcmStateDir,
@@ -9073,7 +9476,7 @@ async function cmdImportLosslessClaw(argv, io, deps = {}) {
     let destDb;
     try {
       if (parsed.dryRun) {
-        const lcmPath = path18.join(memoryDir, "state", "lcm.sqlite");
+        const lcmPath = path19.join(memoryDir, "state", "lcm.sqlite");
         if (fs31.existsSync(lcmPath)) {
           destDb = mod.openExistingLcmDatabaseReadOnly(lcmPath);
         } else {
@@ -9193,9 +9596,9 @@ function printBenchComparisonSummary(comparison, baseline, candidate) {
 }
 
 // src/bench-coding-commands.ts
-import { lstat as lstat3, readFile as readFile3, realpath as realpath2, stat as stat2 } from "fs/promises";
-import os2 from "os";
-import path19 from "path";
+import { lstat as lstat3, readFile as readFile4, realpath as realpath2, stat as stat2 } from "fs/promises";
+import os3 from "os";
+import path20 from "path";
 var UINT32_MAX = 4294967295;
 var FROZEN_GENERATOR_SEED = 81;
 var FROZEN_TASK_COUNT = 30;
@@ -9205,7 +9608,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 = path19.join(
+var DEFAULT_REPEATED_FAILURE_OUTPUT_DIR = path20.join(
   resolveHomeDir(),
   ".remnic",
   "bench",
@@ -9539,7 +9942,7 @@ function parseBenchCodingArgs(args) {
   throw new Error(`unknown bench coding subcommand ${args[0]}`);
 }
 function normalizeCommandPaths(command) {
-  const resolve3 = (value) => path19.resolve(expandTilde(value));
+  const resolve3 = (value) => path20.resolve(expandTilde(value));
   if (command.kind === "repo-generate") {
     return { ...command, outputDir: resolve3(command.outputDir) };
   }
@@ -9570,23 +9973,23 @@ function normalizeCommandPaths(command) {
   return command;
 }
 async function canonicalProspectivePath(value) {
-  let candidate = path19.resolve(value);
+  let candidate = path20.resolve(value);
   const missingSegments = [];
   while (true) {
     try {
-      return path19.join(await realpath2(candidate), ...missingSegments.reverse());
+      return path20.join(await realpath2(candidate), ...missingSegments.reverse());
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
-      const parent = path19.dirname(candidate);
+      const parent = path20.dirname(candidate);
       if (parent === candidate) throw error;
-      missingSegments.push(path19.basename(candidate));
+      missingSegments.push(path20.basename(candidate));
       candidate = parent;
     }
   }
 }
 function isSameOrDescendant(candidate, root) {
-  const relative2 = path19.relative(root, candidate);
-  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative2);
+  const relative2 = path20.relative(root, candidate);
+  return relative2 === "" || relative2 !== ".." && !relative2.startsWith(`..${path20.sep}`) && !path20.isAbsolute(relative2);
 }
 async function pathExists(value) {
   try {
@@ -9605,7 +10008,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
       const configured = process.env[variable]?.trim();
       if (!configured) continue;
       const memoryRoot = await canonicalProspectivePath(
-        path19.resolve(expandTilde(configured))
+        path20.resolve(expandTilde(configured))
       );
       if (isSameOrDescendant(canonicalOutput, memoryRoot)) {
         throw new Error(refusal);
@@ -9613,10 +10016,10 @@ async function assertSafeBenchmarkOutput(outputDir) {
     }
     let candidate = canonicalOutput;
     while (true) {
-      const hasProfile = await pathExists(path19.join(candidate, "profile.md"));
-      const hasMemoryData = await pathExists(path19.join(candidate, "facts")) || await pathExists(path19.join(candidate, "entities")) || await pathExists(path19.join(candidate, "state"));
+      const hasProfile = await pathExists(path20.join(candidate, "profile.md"));
+      const hasMemoryData = await pathExists(path20.join(candidate, "facts")) || await pathExists(path20.join(candidate, "entities")) || await pathExists(path20.join(candidate, "state"));
       if (hasProfile && hasMemoryData) throw new Error(refusal);
-      const parent = path19.dirname(candidate);
+      const parent = path20.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -9628,7 +10031,7 @@ async function assertSafeBenchmarkOutput(outputDir) {
 async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
   try {
     const parsed = JSON.parse(
-      await readFile3(path19.join(runDir, "run.json"), "utf8")
+      await readFile4(path20.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");
@@ -9638,7 +10041,7 @@ async function assertH6StatsRunDirectory(runDir, commandName = "stats") {
   }
 }
 function sanitizeOutput(output) {
-  const home = os2.homedir();
+  const home = os3.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");
@@ -9687,7 +10090,7 @@ async function runRepoVerification(command, bench) {
   if (command.directory === void 0) {
     dataset = await requireFunction(bench, "loadCommittedH6BenchmarkDataset")();
   } else {
-    const serialized = await readFile3(path19.join(command.directory, "dataset.json"), "utf8").catch(
+    const serialized = await readFile4(path20.join(command.directory, "dataset.json"), "utf8").catch(
       () => void 0
     );
     if (serialized === void 0) {
@@ -9815,8 +10218,8 @@ async function cmdBenchCoding(args) {
 }
 
 // src/bench-security-commands.ts
-import path20 from "path";
-var DEFAULT_OUTPUT_DIR = path20.join(
+import path21 from "path";
+var DEFAULT_OUTPUT_DIR = path21.join(
   resolveHomeDir(),
   ".remnic",
   "bench",
@@ -9969,7 +10372,7 @@ ${BENCH_SECURITY_USAGE}`);
 }
 
 // src/bench-research-commands.ts
-import path21 from "path";
+import path22 from "path";
 function emit(result) {
   if (result.output) {
     console.log(result.output);
@@ -9987,7 +10390,7 @@ async function runBenchResearchCommand(parsed) {
     emit(
       await runAttributeCliCommand({
         runRef: parsed.runRef,
-        resultsDir: parsed.resultsDir ?? path21.join(resolveHomeDir(), ".remnic", "bench", "results"),
+        resultsDir: parsed.resultsDir ?? path22.join(resolveHomeDir(), ".remnic", "bench", "results"),
         memoryDir: parsed.memoryDir,
         qmdPath: parsed.qmdPath,
         collection: parsed.collection,
@@ -10257,14 +10660,14 @@ registerPublisher("hermes", () => new HermesMemoryExtensionPublisher());
 registerPublisher("pi", () => new LazyPluginPiPublisher("pi", (mod) => mod.PiMemoryExtensionPublisher));
 registerPublisher("omp", () => new LazyPluginPiPublisher("omp", (mod) => mod.OmpMemoryExtensionPublisher));
 registerPublisher("prime-agent", () => new LazyPluginPiPublisher("prime-agent", (mod) => mod.PrimeAgentMemoryExtensionPublisher));
-var PID_DIR = path22.join(resolveHomeDir(), ".remnic");
-var LEGACY_PID_DIR = path22.join(resolveHomeDir(), ".engram");
-var PID_FILE = path22.join(PID_DIR, "server.pid");
-var LEGACY_PID_FILE = path22.join(LEGACY_PID_DIR, "server.pid");
-var LOG_FILE = path22.join(PID_DIR, "server.log");
-var LEGACY_LOG_FILE = path22.join(LEGACY_PID_DIR, "server.log");
-var CLI_MODULE_DIR = path22.dirname(fileURLToPath6(import.meta.url));
-var CLI_REPO_ROOT2 = path22.resolve(CLI_MODULE_DIR, "../../..");
+var PID_DIR = path23.join(resolveHomeDir(), ".remnic");
+var LEGACY_PID_DIR = path23.join(resolveHomeDir(), ".engram");
+var PID_FILE = path23.join(PID_DIR, "server.pid");
+var LEGACY_PID_FILE = path23.join(LEGACY_PID_DIR, "server.pid");
+var LOG_FILE = path23.join(PID_DIR, "server.log");
+var LEGACY_LOG_FILE = path23.join(LEGACY_PID_DIR, "server.log");
+var CLI_MODULE_DIR = path23.dirname(fileURLToPath6(import.meta.url));
+var CLI_REPO_ROOT2 = path23.resolve(CLI_MODULE_DIR, "../../..");
 var OPENCLAW_GATEWAY_LABEL = "ai.openclaw.gateway";
 var CLI_SUCCESS_EXIT_GRACE_MS = 5e3;
 var CLI_OUTPUT_FLUSH_GRACE_MS = 250;
@@ -10443,12 +10846,12 @@ async function resolveKnownBenchmarkIds() {
   return knownIds;
 }
 function resolveBenchOutputDir() {
-  return path22.join(resolveHomeDir(), ".remnic", "bench", "results");
+  return path23.join(resolveHomeDir(), ".remnic", "bench", "results");
 }
 async function launchBenchUi(resultsDir) {
-  const benchUiDir = path22.join(CLI_REPO_ROOT2, "packages", "bench-ui");
+  const benchUiDir = path23.join(CLI_REPO_ROOT2, "packages", "bench-ui");
   const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
-  if (!fs32.existsSync(path22.join(benchUiDir, "package.json"))) {
+  if (!fs32.existsSync(path23.join(benchUiDir, "package.json"))) {
     console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
     process.exit(1);
   }
@@ -10475,11 +10878,11 @@ async function launchBenchUi(resultsDir) {
   });
 }
 function resolveDatasetDownloadScriptPath() {
-  const bundled = path22.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
+  const bundled = path23.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
   if (fs32.existsSync(bundled)) {
     return bundled;
   }
-  return path22.join(CLI_REPO_ROOT2, "packages", "remnic-cli", "assets", "download-datasets.sh");
+  return path23.join(CLI_REPO_ROOT2, "packages", "remnic-cli", "assets", "download-datasets.sh");
 }
 function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
   const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
@@ -10785,12 +11188,12 @@ async function exportBenchPackageResult(parsed) {
     process.exit(1);
   }
   const result = await loadBenchmarkResult(summary.path);
-  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path22.dirname(summary.path), result.meta.id) : void 0;
+  const reportCardProvenance = parsed.format === "html" ? await loadBenchmarkReportCardProvenance(path23.dirname(summary.path), result.meta.id) : void 0;
   const rendered = renderBenchmarkResultExport(result, parsed.format, {
     ...reportCardProvenance ? { reportCardProvenance } : {}
   });
   if (parsed.output) {
-    fs32.mkdirSync(path22.dirname(parsed.output), { recursive: true });
+    fs32.mkdirSync(path23.dirname(parsed.output), { recursive: true });
     fs32.writeFileSync(parsed.output, rendered);
     console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
     return;
@@ -10812,7 +11215,7 @@ async function manageBenchDatasets(parsed) {
       return {
         benchmark: benchmarkId,
         downloaded: discovered !== void 0,
-        path: discovered ? discovered.dir : path22.join(datasetRoot, benchmarkId),
+        path: discovered ? discovered.dir : path23.join(datasetRoot, benchmarkId),
         source: discovered?.source ?? "canonical"
       };
     });
@@ -10847,7 +11250,7 @@ async function manageBenchDatasets(parsed) {
     runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, parsed.json === true);
     downloaded.push({
       benchmark: benchmarkId,
-      path: path22.join(datasetRoot, benchmarkId)
+      path: path23.join(datasetRoot, benchmarkId)
     });
   }
   if (parsed.json) {
@@ -10986,10 +11389,10 @@ async function calibrateBenchJudges(parsed, rawArgs) {
   }
   const bench = await loadBenchModule();
   const resultsDir = expandTilde(
-    parsed.resultsDir ?? path22.join(resolveHomeDir(), ".remnic", "bench", "results")
+    parsed.resultsDir ?? path23.join(resolveHomeDir(), ".remnic", "bench", "results")
   );
   const calibrationDir = expandTilde(
-    parsed.calibrationDir ?? path22.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    parsed.calibrationDir ?? path23.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const stored = await bench.listBenchmarkResults(resultsDir);
   const allForBenchmark = stored.filter((entry) => entry.benchmark === benchmarkId);
@@ -11548,9 +11951,9 @@ async function loadPublishedPromotionHelpers() {
   const benchModule = await loadBenchModule();
   return {
     async promoteArtifactsToPublished(args) {
-      const { mkdirSync, readFileSync: readFileSync5, writeFileSync } = await import("fs");
-      const path23 = await import("path");
-      mkdirSync(args.publishedOutDir, { recursive: true });
+      const { mkdirSync: mkdirSync2, readFileSync: readFileSync6, writeFileSync: writeFileSync2 } = await import("fs");
+      const path24 = await import("path");
+      mkdirSync2(args.publishedOutDir, { recursive: true });
       if (args.artifactPaths.length === 0) {
         console.warn(
           `[bench published] No artifacts produced for ${args.benchmarkId}; nothing to promote.`
@@ -11558,7 +11961,7 @@ async function loadPublishedPromotionHelpers() {
         return;
       }
       for (const artifactPath of args.artifactPaths) {
-        const raw = readFileSync5(artifactPath, "utf8");
+        const raw = readFileSync6(artifactPath, "utf8");
         const parsedUnknown = JSON.parse(raw);
         const parsedObj = parsedUnknown !== null && typeof parsedUnknown === "object" && !Array.isArray(parsedUnknown) ? parsedUnknown : {};
         const gitShaShort = (parsedObj.meta?.gitSha ?? "unknown").slice(0, 7);
@@ -11566,13 +11969,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 = path23.join(
+        const target = path24.join(
           args.publishedOutDir,
           `${today}-${args.benchmarkId}-${modelSlug}${profileSlug}-${gitShaShort}.json`
         );
-        writeFileSync(target, raw, "utf8");
+        writeFileSync2(target, raw, "utf8");
         console.log(
-          `[bench published] Promoted ${path23.basename(artifactPath)} \u2192 ${target}`
+          `[bench published] Promoted ${path24.basename(artifactPath)} \u2192 ${target}`
         );
       }
       void benchModule;
@@ -11679,7 +12082,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] = path22.join(
+    process.env[CODEX_CLI_BENCH_DIAGNOSTICS_DIR_ENV] = path23.join(
       outputDir,
       "codex-cli-diagnostics"
     );
@@ -11829,7 +12232,7 @@ async function preparePersistedJudgeCalibrationAttachment(benchModule, benchmark
     );
   }
   const calibrationDir = expandTilde(
-    calibrationBinding.calibrationDir ?? path22.join(resolveHomeDir(), ".remnic", "bench", "calibration")
+    calibrationBinding.calibrationDir ?? path23.join(resolveHomeDir(), ".remnic", "bench", "calibration")
   );
   const state = await benchModule.loadJudgeCalibrationState?.(benchmarkId, calibrationDir);
   if (!state) {
@@ -12311,7 +12714,7 @@ async function resolvePackageBenchRuntime(benchModule, parsed, runtimeProfile) {
   );
 }
 function normalizeMemoryDirPath(memoryDir) {
-  return path22.resolve(expandTilde(memoryDir));
+  return path23.resolve(expandTilde(memoryDir));
 }
 function resolveMemoryDir() {
   const configMemoryDir = (() => {
@@ -12324,9 +12727,9 @@ function resolveMemoryDir() {
       return normalizeMemoryDirPath(remnicCfg.memoryDir);
     }
     const home = resolveHomeDir();
-    const standalonePath = path22.join(home, ".remnic", "memory");
-    const legacyStandalonePath = path22.join(home, ".engram", "memory");
-    const openclawPath = path22.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+    const standalonePath = path23.join(home, ".remnic", "memory");
+    const legacyStandalonePath = path23.join(home, ".engram", "memory");
+    const openclawPath = path23.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
     if (fs32.existsSync(standalonePath)) return standalonePath;
     if (fs32.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
@@ -12375,21 +12778,21 @@ function resolveFlagStrict(args, flag) {
 var REMNIC_OPENCLAW_LEGACY_PLUGIN_ID = "openclaw-engram";
 function resolveOpenclawStateDir() {
   const configuredStateDir = process.env.OPENCLAW_STATE_DIR?.trim();
-  return configuredStateDir ? path22.resolve(expandTilde(configuredStateDir)) : path22.join(resolveHomeDir(), ".openclaw");
+  return configuredStateDir ? path23.resolve(expandTilde(configuredStateDir)) : path23.join(resolveHomeDir(), ".openclaw");
 }
 var DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR = [
   process.env.OPENCLAW_CONFIG_PATH,
   process.env.OPENCLAW_ENGRAM_CONFIG_PATH,
-  path22.join(resolveOpenclawStateDir(), "openclaw.json")
+  path23.join(resolveOpenclawStateDir(), "openclaw.json")
 ].filter(Boolean);
 function resolveOpenclawConfigPath(cliPath) {
-  if (cliPath) return path22.resolve(expandTilde(cliPath));
+  if (cliPath) return path23.resolve(expandTilde(cliPath));
   const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
-  if (envPath) return path22.resolve(expandTilde(envPath));
+  if (envPath) return path23.resolve(expandTilde(envPath));
   for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
     if (fs32.existsSync(candidate)) return candidate;
   }
-  return path22.join(resolveOpenclawStateDir(), "openclaw.json");
+  return path23.join(resolveOpenclawStateDir(), "openclaw.json");
 }
 function readOpenclawConfig(configPath) {
   if (!fs32.existsSync(configPath)) return {};
@@ -12448,10 +12851,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 path22.resolve(expandTilde(args.requestedMemoryDir));
+    return path23.resolve(expandTilde(args.requestedMemoryDir));
   }
   if (existingMemoryDir) {
-    return path22.resolve(expandTilde(existingMemoryDir));
+    return path23.resolve(expandTilde(existingMemoryDir));
   }
   return args.fallbackMemoryDir;
 }
@@ -12469,21 +12872,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 path22.resolve(expandTilde(memoryDir));
+      return path23.resolve(expandTilde(memoryDir));
     }
   }
   return fallbackMemoryDir;
 }
 function resolveOpenclawPluginDir(cliPath) {
-  if (cliPath) return path22.resolve(expandTilde(cliPath));
+  if (cliPath) return path23.resolve(expandTilde(cliPath));
   return resolveOpenclawManagedPluginDir();
 }
 function resolveOpenclawManagedPluginDir() {
-  return path22.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  return path23.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
 }
 function resolveOpenclawLegacyPluginDir(cliPath) {
-  if (cliPath) return path22.resolve(expandTilde(cliPath));
-  return path22.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
+  if (cliPath) return path23.resolve(expandTilde(cliPath));
+  return path23.join(resolveOpenclawStateDir(), "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID);
 }
 function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
   const yyyy = now.getFullYear().toString();
@@ -12496,7 +12899,7 @@ function formatOpenclawUpgradeStamp(now = /* @__PURE__ */ new Date()) {
 }
 function backupPathIfPresent(sourcePath, backupPath) {
   if (!fs32.existsSync(sourcePath)) return false;
-  fs32.mkdirSync(path22.dirname(backupPath), { recursive: true });
+  fs32.mkdirSync(path23.dirname(backupPath), { recursive: true });
   fs32.cpSync(sourcePath, backupPath, { recursive: true });
   return true;
 }
@@ -12515,7 +12918,7 @@ function restartOpenclawGateway() {
   });
 }
 function cmdInit() {
-  const configPath = path22.join(process.cwd(), "remnic.config.json");
+  const configPath = path23.join(process.cwd(), "remnic.config.json");
   if (fs32.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
@@ -12523,7 +12926,7 @@ function cmdInit() {
   const template = {
     remnic: {
       openaiApiKey: "${OPENAI_API_KEY}",
-      memoryDir: path22.join(process.cwd(), ".remnic", "memory"),
+      memoryDir: path23.join(process.cwd(), ".remnic", "memory"),
       memoryOsPreset: "balanced"
     },
     server: {
@@ -12585,7 +12988,7 @@ async function cmdStatus(json) {
   console.log(`Remnic server: running${pid ? ` (pid ${pid})` : ""}`);
   await printHealthCheck(resolveDaemonBaseUrl(resolveConfigPath()), resolveStatusProbeToken());
 }
-async function oauthFetch(method, path23, token, body) {
+async function oauthFetch(method, path24, token, body) {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 5e3);
   try {
@@ -12604,7 +13007,7 @@ async function oauthFetch(method, path23, token, body) {
     if (body !== void 0) {
       init.body = JSON.stringify(body);
     }
-    const response = await fetch(`${resolveDaemonBaseUrl(resolveConfigPath())}${path23}`, init);
+    const response = await fetch(`${resolveDaemonBaseUrl(resolveConfigPath())}${path24}`, 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."
@@ -13154,6 +13557,82 @@ function xrayCliIo(recallXray) {
     stdout: (line) => console.log(line)
   };
 }
+function extractWhyRawArgs(rest) {
+  const VALUE_FLAGS = /* @__PURE__ */ new Set(["--format", "--expect", "--namespace", "--session", "--out"]);
+  const positional = [];
+  const options = {};
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (token.startsWith("--")) {
+      if (!VALUE_FLAGS.has(token)) {
+        throw new Error(
+          `Unknown flag ${JSON.stringify(token)}. Supported flags: --format, --expect, --namespace, --session, --out.`
+        );
+      }
+      const next = rest[i + 1];
+      if (next === void 0 || next.startsWith("--")) {
+        throw new Error(
+          `${token} requires a value. Provide it as \`${token} <value>\`, not as a bare flag.`
+        );
+      }
+      options[token.slice(2)] = next;
+      i++;
+      continue;
+    }
+    positional.push(token);
+  }
+  return { rawQuery: positional.join(" "), options };
+}
+async function runWhyCommand(rest, io) {
+  const { rawQuery, options } = extractWhyRawArgs(rest);
+  const parsed = parseWhyCliOptions(rawQuery, options);
+  const response = await io.recallWhy({
+    query: parsed.query,
+    ...parsed.expect !== void 0 ? { expect: parsed.expect } : {},
+    ...parsed.session !== void 0 ? { sessionKey: parsed.session } : {},
+    ...parsed.namespace !== void 0 ? { namespace: parsed.namespace } : {}
+  });
+  if (!response.reportFound || response.report === void 0) {
+    throw new Error(
+      "recall diagnosis unavailable: the requested namespace is not readable by this caller"
+    );
+  }
+  const rendered = renderRecallWhy(response.report, parsed.format);
+  if (parsed.outPath !== void 0) {
+    await io.writeFile(expandTildePath(parsed.outPath), rendered);
+  } else {
+    io.stdout(rendered);
+  }
+}
+async function cmdWhy(rest) {
+  const { rawQuery, options } = extractWhyRawArgs(rest);
+  parseWhyCliOptions(rawQuery, options);
+  const remote = resolveRemoteDaemon(resolveConfigPath());
+  if (remote) {
+    await runWhyCommand(rest, whyCliIo((request) => remoteRecallWhy(remote, request)));
+    return;
+  }
+  initLogger5();
+  const configPath = resolveConfigPath();
+  const raw = fs32.existsSync(configPath) ? JSON.parse(fs32.readFileSync(configPath, "utf8")) : {};
+  const config = parseConfig17(resolveRemnicConfigRecord16(raw));
+  const orchestrator = new Orchestrator11(config);
+  await orchestrator.initialize();
+  await orchestrator.deferredReady;
+  const service = new EngramAccessService2(orchestrator);
+  try {
+    await runWhyCommand(rest, whyCliIo((request) => service.recallWhy(request)));
+  } finally {
+    orchestrator.abortDeferredInit();
+  }
+}
+function whyCliIo(recallWhy) {
+  return {
+    recallWhy,
+    writeFile: (filePath, data) => fsWriteFile(filePath, data, "utf8"),
+    stdout: (line) => console.log(line)
+  };
+}
 async function runWhoKnowsCommand(rest, io) {
   const { topic, options } = extractWhoKnowsRawArgs(rest);
   const parsed = parseWhoKnowsCliOptions(topic, options);
@@ -13222,7 +13701,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions list <page-path>");
         process.exit(1);
       }
-      const absPath = path22.resolve(pagePath);
+      const absPath = path23.resolve(pagePath);
       const history = await listVersions(absPath, versioningConfig, memDir);
       if (json) {
         console.log(JSON.stringify(history, null, 2));
@@ -13247,7 +13726,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions show <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path22.resolve(pagePath);
+      const absPath = path23.resolve(pagePath);
       try {
         const content = await getVersion(absPath, versionId, versioningConfig, memDir);
         console.log(content);
@@ -13265,7 +13744,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions diff <page-path> <v1> <v2>");
         process.exit(1);
       }
-      const absPath = path22.resolve(pagePath);
+      const absPath = path23.resolve(pagePath);
       try {
         const diffOutput = await diffVersions(absPath, v1, v2, versioningConfig, memDir);
         console.log(diffOutput);
@@ -13282,7 +13761,7 @@ async function cmdVersions(rest) {
         console.error("Usage: remnic versions revert <page-path> <version-id>");
         process.exit(1);
       }
-      const absPath = path22.resolve(pagePath);
+      const absPath = path23.resolve(pagePath);
       try {
         const version = await revertToVersion(absPath, versionId, versioningConfig, void 0, memDir);
         if (json) {
@@ -13322,7 +13801,7 @@ async function cmdEnrich(rest) {
   const subcommand = rest[0];
   if (subcommand === "audit") {
     const memoryDir2 = expandTilde(config.memoryDir);
-    const auditDir2 = path22.join(memoryDir2, "enrichment");
+    const auditDir2 = path23.join(memoryDir2, "enrichment");
     const sinceFlag = resolveFlag(rest.slice(1), "--since");
     const entries = await readAuditLog(auditDir2, sinceFlag ?? void 0);
     if (entries.length === 0) {
@@ -13447,7 +13926,7 @@ Registered providers:`);
     return;
   }
   const memoryDir = expandTilde(config.memoryDir);
-  const auditDir = path22.join(memoryDir, "enrichment");
+  const auditDir = path23.join(memoryDir, "enrichment");
   let totalPersisted = 0;
   for (const result of results) {
     for (const candidate of result.acceptedCandidates) {
@@ -13570,7 +14049,7 @@ Root: ${root}`);
       const validNames = new Set(extensions.map((e) => e.name));
       let errors = 0;
       for (const entry of entries) {
-        const entryPath = path22.join(root, entry);
+        const entryPath = path23.join(root, entry);
         try {
           if (!fs32.statSync(entryPath).isDirectory()) continue;
         } catch {
@@ -13701,7 +14180,7 @@ ${section}
       const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
       fs32.mkdirSync(saveDir, { recursive: true });
       const filename = briefingFilename(new Date(result.window.to), format);
-      const filePath = path22.join(saveDir, filename);
+      const filePath = path23.join(saveDir, filename);
       fs32.writeFileSync(filePath, payload + (payload.endsWith("\n") ? "" : "\n"));
       console.error(`Saved briefing: ${filePath}`);
     } catch (err) {
@@ -13857,7 +14336,7 @@ async function cmdDoctor() {
       const rawMemoryDir = entryConfig?.memoryDir;
       const configuredMemoryDir = typeof rawMemoryDir === "string" ? rawMemoryDir : void 0;
       if (configuredMemoryDir) {
-        const resolvedMemDir = path22.resolve(expandTilde(configuredMemoryDir));
+        const resolvedMemDir = path23.resolve(expandTilde(configuredMemoryDir));
         let memDirOk = false;
         let memDirDetail = `${resolvedMemDir} (not found)`;
         let memDirRemediation = `Run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create the directory.`;
@@ -14070,7 +14549,7 @@ async function cmdMigrate(json, rollback) {
   console.log(`  Rollback: ${result.rollbackCommand}`);
 }
 function cmdOnboard(dirPath, json) {
-  const directory = path22.resolve(dirPath || process.cwd());
+  const directory = path23.resolve(dirPath || process.cwd());
   const result = onboard({ directory });
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -14089,7 +14568,7 @@ Suggested namespace: ${result.plan.suggestedNamespace}`);
 async function cmdCurate(targetPath, json) {
   const memoryDir = resolveMemoryDir();
   const result = await curate({
-    targetPath: path22.resolve(targetPath),
+    targetPath: path23.resolve(targetPath),
     memoryDir,
     source: "curation",
     checkDuplicates: true,
@@ -14218,8 +14697,8 @@ async function cmdSync(action, rest, json) {
   }
 }
 function localOfflineSourceId(memoryDir) {
-  const host = os3.hostname() || "unknown-host";
-  const dirHash = createHash6("sha256").update(path22.resolve(memoryDir)).digest("hex").slice(0, 16);
+  const host = os4.hostname() || "unknown-host";
+  const dirHash = createHash6("sha256").update(path23.resolve(memoryDir)).digest("hex").slice(0, 16);
   return `remnic-local:${host}:${dirHash}`;
 }
 function normalizeOfflineRemoteUrl(raw) {
@@ -14628,10 +15107,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(path23) {
-    super(`remote file changed while fetching offline content: ${path23}`);
+  constructor(path24) {
+    super(`remote file changed while fetching offline content: ${path24}`);
     this.name = "OfflineRemoteFileChangedError";
-    this.path = path23;
+    this.path = path24;
   }
 };
 function isOfflineRemoteFileChangedError(error) {
@@ -14892,7 +15371,7 @@ async function pushOfflineFileContentFromChunkReader(args) {
   }
   const hash = createHash6("sha256");
   const chunks = args.readFileChunks({
-    root: path22.resolve(args.memoryDir),
+    root: path23.resolve(args.memoryDir),
     path: args.file.path,
     filePath,
     chunkSize: OFFLINE_SYNC_FILE_CONTENT_UPLOAD_CHUNK_BYTES
@@ -16006,7 +16485,7 @@ Environment fallbacks:
   REMNIC_OFFLINE_TOKEN > REMNIC_AUTH_TOKEN > ENGRAM_AUTH_TOKEN.`);
     return;
   }
-  const memoryDir = path22.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
+  const memoryDir = path23.resolve(expandTilde(resolveRequiredValueFlag(rest, "--memory-dir") ?? resolveMemoryDir()));
   const namespace = resolveRequiredValueFlag(rest, "--namespace");
   const includeTranscripts = !hasFlag(rest, "--no-transcripts");
   const stateOverride = resolveRequiredValueFlag(rest, "--state");
@@ -16027,7 +16506,7 @@ Environment fallbacks:
   const remoteUrl = needsRemote ? resolveOfflineRemoteUrl(rest) : resolveOptionalOfflineRemoteUrl(rest);
   const knownAction = needsRemote || action === "status";
   const token = knownAction ? resolveOfflineToken(rest) : void 0;
-  const statePath = statePathExplicit ? path22.resolve(expandTilde(stateOverride)) : remoteUrl !== void 0 ? defaultOfflineSyncStatePath(memoryDir, remoteUrl, namespace) : void 0;
+  const statePath = statePathExplicit ? path23.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");
     fs32.mkdirSync(memoryDir, { recursive: true });
@@ -16209,11 +16688,11 @@ Environment fallbacks:
           failures: result.largeFilePushFailures
         });
         largeFileFailureCounts = advanced.counts;
-        for (const path23 of advanced.newlySkipped) {
-          if (skippedLargeFiles.has(path23)) continue;
-          skippedLargeFiles.add(path23);
+        for (const path24 of advanced.newlySkipped) {
+          if (skippedLargeFiles.has(path24)) continue;
+          skippedLargeFiles.add(path24);
           console.warn(
-            `offline sync: permanently skipping ${path23} 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 ${path24} 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;
@@ -16228,11 +16707,11 @@ Environment fallbacks:
             failures: error.failures
           });
           largeFileFailureCounts = advanced.counts;
-          for (const path23 of advanced.newlySkipped) {
-            if (skippedLargeFiles.has(path23)) continue;
-            skippedLargeFiles.add(path23);
+          for (const path24 of advanced.newlySkipped) {
+            if (skippedLargeFiles.has(path24)) continue;
+            skippedLargeFiles.add(path24);
             console.warn(
-              `offline sync: permanently skipping ${path23} 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 ${path24} 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)`
             );
           }
         }
@@ -16373,7 +16852,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: path22.join(memoryDir, "skills"),
+              skillsRoot: path23.join(memoryDir, "skills"),
               rollbackTokenEntry: preInstallTokenEntry,
               log: { info: console.log, warn: console.warn, error: console.error }
             });
@@ -16733,15 +17212,15 @@ async function cmdConnectorsMarketplace(subAction, rest, json) {
     }
     const manifest = generateMarketplaceManifest();
     await writeMarketplaceManifest(outputDir, manifest);
-    const outPath = path22.join(outputDir, "marketplace.json");
+    const outPath = path23.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] ?? path22.join(process.cwd(), "marketplace.json");
-    const resolved = path22.resolve(targetPath);
+    const targetPath = rest.filter((a) => !a.startsWith("--"))[0] ?? path23.join(process.cwd(), "marketplace.json");
+    const resolved = path23.resolve(targetPath);
     if (!fs32.existsSync(resolved)) {
       console.error(`File not found: ${resolved}`);
       process.exit(1);
@@ -17157,7 +17636,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: ${path22.basename(latestStatusPath)}`);
+    printBenchStatusLine(parsed.json, `Resuming from: ${path23.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;
@@ -17322,9 +17801,9 @@ Options:
     );
     process.exit(1);
   } else {
-    fixturePath = path22.resolve(expandTilde(fixturePathRaw));
+    fixturePath = path23.resolve(expandTilde(fixturePathRaw));
   }
-  const outPath = path22.resolve(expandTilde(outPathRaw));
+  const outPath = path23.resolve(expandTilde(outPathRaw));
   const benchModule = await loadBenchModule();
   const runner = benchModule.runProceduralAblationCli;
   if (typeof runner !== "function") {
@@ -17343,7 +17822,7 @@ Options:
   );
   console.log(`wrote ${outPath}`);
 }
-var LOGS_DIR = path22.join(PID_DIR, "logs");
+var LOGS_DIR = path23.join(PID_DIR, "logs");
 var LAUNCHD_PLIST_PATHS = launchdPlistPaths(resolveHomeDir());
 var [LAUNCHD_PLIST_PATH] = LAUNCHD_PLIST_PATHS;
 var SYSTEMD_UNIT_PATHS = systemdUnitPaths(resolveHomeDir());
@@ -17420,7 +17899,7 @@ function selectLaunchdInspection(openclawPluginModeConfigured) {
   for (const plistPath of LAUNCHD_PLIST_PATHS.slice(1)) {
     const legacy = inspectLaunchdPlist(plistPath);
     if (!legacy.installed) continue;
-    const label = path22.basename(plistPath, ".plist");
+    const label = path23.basename(plistPath, ".plist");
     return legacy.ok ? {
       ...legacy,
       warn: true,
@@ -17454,10 +17933,10 @@ function daemonInstall() {
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
   fs32.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
-    const templatePath = path22.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
+    const templatePath = path23.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
     const template = fs32.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs32.mkdirSync(path22.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs32.mkdirSync(path23.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
     fs32.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       launchdLoadPlist(LAUNCHD_PLIST_PATH);
@@ -17474,10 +17953,10 @@ function daemonInstall() {
     console.log(`  RunAtLoad: true, KeepAlive: true`);
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
-    const templatePath = path22.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
+    const templatePath = path23.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
     const template = fs32.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs32.mkdirSync(path22.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs32.mkdirSync(path23.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
     fs32.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess2.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
@@ -17976,7 +18455,7 @@ Clean complete: cleaned=${result.cleaned}`
 }
 async function cmdOpenclawInstall(opts) {
   const configPath = resolveOpenclawConfigPath(opts.configPath);
-  const fallbackMemoryDir = path22.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+  const fallbackMemoryDir = path23.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   console.log(`OpenClaw config: ${configPath}`);
   const existingConfig = readOpenclawConfig(configPath);
   const { plugins, entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
@@ -18079,7 +18558,7 @@ Remove it first and re-run, or choose a different path with --memory-dir.`
     fs32.mkdirSync(memoryDir, { recursive: true });
     console.log(`Created memory directory: ${memoryDir}`);
   }
-  const configDir = path22.dirname(configPath);
+  const configDir = path23.dirname(configPath);
   if (!fs32.existsSync(configDir)) {
     fs32.mkdirSync(configDir, { recursive: true });
   }
@@ -18108,12 +18587,12 @@ async function cmdOpenclawUpgrade(opts) {
   const pluginDir = resolveOpenclawPluginDir(opts.pluginDir);
   const managedTargetDir = resolveOpenclawManagedPluginDir();
   const legacyPluginDirForBackup = opts.legacyPluginDirForBackup ? resolveOpenclawLegacyPluginDir(opts.legacyPluginDirForBackup) : void 0;
-  const fallbackMemoryDir = path22.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
+  const fallbackMemoryDir = path23.join(resolveOpenclawStateDir(), "workspace", "memory", "local");
   const packageSpec = buildOpenclawManagedUpgradePackageSpec(opts.version);
   const configExistedBefore = fs32.existsSync(configPath);
   const existingConfig = readOpenclawConfig(configPath);
   const { entries, slots } = parseOpenclawPluginState(existingConfig, configPath);
-  const preservedMemoryDir = opts.memoryDir ? path22.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
+  const preservedMemoryDir = opts.memoryDir ? path23.resolve(expandTilde(opts.memoryDir)) : resolveCurrentOpenclawMemoryDir(entries, slots, fallbackMemoryDir);
   console.log(`OpenClaw config: ${configPath}`);
   console.log(`Plugin dir:      ${pluginDir}`);
   if (legacyPluginDirForBackup) {
@@ -18121,7 +18600,7 @@ async function cmdOpenclawUpgrade(opts) {
   }
   console.log(`Memory dir:      ${preservedMemoryDir}`);
   console.log(`Package spec:    ${packageSpec}`);
-  console.log(`Backup root:     ${path22.join(resolveOpenclawStateDir(), "backups")}`);
+  console.log(`Backup root:     ${path23.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`] : [],
@@ -18159,9 +18638,9 @@ async function cmdOpenclawUpgrade(opts) {
     assertDirectoryPathOrMissing(legacyPluginDirForBackup, "Legacy OpenClaw plugin dir");
   }
   const backupDir = createOpenclawUpgradeBackupDir();
-  const configBackupPath = path22.join(backupDir, "openclaw.json");
-  const pluginBackupDir = path22.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
-  const legacyPluginBackupDir = legacyPluginDirForBackup ? path22.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
+  const configBackupPath = path23.join(backupDir, "openclaw.json");
+  const pluginBackupDir = path23.join(backupDir, "extensions", REMNIC_OPENCLAW_PLUGIN_ID);
+  const legacyPluginBackupDir = legacyPluginDirForBackup ? path23.join(backupDir, "extensions", REMNIC_OPENCLAW_LEGACY_PLUGIN_ID) : void 0;
   const backupNotes = [];
   if (backupPathIfPresent(configPath, configBackupPath)) {
     backupNotes.push(`+ Backed up config to ${configBackupPath}`);
@@ -18211,7 +18690,7 @@ async function cmdOpenclawUpgrade(opts) {
     const managedRollbackDir = publishedInstallError ? publishedInstallError.managedRollbackDir : installResult?.managedRollbackDir;
     const managedRollbackTargetDir = publishedInstallError?.managedRollbackTargetDir ?? installResult?.managedRollbackTargetDir ?? managedTargetDir;
     const requiresHostManagedRestore = publishedInstallError?.requiresHostManagedRestore ?? installResult?.requiresHostManagedRestore ?? false;
-    const managedRollbackSharesPluginDir = managedRollbackDir && path22.resolve(managedRollbackTargetDir) === path22.resolve(pluginDir);
+    const managedRollbackSharesPluginDir = managedRollbackDir && path23.resolve(managedRollbackTargetDir) === path23.resolve(pluginDir);
     const pluginRollbackDir = managedRollbackSharesPluginDir ? requiresHostManagedRestore ? rollbackDir : rollbackDir ?? managedRollbackDir : rollbackDir;
     const shouldRestorePlugin = Boolean(
       installResult && !requiresHostManagedRestore || pluginRollbackDir || publishedInstallError?.shouldRestoreBackup
@@ -18268,7 +18747,7 @@ async function cmdOpenclawUpgrade(opts) {
       rollbackErrors.push(error);
     }
     if (pendingConfigRestoreError) rollbackErrors.push(pendingConfigRestoreError);
-    if (managedRollbackDir && path22.resolve(managedRollbackTargetDir) !== path22.resolve(pluginDir) && !requiresHostManagedRestore) {
+    if (managedRollbackDir && path23.resolve(managedRollbackTargetDir) !== path23.resolve(pluginDir) && !requiresHostManagedRestore) {
       try {
         rollbackNotes.push(
           ...rollbackOpenclawUpgrade({
@@ -18334,9 +18813,9 @@ 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 = path22.join(resolveOpenclawStateDir(), "backups");
+  const backupsRoot = path23.join(resolveOpenclawStateDir(), "backups");
   fs32.mkdirSync(backupsRoot, { recursive: true });
-  return fs32.mkdtempSync(path22.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
+  return fs32.mkdtempSync(path23.join(backupsRoot, `remnic-openclaw-upgrade-${formatOpenclawUpgradeStamp()}-`));
 }
 async function cmdTaxonomy(rest) {
   initLogger5();
@@ -18378,8 +18857,8 @@ async function cmdTaxonomy(rest) {
       const doc = generateResolverDocument(taxonomy);
       console.log(doc);
       if (config.taxonomyAutoGenResolver) {
-        const resolverPath = path22.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
-        fs32.mkdirSync(path22.dirname(resolverPath), { recursive: true });
+        const resolverPath = path23.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs32.mkdirSync(path23.dirname(resolverPath), { recursive: true });
         fs32.writeFileSync(resolverPath, doc);
         console.error(`Written: ${resolverPath}`);
       }
@@ -18425,7 +18904,7 @@ async function cmdTaxonomy(rest) {
       console.log(`Added category "${id}" (${name}).`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path22.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        const resolverPath = path23.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
         fs32.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
@@ -18456,7 +18935,7 @@ async function cmdTaxonomy(rest) {
       console.log(`Removed category "${id}".`);
       if (config.taxonomyAutoGenResolver) {
         const doc = generateResolverDocument(taxonomy);
-        const resolverPath = path22.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        const resolverPath = path23.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
         fs32.writeFileSync(resolverPath, doc);
         console.error(`Regenerated: ${resolverPath}`);
       }
@@ -18738,7 +19217,7 @@ async function runTrainingExport(args, stdout = process.stdout) {
     );
   }
   const formatted = adapter.formatRecords(records);
-  const outDir = path22.dirname(args.output);
+  const outDir = path23.dirname(args.output);
   fs32.mkdirSync(outDir, { recursive: true });
   const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
   fs32.writeFileSync(tmpPath, formatted, "utf-8");
@@ -18794,6 +19273,9 @@ async function main(argv = process.argv.slice(2)) {
     case "xray":
       await cmdXray(rest);
       break;
+    case "why":
+      await cmdWhy(rest);
+      break;
     case "who-knows":
       await cmdWhoKnows(rest);
       break;
@@ -18806,6 +19288,9 @@ async function main(argv = process.argv.slice(2)) {
     case "doctor":
       await cmdDoctor();
       break;
+    case "report":
+      await cmdReport({ json: rest.includes("--json"), includeBench: rest.includes("--include-bench") });
+      break;
     case "config":
       cmdConfig();
       break;
@@ -18861,7 +19346,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") ?? path22.join(process.cwd(), ".remnic", "context-tree");
+      const outputDir = resolveFlag(rest, "--output") ?? path23.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");
@@ -18938,7 +19423,7 @@ async function main(argv = process.argv.slice(2)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
-        const indexPath = path22.join(treeDir, "INDEX.md");
+        const indexPath = path23.join(treeDir, "INDEX.md");
         if (!fs32.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
@@ -19365,6 +19850,10 @@ Usage:
   remnic xray <query> [--format text|markdown|json] [--budget <chars>] [--namespace <ns>] [--out <path>]
     Run a recall with X-ray capture and print the unified snapshot
     (tier + audit + MMR + filters). Part of #570. Text output by default.
+  remnic why <query> [--expect <id|substring>] [--format markdown|json] [--namespace <ns>] [--session <key>] [--out <path>]
+    Diagnose why a query did NOT recall what you expected (#3033). Prints
+    per-stage candidate counts and drop reasons; with --expect, names the
+    exact stage that dropped that memory plus a remediation hint.
   remnic who-knows <topic> [--limit N] [--json] [--namespace <ns>]  Rank entities by topic expertise
   remnic wearables <status|check|sync|transcript|search|memories|speakers|corrections>
     Wearable transcript sources (Limitless / Bee / Omi): pull + clean +
@@ -19547,6 +20036,7 @@ export {
   chunkOfflineChangesetApplyBatches,
   chunkOfflineFileContentBatches,
   directHydrateLargeOfflineFiles,
+  extractWhyRawArgs,
   extractXrayRawArgs,
   fetchOfflineSnapshot,
   formatOfflineLargeFilePushFailureMessage,
@@ -19581,6 +20071,7 @@ export {
   runOfflineSyncOnce,
   runTrainingExport,
   runWhoKnowsCommand,
+  runWhyCommand,
   runXrayCommand,
   shouldDirectHydrateOfflineFile,
   stripConfigArgv,