@remnic/cli 1.0.3 → 1.0.4

package/dist/index.js

@@ -1,7 +1,15 @@
+import {
+  checkRegression,
+  loadBaseline,
+  runBenchSuite,
+  runExplain
+} from "./chunk-U4MQO3IF.js";
+
 // src/index.ts
-import fs2 from "fs";
+import fs from "fs";
 import path2 from "path";
 import * as childProcess from "child_process";
+import { fileURLToPath } from "url";
 import {
   parseConfig,
   Orchestrator,
@@ -34,291 +42,430 @@ import {
   getManifestPath,
   generateContextTree,
   migrateFromEngram,
-  rollbackFromEngramMigration
+  rollbackFromEngramMigration,
+  buildBriefing,
+  parseBriefingWindow,
+  parseBriefingFocus,
+  validateBriefingFormat,
+  resolveBriefingSaveDir,
+  briefingFilename,
+  FileCalendarSource,
+  listVersions,
+  getVersion,
+  revertToVersion,
+  diffVersions,
+  readManifest,
+  createBackend,
+  runBinaryLifecyclePipeline,
+  DEFAULT_SCAN_PATTERNS,
+  DEFAULT_MAX_BINARY_SIZE_BYTES,
+  publisherForConnector,
+  hostIdForConnector,
+  registerPublisher,
+  PUBLISHERS,
+  CodexMemoryExtensionPublisher,
+  ClaudeCodeMemoryExtensionPublisher,
+  HermesMemoryExtensionPublisher,
+  DEFAULT_TAXONOMY,
+  resolveCategory,
+  generateResolverDocument,
+  loadTaxonomy,
+  saveTaxonomy,
+  validateSlug,
+  validateTaxonomy,
+  generateMarketplaceManifest,
+  checkMarketplaceManifest,
+  writeMarketplaceManifest,
+  installFromMarketplace,
+  EnrichmentProviderRegistry,
+  WebSearchProvider,
+  runEnrichmentPipeline,
+  appendAuditEntry,
+  readAuditLog,
+  defaultEnrichmentPipelineConfig,
+  discoverMemoryExtensions,
+  resolveExtensionsRoot,
+  coerceInstallExtension
 } from "@remnic/core";
 
-// ../bench/src/benchmark.ts
-import fs from "fs";
-import path from "path";
-var DEFAULT_BASELINE_PATH = path.join(
-  process.cwd(),
-  "benchmarks",
-  "baseline.json"
-);
-var DEFAULT_REPORT_PATH = path.join(
-  process.cwd(),
-  "benchmarks",
-  "report.json"
-);
-var BASELINE_VERSION = 1;
-var DEFAULT_QUERIES = [
-  "What is the storage?",
-  "How do I access storage?",
-  "What categories exist?",
-  "How is memory organized?",
-  "What is the recall budget?",
-  "What is the extraction pipeline?",
-  "What facts are stored about the project?",
-  "What is the architecture?"
-];
-var DEFAULT_TOLERANCE = 10;
-function hrTimeMs() {
-  const [s, ns] = process.hrtime();
-  return s * 1e3 + Math.round(ns / 1e6);
-}
-function loadBaseline(baselinePath) {
-  const p = baselinePath ?? DEFAULT_BASELINE_PATH;
-  if (!fs.existsSync(p)) return void 0;
-  try {
-    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
-    if (raw.version !== BASELINE_VERSION) {
-      console.warn(
-        `Baseline version mismatch: expected ${BASELINE_VERSION}, got ${raw.version}`
-      );
+// src/service-candidates.ts
+function firstSuccessfulResult(candidates, attempt) {
+  for (const candidate of candidates) {
+    try {
+      const result = attempt(candidate);
+      if (result !== void 0) return result;
+    } catch {
     }
-    return raw;
-  } catch {
-    return void 0;
   }
+  return void 0;
 }
-function saveBaseline(baselinePath, baseline) {
-  fs.mkdirSync(path.dirname(baselinePath), { recursive: true });
-  fs.writeFileSync(baselinePath, JSON.stringify(baseline, null, 2) + "\n");
-}
-async function recallWithTiers(service, query) {
-  const tiers = [];
-  const tierDetails = [];
-  const t0 = hrTimeMs();
-  const r0 = await service.recall({ query, mode: "auto" });
-  const d0 = hrTimeMs() - t0;
-  if (r0.results && r0.results.length > 0) {
-    const hasExactMatch = r0.results.some(
-      (m) => m.preview.toLowerCase().includes(query.toLowerCase())
-    );
-    if (hasExactMatch) {
-      tiers.push("exact_match");
-      tierDetails.push({
-        tier: "exact_match",
-        latencyMs: d0,
-        resultsCount: r0.results.length
-      });
-      return { tiers, tierDetails };
-    }
-  }
-  const t1 = hrTimeMs();
-  const r1 = await service.recall({ query, mode: "auto" });
-  const d1 = hrTimeMs() - t1;
-  const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
-  const hasKeywordMatch = (r1.results ?? []).some(
-    (m) => queryWords.some((kw) => m.preview.toLowerCase().includes(kw))
-  );
-  if (hasKeywordMatch) {
-    tiers.push("category_match");
-    tierDetails.push({
-      tier: "category_match",
-      latencyMs: d1,
-      resultsCount: r1.results.length
-    });
-    return { tiers, tierDetails };
-  }
-  const t2 = hrTimeMs();
-  const r2 = await service.recall({ query, mode: "auto" });
-  const d2 = hrTimeMs() - t2;
-  const tagged = (r2.results ?? []).filter((m) => m.tags && m.tags.length > 0);
-  if (tagged.length > 0) {
-    tiers.push("high_confidence");
-    tierDetails.push({
-      tier: "high_confidence",
-      latencyMs: d2,
-      resultsCount: tagged.length
-    });
-    return { tiers, tierDetails };
-  }
-  const t3 = hrTimeMs();
-  const r3 = await service.recall({ query, mode: "auto" });
-  const d3 = hrTimeMs() - t3;
-  if (r3.results && r3.results.length > 0) {
-    tiers.push("semantic_search");
-    tierDetails.push({
-      tier: "semantic_search",
-      latencyMs: d3,
-      resultsCount: r3.results.length
-    });
-    return { tiers, tierDetails };
-  }
-  const t4 = hrTimeMs();
-  const r4 = await service.recall({ query, mode: "full" });
-  const d4 = hrTimeMs() - t4;
-  if (r4.results && r4.results.length > 0) {
-    tiers.push("full_search");
-    tierDetails.push({
-      tier: "full_search",
-      latencyMs: d4,
-      resultsCount: r4.results.length
-    });
-    return { tiers, tierDetails };
-  }
-  tiers.push("no_results");
-  tierDetails.push({
-    tier: "no_results",
-    latencyMs: d0 + d1 + d2 + d3 + d4,
-    resultsCount: 0
+function firstSuccessfulCandidate(candidates, attempt) {
+  return firstSuccessfulResult(candidates, (candidate) => {
+    attempt(candidate);
+    return candidate;
   });
-  return { tiers, tierDetails };
 }
-async function runExplain(service, query) {
-  const start = hrTimeMs();
-  const { tiers, tierDetails } = await recallWithTiers(service, query);
-  const totalDuration = hrTimeMs() - start;
-  return {
-    query,
-    tiersUsed: tiers,
-    tierResults: tierDetails,
-    durationMs: tierDetails[0]?.latencyMs ?? totalDuration,
-    totalDurationMs: totalDuration
-  };
+
+// src/bench-args.ts
+import path from "path";
+
+// src/path-utils.ts
+function resolveHomeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "~";
 }
-async function runSingle(service, queryText) {
-  const start = hrTimeMs();
-  const { tiers, tierDetails } = await recallWithTiers(service, queryText);
-  const duration = hrTimeMs() - start;
-  return {
-    query: queryText,
-    latencyMs: duration,
-    tiersUsed: tiers,
-    throughput: duration > 0 ? 1 / (duration / 1e3) : 0,
-    resultsCount: tierDetails.reduce((sum, t) => sum + t.resultsCount, 0),
-    totalDurationMs: duration,
-    tierDetails
-  };
+function expandTilde(p) {
+  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+    return resolveHomeDir() + p.slice(1);
+  }
+  const home = resolveHomeDir();
+  if (p === "$HOME" || p.startsWith("$HOME/") || p.startsWith("$HOME\\")) {
+    return home + p.slice(5);
+  }
+  if (p === "${HOME}" || p.startsWith("${HOME}/") || p.startsWith("${HOME}\\")) {
+    return home + p.slice(7);
+  }
+  return p;
 }
-async function runBenchSuite(service, config = {}) {
-  const queries = config.queries ?? DEFAULT_QUERIES;
-  const regressionTolerance = config.regressionTolerance ?? DEFAULT_TOLERANCE;
-  const baselinePath = config.baselinePath ?? DEFAULT_BASELINE_PATH;
-  const reportPath = config.reportPath ?? DEFAULT_REPORT_PATH;
-  const explain = config.explain ?? false;
-  const results = [];
-  const suiteStart = hrTimeMs();
-  for (const q of queries) {
-    if (explain) {
-      const ex = await runExplain(service, q);
-      results.push({
-        query: ex.query,
-        latencyMs: ex.durationMs,
-        tiersUsed: ex.tiersUsed,
-        throughput: ex.totalDurationMs > 0 ? 1 / (ex.totalDurationMs / 1e3) : 0,
-        resultsCount: ex.tierResults.reduce(
-          (sum, t) => sum + t.resultsCount,
-          0
-        ),
-        totalDurationMs: ex.totalDurationMs,
-        tierDetails: ex.tierResults
-      });
-    } else {
-      results.push(await runSingle(service, q));
-    }
+
+// src/bench-args.ts
+function readBenchOptionValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return void 0;
   }
-  const totalDuration = hrTimeMs() - suiteStart;
-  const metrics = {};
-  for (const r of results) {
-    metrics[r.query] = r.latencyMs;
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`ERROR: ${flag} requires a value.`);
   }
-  const report = generateReport(results, reportPath);
-  const baseline = loadBaseline(baselinePath);
-  const regressionResult = checkRegression(
-    metrics,
-    baseline,
-    regressionTolerance
-  );
-  if (!baseline) {
-    saveBaseline(baselinePath, {
-      version: BASELINE_VERSION,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      metrics
-    });
+  return value;
+}
+function collectBenchmarks(argv) {
+  const benchmarks = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--dataset-dir") {
+      index += 1;
+      continue;
+    }
+    if (!arg.startsWith("-")) {
+      benchmarks.push(arg);
+    }
   }
+  return benchmarks;
+}
+function parseBenchActionArgs(argv) {
+  const [first, ...rest] = argv;
+  const action = first === "list" || first === "run" || first === "check" || first === "report" ? first : first === void 0 || first === "--help" || first === "-h" ? "help" : "run";
   return {
-    results,
-    report,
-    totalDurationMs: totalDuration,
-    regressions: regressionResult.regressions
+    action,
+    args: action === "run" && action !== first ? argv : rest
   };
 }
-function checkRegression(metrics, baseline, tolerance) {
-  if (!baseline) return { passed: true, regressions: [] };
-  const regressions = [];
-  for (const [metricName, currentValue] of Object.entries(metrics)) {
-    const baselineValue = baseline.metrics[metricName];
-    if (baselineValue === void 0) continue;
-    const changePercent = baselineValue > 0 ? (currentValue - baselineValue) / baselineValue * 100 : 0;
-    regressions.push({
-      metric: metricName,
-      currentValue,
-      baselineValue,
-      tolerance,
-      passed: changePercent <= tolerance
-    });
-  }
+function parseBenchArgs(argv) {
+  const { action, args } = parseBenchActionArgs(argv);
+  const benchmarks = collectBenchmarks(args);
+  const datasetDir = readBenchOptionValue(args, "--dataset-dir");
   return {
-    passed: regressions.every((r) => r.passed),
-    regressions
+    action,
+    benchmarks,
+    quick: args.includes("--quick"),
+    all: args.includes("--all"),
+    json: args.includes("--json"),
+    datasetDir: datasetDir ? path.resolve(expandTilde(datasetDir)) : void 0
   };
 }
-function generateReport(results, reportPath) {
-  const report = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    queries: results.map((r) => ({
-      query: r.query,
-      tiersUsed: r.tiersUsed,
-      durationMs: r.latencyMs,
-      resultsCount: r.resultsCount,
-      throughput: r.throughput,
-      tierDetails: r.tierDetails
-    })),
-    totalDurationMs: results.reduce(
-      (sum, r) => sum + r.totalDurationMs,
-      0
-    )
-  };
-  if (reportPath) {
-    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2) + "\n");
+
+// src/cli-args.ts
+function resolveFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function hasFlag(args, flag) {
+  return args.indexOf(flag) !== -1;
+}
+var TAXONOMY_RESOLVE_BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json"]);
+function stripResolveFlags(args, booleanFlags = TAXONOMY_RESOLVE_BOOLEAN_FLAGS) {
+  const textParts = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith("--")) {
+      if (!booleanFlags.has(args[i])) {
+        i++;
+      }
+      continue;
+    }
+    textParts.push(args[i]);
   }
-  return report;
+  return textParts;
 }
 
-// src/service-candidates.ts
-function firstSuccessfulResult(candidates, attempt) {
-  for (const candidate of candidates) {
-    try {
-      const result = attempt(candidate);
-      if (result !== void 0) return result;
-    } catch {
+// src/parse-connector-config.ts
+function parseConnectorConfig(args) {
+  const config = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--config=")) {
+      const rest = arg.slice("--config=".length);
+      const eqIdx = rest.indexOf("=");
+      if (eqIdx !== -1) {
+        const key = rest.slice(0, eqIdx);
+        const value = rest.slice(eqIdx + 1);
+        if (key) config[key] = value;
+      }
+    } else if (arg === "--config") {
+      const next = args[i + 1];
+      if (next !== void 0) {
+        const eqIdx = next.indexOf("=");
+        if (eqIdx !== -1) {
+          const key = next.slice(0, eqIdx);
+          const value = next.slice(eqIdx + 1);
+          if (key) {
+            config[key] = value;
+            i++;
+          }
+        }
+      }
     }
   }
-  return void 0;
+  return config;
 }
-function firstSuccessfulCandidate(candidates, attempt) {
-  return firstSuccessfulResult(candidates, (candidate) => {
-    attempt(candidate);
-    return candidate;
-  });
+function stripConfigArgv(args) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--config=")) {
+      continue;
+    } else if (arg === "--config") {
+      const next = args[i + 1];
+      if (next !== void 0 && next.includes("=") && !next.startsWith("--")) {
+        i++;
+      }
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
 }
 
 // src/index.ts
+registerPublisher("codex", () => new CodexMemoryExtensionPublisher());
+registerPublisher("claude-code", () => new ClaudeCodeMemoryExtensionPublisher());
+registerPublisher("hermes", () => new HermesMemoryExtensionPublisher());
 function readCompatEnv(primary, legacy) {
   return process.env[primary] ?? process.env[legacy];
 }
-function resolveHomeDir() {
-  return process.env.HOME ?? process.env.USERPROFILE ?? "~";
-}
 var PID_DIR = path2.join(resolveHomeDir(), ".remnic");
 var LEGACY_PID_DIR = path2.join(resolveHomeDir(), ".engram");
 var PID_FILE = path2.join(PID_DIR, "server.pid");
 var LEGACY_PID_FILE = path2.join(LEGACY_PID_DIR, "server.pid");
 var LOG_FILE = path2.join(PID_DIR, "server.log");
 var LEGACY_LOG_FILE = path2.join(LEGACY_PID_DIR, "server.log");
+var CLI_MODULE_DIR = path2.dirname(fileURLToPath(import.meta.url));
+var CLI_REPO_ROOT = path2.resolve(CLI_MODULE_DIR, "../../..");
+var EVAL_RUNNER_PATH = path2.join(CLI_REPO_ROOT, "evals", "run.ts");
+var BENCHMARK_CATALOG = [
+  {
+    id: "ama-bench",
+    title: "AMA-Bench",
+    category: "agentic",
+    summary: "Agent Memory Abilities benchmark for long-horizon agent workflows."
+  },
+  {
+    id: "memory-arena",
+    title: "Memory Arena",
+    category: "agentic",
+    summary: "Interdependent multi-session tasks that stress operational recall."
+  },
+  {
+    id: "amemgym",
+    title: "AMemGym",
+    category: "agentic",
+    summary: "Interactive personalization benchmark for agent memory adaptation."
+  },
+  {
+    id: "longmemeval",
+    title: "LongMemEval",
+    category: "retrieval",
+    summary: "Long-term memory retrieval benchmark across core memory abilities."
+  },
+  {
+    id: "locomo",
+    title: "LoCoMo",
+    category: "conversational",
+    summary: "Long-conversation memory benchmark for persistent dialogue context."
+  }
+];
+var BENCHMARK_IDS = new Set(BENCHMARK_CATALOG.map((entry) => entry.id));
+function getBenchUsageText() {
+  return `Usage: remnic bench <list|run> [options] [benchmark...]
+       remnic benchmark <list|run|check|report> [options] [benchmark...]
+
+Commands:
+  list                     List published benchmark packs
+  run [benchmark...]       Run one or more benchmark packs
+  check                    Legacy latency regression gate (compatibility)
+  report                   Legacy latency report generator (compatibility)
+
+Options:
+  --quick                  Run a lightweight quick pass (maps to --lightweight --limit 1)
+  --all                    Run every published benchmark
+  --dataset-dir <path>     Override the benchmark dataset directory for full runs
+  --json                   Output JSON for \`list\`
+
+Examples:
+  remnic bench list
+  remnic bench run --quick longmemeval
+  remnic bench run longmemeval --dataset-dir ~/datasets/longmemeval
+  remnic benchmark run --quick longmemeval`;
+}
+function buildBenchRunnerArgs(parsed, benchmarkId) {
+  const args = [EVAL_RUNNER_PATH, "--benchmark", benchmarkId];
+  if (parsed.quick) {
+    args.push("--lightweight", "--limit", "1");
+  }
+  if (parsed.datasetDir) {
+    args.push("--dataset-dir", parsed.datasetDir);
+  }
+  return args;
+}
+function coerceBenchCategory(benchmarkId, category) {
+  if (category === "agentic" || category === "retrieval" || category === "conversational") {
+    return category;
+  }
+  return BENCHMARK_CATALOG.find((entry) => entry.id === benchmarkId)?.category ?? "retrieval";
+}
+async function listBenchmarksFromPackage() {
+  const result = await loadBenchDefinitionsFromPackage();
+  if (!result) {
+    return void 0;
+  }
+  return result.map((entry) => ({
+    id: entry.id,
+    title: entry.title ?? entry.id,
+    category: coerceBenchCategory(entry.id, entry.meta?.category),
+    summary: entry.meta?.description ?? ""
+  }));
+}
+async function loadBenchDefinitionsFromPackage() {
+  try {
+    const benchModule = await import("./dist-B67STFFX.js");
+    if (!benchModule.listBenchmarks) return void 0;
+    const result = benchModule.listBenchmarks();
+    return Array.isArray(result) ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function resolveAllBenchmarks() {
+  const packageBenchmarks = await loadBenchDefinitionsFromPackage();
+  if (packageBenchmarks) {
+    return packageBenchmarks.filter((entry) => entry.runnerAvailable).map((entry) => entry.id);
+  }
+  if (!fs.existsSync(EVAL_RUNNER_PATH)) {
+    return [];
+  }
+  return BENCHMARK_CATALOG.map((entry) => entry.id);
+}
+async function resolveKnownBenchmarkIds() {
+  const knownIds = new Set(BENCHMARK_IDS);
+  const packageBenchmarks = await loadBenchDefinitionsFromPackage();
+  if (packageBenchmarks) {
+    for (const benchmark of packageBenchmarks) {
+      knownIds.add(benchmark.id);
+    }
+  }
+  return knownIds;
+}
+async function runBenchViaFallback(parsed, benchmarkId) {
+  if (!fs.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 = [
+    path2.join(CLI_REPO_ROOT, "node_modules", ".bin", "tsx"),
+    path2.join(CLI_REPO_ROOT, "packages", "remnic-cli", "node_modules", ".bin", "tsx")
+  ];
+  const tsxCmd = tsxCandidates.find((candidate) => fs.existsSync(candidate)) ?? "tsx";
+  childProcess.execFileSync(tsxCmd, buildBenchRunnerArgs(parsed, benchmarkId), {
+    stdio: "inherit",
+    env: process.env
+  });
+}
+function resolveBenchOutputDir() {
+  return path2.join(resolveHomeDir(), ".remnic", "bench", "results");
+}
+function resolveBenchDatasetDir(benchmarkId, quick, datasetDirOverride) {
+  if (datasetDirOverride) {
+    return datasetDirOverride;
+  }
+  if (quick) {
+    return void 0;
+  }
+  const repoDatasetDir = path2.join(CLI_REPO_ROOT, "evals", "datasets", benchmarkId);
+  try {
+    return fs.statSync(repoDatasetDir).isDirectory() ? repoDatasetDir : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function printBenchPackageSummary(result, outputPath) {
+  console.log(`Benchmark: ${result.meta.benchmark}`);
+  console.log(`Mode: ${result.meta.mode}`);
+  console.log(`Tasks: ${result.results.tasks.length}`);
+  console.log(`Mean query latency: ${result.cost.meanQueryLatencyMs.toFixed(1)}ms`);
+  for (const [metric, aggregate] of Object.entries(result.results.aggregates).sort()) {
+    console.log(`  ${metric.padEnd(20)} ${aggregate.mean.toFixed(4)}`);
+  }
+  console.log(`Results saved: ${outputPath}`);
+}
+async function runBenchViaPackage(parsed, benchmarkId) {
+  let benchModule;
+  try {
+    benchModule = await import("./dist-B67STFFX.js");
+  } catch {
+    return false;
+  }
+  const definition = benchModule.getBenchmark?.(benchmarkId);
+  if (!definition?.runnerAvailable || !benchModule.runBenchmark || !benchModule.writeBenchmarkResult) {
+    return false;
+  }
+  const createAdapter = parsed.quick ? benchModule.createLightweightAdapter : benchModule.createRemnicAdapter;
+  if (!createAdapter) {
+    return false;
+  }
+  const outputDir = resolveBenchOutputDir();
+  const datasetDir = resolveBenchDatasetDir(
+    benchmarkId,
+    parsed.quick,
+    parsed.datasetDir
+  );
+  if (!parsed.quick && !datasetDir) {
+    throw new Error(
+      `full benchmark runs for "${benchmarkId}" require dataset files. Pass --dataset-dir <path> or run from a Remnic repo checkout with evals/datasets/${benchmarkId}.`
+    );
+  }
+  const system = await createAdapter();
+  try {
+    const result = await benchModule.runBenchmark(benchmarkId, {
+      mode: parsed.quick ? "quick" : "full",
+      datasetDir,
+      outputDir,
+      limit: parsed.quick ? 1 : void 0,
+      adapterMode: parsed.quick ? "lightweight" : "direct",
+      system
+    });
+    const writtenPath = await benchModule.writeBenchmarkResult(result, outputDir);
+    if (parsed.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printBenchPackageSummary(result, writtenPath);
+    }
+    return true;
+  } finally {
+    await system.destroy();
+  }
+}
 function resolveConfigPath(cliPath) {
   if (cliPath) return path2.resolve(cliPath);
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
@@ -330,7 +477,7 @@ function resolveConfigPath(cliPath) {
     path2.join(resolveHomeDir(), ".config", "engram", "config.json")
   ];
   for (const candidate of candidates) {
-    if (fs2.existsSync(candidate)) return candidate;
+    if (fs.existsSync(candidate)) return candidate;
   }
   return path2.join(resolveHomeDir(), ".config", "remnic", "config.json");
 }
@@ -339,24 +486,24 @@ function resolveMemoryDir() {
     const envMemoryDir = readCompatEnv("REMNIC_MEMORY_DIR", "ENGRAM_MEMORY_DIR");
     if (envMemoryDir) return envMemoryDir;
     const configPath = resolveConfigPath();
-    const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+    const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
     const remnicCfg = raw.remnic ?? raw.engram ?? raw;
     if (remnicCfg.memoryDir) return remnicCfg.memoryDir;
     const home = resolveHomeDir();
     const standalonePath = path2.join(home, ".remnic", "memory");
     const legacyStandalonePath = path2.join(home, ".engram", "memory");
     const openclawPath = path2.join(home, ".openclaw", "workspace", "memory", "local");
-    if (fs2.existsSync(standalonePath)) return standalonePath;
-    if (fs2.existsSync(legacyStandalonePath)) return legacyStandalonePath;
+    if (fs.existsSync(standalonePath)) return standalonePath;
+    if (fs.existsSync(legacyStandalonePath)) return legacyStandalonePath;
     return openclawPath;
   })();
   const manifestPath = getManifestPath();
-  if (fs2.existsSync(manifestPath)) {
+  if (fs.existsSync(manifestPath)) {
     try {
       const active = getActiveSpace();
       if (active?.memoryDir) {
-        if (!fs2.existsSync(active.memoryDir)) {
-          fs2.mkdirSync(active.memoryDir, { recursive: true });
+        if (!fs.existsSync(active.memoryDir)) {
+          fs.mkdirSync(active.memoryDir, { recursive: true });
         }
         return active.memoryDir;
       }
@@ -370,23 +517,51 @@ function resolveMemoryDir() {
   }
   return configMemoryDir;
 }
-function resolveFlag(args, flag) {
+function resolveFlagStrict(args, flag) {
   const idx = args.indexOf(flag);
-  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+  if (idx === -1 || idx + 1 >= args.length) return void 0;
+  const next = args[idx + 1];
+  return next.startsWith("-") ? void 0 : next;
 }
-function parseConnectorConfig(args) {
-  const config = {};
-  for (const arg of args) {
-    if (arg.startsWith("--config=")) {
-      const [key, value] = arg.slice("--config=".length).split("=");
-      if (key && value) config[key] = value;
-    }
+var REMNIC_OPENCLAW_PLUGIN_ID = "openclaw-remnic";
+var REMNIC_OPENCLAW_LEGACY_PLUGIN_ID = "openclaw-engram";
+var DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR = [
+  process.env.OPENCLAW_CONFIG_PATH,
+  process.env.OPENCLAW_ENGRAM_CONFIG_PATH,
+  path2.join(resolveHomeDir(), ".openclaw", "openclaw.json")
+].filter(Boolean);
+function resolveOpenclawConfigPath(cliPath) {
+  if (cliPath) return path2.resolve(expandTilde(cliPath));
+  const envPath = process.env.OPENCLAW_CONFIG_PATH || process.env.OPENCLAW_ENGRAM_CONFIG_PATH;
+  if (envPath) return path2.resolve(expandTilde(envPath));
+  for (const candidate of DEFAULT_OPENCLAW_CONFIG_PATHS_FOR_DOCTOR) {
+    if (fs.existsSync(candidate)) return candidate;
   }
-  return config;
+  return path2.join(resolveHomeDir(), ".openclaw", "openclaw.json");
+}
+function readOpenclawConfig(configPath) {
+  if (!fs.existsSync(configPath)) return {};
+  const raw = fs.readFileSync(configPath, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `OpenClaw config at ${configPath} contains invalid JSON \u2014 refusing to overwrite.
+Fix the file manually, then re-run.
+Parse error: ${err.message}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(
+      `OpenClaw config at ${configPath} is not a JSON object (got ${Array.isArray(parsed) ? "array" : typeof parsed}) \u2014 refusing to overwrite.`
+    );
+  }
+  return parsed;
 }
 function cmdInit() {
   const configPath = path2.join(process.cwd(), "remnic.config.json");
-  if (fs2.existsSync(configPath)) {
+  if (fs.existsSync(configPath)) {
     console.log(`Config already exists: ${configPath}`);
     return;
   }
@@ -402,7 +577,7 @@ function cmdInit() {
       authToken: "${REMNIC_AUTH_TOKEN}"
     }
   };
-  fs2.writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
+  fs.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-...");
@@ -448,7 +623,7 @@ async function cmdQuery(queryText, json, explain) {
   }
   initLogger();
   const configPath = resolveConfigPath();
-  const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = raw.remnic ?? raw.engram ?? raw;
   const config = parseConfig(remnicCfg);
   const orchestrator = new Orchestrator(config);
@@ -482,6 +657,503 @@ async function cmdQuery(queryText, json, explain) {
     }
   }
 }
+async function cmdVersions(rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  if (!config.versioningEnabled) {
+    console.error("Page versioning is disabled (versioningEnabled = false).");
+    process.exit(1);
+  }
+  const versioningConfig = {
+    enabled: config.versioningEnabled,
+    maxVersionsPerPage: config.versioningMaxPerPage,
+    sidecarDir: config.versioningSidecarDir
+  };
+  const memDir = resolveMemoryDir();
+  const action = rest[0] ?? "help";
+  const json = rest.includes("--json");
+  switch (action) {
+    case "list": {
+      const pagePath = rest[1];
+      if (!pagePath) {
+        console.error("Usage: remnic versions list <page-path>");
+        process.exit(1);
+      }
+      const absPath = path2.resolve(pagePath);
+      const history = await listVersions(absPath, versioningConfig, memDir);
+      if (json) {
+        console.log(JSON.stringify(history, null, 2));
+      } else {
+        if (history.versions.length === 0) {
+          console.log(`No versions found for ${pagePath}`);
+        } else {
+          console.log(`Versions for ${pagePath} (current: v${history.currentVersion}):
+`);
+          for (const v of history.versions) {
+            const note = v.note ? ` \u2014 ${v.note}` : "";
+            console.log(`  v${v.versionId}  ${v.timestamp}  ${v.trigger}  ${v.sizeBytes} bytes${note}`);
+          }
+        }
+      }
+      break;
+    }
+    case "show": {
+      const pagePath = rest[1];
+      const versionId = rest[2];
+      if (!pagePath || !versionId) {
+        console.error("Usage: remnic versions show <page-path> <version-id>");
+        process.exit(1);
+      }
+      const absPath = path2.resolve(pagePath);
+      try {
+        const content = await getVersion(absPath, versionId, versioningConfig, memDir);
+        console.log(content);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      break;
+    }
+    case "diff": {
+      const pagePath = rest[1];
+      const v1 = rest[2];
+      const v2 = rest[3];
+      if (!pagePath || !v1 || !v2) {
+        console.error("Usage: remnic versions diff <page-path> <v1> <v2>");
+        process.exit(1);
+      }
+      const absPath = path2.resolve(pagePath);
+      try {
+        const diffOutput = await diffVersions(absPath, v1, v2, versioningConfig, memDir);
+        console.log(diffOutput);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      break;
+    }
+    case "revert": {
+      const pagePath = rest[1];
+      const versionId = rest[2];
+      if (!pagePath || !versionId) {
+        console.error("Usage: remnic versions revert <page-path> <version-id>");
+        process.exit(1);
+      }
+      const absPath = path2.resolve(pagePath);
+      try {
+        const version = await revertToVersion(absPath, versionId, versioningConfig, void 0, memDir);
+        if (json) {
+          console.log(JSON.stringify(version, null, 2));
+        } else {
+          console.log(`Reverted ${pagePath} to version ${versionId}.`);
+          console.log(`Created snapshot v${version.versionId} of previous content.`);
+        }
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      console.log(`
+remnic versions \u2014 Page-level versioning
+
+Usage:
+  remnic versions list <page-path>              List all versions of a page
+  remnic versions show <page-path> <id>         Print content of a specific version
+  remnic versions diff <page-path> <v1> <v2>    Show diff between two versions
+  remnic versions revert <page-path> <id>       Revert page to a specific version
+
+Options:
+  --json    Output in JSON format
+`);
+      break;
+  }
+}
+async function cmdEnrich(rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  const subcommand = rest[0];
+  if (subcommand === "audit") {
+    const memoryDir2 = expandTilde(config.memoryDir);
+    const auditDir2 = path2.join(memoryDir2, "enrichment");
+    const sinceFlag = resolveFlag(rest.slice(1), "--since");
+    const entries = await readAuditLog(auditDir2, sinceFlag ?? void 0);
+    if (entries.length === 0) {
+      console.log("No enrichment audit entries found.");
+      return;
+    }
+    for (const entry of entries) {
+      const status = entry.accepted ? "ACCEPTED" : "REJECTED";
+      const url = entry.sourceUrl ? ` (${entry.sourceUrl})` : "";
+      console.log(
+        `[${entry.timestamp}] ${status} ${entry.entityName} via ${entry.provider}: ${entry.candidateText}${url}`
+      );
+    }
+    return;
+  }
+  if (subcommand === "providers") {
+    const pipelineConfig2 = defaultEnrichmentPipelineConfig();
+    pipelineConfig2.enabled = config.enrichmentEnabled;
+    pipelineConfig2.maxCandidatesPerEntity = config.enrichmentMaxCandidatesPerEntity;
+    pipelineConfig2.autoEnrichOnCreate = config.enrichmentAutoOnCreate;
+    pipelineConfig2.providers = [
+      { id: "web-search", enabled: true, costTier: "cheap" }
+    ];
+    const orchestrator2 = new Orchestrator(config);
+    await orchestrator2.initialize();
+    const searchBackend2 = orchestrator2.qmd;
+    const searchFn2 = searchBackend2.isAvailable() ? async (query) => {
+      const results2 = await searchBackend2.search(query, void 0, 10);
+      return results2.map((r) => r.snippet);
+    } : void 0;
+    const registry2 = new EnrichmentProviderRegistry();
+    registry2.register(new WebSearchProvider({ searchFn: searchFn2 }));
+    const allEnabled = registry2.listEnabled(pipelineConfig2);
+    console.log(`Pipeline enabled: ${pipelineConfig2.enabled}`);
+    console.log(`Auto-enrich on create: ${pipelineConfig2.autoEnrichOnCreate}`);
+    console.log(`Max candidates per entity: ${pipelineConfig2.maxCandidatesPerEntity}`);
+    console.log(`
+Registered providers:`);
+    const webSearch = registry2.get("web-search");
+    if (webSearch) {
+      const available = await webSearch.isAvailable();
+      console.log(`  - web-search (${webSearch.costTier}) \u2014 ${available ? "available" : "unavailable (no searchFn configured)"}`);
+    }
+    if (allEnabled.length === 0) {
+      console.log("\n  No providers are currently enabled in config.");
+    }
+    return;
+  }
+  if (!config.enrichmentEnabled) {
+    console.error("Enrichment pipeline is disabled (enrichmentEnabled = false).");
+    process.exit(1);
+  }
+  const dryRun = rest.includes("--dry-run");
+  const all = rest.includes("--all");
+  if (!all && (!subcommand || subcommand.startsWith("--"))) {
+    console.error("Usage: remnic enrich <entity-name> | --all | --dry-run | audit | providers");
+    process.exit(1);
+  }
+  const orchestrator = new Orchestrator(config);
+  await orchestrator.initialize();
+  const storage = await orchestrator.getStorage(config.defaultNamespace);
+  const entityFiles = await storage.readAllEntityFiles();
+  let targets = entityFiles;
+  if (!all && subcommand && !subcommand.startsWith("--")) {
+    const match = entityFiles.find(
+      (e) => e.name.toLowerCase() === subcommand.toLowerCase()
+    );
+    if (!match) {
+      console.error(`Entity not found: ${subcommand}`);
+      process.exit(1);
+    }
+    targets = [match];
+  }
+  if (targets.length === 0) {
+    console.log("No entities to enrich.");
+    return;
+  }
+  const pipelineConfig = defaultEnrichmentPipelineConfig();
+  pipelineConfig.enabled = true;
+  pipelineConfig.maxCandidatesPerEntity = config.enrichmentMaxCandidatesPerEntity;
+  pipelineConfig.providers = [
+    { id: "web-search", enabled: true, costTier: "cheap" }
+  ];
+  pipelineConfig.importanceThresholds = {
+    critical: ["web-search"],
+    high: ["web-search"],
+    normal: ["web-search"],
+    low: []
+  };
+  const searchBackend = orchestrator.qmd;
+  const searchFn = searchBackend.isAvailable() ? async (query) => {
+    const results2 = await searchBackend.search(query, void 0, 10);
+    return results2.map((r) => r.snippet);
+  } : void 0;
+  const registry = new EnrichmentProviderRegistry();
+  registry.register(new WebSearchProvider({ searchFn }));
+  const inputs = targets.map((ef) => ({
+    name: ef.name,
+    type: ef.type,
+    knownFacts: ef.facts,
+    importanceLevel: "normal"
+  }));
+  if (dryRun) {
+    console.log(`Dry run: would enrich ${inputs.length} entity(ies):`);
+    for (const input of inputs) {
+      const providers = registry.getForImportance(input.importanceLevel, pipelineConfig);
+      console.log(`  - ${input.name} (${input.type}) \u2014 ${providers.length} provider(s)`);
+    }
+    return;
+  }
+  console.log(`Enriching ${inputs.length} entity(ies)...`);
+  const noopLog = { info() {
+  }, warn() {
+  }, error() {
+  }, debug() {
+  } };
+  const results = await runEnrichmentPipeline(inputs, registry, pipelineConfig, noopLog);
+  if (results.length === 0) {
+    console.log("No enrichment results (no providers matched).");
+    return;
+  }
+  const memoryDir = expandTilde(config.memoryDir);
+  const auditDir = path2.join(memoryDir, "enrichment");
+  let totalPersisted = 0;
+  for (const result of results) {
+    for (const candidate of result.acceptedCandidates) {
+      let persisted = false;
+      try {
+        await storage.writeMemory(candidate.category, candidate.text, {
+          confidence: candidate.confidence,
+          tags: [...candidate.tags ?? [], "enrichment", candidate.source],
+          entityRef: result.entityName,
+          source: `enrichment:${candidate.source}`
+        });
+        persisted = true;
+        totalPersisted++;
+      } catch (err) {
+        console.error(
+          `  Failed to persist candidate for ${result.entityName}: ${err instanceof Error ? err.message : String(err)}`
+        );
+        try {
+          await appendAuditEntry(auditDir, {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            entityName: result.entityName,
+            provider: result.provider,
+            candidateText: candidate.text,
+            sourceUrl: candidate.sourceUrl,
+            accepted: false,
+            reason: `persist failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        } catch {
+        }
+      }
+      if (persisted) {
+        try {
+          await appendAuditEntry(auditDir, {
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            entityName: result.entityName,
+            provider: result.provider,
+            candidateText: candidate.text,
+            sourceUrl: candidate.sourceUrl,
+            accepted: true
+          });
+        } catch (auditErr) {
+          console.warn(
+            `  Warning: audit write failed for ${result.entityName} (memory was persisted): ${auditErr instanceof Error ? auditErr.message : String(auditErr)}`
+          );
+        }
+      }
+    }
+  }
+  if (totalPersisted > 0 && searchBackend.isAvailable()) {
+    try {
+      await searchBackend.update();
+    } catch {
+    }
+  }
+  for (const result of results) {
+    console.log(
+      `  ${result.entityName} via ${result.provider}: ${result.candidatesAccepted} accepted, ${result.candidatesRejected} rejected (${result.elapsed}ms)`
+    );
+  }
+  if (totalPersisted > 0) {
+    console.log(`
+  ${totalPersisted} candidate(s) persisted to memory store.`);
+  }
+}
+async function cmdExtensions(action, rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  const root = resolveExtensionsRoot(config);
+  const noopLog = { warn: () => {
+  }, debug: () => {
+  } };
+  const warnLog = {
+    warn: (msg) => console.warn(msg),
+    debug: () => {
+    }
+  };
+  switch (action) {
+    case "list": {
+      const extensions = await discoverMemoryExtensions(root, noopLog);
+      if (extensions.length === 0) {
+        console.log("No memory extensions found.");
+        console.log(`  Scanned: ${root}`);
+        return;
+      }
+      console.log(`Memory extensions (${extensions.length}):`);
+      for (const ext of extensions) {
+        const schemaInfo = ext.schema?.version ? ` v${ext.schema.version}` : "";
+        const types = ext.schema?.memoryTypes?.join(", ") ?? "any";
+        console.log(`  ${ext.name}${schemaInfo}  (types: ${types})`);
+      }
+      console.log(`
+Root: ${root}`);
+      break;
+    }
+    case "show": {
+      const name = rest[0];
+      if (!name) {
+        console.error("Usage: remnic extensions show <name>");
+        process.exitCode = 1;
+        return;
+      }
+      const extensions = await discoverMemoryExtensions(root, noopLog);
+      const ext = extensions.find((e) => e.name === name);
+      if (!ext) {
+        console.error(`Extension "${name}" not found in ${root}`);
+        process.exitCode = 1;
+        return;
+      }
+      console.log(ext.instructions);
+      break;
+    }
+    case "validate": {
+      const extensions = await discoverMemoryExtensions(root, warnLog);
+      let entries = [];
+      try {
+        entries = fs.readdirSync(root);
+      } catch {
+        console.log(`Extensions root does not exist: ${root}`);
+        process.exitCode = 0;
+        return;
+      }
+      const validNames = new Set(extensions.map((e) => e.name));
+      let errors = 0;
+      for (const entry of entries) {
+        const entryPath = path2.join(root, entry);
+        try {
+          if (!fs.statSync(entryPath).isDirectory()) continue;
+        } catch {
+          continue;
+        }
+        if (!validNames.has(entry)) {
+          errors++;
+        }
+      }
+      console.log(`Validated: ${extensions.length} valid, ${errors} skipped`);
+      if (errors > 0) {
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "reload": {
+      console.log("Extension cache reloaded (no-op: caching not yet implemented).");
+      break;
+    }
+    default:
+      console.log(`Usage: remnic extensions <list|show|validate|reload>
+
+  list                 List discovered extensions
+  show <name>          Print instructions.md content
+  validate             Validate all extensions, exit non-zero on errors
+  reload               Reserved for future caching (no-op)
+`);
+      break;
+  }
+}
+async function cmdBriefing(rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  if (!config.briefing.enabled) {
+    console.error("Briefing is disabled in config (briefing.enabled = false).");
+    process.exit(1);
+  }
+  const sinceFlag = resolveFlag(rest, "--since");
+  const focusFlag = resolveFlag(rest, "--focus");
+  const formatFlag = resolveFlag(rest, "--format");
+  const save = rest.includes("--save") || config.briefing.saveByDefault;
+  if (hasFlag(rest, "--since") && sinceFlag === void 0) {
+    console.error("Missing value for --since. Accepted: yesterday, today, NNh, NNd, NNw.");
+    process.exit(1);
+  }
+  if (hasFlag(rest, "--format") && formatFlag === void 0) {
+    console.error("Missing value for --format. Accepted: markdown, json.");
+    process.exit(1);
+  }
+  if (hasFlag(rest, "--focus") && (focusFlag === void 0 || focusFlag.startsWith("--"))) {
+    console.error(
+      "Missing value for --focus. Expected: project:<id>, topic:<name>, or person:<id>."
+    );
+    process.exit(1);
+  }
+  const token = sinceFlag ?? config.briefing.defaultWindow;
+  const window = parseBriefingWindow(token);
+  if (!window) {
+    console.error(
+      `Invalid --since value: ${token}. Accepted: yesterday, today, NNh, NNd, NNw.`
+    );
+    process.exit(1);
+  }
+  const rawFocus = typeof focusFlag === "string" ? focusFlag.trim() : "";
+  const focus = rawFocus.length > 0 ? parseBriefingFocus(rawFocus) : null;
+  if (rawFocus.length > 0 && !focus) {
+    console.error(
+      `Invalid --focus value: expected project:<id>, topic:<name>, or person:<id>, got: ${focusFlag}`
+    );
+    process.exit(1);
+  }
+  const jsonFlag = rest.includes("--json");
+  if (jsonFlag && formatFlag !== void 0 && formatFlag !== "json") {
+    console.error(
+      `Conflicting flags: --json and --format ${formatFlag}. Use one or the other.`
+    );
+    process.exit(1);
+  }
+  const effectiveFormatFlag = jsonFlag ? "json" : formatFlag;
+  const formatError = validateBriefingFormat(effectiveFormatFlag);
+  if (formatError) {
+    console.error(formatError);
+    process.exit(1);
+  }
+  const format = effectiveFormatFlag === "json" ? "json" : effectiveFormatFlag === "markdown" ? "markdown" : config.briefing.defaultFormat;
+  const orchestrator = new Orchestrator(config);
+  await orchestrator.initialize();
+  const storage = await orchestrator.getStorage(config.defaultNamespace);
+  const calendarSource = config.briefing.calendarSource ? new FileCalendarSource(config.briefing.calendarSource) : void 0;
+  const result = await buildBriefing({
+    storage,
+    window,
+    focus,
+    namespace: config.defaultNamespace,
+    calendarSource,
+    maxFollowups: config.briefing.maxFollowups,
+    allowLlm: config.briefing.llmFollowups,
+    openaiApiKey: config.openaiApiKey,
+    openaiBaseUrl: config.openaiBaseUrl,
+    model: config.model
+  });
+  const payload = format === "json" ? JSON.stringify(result.json, null, 2) : result.markdown;
+  console.log(payload);
+  if (save) {
+    try {
+      const saveDir = resolveBriefingSaveDir(config.briefing.saveDir);
+      fs.mkdirSync(saveDir, { recursive: true });
+      const filename = briefingFilename(new Date(result.window.to), format);
+      const filePath = path2.join(saveDir, filename);
+      fs.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)}`);
+      process.exit(1);
+    }
+  }
+}
 function cmdDoctor() {
   const checks = [];
   const nodeVersion = process.version;
@@ -492,7 +1164,7 @@ function cmdDoctor() {
     detail: `${nodeVersion} (requires >= 22.12.0)`
   });
   const configPath = resolveConfigPath();
-  const configExists = fs2.existsSync(configPath);
+  const configExists = fs.existsSync(configPath);
   checks.push({ name: "Config file", ok: configExists, detail: configPath });
   const hasApiKey = !!process.env.OPENAI_API_KEY;
   checks.push({
@@ -502,7 +1174,7 @@ function cmdDoctor() {
   });
   const memoryDir = resolveMemoryDir();
   try {
-    fs2.mkdirSync(memoryDir, { recursive: true });
+    fs.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}` });
@@ -513,19 +1185,128 @@ function cmdDoctor() {
     ok: svcState.running,
     detail: svcState.running ? `running${svcState.pid ? ` (pid ${svcState.pid})` : ""}` : "stopped"
   });
+  const openclawConfigPath = resolveOpenclawConfigPath();
+  const openclawConfigExists = fs.existsSync(openclawConfigPath);
+  let openclawConfig = {};
+  let openclawConfigValid = false;
+  if (openclawConfigExists) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(openclawConfigPath, "utf-8"));
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        openclawConfig = parsed;
+        openclawConfigValid = true;
+      } else {
+        openclawConfigValid = false;
+      }
+    } catch {
+      openclawConfigValid = false;
+    }
+  }
+  checks.push({
+    name: "OpenClaw config file",
+    ok: openclawConfigExists && openclawConfigValid,
+    warn: openclawConfigExists && !openclawConfigValid,
+    detail: openclawConfigExists ? openclawConfigValid ? openclawConfigPath : `${openclawConfigPath} (invalid JSON)` : `${openclawConfigPath} (not found)`,
+    remediation: openclawConfigExists && !openclawConfigValid ? "Fix the JSON syntax in your OpenClaw config file." : !openclawConfigExists ? "Run `remnic openclaw install` to create the OpenClaw config with the Remnic entry." : void 0
+  });
+  if (openclawConfigValid) {
+    const rawPlugins = openclawConfig.plugins;
+    const pluginsIsObject = rawPlugins && typeof rawPlugins === "object" && !Array.isArray(rawPlugins);
+    if (!pluginsIsObject && rawPlugins !== void 0) {
+      checks.push({
+        name: "OpenClaw plugins",
+        ok: false,
+        detail: `plugins is ${typeof rawPlugins}, expected object`,
+        remediation: "Run `remnic openclaw install` to recreate the plugins section."
+      });
+    }
+    const plugins = pluginsIsObject ? rawPlugins : {};
+    const entries = plugins.entries && typeof plugins.entries === "object" && !Array.isArray(plugins.entries) ? plugins.entries : null;
+    const slots = plugins.slots && typeof plugins.slots === "object" && !Array.isArray(plugins.slots) ? plugins.slots : null;
+    const entriesIsArray = Array.isArray(plugins.entries);
+    checks.push({
+      name: "OpenClaw plugins.entries",
+      ok: !!entries,
+      detail: entries ? "present" : entriesIsArray ? "invalid (array)" : "missing",
+      remediation: !entries ? "Run `remnic openclaw install` to add the Remnic plugin entry." : void 0
+    });
+    if (entries) {
+      const isValidEntry = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+      const hasNew = REMNIC_OPENCLAW_PLUGIN_ID in entries && isValidEntry(entries[REMNIC_OPENCLAW_PLUGIN_ID]);
+      const hasLegacy = REMNIC_OPENCLAW_LEGACY_PLUGIN_ID in entries && isValidEntry(entries[REMNIC_OPENCLAW_LEGACY_PLUGIN_ID]);
+      const keyExistsButMalformed = REMNIC_OPENCLAW_PLUGIN_ID in entries && !hasNew || REMNIC_OPENCLAW_LEGACY_PLUGIN_ID in entries && !hasLegacy;
+      checks.push({
+        name: "OpenClaw plugin entry",
+        ok: hasNew,
+        warn: !hasNew && hasLegacy || keyExistsButMalformed,
+        detail: hasNew ? `${REMNIC_OPENCLAW_PLUGIN_ID} entry found` : hasLegacy ? `only legacy ${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID} entry found (upgrade recommended)` : keyExistsButMalformed ? "entry key exists but value is not a valid object" : "no Remnic entry found",
+        remediation: keyExistsButMalformed ? "Run `remnic openclaw install` to recreate the Remnic plugin entry with correct structure." : !hasNew && hasLegacy ? `Run \`remnic openclaw install\` to migrate from the legacy ${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID} to ${REMNIC_OPENCLAW_PLUGIN_ID}.` : !hasNew ? "Run `remnic openclaw install` to add the Remnic plugin entry." : void 0
+      });
+      const slotValue = slots?.memory;
+      const validEntryIds = Object.keys(entries);
+      const slotMissing = !slotValue;
+      const slotMismatch = !slotMissing && !validEntryIds.includes(slotValue);
+      const slotMatchesEntry = !slotMissing && !slotMismatch;
+      const slotIsLegacy = slotMatchesEntry && slotValue === REMNIC_OPENCLAW_LEGACY_PLUGIN_ID;
+      const slotIsPreferred = slotMatchesEntry && slotValue === REMNIC_OPENCLAW_PLUGIN_ID;
+      checks.push({
+        name: "OpenClaw plugins.slots.memory",
+        ok: slotMatchesEntry,
+        warn: slotMatchesEntry && !slotIsPreferred,
+        detail: slotMissing ? "(unset)" : slotMismatch ? `"${slotValue}" (not found in entries: ${validEntryIds.join(", ")})` : `"${slotValue}"`,
+        remediation: slotMissing ? `Run \`remnic openclaw install\` to set plugins.slots.memory = "${REMNIC_OPENCLAW_PLUGIN_ID}". Without this, hooks never fire.` : slotMismatch ? `plugins.slots.memory = "${slotValue}" but no matching entry exists. Run \`remnic openclaw install\` to fix.` : slotIsLegacy ? `Slot is set to the legacy id "${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}". Run \`remnic openclaw install\` to migrate to "${REMNIC_OPENCLAW_PLUGIN_ID}" (optional \u2014 hooks fire with either id while the legacy entry is present).` : slotMatchesEntry && !slotIsPreferred && !slotIsLegacy ? `plugins.slots.memory = "${slotValue}" points to another plugin. Run \`remnic openclaw install\` to set it to "${REMNIC_OPENCLAW_PLUGIN_ID}".` : void 0
+      });
+      const activeSlotEntry = slotValue ? entries[slotValue] : void 0;
+      const entryToCheck = activeSlotEntry ?? entries[REMNIC_OPENCLAW_PLUGIN_ID] ?? entries[REMNIC_OPENCLAW_LEGACY_PLUGIN_ID];
+      const entryConfig = entryToCheck?.config && typeof entryToCheck.config === "object" ? entryToCheck.config : null;
+      const rawMemoryDir = entryConfig?.memoryDir;
+      const configuredMemoryDir = typeof rawMemoryDir === "string" ? rawMemoryDir : void 0;
+      if (configuredMemoryDir) {
+        const resolvedMemDir = path2.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 (fs.existsSync(resolvedMemDir)) {
+          try {
+            const stat = fs.statSync(resolvedMemDir);
+            if (stat.isDirectory()) {
+              memDirOk = true;
+              memDirDetail = resolvedMemDir;
+              memDirRemediation = void 0;
+            } else {
+              memDirDetail = `${resolvedMemDir} (exists but is not a directory)`;
+              memDirRemediation = `Remove the file at ${resolvedMemDir} and run \`remnic openclaw install --memory-dir "${resolvedMemDir}"\` to create it as a directory.`;
+            }
+          } catch {
+            memDirDetail = `${resolvedMemDir} (cannot stat)`;
+          }
+        }
+        checks.push({
+          name: "OpenClaw memoryDir",
+          ok: memDirOk,
+          warn: !memDirOk,
+          detail: memDirDetail,
+          remediation: memDirRemediation
+        });
+      }
+    }
+  }
   for (const check of checks) {
-    const icon = check.ok ? "\u2713" : "\u2717";
+    const icon = check.ok ? check.warn ? "\u26A0" : "\u2713" : check.warn ? "\u26A0" : "\u2717";
     console.log(`  ${icon} ${check.name}: ${check.detail}`);
+    if ((!check.ok || check.warn) && check.remediation) {
+      console.log(`      \u2192 ${check.remediation}`);
+    }
   }
 }
 function cmdConfig() {
   const configPath = resolveConfigPath();
-  if (!fs2.existsSync(configPath)) {
+  if (!fs.existsSync(configPath)) {
     console.log("No config file found. Run `remnic init` to create one.");
     return;
   }
   console.log(`Config: ${configPath}`);
-  const rawConfig = fs2.readFileSync(configPath, "utf8");
+  const rawConfig = fs.readFileSync(configPath, "utf8");
   const redacted = rawConfig.replace(
     /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
     "$1[REDACTED]$3"
@@ -689,7 +1470,8 @@ function cmdDedup(json) {
   console.log(`Duration: ${result.durationMs}ms`);
 }
 async function cmdConnectors(action, rest, json) {
-  const nonFlagArgs = rest.filter((a) => !a.startsWith("--"));
+  const strippedRest = stripConfigArgv(rest);
+  const nonFlagArgs = strippedRest.filter((a) => !a.startsWith("--"));
   const connectorId = nonFlagArgs[0];
   if (action === "list") {
     const { installed, available } = listConnectors();
@@ -707,40 +1489,211 @@ async function cmdConnectors(action, rest, json) {
       console.error("Usage: remnic connectors install <id>");
       process.exit(1);
     }
+    const connectorConfig = parseConnectorConfig(rest);
     const result = installConnector({
       connectorId,
-      config: parseConnectorConfig(rest),
+      config: connectorConfig,
       force: rest.includes("--force")
     });
+    if (result.status === "error") {
+      console.error(result.message);
+      process.exit(1);
+    }
     console.log(result.message);
     if (result.configPath) console.log(`  Config: ${result.configPath}`);
     if (result.status === "already_installed") console.log("Use --force to reinstall.");
     if (result.status === "config_required") console.log("Set config with --config <key>=<value>");
-    if (result.status === "error") console.error(`Error: ${result.message}`);
+    if (result.status === "installed") {
+      const pub = publisherForConnector(connectorId);
+      if (pub) {
+        try {
+          const available = await pub.isHostAvailable();
+          if (available) {
+            const memoryDir = resolveMemoryDir();
+            const connectorNamespace = typeof connectorConfig?.namespace === "string" && connectorConfig.namespace.length > 0 ? connectorConfig.namespace : void 0;
+            const pubResult = await pub.publish({
+              config: { memoryDir, namespace: connectorNamespace },
+              skillsRoot: path2.join(memoryDir, "skills"),
+              log: { info: console.log, warn: console.warn, error: console.error }
+            });
+            if (pubResult.filesWritten.length > 0) {
+              console.log(`  Published memory extension to ${pubResult.extensionRoot}`);
+            }
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          console.warn(`  Warning: memory extension publish failed: ${msg}`);
+        }
+      }
+    }
   } else if (action === "remove") {
     if (!connectorId) {
       console.error("Usage: remnic connectors remove <id>");
       process.exit(1);
     }
     const result = removeConnector(connectorId);
+    if (result.status === "error") {
+      console.error(result.message);
+      process.exit(1);
+    }
     console.log(result.message);
+    if (result.status === "skipped" && result.reason === "config-parse-failed") {
+      console.error(
+        `Error: removal skipped because the connector config could not be parsed. Fix or delete the config file at ${result.configPath} manually and retry.`
+      );
+      process.exit(1);
+    }
   } else if (action === "doctor") {
     if (!connectorId) {
       console.error("Usage: remnic connectors doctor <id>");
       process.exit(1);
     }
     const result = await doctorConnector(connectorId);
+    const publisherChecks = [];
+    const targetHostId = hostIdForConnector(connectorId);
+    const factory = PUBLISHERS[targetHostId];
+    const connectorInstance = listConnectors().installed.find(
+      (c) => c.connectorId === connectorId
+    );
+    const savedInstallExt = connectorInstance ? coerceInstallExtension(connectorInstance.config.installExtension) : void 0;
+    const extensionOptedOut = savedInstallExt === false;
+    if (factory) {
+      if (extensionOptedOut) {
+        publisherChecks.push({
+          name: `Publisher: ${targetHostId}`,
+          ok: true,
+          detail: "skipped (installExtension=false)"
+        });
+      } else {
+        try {
+          const pub = factory();
+          const available = await pub.isHostAvailable();
+          const extRoot = available ? await pub.resolveExtensionRoot() : "(host not installed)";
+          const extensionExists = available && extRoot ? fs.existsSync(extRoot) : false;
+          publisherChecks.push({
+            name: `Publisher: ${targetHostId}`,
+            ok: !available || extensionExists,
+            detail: !available ? "host not installed (skip)" : extensionExists ? `extension at ${extRoot}` : `extension missing at ${extRoot} \u2014 run \`remnic connectors install ${connectorId}\``
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          publisherChecks.push({
+            name: `Publisher: ${targetHostId}`,
+            ok: false,
+            detail: `error: ${msg}`
+          });
+        }
+      }
+    }
+    const allChecks = [...result.checks, ...publisherChecks];
+    const healthy = allChecks.every((c) => c.ok);
     if (json) {
-      console.log(JSON.stringify(result, null, 2));
+      console.log(JSON.stringify({ ...result, checks: allChecks, healthy }, null, 2));
     } else {
-      for (const check of result.checks) {
+      for (const check of allChecks) {
         const icon = check.ok ? "\u2713" : "\u2717";
         console.log(`  ${icon} ${check.name}: ${check.detail}`);
       }
-      console.log(result.healthy ? "\nConnector healthy" : "\nConnector has issues");
+      console.log(healthy ? "\nConnector healthy" : "\nConnector has issues");
+    }
+  } else if (action === "marketplace") {
+    const subAction = nonFlagArgs[0];
+    let subActionRemoved = false;
+    const marketplaceRest = rest.filter((a) => {
+      if (!subActionRemoved && a === subAction) {
+        subActionRemoved = true;
+        return false;
+      }
+      return true;
+    });
+    await cmdConnectorsMarketplace(subAction, marketplaceRest, json);
+  } else {
+    console.log("Usage: remnic connectors <list|install|remove|doctor|marketplace> [id]");
+    process.exit(1);
+  }
+}
+async function cmdConnectorsMarketplace(subAction, rest, json) {
+  const configPath = resolveConfigPath(resolveFlagStrict(rest, "--config"));
+  const rawConfig = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const pluginConfig = rawConfig.remnic ?? rawConfig.engram ?? rawConfig;
+  const config = parseConfig(pluginConfig);
+  if (subAction === "generate") {
+    const outputDir = resolveFlagStrict(rest, "--output") ?? process.cwd();
+    const manifest = generateMarketplaceManifest();
+    await writeMarketplaceManifest(outputDir, manifest);
+    const outPath = path2.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] ?? path2.join(process.cwd(), "marketplace.json");
+    const resolved = path2.resolve(targetPath);
+    if (!fs.existsSync(resolved)) {
+      console.error(`File not found: ${resolved}`);
+      process.exit(1);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(resolved, "utf8"));
+    } catch {
+      console.error(`Invalid JSON in ${resolved}`);
+      process.exit(1);
+    }
+    const validation = checkMarketplaceManifest(parsed);
+    if (json) {
+      console.log(JSON.stringify(validation, null, 2));
+    }
+    if (validation.valid) {
+      if (!json) console.log(`Valid marketplace manifest: ${resolved}`);
+    } else {
+      if (!json) {
+        console.error(`Invalid marketplace manifest: ${resolved}`);
+        for (const err of validation.errors) {
+          console.error(`  - ${err}`);
+        }
+      }
+      process.exit(1);
+    }
+  } else if (subAction === "install") {
+    const source = rest.filter((a) => !a.startsWith("--"))[0];
+    if (!source) {
+      console.error("Usage: remnic connectors marketplace install <source> [--type github|git|local|url]");
+      process.exit(1);
+    }
+    const validTypes = /* @__PURE__ */ new Set(["github", "git", "local", "url"]);
+    const hasTypeFlag = rest.includes("--type");
+    const typeFlag = resolveFlagStrict(rest, "--type") ?? (hasTypeFlag ? void 0 : "github");
+    if (typeFlag === void 0) {
+      console.error(`--type requires a value. Must be one of: ${[...validTypes].join(", ")}`);
+      process.exit(1);
+    }
+    if (!validTypes.has(typeFlag)) {
+      console.error(`Invalid --type: "${typeFlag}". Must be one of: ${[...validTypes].join(", ")}`);
+      process.exit(1);
+    }
+    const result = await installFromMarketplace(
+      source,
+      typeFlag,
+      config
+    );
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(result.message);
+      if (result.pluginsFound.length > 0) {
+        console.log(`  Plugins: ${result.pluginsFound.join(", ")}`);
+      }
     }
+    if (!result.ok) process.exit(1);
   } else {
-    console.log("Usage: remnic connectors <list|install|remove|doctor> [id]");
+    console.log(`Usage: remnic connectors marketplace <generate|validate|install> [args]
+
+  generate [--output <dir>]            Generate marketplace.json
+  validate [path]                      Validate a marketplace.json file
+  install <source> [--type <type>]     Install from marketplace source
+                                       Types: github, git, local, url (default: github)`);
     process.exit(1);
   }
 }
@@ -880,10 +1833,10 @@ async function cmdSpace(action, rest, json) {
     process.exit(1);
   }
 }
-async function cmdBenchmark(action, rest, json) {
+async function cmdLegacyBenchmark(action, rest, json) {
   initLogger();
   const configPath = resolveConfigPath();
-  const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
   const remnicCfg = raw.remnic ?? raw.engram ?? raw;
   const config = parseConfig(remnicCfg);
   const orchestrator = new Orchestrator(config);
@@ -955,6 +1908,55 @@ async function cmdBenchmark(action, rest, json) {
     process.exit(1);
   }
 }
+async function cmdBench(rest) {
+  const benchAction = parseBenchActionArgs(rest);
+  let parsed;
+  try {
+    parsed = parseBenchArgs(rest);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (parsed.action === "help") {
+    console.log(getBenchUsageText());
+    return;
+  }
+  if (parsed.action === "check" || parsed.action === "report") {
+    await cmdLegacyBenchmark(parsed.action, benchAction.args, parsed.json);
+    return;
+  }
+  if (parsed.action === "list") {
+    const catalog = await listBenchmarksFromPackage() ?? BENCHMARK_CATALOG;
+    if (parsed.json) {
+      console.log(JSON.stringify(catalog, null, 2));
+      return;
+    }
+    console.log("Published benchmarks:");
+    for (const entry of catalog) {
+      console.log(`  ${entry.id.padEnd(14)} ${entry.category.padEnd(14)} ${entry.summary}`);
+    }
+    return;
+  }
+  const selectedBenchmarks = parsed.all ? await resolveAllBenchmarks() : parsed.benchmarks;
+  if (selectedBenchmarks.length === 0) {
+    console.error(
+      parsed.all ? "ERROR: no runnable benchmarks are available for --all in this install. Use 'remnic bench list' to inspect the catalog." : "ERROR: specify benchmark name(s) or --all. Use 'remnic bench list' to see available."
+    );
+    process.exit(1);
+  }
+  const knownBenchmarkIds = await resolveKnownBenchmarkIds();
+  const unknown = selectedBenchmarks.filter((benchmarkId) => !knownBenchmarkIds.has(benchmarkId));
+  if (unknown.length > 0) {
+    console.error(`ERROR: unknown benchmark(s): ${unknown.join(", ")}. Use 'remnic bench list' to see available.`);
+    process.exit(1);
+  }
+  for (const benchmarkId of selectedBenchmarks) {
+    const handledByPackage = await runBenchViaPackage(parsed, benchmarkId);
+    if (!handledByPackage) {
+      await runBenchViaFallback(parsed, benchmarkId);
+    }
+  }
+}
 var LOGS_DIR = path2.join(PID_DIR, "logs");
 var LAUNCHD_LABEL = "ai.remnic.daemon";
 var LEGACY_LAUNCHD_LABEL = "ai.engram.daemon";
@@ -989,7 +1991,7 @@ var LEGACY_SYSTEMD_UNIT_PATH = path2.join(
 function readPid() {
   for (const file of [PID_FILE, LEGACY_PID_FILE]) {
     try {
-      return parseInt(fs2.readFileSync(file, "utf8").trim(), 10);
+      return parseInt(fs.readFileSync(file, "utf8").trim(), 10);
     } catch {
     }
   }
@@ -998,7 +2000,7 @@ function readPid() {
 function inferPort() {
   try {
     const configPath = resolveConfigPath();
-    const raw = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+    const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
     return raw.server?.port ?? 4318;
   } catch {
     return 4318;
@@ -1009,7 +2011,7 @@ function resolveNodePath() {
 }
 function resolveServerBin() {
   const distPath = path2.resolve(import.meta.dirname, "../../remnic-server/dist/index.js");
-  if (fs2.existsSync(distPath)) return distPath;
+  if (fs.existsSync(distPath)) return distPath;
   const srcPath = path2.resolve(import.meta.dirname, "../../remnic-server/src/index.ts");
   return srcPath;
 }
@@ -1037,13 +2039,13 @@ function daemonInstall() {
     process.exit(1);
   }
   const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
-  fs2.mkdirSync(LOGS_DIR, { recursive: true });
+  fs.mkdirSync(LOGS_DIR, { recursive: true });
   if (isMacOS()) {
     const templatePath = path2.resolve(import.meta.dirname, "../templates/launchd/ai.remnic.daemon.plist");
-    const template = fs2.readFileSync(templatePath, "utf8");
+    const template = fs.readFileSync(templatePath, "utf8");
     const plist = renderTemplate(template, vars);
-    fs2.mkdirSync(path2.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
-    fs2.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    fs.mkdirSync(path2.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs.writeFileSync(LAUNCHD_PLIST_PATH, plist);
     try {
       childProcess.execSync(`launchctl load -w "${LAUNCHD_PLIST_PATH}"`, { stdio: "pipe" });
     } catch {
@@ -1054,10 +2056,10 @@ function daemonInstall() {
     console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
   } else if (isLinux()) {
     const templatePath = path2.resolve(import.meta.dirname, "../templates/systemd/remnic.service");
-    const template = fs2.readFileSync(templatePath, "utf8");
+    const template = fs.readFileSync(templatePath, "utf8");
     const unit = renderTemplate(template, vars);
-    fs2.mkdirSync(path2.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
-    fs2.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    fs.mkdirSync(path2.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs.writeFileSync(SYSTEMD_UNIT_PATH, unit);
     try {
       childProcess.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
       childProcess.execSync(`systemctl --user enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
@@ -1081,7 +2083,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs2.unlinkSync(plistPath);
+        fs.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -1101,7 +2103,7 @@ function daemonUninstall() {
     let removed = false;
     for (const unitPath of [SYSTEMD_UNIT_PATH, LEGACY_SYSTEMD_UNIT_PATH]) {
       try {
-        fs2.unlinkSync(unitPath);
+        fs.unlinkSync(unitPath);
         removed = true;
         console.log(`Removed systemd service: ${unitPath}`);
       } catch {
@@ -1159,17 +2161,36 @@ function isServiceRunning() {
   }
   return { running: false };
 }
-function daemonStatus() {
+async function daemonStatus() {
   const { running, pid } = isServiceRunning();
   const port = inferPort();
-  const serviceInstalled = isMacOS() ? fs2.existsSync(LAUNCHD_PLIST_PATH) || fs2.existsSync(LEGACY_LAUNCHD_PLIST_PATH) : isLinux() ? fs2.existsSync(SYSTEMD_UNIT_PATH) || fs2.existsSync(LEGACY_SYSTEMD_UNIT_PATH) : false;
+  const serviceInstalled = isMacOS() ? fs.existsSync(LAUNCHD_PLIST_PATH) || fs.existsSync(LEGACY_LAUNCHD_PLIST_PATH) : isLinux() ? fs.existsSync(SYSTEMD_UNIT_PATH) || fs.existsSync(LEGACY_SYSTEMD_UNIT_PATH) : false;
   console.log(`Remnic daemon status:`);
   console.log(`  Running:   ${running ? `yes${pid ? ` (pid ${pid})` : ""}` : "no"}`);
   console.log(`  Port:      ${port}`);
   console.log(`  Service:   ${serviceInstalled ? "installed" : "not installed"}`);
   console.log(`  Platform:  ${process.platform}`);
-  console.log(`  PID file:  ${fs2.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
-  console.log(`  Log file:  ${fs2.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  console.log(`  PID file:  ${fs.existsSync(PID_FILE) ? PID_FILE : LEGACY_PID_FILE}`);
+  console.log(`  Log file:  ${fs.existsSync(LOG_FILE) ? LOG_FILE : LEGACY_LOG_FILE}`);
+  try {
+    const configPath = resolveConfigPath();
+    const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+    const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+    const config = parseConfig(remnicCfg);
+    const extRoot = resolveExtensionsRoot(config);
+    const noopLog = { warn: () => {
+    }, debug: () => {
+    } };
+    const exts = await discoverMemoryExtensions(extRoot, noopLog);
+    if (exts.length > 0) {
+      const names = exts.map((e) => e.name).join(", ");
+      console.log(`  Memory extensions: ${exts.length} active (${names})`);
+    } else {
+      console.log(`  Memory extensions: none`);
+    }
+  } catch {
+    console.log(`  Memory extensions: unknown (config error)`);
+  }
 }
 function daemonStart() {
   const svc = isServiceRunning();
@@ -1177,7 +2198,7 @@ function daemonStart() {
     console.log(`Already running${svc.pid ? ` (pid ${svc.pid})` : " (via service manager)"}`);
     return;
   }
-  if (isMacOS() && (fs2.existsSync(LAUNCHD_PLIST_PATH) || fs2.existsSync(LEGACY_LAUNCHD_PLIST_PATH))) {
+  if (isMacOS() && (fs.existsSync(LAUNCHD_PLIST_PATH) || fs.existsSync(LEGACY_LAUNCHD_PLIST_PATH))) {
     const label = firstSuccessfulCandidate([LAUNCHD_LABEL, LEGACY_LAUNCHD_LABEL], (candidate) => {
       childProcess.execSync(`launchctl start ${candidate} 2>/dev/null`, { stdio: "pipe" });
     });
@@ -1185,7 +2206,7 @@ function daemonStart() {
       console.log(`Started remnic daemon via launchd (${label})`);
       return;
     }
-  } else if (isLinux() && (fs2.existsSync(SYSTEMD_UNIT_PATH) || fs2.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
+  } else if (isLinux() && (fs.existsSync(SYSTEMD_UNIT_PATH) || fs.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
     const serviceName = firstSuccessfulCandidate([SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE], (candidate) => {
       childProcess.execSync(`systemctl --user start ${candidate}`, { stdio: "pipe" });
     });
@@ -1194,9 +2215,9 @@ function daemonStart() {
       return;
     }
   }
-  fs2.mkdirSync(PID_DIR, { recursive: true });
-  fs2.mkdirSync(LOGS_DIR, { recursive: true });
-  const logStream = fs2.openSync(LOG_FILE, "a");
+  fs.mkdirSync(PID_DIR, { recursive: true });
+  fs.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs.openSync(LOG_FILE, "a");
   const serverBin = resolveServerBin();
   const isSource = serverBin.endsWith(".ts");
   let cmd;
@@ -1218,12 +2239,12 @@ function daemonStart() {
     }
   });
   child.unref();
-  fs2.writeFileSync(PID_FILE, String(child.pid));
+  fs.writeFileSync(PID_FILE, String(child.pid));
   console.log(`Started remnic server (pid ${child.pid})`);
   console.log(`  Log: ${LOG_FILE}`);
 }
 function daemonStop() {
-  if (isMacOS() && (fs2.existsSync(LAUNCHD_PLIST_PATH) || fs2.existsSync(LEGACY_LAUNCHD_PLIST_PATH))) {
+  if (isMacOS() && (fs.existsSync(LAUNCHD_PLIST_PATH) || fs.existsSync(LEGACY_LAUNCHD_PLIST_PATH))) {
     const label = firstSuccessfulCandidate([LAUNCHD_LABEL, LEGACY_LAUNCHD_LABEL], (candidate) => {
       childProcess.execSync(`launchctl stop ${candidate} 2>/dev/null`, { stdio: "pipe" });
     });
@@ -1231,7 +2252,7 @@ function daemonStop() {
       console.log(`Stopped remnic daemon via launchd (${label})`);
       return;
     }
-  } else if (isLinux() && (fs2.existsSync(SYSTEMD_UNIT_PATH) || fs2.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
+  } else if (isLinux() && (fs.existsSync(SYSTEMD_UNIT_PATH) || fs.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
     const serviceName = firstSuccessfulCandidate([SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE], (candidate) => {
       childProcess.execSync(`systemctl --user stop ${candidate}`, { stdio: "pipe" });
     });
@@ -1252,11 +2273,11 @@ function daemonStop() {
     console.log("Process not found (cleaning up PID file)");
   }
   try {
-    fs2.unlinkSync(PID_FILE);
+    fs.unlinkSync(PID_FILE);
   } catch {
   }
   try {
-    fs2.unlinkSync(LEGACY_PID_FILE);
+    fs.unlinkSync(LEGACY_PID_FILE);
   } catch {
   }
 }
@@ -1304,6 +2325,470 @@ function cmdTokenRevoke(connector) {
     console.log(`No token found for ${connector}`);
   }
 }
+async function promptYesNo(question, defaultYes = true) {
+  if (!process.stdin.isTTY) return defaultYes;
+  process.stdout.write(question + " ");
+  return new Promise((resolve) => {
+    let buf = "";
+    const cleanup = () => {
+      process.stdin.removeListener("data", onData);
+      process.stdin.removeListener("end", onEnd);
+      process.stdin.removeListener("close", onEnd);
+      process.stdin.pause();
+    };
+    const onEnd = () => {
+      cleanup();
+      resolve(defaultYes);
+    };
+    const onData = (chunk) => {
+      buf += chunk.toString();
+      const nl = buf.indexOf("\n");
+      if (nl >= 0) {
+        cleanup();
+        const answer = buf.slice(0, nl).trim().toLowerCase();
+        if (answer === "" || answer === "y" || answer === "yes") {
+          resolve(defaultYes || answer !== "");
+        } else if (answer === "n" || answer === "no") {
+          resolve(false);
+        } else {
+          resolve(defaultYes);
+        }
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+    process.stdin.on("end", onEnd);
+    process.stdin.on("close", onEnd);
+  });
+}
+async function cmdBinary(rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  const memoryDir = resolveMemoryDir();
+  const blConfig = {
+    enabled: config.binaryLifecycleEnabled,
+    gracePeriodDays: config.binaryLifecycleGracePeriodDays,
+    maxBinarySizeBytes: DEFAULT_MAX_BINARY_SIZE_BYTES,
+    scanPatterns: DEFAULT_SCAN_PATTERNS,
+    backend: {
+      type: config.binaryLifecycleBackendType,
+      basePath: config.binaryLifecycleBackendPath ? expandTilde(config.binaryLifecycleBackendPath) : void 0
+    }
+  };
+  const action = rest[0] ?? "help";
+  switch (action) {
+    case "scan": {
+      const manifest = await readManifest(memoryDir);
+      const { scanForBinaries } = await import("@remnic/core");
+      const found = await scanForBinaries(memoryDir, blConfig, manifest);
+      if (found.length === 0) {
+        console.log("No untracked binary files found.");
+      } else {
+        console.log(`Found ${found.length} untracked binary file(s):`);
+        for (const p of found) {
+          console.log(`  ${p}`);
+        }
+      }
+      break;
+    }
+    case "status": {
+      const manifest = await readManifest(memoryDir);
+      const counts = {
+        total: manifest.assets.length,
+        pending: manifest.assets.filter((a) => a.status === "pending").length,
+        mirrored: manifest.assets.filter((a) => a.status === "mirrored").length,
+        redirected: manifest.assets.filter((a) => a.status === "redirected").length,
+        cleaned: manifest.assets.filter((a) => a.status === "cleaned").length,
+        error: manifest.assets.filter((a) => a.status === "error").length
+      };
+      const totalBytes = manifest.assets.reduce((sum, a) => sum + a.sizeBytes, 0);
+      console.log(`Binary lifecycle manifest (${memoryDir}):`);
+      console.log(`  Total assets:  ${counts.total}`);
+      console.log(`  Pending:       ${counts.pending}`);
+      console.log(`  Mirrored:      ${counts.mirrored}`);
+      console.log(`  Redirected:    ${counts.redirected}`);
+      console.log(`  Cleaned:       ${counts.cleaned}`);
+      console.log(`  Errors:        ${counts.error}`);
+      console.log(`  Total size:    ${(totalBytes / 1024).toFixed(1)} KB`);
+      if (manifest.lastScanAt) {
+        console.log(`  Last scan:     ${manifest.lastScanAt}`);
+      }
+      break;
+    }
+    case "run": {
+      const dryRun = rest.includes("--dry-run");
+      const backend = createBackend(blConfig.backend);
+      const log = {
+        info: (msg) => console.log(msg),
+        warn: (msg) => console.warn(msg),
+        error: (msg) => console.error(msg)
+      };
+      const result = await runBinaryLifecyclePipeline(
+        memoryDir,
+        blConfig,
+        backend,
+        log,
+        { dryRun }
+      );
+      console.log(
+        `
+Pipeline complete${dryRun ? " (dry-run)" : ""}: scanned=${result.scanned}, mirrored=${result.mirrored}, redirected=${result.redirected}, cleaned=${result.cleaned}`
+      );
+      if (result.errors.length > 0) {
+        console.error(`Errors (${result.errors.length}):`);
+        for (const e of result.errors) console.error(`  ${e}`);
+      }
+      break;
+    }
+    case "clean": {
+      const force = rest.includes("--force");
+      if (!force) {
+        console.error("Use --force to confirm cleanup of local binary copies.");
+        process.exit(1);
+      }
+      const backend = createBackend(blConfig.backend);
+      const log = {
+        info: (msg) => console.log(msg),
+        warn: (msg) => console.warn(msg),
+        error: (msg) => console.error(msg)
+      };
+      const result = await runBinaryLifecyclePipeline(
+        memoryDir,
+        blConfig,
+        backend,
+        log,
+        { forceClean: true }
+      );
+      console.log(
+        `
+Clean complete: cleaned=${result.cleaned}`
+      );
+      if (result.errors.length > 0) {
+        console.error(`Errors (${result.errors.length}):`);
+        for (const e of result.errors) console.error(`  ${e}`);
+      }
+      break;
+    }
+    default:
+      console.log(`Usage: remnic binary <scan|status|run|clean>
+
+  scan               Scan for untracked binary files
+  status             Show binary lifecycle manifest summary
+  run [--dry-run]    Run full binary lifecycle pipeline
+  clean --force      Force-clean local copies past grace period`);
+      break;
+  }
+}
+async function cmdOpenclawInstall(opts) {
+  const configPath = resolveOpenclawConfigPath(opts.configPath);
+  const fallbackMemoryDir = path2.join(resolveHomeDir(), ".openclaw", "workspace", "memory", "local");
+  console.log(`OpenClaw config: ${configPath}`);
+  const existingConfig = readOpenclawConfig(configPath);
+  const rawPlugins = existingConfig.plugins;
+  if (rawPlugins !== void 0 && (typeof rawPlugins !== "object" || rawPlugins === null || Array.isArray(rawPlugins))) {
+    throw new Error(
+      `OpenClaw config at ${configPath} has an invalid plugins field (expected an object, got ${Array.isArray(rawPlugins) ? "array" : typeof rawPlugins}). Fix the file manually and re-run.`
+    );
+  }
+  const plugins = rawPlugins ?? {};
+  const rawEntries = plugins.entries;
+  if (rawEntries !== void 0 && (typeof rawEntries !== "object" || rawEntries === null || Array.isArray(rawEntries))) {
+    throw new Error(
+      `OpenClaw config at ${configPath} has an invalid plugins.entries field (expected an object, got ${Array.isArray(rawEntries) ? "array" : typeof rawEntries}). Fix the file manually and re-run.`
+    );
+  }
+  const entries = rawEntries ?? {};
+  const rawSlots = plugins.slots;
+  if (rawSlots !== void 0 && (typeof rawSlots !== "object" || rawSlots === null || Array.isArray(rawSlots))) {
+    throw new Error(
+      `OpenClaw config at ${configPath} has an invalid plugins.slots field (expected an object, got ${Array.isArray(rawSlots) ? "array" : typeof rawSlots}). Fix the file manually and re-run.`
+    );
+  }
+  const slots = rawSlots ?? {};
+  const hasLegacy = REMNIC_OPENCLAW_LEGACY_PLUGIN_ID in entries;
+  const hasNew = REMNIC_OPENCLAW_PLUGIN_ID in entries;
+  const currentSlot = slots.memory;
+  let migrateLegacy = false;
+  if (hasLegacy && !opts.yes) {
+    migrateLegacy = await promptYesNo(
+      `Found legacy '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry. Migrate to '${REMNIC_OPENCLAW_PLUGIN_ID}'? [Y/n]`,
+      true
+    );
+  } else if (hasLegacy) {
+    migrateLegacy = true;
+  }
+  const legacyEntry = entries[REMNIC_OPENCLAW_LEGACY_PLUGIN_ID];
+  const existingNewEntry = entries[REMNIC_OPENCLAW_PLUGIN_ID];
+  const legacyConfigToMerge = migrateLegacy && legacyEntry?.config && typeof legacyEntry.config === "object" ? legacyEntry.config : {};
+  const existingNewEntryConfig = existingNewEntry?.config && typeof existingNewEntry.config === "object" ? existingNewEntry.config : {};
+  const existingMemoryDir = (typeof existingNewEntryConfig.memoryDir === "string" ? existingNewEntryConfig.memoryDir : void 0) || (migrateLegacy && typeof legacyConfigToMerge.memoryDir === "string" ? legacyConfigToMerge.memoryDir : void 0);
+  const memoryDir = opts.memoryDir ? path2.resolve(expandTilde(opts.memoryDir)) : existingMemoryDir ? path2.resolve(expandTilde(existingMemoryDir)) : fallbackMemoryDir;
+  console.log(`Memory dir:      ${memoryDir}`);
+  const legacyNonConfigFields = {};
+  if (migrateLegacy && legacyEntry && typeof legacyEntry === "object" && !Array.isArray(legacyEntry)) {
+    for (const [k, v] of Object.entries(legacyEntry)) {
+      if (k !== "config") legacyNonConfigFields[k] = v;
+    }
+  }
+  const existingNewEntryFields = existingNewEntry && typeof existingNewEntry === "object" && !Array.isArray(existingNewEntry) ? existingNewEntry : {};
+  const newEntry = {
+    ...legacyNonConfigFields,
+    ...existingNewEntryFields,
+    config: {
+      ...legacyConfigToMerge,
+      ...existingNewEntryConfig,
+      memoryDir
+    }
+  };
+  const updatedEntries = { ...entries };
+  updatedEntries[REMNIC_OPENCLAW_PLUGIN_ID] = newEntry;
+  const slotIsActiveLegacy = hasLegacy && !migrateLegacy && currentSlot === REMNIC_OPENCLAW_LEGACY_PLUGIN_ID;
+  const updatedSlots = slotIsActiveLegacy ? { ...slots } : { ...slots, memory: REMNIC_OPENCLAW_PLUGIN_ID };
+  const updatedConfig = {
+    ...existingConfig,
+    plugins: {
+      ...plugins,
+      entries: updatedEntries,
+      slots: updatedSlots
+    }
+  };
+  const changes = [];
+  if (!hasNew) changes.push(`+ Added plugins.entries["${REMNIC_OPENCLAW_PLUGIN_ID}"]`);
+  else changes.push(`~ Updated plugins.entries["${REMNIC_OPENCLAW_PLUGIN_ID}"].config.memoryDir`);
+  if (!slotIsActiveLegacy && currentSlot !== REMNIC_OPENCLAW_PLUGIN_ID) {
+    changes.push(`~ Set plugins.slots.memory = "${REMNIC_OPENCLAW_PLUGIN_ID}" (was: ${currentSlot ?? "(unset)"})`);
+  } else if (slotIsActiveLegacy) {
+    changes.push(`  Slot left as "${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}" \u2014 re-run with --yes to activate the new entry`);
+  }
+  if (!fs.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)`);
+  }
+  if (opts.dryRun) {
+    console.log("\n--- DRY RUN \u2014 no changes written ---");
+    for (const c of changes) console.log("  " + c);
+    const dryRunPlugins = updatedConfig.plugins;
+    const dryRunEntries = dryRunPlugins.entries;
+    const entrySummary = dryRunEntries ? Object.keys(dryRunEntries).map((k) => {
+      const cfg = dryRunEntries[k]?.config;
+      return `  ${k}: { config: { memoryDir: ${cfg?.memoryDir ?? "(unset)"}, ... } }`;
+    }).join("\n") : "  (none)";
+    console.log("\nResulting plugins.entries:");
+    console.log(entrySummary);
+    console.log(`
+Resulting plugins.slots.memory: ${dryRunPlugins.slots?.memory ?? "(unset)"}`);
+    return;
+  }
+  if (fs.existsSync(memoryDir)) {
+    const st = fs.statSync(memoryDir);
+    if (!st.isDirectory()) {
+      throw new Error(
+        `Cannot use ${memoryDir} as the memory directory \u2014 a file already exists at that path.
+Remove it first and re-run, or choose a different path with --memory-dir.`
+      );
+    }
+  } else {
+    fs.mkdirSync(memoryDir, { recursive: true });
+    console.log(`Created memory directory: ${memoryDir}`);
+  }
+  const configDir = path2.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(updatedConfig, null, 2) + "\n");
+  console.log("\nDone! Summary of changes:");
+  for (const c of changes) console.log("  " + c);
+  if (hasLegacy && migrateLegacy) {
+    console.log(
+      `
+Note: The legacy '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry has been kept alongside '${REMNIC_OPENCLAW_PLUGIN_ID}'.`
+    );
+    console.log(
+      "Once you verify that [remnic] gateway_start fired appears in your gateway log,"
+    );
+    console.log(`you can safely remove the '${REMNIC_OPENCLAW_LEGACY_PLUGIN_ID}' entry from openclaw.json.`);
+  }
+  console.log("\nNext steps:");
+  console.log("  1. Restart the OpenClaw gateway:");
+  console.log("       launchctl kickstart -k gui/$(id -u)/ai.openclaw.gateway");
+  console.log("  2. Start a conversation \u2014 check your gateway log for:");
+  console.log("       [remnic] gateway_start fired \u2014 Remnic memory plugin is active");
+  console.log("  3. Run `remnic doctor` to verify the full configuration.");
+}
+async function cmdTaxonomy(rest) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  if (!config.taxonomyEnabled) {
+    console.error(
+      "Taxonomy is disabled in config (taxonomyEnabled = false). Enable it to use taxonomy commands."
+    );
+    process.exit(1);
+  }
+  const subCommand = rest[0];
+  switch (subCommand) {
+    case "show": {
+      const taxonomy = await loadTaxonomy(config.memoryDir);
+      const json = rest.includes("--json");
+      if (json) {
+        console.log(JSON.stringify(taxonomy, null, 2));
+      } else {
+        console.log(`Taxonomy v${taxonomy.version} \u2014 ${taxonomy.categories.length} categories
+`);
+        const idWidth = Math.max(4, ...taxonomy.categories.map((c) => c.id.length));
+        const nameWidth = Math.max(6, ...taxonomy.categories.map((c) => c.name.length));
+        const header = `${"ID".padEnd(idWidth)}  ${"Name".padEnd(nameWidth)}  ${"Pri".padStart(3)}  Memory Categories`;
+        console.log(header);
+        console.log("-".repeat(header.length + 10));
+        const sorted = [...taxonomy.categories].sort((a, b) => a.priority - b.priority);
+        for (const cat of sorted) {
+          const line = `${cat.id.padEnd(idWidth)}  ${cat.name.padEnd(nameWidth)}  ${String(cat.priority).padStart(3)}  ${cat.memoryCategories.join(", ")}`;
+          console.log(line);
+        }
+      }
+      break;
+    }
+    case "resolver": {
+      const taxonomy = await loadTaxonomy(config.memoryDir);
+      const doc = generateResolverDocument(taxonomy);
+      console.log(doc);
+      if (config.taxonomyAutoGenResolver) {
+        const resolverPath = path2.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs.mkdirSync(path2.dirname(resolverPath), { recursive: true });
+        fs.writeFileSync(resolverPath, doc);
+        console.error(`Written: ${resolverPath}`);
+      }
+      break;
+    }
+    case "add": {
+      const id = rest[1];
+      const name = rest[2];
+      if (!id || !name) {
+        console.error("Usage: remnic taxonomy add <id> <name>");
+        process.exit(1);
+      }
+      try {
+        validateSlug(id);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      const taxonomy = await loadTaxonomy(config.memoryDir);
+      if (taxonomy.categories.some((c) => c.id === id)) {
+        console.error(`Category "${id}" already exists.`);
+        process.exit(1);
+      }
+      const descriptionFlag = resolveFlag(rest, "--description");
+      const priorityFlag = resolveFlag(rest, "--priority");
+      const memoryCategoriesFlag = resolveFlag(rest, "--memory-categories");
+      const newCat = {
+        id,
+        name,
+        description: descriptionFlag ?? `Custom category: ${name}`,
+        filingRules: [`Content belonging to ${name}`],
+        priority: priorityFlag ? Number(priorityFlag) : 100,
+        memoryCategories: memoryCategoriesFlag ? memoryCategoriesFlag.split(",").map((s) => s.trim()) : []
+      };
+      taxonomy.categories.push(newCat);
+      try {
+        validateTaxonomy(taxonomy);
+      } catch (err) {
+        console.error(`Invalid taxonomy: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+      }
+      await saveTaxonomy(config.memoryDir, taxonomy);
+      console.log(`Added category "${id}" (${name}).`);
+      if (config.taxonomyAutoGenResolver) {
+        const doc = generateResolverDocument(taxonomy);
+        const resolverPath = path2.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs.writeFileSync(resolverPath, doc);
+        console.error(`Regenerated: ${resolverPath}`);
+      }
+      break;
+    }
+    case "remove": {
+      const id = rest[1];
+      if (!id) {
+        console.error("Usage: remnic taxonomy remove <id>");
+        process.exit(1);
+      }
+      const taxonomy = await loadTaxonomy(config.memoryDir);
+      const idx = taxonomy.categories.findIndex((c) => c.id === id);
+      if (idx === -1) {
+        console.error(`Category "${id}" not found.`);
+        process.exit(1);
+      }
+      const target = taxonomy.categories[idx];
+      const isDefault = DEFAULT_TAXONOMY.categories.some((c) => c.id === id);
+      if (isDefault && target.memoryCategories.length > 0) {
+        console.error(
+          `Cannot remove default category "${id}" that maps MemoryCategory values: ${target.memoryCategories.join(", ")}. Reassign them first.`
+        );
+        process.exit(1);
+      }
+      taxonomy.categories.splice(idx, 1);
+      await saveTaxonomy(config.memoryDir, taxonomy);
+      console.log(`Removed category "${id}".`);
+      if (config.taxonomyAutoGenResolver) {
+        const doc = generateResolverDocument(taxonomy);
+        const resolverPath = path2.join(config.memoryDir, ".taxonomy", "RESOLVER.md");
+        fs.writeFileSync(resolverPath, doc);
+        console.error(`Regenerated: ${resolverPath}`);
+      }
+      break;
+    }
+    case "resolve": {
+      const resolveArgs = rest.slice(1);
+      const textParts = stripResolveFlags(resolveArgs, TAXONOMY_RESOLVE_BOOLEAN_FLAGS);
+      const text = textParts.join(" ");
+      if (!text) {
+        console.error("Usage: remnic taxonomy resolve <text>");
+        process.exit(1);
+      }
+      const categoryFlag = resolveFlag(rest, "--category");
+      const memoryCategory = categoryFlag ?? "fact";
+      const taxonomy = await loadTaxonomy(config.memoryDir);
+      const decision = resolveCategory(text, memoryCategory, taxonomy);
+      const json = rest.includes("--json");
+      if (json) {
+        console.log(JSON.stringify(decision, null, 2));
+      } else {
+        console.log(`Category:   ${decision.categoryId}`);
+        console.log(`Confidence: ${decision.confidence.toFixed(2)}`);
+        console.log(`Reason:     ${decision.reason}`);
+        if (decision.alternatives.length > 0) {
+          console.log(`
+Alternatives:`);
+          for (const alt of decision.alternatives.slice(0, 3)) {
+            console.log(`  - ${alt.categoryId}: ${alt.reason}`);
+          }
+        }
+      }
+      break;
+    }
+    default:
+      console.log(`
+remnic taxonomy \u2014 MECE knowledge directory
+
+Usage:
+  remnic taxonomy show [--json]                     Show current taxonomy
+  remnic taxonomy resolver                          Print/regenerate RESOLVER.md
+  remnic taxonomy add <id> <name> [options]         Add a custom category
+    --description <text>                              Category description
+    --priority <number>                               Priority (lower wins, default 100)
+    --memory-categories <list>                        Comma-separated MemoryCategory values
+  remnic taxonomy remove <id>                       Remove a custom category
+  remnic taxonomy resolve <text> [--category <cat>] Test: resolve text to a category
+    --json                                            JSON output
+`);
+      break;
+  }
+}
 async function main(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;
   if (command !== "migrate") {
@@ -1356,7 +2841,7 @@ async function main(argv = process.argv.slice(2)) {
           daemonUninstall();
           break;
         case "status":
-          daemonStatus();
+          await daemonStatus();
           break;
         default:
           console.log("Usage: remnic daemon <start|stop|restart|install|uninstall|status>");
@@ -1451,7 +2936,7 @@ async function main(argv = process.argv.slice(2)) {
             }
           }, 500);
         };
-        fs2.watch(memoryDir, { recursive: true }, (_event, filename) => {
+        fs.watch(memoryDir, { recursive: true }, (_event, filename) => {
           if (filename && filename.startsWith(".")) return;
           rebuild();
         });
@@ -1459,12 +2944,12 @@ async function main(argv = process.argv.slice(2)) {
         });
       } else if (subAction === "validate") {
         const treeDir = outputDir;
-        if (!fs2.existsSync(treeDir)) {
+        if (!fs.existsSync(treeDir)) {
           console.error(`Context tree not found at ${treeDir}. Run 'remnic tree generate' first.`);
           process.exit(1);
         }
         const indexPath = path2.join(treeDir, "INDEX.md");
-        if (!fs2.existsSync(indexPath)) {
+        if (!fs.existsSync(indexPath)) {
           console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
           process.exit(1);
         }
@@ -1529,10 +3014,61 @@ Options:
       await cmdSpace(action, rest.slice(1), json);
       break;
     }
+    case "bench": {
+      await cmdBench(rest);
+      break;
+    }
     case "benchmark": {
-      const action = rest[0] ?? "run";
-      const json = rest.includes("--json");
-      await cmdBenchmark(action, rest.slice(1), json);
+      await cmdBench(rest);
+      break;
+    }
+    case "briefing": {
+      await cmdBriefing(rest);
+      break;
+    }
+    case "versions": {
+      await cmdVersions(rest);
+      break;
+    }
+    case "binary": {
+      await cmdBinary(rest);
+      break;
+    }
+    case "taxonomy": {
+      await cmdTaxonomy(rest);
+      break;
+    }
+    case "enrich": {
+      await cmdEnrich(rest);
+      break;
+    }
+    case "extensions": {
+      const action = rest[0] ?? "help";
+      await cmdExtensions(action, rest.slice(1));
+      break;
+    }
+    case "openclaw": {
+      const subAction = rest[0] ?? "help";
+      if (subAction === "install") {
+        const yes = rest.includes("--yes") || rest.includes("-y") || rest.includes("--force");
+        const dryRun = rest.includes("--dry-run");
+        const memoryDir = resolveFlagStrict(rest, "--memory-dir");
+        const configOverride = resolveFlagStrict(rest, "--config");
+        await cmdOpenclawInstall({ yes, dryRun, memoryDir, configPath: configOverride });
+      } else {
+        console.log(`Usage: remnic openclaw <install>
+
+  install    Configure OpenClaw to use Remnic as the memory plugin.
+
+             Sets plugins.entries["${REMNIC_OPENCLAW_PLUGIN_ID}"] and plugins.slots.memory
+             in ~/.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)
+  --config <path>         Override OpenClaw config path`);
+      }
       break;
     }
     default:
@@ -1547,6 +3083,11 @@ Usage:
 
   remnic doctor                Run diagnostics
   remnic config                Show current config
+  remnic openclaw install      Configure OpenClaw to use Remnic memory (sets slot + entry)
+    --yes / -y / --force       Skip prompts
+    --dry-run                  Preview changes without writing
+    --memory-dir <path>        Custom memory directory
+    --config <path>            Custom OpenClaw config path
   remnic daemon <start|stop|restart|install|uninstall|status>  Manage background server
   remnic token <generate|list|revoke> [connector-id]  Manage auth tokens
   remnic tree <generate|watch|validate>  Generate context tree
@@ -1555,10 +3096,36 @@ Usage:
   remnic review <list|approve|dismiss|flag> [id]  Review inbox
   remnic sync <run|watch> [--source <dir>] Diff-aware sync
   remnic dedup [--json]             Find duplicate memories
-  remnic connectors <list|install|remove|doctor> [id]  Manage connectors
+  remnic connectors <list|install|remove|doctor|marketplace> [id]  Manage connectors
+    marketplace generate    Generate marketplace.json for Codex
+    marketplace validate    Validate a marketplace.json file
+    marketplace install     Install from a marketplace source
+  remnic extensions <list|show|validate|reload>  Manage memory extensions
   remnic space <list|switch|create|delete|push|pull|share|promote|audit>  Manage spaces
     create accepts --parent <id> to set parent-child relationship
-  remnic benchmark <run|check|report> [queries...] [--explain] [--baseline=<path>] [--report=<path>]
+  remnic bench <list|run> [benchmark...] [--quick] [--all] [--dataset-dir <path>] [--json]
+    benchmark is kept as a compatibility alias. check/report remain under that alias.
+  remnic benchmark <list|run|check|report> [queries...] [--explain] [--baseline=<path>] [--report=<path>]
+  remnic briefing [--since <window>] [--focus <filter>] [--save] [--format markdown|json]
+    Daily context briefing. Windows: yesterday, today, NNh, NNd, NNw.
+    Focus: person:<name>, project:<name>, topic:<name>.
+  remnic versions <list|show|diff|revert> <page-path> [id] [--json]
+    Page-level versioning: list, show, diff, or revert page snapshots.
+  remnic binary scan               Scan for untracked binary files
+  remnic binary status             Show binary lifecycle manifest summary
+  remnic binary run [--dry-run]    Run full binary lifecycle pipeline
+  remnic binary clean --force      Force-clean binaries past grace period
+  remnic taxonomy <show|resolver|add|remove|resolve>  MECE knowledge directory
+    show [--json]                     Show current taxonomy
+    resolver                          Print/regenerate RESOLVER.md
+    add <id> <name> [--priority N]    Add custom category
+    remove <id>                       Remove custom category
+    resolve <text> [--category <cat>] Test resolver on sample text
+  remnic enrich <entity-name>    Manually enrich a specific entity
+  remnic enrich --all            Enrich all entities
+  remnic enrich --dry-run        Preview what would be enriched
+  remnic enrich audit            Show recent enrichment audit log
+  remnic enrich providers        List registered providers and their status
 
 Options:
   --json    Output in JSON format
@@ -1577,5 +3144,15 @@ if (argv1Base.endsWith("remnic.ts") || argv1Base.endsWith("remnic.js") || argv1B
   });
 }
 export {
-  main
+  BENCHMARK_CATALOG,
+  TAXONOMY_RESOLVE_BOOLEAN_FLAGS,
+  buildBenchRunnerArgs,
+  getBenchUsageText,
+  hasFlag,
+  main,
+  parseBenchArgs,
+  parseConnectorConfig,
+  resolveFlag,
+  stripConfigArgv,
+  stripResolveFlags
 };