@remnic/cli 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,7 +1,30 @@
+import {
+  buildBenchmarkPublishFeed,
+  checkRegression,
+  compareResults,
+  defaultBenchmarkBaselineDir,
+  defaultBenchmarkPublishPath,
+  deleteBenchmarkResults,
+  discoverAllProviders,
+  getBenchmarkLowerIsBetter,
+  listBenchmarkBaselines,
+  listBenchmarkResults,
+  loadBaseline,
+  loadBenchmarkBaseline,
+  loadBenchmarkResult,
+  renderBenchmarkResultExport,
+  resolveBenchmarkResultReference,
+  runBenchSuite,
+  runExplain,
+  saveBenchmarkBaseline,
+  writeBenchmarkPublishFeed
+} from "./chunk-GAZ3DFWX.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 +57,1309 @@ 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";
+import {
+  convertMemoriesToRecords,
+  getTrainingExportAdapter as getTrainingExportAdapter2,
+  listTrainingExportAdapters,
+  parseStrictCliDate
 } from "@remnic/core";
 
-// ../bench/src/benchmark.ts
-import fs from "fs";
+// ../export-weclone/dist/index.js
+import {
+  getTrainingExportAdapter,
+  registerTrainingExportAdapter
+} from "@remnic/core";
+var wecloneExportAdapter = {
+  name: "weclone",
+  fileExtension: ".json",
+  formatRecords(records) {
+    const alpacaRecords = records.map((r) => ({
+      instruction: r.instruction,
+      input: r.input,
+      output: r.output
+    }));
+    return JSON.stringify(alpacaRecords, null, 2);
+  }
+};
+var DEFAULT_MAX_PAIRS = 1;
+var QUESTION_TEMPLATES = {
+  preferences: [
+    "What kind of {topic} do you like?",
+    "What's your preference for {topic}?",
+    "What are your favorite {topic}?"
+  ],
+  opinions: [
+    "What do you think about {topic}?",
+    "How do you feel about {topic}?",
+    "What's your opinion on {topic}?"
+  ],
+  expertise: [
+    "Tell me about {topic}.",
+    "What do you know about {topic}?",
+    "Can you explain {topic}?"
+  ],
+  personal: [
+    "Can you tell me about your {topic}?",
+    "Tell me about your {topic}.",
+    "What can you share about your {topic}?"
+  ]
+};
+var DEFAULT_TEMPLATES = [
+  "Tell me about {topic}.",
+  "What can you share about {topic}?"
+];
+var CATEGORY_TO_TEMPLATE = {
+  preference: "preferences",
+  fact: "expertise",
+  entity: "expertise",
+  skill: "expertise",
+  correction: "opinions",
+  decision: "opinions",
+  principle: "opinions",
+  rule: "opinions",
+  personal: "personal",
+  relationship: "personal",
+  commitment: "personal",
+  moment: "personal"
+};
+function synthesizeTrainingPairs(records, options) {
+  const maxPairs = options?.maxPairsPerRecord ?? DEFAULT_MAX_PAIRS;
+  const style = options?.styleMarkers;
+  const result = [];
+  for (let i = 0; i < records.length; i++) {
+    const record = records[i];
+    const templateKey = resolveTemplateKey(record.category);
+    const topic = extractTopic(record.instruction);
+    const templates = QUESTION_TEMPLATES[templateKey] ?? DEFAULT_TEMPLATES;
+    const pairCount = Math.min(maxPairs, templates.length);
+    for (let j = 0; j < pairCount; j++) {
+      const templateIndex = (i + j) % templates.length;
+      const question = templates[templateIndex].replace("{topic}", topic);
+      let output = record.output;
+      if (style?.usesLowercase) {
+        output = output.toLowerCase();
+      }
+      result.push({
+        instruction: question,
+        input: "",
+        output,
+        category: record.category,
+        confidence: record.confidence,
+        sourceIds: record.sourceIds
+      });
+    }
+  }
+  return result;
+}
+function resolveTemplateKey(category) {
+  if (!category) return "";
+  return CATEGORY_TO_TEMPLATE[category.toLowerCase()] ?? "";
+}
+function extractTopic(instruction) {
+  const tagMatch = instruction.match(/\(([^()]+)\)/);
+  if (tagMatch) {
+    return tagMatch[1].trim().toLowerCase();
+  }
+  return "this";
+}
+var PII_PATTERNS = [
+  {
+    // Email: user@domain.tld
+    name: "email",
+    regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g
+  },
+  {
+    // SSN: 123-45-6789 (exactly 3-2-4 digit groups)
+    name: "ssn",
+    regex: /\b\d{3}-\d{2}-\d{4}\b/g
+  },
+  {
+    // Credit card: 4 groups of 4 digits separated by dashes or spaces
+    name: "credit_card",
+    regex: /\b\d{4}[-\s]\d{4}[-\s]\d{4}[-\s]\d{4}\b/g
+  },
+  {
+    // IP address: four octets 0-255
+    name: "ip_address",
+    regex: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g
+  },
+  {
+    // Phone: optional +1- prefix, then 3-3-4 with dashes, dots, or spaces
+    // Also matches (555) 123-4567 format
+    name: "phone",
+    regex: /(?:\+\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]\d{3}[-.\s]\d{4}\b/g
+  }
+];
+var SCANNED_FIELDS = [
+  "instruction",
+  "input",
+  "output"
+];
+function sweepPii(records) {
+  const redactionDetails = [];
+  const recordHasRedaction = /* @__PURE__ */ new Set();
+  const cleanRecords = records.map((record, idx) => {
+    const cleaned = { ...record };
+    for (const field of SCANNED_FIELDS) {
+      let value = record[field];
+      if (!value) continue;
+      for (const pattern of PII_PATTERNS) {
+        pattern.regex.lastIndex = 0;
+        if (pattern.regex.test(value)) {
+          pattern.regex.lastIndex = 0;
+          value = value.replace(pattern.regex, "[REDACTED]");
+          recordHasRedaction.add(idx);
+          redactionDetails.push({
+            index: idx,
+            field,
+            pattern: pattern.name
+          });
+        }
+      }
+      cleaned[field] = value;
+    }
+    return cleaned;
+  });
+  return {
+    cleanRecords,
+    redactedCount: recordHasRedaction.size,
+    redactionDetails
+  };
+}
+function ensureWecloneExportAdapterRegistered() {
+  if (getTrainingExportAdapter(wecloneExportAdapter.name) !== void 0) {
+    return false;
+  }
+  registerTrainingExportAdapter(wecloneExportAdapter);
+  return true;
+}
+try {
+  ensureWecloneExportAdapterRegistered();
+} catch {
+}
+
+// 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 void 0;
+}
+function firstSuccessfulCandidate(candidates, attempt) {
+  return firstSuccessfulResult(candidates, (candidate) => {
+    attempt(candidate);
+    return candidate;
+  });
+}
+
+// src/bench-args.ts
 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?"
+
+// src/path-utils.ts
+function resolveHomeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "~";
+}
+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;
+}
+
+// src/bench-args.ts
+function readBenchOptionValue(argv, flag) {
+  const index = argv.indexOf(flag);
+  if (index === -1) {
+    return void 0;
+  }
+  const value = argv[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`ERROR: ${flag} requires a value.`);
+  }
+  return value;
+}
+function collectBenchmarks(argv) {
+  const benchmarks = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--dataset-dir" || arg === "--results-dir" || arg === "--baselines-dir" || arg === "--threshold" || arg === "--custom" || arg === "--format" || arg === "--output" || arg === "--target") {
+      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 === "datasets" || first === "runs" || first === "compare" || first === "ui" || first === "results" || first === "baseline" || first === "export" || first === "providers" || first === "publish" || first === "check" || first === "report" ? first : first === void 0 || first === "--help" || first === "-h" ? "help" : "run";
+  return {
+    action,
+    args: action === "run" && action !== first ? argv : rest
+  };
+}
+function parseBenchArgs(argv) {
+  const { action, args } = parseBenchActionArgs(argv);
+  const baselineAction = action === "baseline" ? args[0] === "save" || args[0] === "list" ? args[0] : void 0 : void 0;
+  const datasetAction = action === "datasets" ? args[0] === "download" || args[0] === "status" ? args[0] : void 0 : void 0;
+  const providerAction = action === "providers" ? args[0] === "discover" ? args[0] : void 0 : void 0;
+  const runAction = action === "runs" ? args[0] === "list" || args[0] === "show" || args[0] === "delete" ? args[0] : void 0 : void 0;
+  if (action === "baseline" && baselineAction === void 0) {
+    throw new Error("ERROR: baseline requires a subcommand: save or list.");
+  }
+  if (action === "datasets" && datasetAction === void 0) {
+    throw new Error("ERROR: datasets requires a subcommand: download or status.");
+  }
+  if (action === "providers" && providerAction === void 0) {
+    throw new Error("ERROR: providers requires a subcommand: discover.");
+  }
+  if (action === "runs" && runAction === void 0) {
+    throw new Error("ERROR: runs requires a subcommand: list, show, or delete.");
+  }
+  const benchmarkArgs = action === "baseline" || action === "datasets" || action === "providers" || action === "runs" ? args.slice(1) : args;
+  const benchmarks = collectBenchmarks(benchmarkArgs);
+  const datasetDir = readBenchOptionValue(args, "--dataset-dir");
+  const resultsDir = readBenchOptionValue(args, "--results-dir");
+  const baselinesDir = readBenchOptionValue(args, "--baselines-dir");
+  const thresholdRaw = readBenchOptionValue(args, "--threshold");
+  const customRaw = readBenchOptionValue(args, "--custom");
+  const formatRaw = readBenchOptionValue(args, "--format");
+  const output = readBenchOptionValue(args, "--output");
+  const targetRaw = readBenchOptionValue(args, "--target");
+  let threshold;
+  if (thresholdRaw !== void 0) {
+    threshold = Number(thresholdRaw);
+    if (!Number.isFinite(threshold) || threshold < 0) {
+      throw new Error("ERROR: --threshold must be a non-negative number.");
+    }
+  }
+  let format;
+  if (formatRaw !== void 0) {
+    if (formatRaw !== "json" && formatRaw !== "csv" && formatRaw !== "html") {
+      throw new Error('ERROR: --format must be "json", "csv", or "html".');
+    }
+    format = formatRaw;
+  }
+  let target;
+  if (targetRaw !== void 0) {
+    if (targetRaw !== "remnic-ai") {
+      throw new Error('ERROR: --target must be "remnic-ai".');
+    }
+    target = targetRaw;
+  }
+  return {
+    action,
+    benchmarks,
+    quick: args.includes("--quick"),
+    all: args.includes("--all"),
+    json: args.includes("--json"),
+    detail: args.includes("--detail"),
+    datasetDir: datasetDir ? path.resolve(expandTilde(datasetDir)) : void 0,
+    resultsDir: resultsDir ? path.resolve(expandTilde(resultsDir)) : void 0,
+    baselinesDir: baselinesDir ? path.resolve(expandTilde(baselinesDir)) : void 0,
+    threshold,
+    custom: customRaw ? path.resolve(expandTilde(customRaw)) : void 0,
+    baselineAction,
+    datasetAction,
+    providerAction,
+    runAction,
+    format,
+    output: output ? path.resolve(expandTilde(output)) : void 0,
+    target
+  };
+}
+
+// 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 textParts;
+}
+
+// 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 config;
+}
+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];
+}
+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 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;
+var BENCHMARK_IDS = new Set(BENCHMARK_CATALOG.map((entry) => entry.id));
+function getBenchUsageText() {
+  return `Usage: remnic bench <list|run|datasets|runs|compare|results|baseline|export|publish|ui|providers> [options] [benchmark...]
+       remnic benchmark <list|run|datasets|runs|compare|results|baseline|export|publish|ui|providers|check|report> [options] [benchmark...]
+
+Commands:
+  list                     List published benchmark packs
+  run [benchmark...]       Run one or more benchmark packs
+  datasets download [benchmark...]
+                           Download local datasets for supported published benchmarks
+  datasets status          Show local dataset availability for supported benchmarks
+  runs list                List stored benchmark runs
+  runs show <run>          Show one stored benchmark run
+  runs delete <run...>     Delete one or more stored benchmark runs
+  compare <base> <cand>    Compare two stored benchmark runs by id or file path
+  results [run]            List stored runs or inspect a stored run
+  baseline save <name> [run]
+                           Save a stored run as a named baseline
+  baseline list            List saved baselines
+  export <run> --format <json|csv|html>
+                           Export one stored run as JSON, aggregate-metrics CSV, or static HTML
+  publish --target remnic-ai
+                           Generate the Remnic.ai benchmark feed from stored runs
+  ui                       Launch the local benchmark overview UI
+  providers discover       Auto-detect available local provider backends
+  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
+  --custom <path>          Run a YAML-defined custom benchmark file
+  --results-dir <path>     Override the stored benchmark results directory
+  --baselines-dir <path>   Override the named baseline directory
+  --threshold <value>      Regression threshold for compare (default: 0.05)
+  --detail                 Include per-task details for bench results
+  --format <json|csv|html> Output format for bench export
+  --output <path>          Write bench export output to a file
+  --target <name>          Publish target for bench publish (remnic-ai)
+  --json                   Output JSON for \`list\`
+
+Examples:
+  remnic bench list
+  remnic bench datasets status
+  remnic bench datasets download longmemeval
+  remnic bench datasets download --all
+  remnic bench runs list
+  remnic bench runs show candidate-run --detail
+  remnic bench runs delete candidate-run
+  remnic bench run --quick longmemeval
+  remnic bench run longmemeval --dataset-dir ~/datasets/longmemeval
+  remnic bench compare base-run candidate-run
+  remnic bench results
+  remnic bench results candidate-run --detail
+  remnic bench baseline save main candidate-run
+  remnic bench baseline list
+  remnic bench export candidate-run --format csv --output ./candidate.csv
+  remnic bench export candidate-run --format html --output ./report.html
+  remnic bench publish --target remnic-ai
+  remnic bench providers discover
+  remnic bench run --custom ./my-bench.yaml
+  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 raw = JSON.parse(fs.readFileSync(p, "utf8"));
-    if (raw.version !== BASELINE_VERSION) {
-      console.warn(
-        `Baseline version mismatch: expected ${BASELINE_VERSION}, got ${raw.version}`
+    const benchModule = await import("./dist-7DCVQLUB.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");
+}
+var DOWNLOADABLE_BENCHMARK_DATASETS = [
+  "ama-bench",
+  "memory-arena",
+  "amemgym",
+  "longmemeval",
+  "locomo"
+];
+var DOWNLOADED_DATASET_MARKERS = {
+  "ama-bench": { anyOf: ["open_end_qa_set.jsonl"] },
+  longmemeval: {
+    anyOf: ["longmemeval_oracle.json", "longmemeval_s_cleaned.json", "longmemeval.json"]
+  },
+  amemgym: {
+    anyOf: ["amemgym-v1-base.json", "amemgym-tasks.json", "data.json"]
+  },
+  locomo: { anyOf: ["locomo10.json", "locomo.json"] },
+  "memory-arena": { ext: ".jsonl" }
+};
+function isDatasetDownloaded(datasetPath, benchmarkId) {
+  let stats;
+  try {
+    stats = fs.statSync(datasetPath);
+  } catch {
+    return false;
+  }
+  if (!stats.isDirectory()) {
+    return false;
+  }
+  const marker = DOWNLOADED_DATASET_MARKERS[benchmarkId];
+  if (!marker) {
+    try {
+      return fs.readdirSync(datasetPath).length > 0;
+    } catch {
+      return false;
+    }
+  }
+  if (marker.anyOf) {
+    return marker.anyOf.some((name) => {
+      try {
+        return fs.statSync(path2.join(datasetPath, name)).isFile();
+      } catch {
+        return false;
+      }
+    });
+  }
+  if (marker.ext) {
+    try {
+      return fs.readdirSync(datasetPath).some((name) => name.endsWith(marker.ext));
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+async function launchBenchUi(resultsDir) {
+  const benchUiDir = path2.join(CLI_REPO_ROOT, "packages", "bench-ui");
+  const pnpmCmd = process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+  if (!fs.existsSync(path2.join(benchUiDir, "package.json"))) {
+    console.error("ERROR: @remnic/bench-ui is not available in this checkout.");
+    process.exit(1);
+  }
+  console.log(`Launching bench UI with results from ${resultsDir}`);
+  console.log("Press Ctrl+C to stop the local server.");
+  const child = childProcess.spawn(pnpmCmd, ["exec", "vite", "--host", "127.0.0.1"], {
+    cwd: benchUiDir,
+    stdio: "inherit",
+    shell: process.platform === "win32",
+    env: {
+      ...process.env,
+      REMNIC_BENCH_RESULTS_DIR: resultsDir
+    }
+  });
+  await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (code === 0 || signal === "SIGINT" || signal === "SIGTERM") {
+        resolve();
+        return;
+      }
+      reject(new Error(`bench UI exited with code ${code ?? "unknown"}`));
+    });
+  });
+}
+function resolveBenchBaselineDir() {
+  return defaultBenchmarkBaselineDir();
+}
+function resolveRepoDatasetRoot() {
+  const repoCandidate = path2.join(CLI_REPO_ROOT, "evals", "datasets");
+  if (isRepoCheckout()) {
+    return repoCandidate;
+  }
+  return path2.join(resolveHomeDir(), ".remnic", "bench", "datasets");
+}
+function listDownloadableBenchmarks() {
+  return [...DOWNLOADABLE_BENCHMARK_DATASETS];
+}
+function resolveDatasetDownloadScriptPath() {
+  const bundled = path2.join(CLI_MODULE_DIR, "assets", "download-datasets.sh");
+  if (fs.existsSync(bundled)) {
+    return bundled;
+  }
+  return path2.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh");
+}
+function isRepoCheckout() {
+  return fs.existsSync(path2.join(CLI_REPO_ROOT, "pnpm-workspace.yaml")) && fs.existsSync(path2.join(CLI_REPO_ROOT, "evals", "scripts", "download-datasets.sh"));
+}
+function runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, jsonMode) {
+  const stdio = jsonMode ? ["inherit", process.stderr, "inherit"] : "inherit";
+  const env = { ...process.env, DATASETS_DIR: datasetRoot };
+  const options = {
+    cwd: CLI_REPO_ROOT,
+    stdio,
+    env
+  };
+  const args = ["--benchmark", benchmarkId];
+  if (process.platform !== "win32") {
+    childProcess.execFileSync(scriptPath, args, options);
+    return;
+  }
+  const bashProbe = childProcess.spawnSync("bash", ["--version"], { stdio: "ignore" });
+  if (bashProbe.error || bashProbe.status !== 0) {
+    throw new Error(
+      "bench datasets download requires bash on Windows (Git Bash or WSL). Install bash or run this command from a Unix shell."
+    );
+  }
+  childProcess.execFileSync("bash", [scriptPath, ...args], options);
+}
+function resolveSelectedDatasetDownloads(parsed) {
+  const supported = listDownloadableBenchmarks();
+  if (parsed.all) {
+    return supported;
+  }
+  if (parsed.benchmarks.length === 0) {
+    console.error(
+      "ERROR: datasets download requires at least one benchmark id or --all. Usage: remnic bench datasets download <benchmark...> [--all] [--json]"
+    );
+    process.exit(1);
+  }
+  const selected = [...new Set(parsed.benchmarks)];
+  const unsupported = selected.filter((benchmarkId) => !supported.includes(benchmarkId));
+  if (unsupported.length > 0) {
+    console.error(
+      `ERROR: unsupported downloadable benchmark dataset(s): ${unsupported.join(", ")}. Supported datasets: ${supported.join(", ")}.`
+    );
+    process.exit(1);
+  }
+  return selected;
+}
+function resolveBenchDatasetDir(benchmarkId, quick, datasetDirOverride) {
+  if (datasetDirOverride) {
+    return datasetDirOverride;
+  }
+  if (quick) {
+    return void 0;
+  }
+  const datasetDir = path2.join(resolveRepoDatasetRoot(), benchmarkId);
+  if (isDatasetDownloaded(datasetDir, benchmarkId)) {
+    return datasetDir;
+  }
+  return void 0;
+}
+function printBenchPackageSummary(result, outputPath, outputLabel = "Results saved") {
+  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(`${outputLabel}: ${outputPath}`);
+}
+function printStoredBenchResultSummary(result, summary) {
+  printBenchPackageSummary(result, summary.path, "Stored result");
+  console.log(`Run id: ${summary.id}`);
+}
+function printStoredBenchResultDetails(result, summary) {
+  printStoredBenchResultSummary(result, summary);
+  if (result.results.tasks.length === 0) {
+    console.log("Tasks: none");
+    return;
+  }
+  console.log("Task breakdown:");
+  for (const task of result.results.tasks) {
+    const scores = Object.entries(task.scores).sort(([left], [right]) => left.localeCompare(right)).map(([metric, value]) => `${metric}=${value.toFixed(4)}`).join(", ");
+    console.log(
+      `  ${task.taskId}: ${task.latencyMs.toFixed(1)}ms${scores.length > 0 ? ` [${scores}]` : ""}`
+    );
+  }
+}
+function printBenchComparisonSummary(comparison, baseline, candidate) {
+  console.log(`Benchmark: ${comparison.benchmark}`);
+  console.log(`Baseline: ${baseline.id} (${baseline.path})`);
+  console.log(`Candidate: ${candidate.id} (${candidate.path})`);
+  console.log(`Verdict: ${comparison.verdict}`);
+  const metrics = Object.entries(comparison.metricDeltas).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  if (metrics.length === 0) {
+    console.log("No overlapping metrics were found between the two results.");
+    return;
+  }
+  console.log("Metrics:");
+  for (const [metric, delta] of metrics) {
+    const percent = Number.isFinite(delta.percentChange) ? `${(delta.percentChange * 100).toFixed(2)}%` : delta.percentChange > 0 ? "+Infinity%" : "-Infinity%";
+    const direction = delta.delta >= 0 ? "+" : "";
+    console.log(
+      `  ${metric.padEnd(18)} ${delta.baseline.toFixed(4)} -> ${delta.candidate.toFixed(4)} (${direction}${delta.delta.toFixed(4)}, ${percent}, d=${delta.effectSize.cohensD.toFixed(3)} ${delta.effectSize.interpretation})`
+    );
+    if (delta.ciOnDelta) {
+      console.log(
+        `    CI95 delta: [${delta.ciOnDelta.lower.toFixed(4)}, ${delta.ciOnDelta.upper.toFixed(4)}]`
       );
     }
-    return raw;
-  } catch {
-    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())
+async function compareBenchPackageResults(parsed) {
+  const refs = parsed.benchmarks;
+  if (refs.length !== 2) {
+    console.error(
+      "ERROR: compare requires exactly two stored result references. Usage: remnic bench compare <baseline> <candidate> [--results-dir <path>] [--threshold <value>] [--json]"
+    );
+    process.exit(1);
+  }
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  const [baselineRef, candidateRef] = refs;
+  const baselineSummary = await resolveBenchmarkResultReference(resultsDir, baselineRef);
+  const candidateSummary = await resolveBenchmarkResultReference(resultsDir, candidateRef);
+  if (!baselineSummary) {
+    console.error(`ERROR: benchmark result not found: ${baselineRef}`);
+    process.exit(1);
+  }
+  if (!candidateSummary) {
+    console.error(`ERROR: benchmark result not found: ${candidateRef}`);
+    process.exit(1);
+  }
+  const baseline = await loadBenchmarkResult(baselineSummary.path);
+  const candidate = await loadBenchmarkResult(candidateSummary.path);
+  if (baseline.meta.benchmark !== candidate.meta.benchmark) {
+    console.error(
+      `ERROR: benchmark mismatch: ${baseline.meta.benchmark} vs ${candidate.meta.benchmark}. Compare runs from the same benchmark.`
+    );
+    process.exit(1);
+  }
+  const comparison = compareResults(
+    baseline,
+    candidate,
+    parsed.threshold ?? 0.05,
+    getBenchmarkLowerIsBetter(candidate.meta.benchmark)
+  );
+  if (parsed.json) {
+    console.log(JSON.stringify({
+      benchmark: comparison.benchmark,
+      baseline: baselineSummary,
+      candidate: candidateSummary,
+      comparison
+    }, null, 2));
+  } else {
+    printBenchComparisonSummary(comparison, baselineSummary, candidateSummary);
+  }
+  if (comparison.verdict === "regression") {
+    process.exit(1);
+  }
+}
+async function showBenchPackageResults(parsed) {
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  if (parsed.benchmarks.length === 0) {
+    const summaries = await listBenchmarkResults(resultsDir);
+    if (parsed.json) {
+      console.log(JSON.stringify(summaries, null, 2));
+      return;
+    }
+    if (summaries.length === 0) {
+      console.log(`No stored benchmark runs found in ${resultsDir}`);
+      return;
+    }
+    console.log("Stored benchmark runs:");
+    for (const summary2 of summaries) {
+      console.log(
+        `  ${summary2.id.padEnd(24)} ${summary2.benchmark.padEnd(16)} ${summary2.mode.padEnd(5)} ${summary2.timestamp}`
+      );
+    }
+    return;
+  }
+  if (parsed.benchmarks.length !== 1) {
+    console.error(
+      "ERROR: results accepts at most one stored result reference. Usage: remnic bench results [run] [--detail] [--results-dir <path>] [--json]"
+    );
+    process.exit(1);
+  }
+  const reference = parsed.benchmarks[0];
+  const summary = await resolveBenchmarkResultReference(resultsDir, reference);
+  if (!summary) {
+    console.error(`ERROR: benchmark result not found: ${reference}`);
+    process.exit(1);
+  }
+  const result = await loadBenchmarkResult(summary.path);
+  if (parsed.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (parsed.detail) {
+    printStoredBenchResultDetails(result, summary);
+  } else {
+    printStoredBenchResultSummary(result, summary);
+  }
+}
+async function manageBenchBaselines(parsed) {
+  const baselineDir = parsed.baselinesDir ?? resolveBenchBaselineDir();
+  if (parsed.baselineAction === "list") {
+    const baselines = await listBenchmarkBaselines(baselineDir);
+    if (parsed.json) {
+      console.log(JSON.stringify(baselines, null, 2));
+      return;
+    }
+    if (baselines.length === 0) {
+      console.log(`No saved baselines found in ${baselineDir}`);
+      return;
+    }
+    console.log("Saved baselines:");
+    for (const baseline of baselines) {
+      console.log(
+        `  ${baseline.name.padEnd(20)} ${baseline.benchmark.padEnd(16)} ${baseline.mode.padEnd(5)} ${baseline.timestamp}`
+      );
+    }
+    return;
+  }
+  if (parsed.baselineAction !== "save") {
+    console.error("ERROR: baseline requires a subcommand: save or list.");
+    process.exit(1);
+  }
+  if (parsed.benchmarks.length < 1 || parsed.benchmarks.length > 2) {
+    console.error(
+      "ERROR: baseline save requires a name and optionally one stored result reference. Usage: remnic bench baseline save <name> [run] [--results-dir <path>] [--baselines-dir <path>] [--json]"
+    );
+    process.exit(1);
+  }
+  const [name, explicitReference] = parsed.benchmarks;
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  const sourceSummary = explicitReference ? await resolveBenchmarkResultReference(resultsDir, explicitReference) : (await listBenchmarkResults(resultsDir))[0];
+  if (!sourceSummary) {
+    console.error(
+      explicitReference ? `ERROR: benchmark result not found: ${explicitReference}` : `ERROR: no stored benchmark runs found in ${resultsDir}`
+    );
+    process.exit(1);
+  }
+  const result = await loadBenchmarkResult(sourceSummary.path);
+  let writtenPath;
+  try {
+    writtenPath = await saveBenchmarkBaseline(
+      baselineDir,
+      name,
+      result,
+      { id: sourceSummary.id, path: sourceSummary.path }
+    );
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (parsed.json) {
+    const baseline = await loadBenchmarkBaseline(writtenPath);
+    console.log(JSON.stringify({
+      name: baseline.name,
+      path: writtenPath,
+      source: baseline.source,
+      benchmark: baseline.result.meta.benchmark,
+      timestamp: baseline.savedAt
+    }, null, 2));
+    return;
+  }
+  console.log(`Saved baseline "${name}" to ${writtenPath}`);
+  console.log(`  Source run: ${sourceSummary.id}`);
+  console.log(`  Benchmark: ${result.meta.benchmark}`);
+}
+async function exportBenchPackageResult(parsed) {
+  if (parsed.benchmarks.length !== 1) {
+    console.error(
+      "ERROR: export requires exactly one stored result reference. Usage: remnic bench export <run> --format <json|csv|html> [--output <path>] [--results-dir <path>]"
+    );
+    process.exit(1);
+  }
+  if (!parsed.format) {
+    console.error("ERROR: export requires --format json, csv, or html.");
+    process.exit(1);
+  }
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  const reference = parsed.benchmarks[0];
+  const summary = await resolveBenchmarkResultReference(resultsDir, reference);
+  if (!summary) {
+    console.error(`ERROR: benchmark result not found: ${reference}`);
+    process.exit(1);
+  }
+  const result = await loadBenchmarkResult(summary.path);
+  const rendered = renderBenchmarkResultExport(result, parsed.format);
+  if (parsed.output) {
+    fs.mkdirSync(path2.dirname(parsed.output), { recursive: true });
+    fs.writeFileSync(parsed.output, rendered);
+    console.log(`Exported ${summary.id} as ${parsed.format} to ${parsed.output}`);
+    return;
+  }
+  process.stdout.write(rendered);
+}
+async function manageBenchDatasets(parsed) {
+  const datasetRoot = resolveRepoDatasetRoot();
+  const supported = listDownloadableBenchmarks();
+  if (parsed.datasetAction === "status") {
+    if (parsed.benchmarks.length > 0 || parsed.all) {
+      console.error(
+        "ERROR: datasets status does not accept benchmark names or --all. Usage: remnic bench datasets status [--json]"
+      );
+      process.exit(1);
+    }
+    const status = supported.map((benchmarkId) => {
+      const datasetPath = path2.join(datasetRoot, benchmarkId);
+      return {
+        benchmark: benchmarkId,
+        downloaded: isDatasetDownloaded(datasetPath, benchmarkId),
+        path: datasetPath
+      };
+    });
+    if (parsed.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+    console.log("Downloadable benchmark datasets:");
+    for (const entry of status) {
+      console.log(
+        `  ${entry.benchmark.padEnd(16)} ${entry.downloaded ? "downloaded" : "missing"}  ${entry.path}`
+      );
+    }
+    console.log("");
+    console.log(
+      "Only the script-backed published datasets are managed here. Other benchmark fixtures remain repo-managed or manual."
+    );
+    return;
+  }
+  if (parsed.datasetAction !== "download") {
+    console.error("ERROR: datasets requires a subcommand: download or status.");
+    process.exit(1);
+  }
+  const scriptPath = resolveDatasetDownloadScriptPath();
+  if (!fs.existsSync(scriptPath)) {
+    console.error(`ERROR: dataset download script not found: ${scriptPath}`);
+    process.exit(1);
+  }
+  const selected = resolveSelectedDatasetDownloads(parsed);
+  const downloaded = [];
+  for (const benchmarkId of selected) {
+    runDatasetDownloadScript(scriptPath, benchmarkId, datasetRoot, parsed.json === true);
+    downloaded.push({
+      benchmark: benchmarkId,
+      path: path2.join(datasetRoot, benchmarkId)
+    });
+  }
+  if (parsed.json) {
+    console.log(JSON.stringify(downloaded, null, 2));
+    return;
+  }
+  console.log("Downloaded benchmark datasets:");
+  for (const entry of downloaded) {
+    console.log(`  ${entry.benchmark}  ${entry.path}`);
+  }
+}
+async function manageBenchRuns(parsed) {
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  if (parsed.runAction === "list") {
+    if (parsed.benchmarks.length > 0 || parsed.all) {
+      console.error(
+        "ERROR: runs list does not accept benchmark names or --all. Usage: remnic bench runs list [--results-dir <path>] [--json]"
+      );
+      process.exit(1);
+    }
+    await showBenchPackageResults({ ...parsed, action: "results", benchmarks: [] });
+    return;
+  }
+  if (parsed.runAction === "show") {
+    if (parsed.benchmarks.length !== 1 || parsed.all) {
+      console.error(
+        "ERROR: runs show requires exactly one stored result reference. Usage: remnic bench runs show <run> [--detail] [--results-dir <path>] [--json]"
+      );
+      process.exit(1);
+    }
+    await showBenchPackageResults(parsed);
+    return;
+  }
+  if (parsed.runAction === "delete") {
+    if (parsed.benchmarks.length === 0 || parsed.all) {
+      console.error(
+        "ERROR: runs delete requires at least one stored result reference. Usage: remnic bench runs delete <run...> [--results-dir <path>] [--json]"
+      );
+      process.exit(1);
+    }
+    const deleted = await deleteBenchmarkResults(resultsDir, parsed.benchmarks);
+    if (parsed.json) {
+      console.log(JSON.stringify(deleted, null, 2));
+    } else {
+      if (deleted.deleted.length === 0) {
+        console.log("No benchmark runs were deleted.");
+      } else {
+        console.log("Deleted benchmark runs:");
+        for (const summary of deleted.deleted) {
+          console.log(`  ${summary.id}  ${summary.path}`);
+        }
+      }
+      if (deleted.missing.length > 0) {
+        console.log("Missing benchmark runs:");
+        for (const reference of deleted.missing) {
+          console.log(`  ${reference}`);
+        }
+      }
+    }
+    if (deleted.missing.length > 0) {
+      process.exit(1);
+    }
+    return;
+  }
+  console.error("ERROR: runs requires a subcommand: list, show, or delete.");
+  process.exit(1);
+}
+async function discoverBenchProviders(parsed) {
+  if (parsed.benchmarks.length > 0) {
+    console.error(
+      "ERROR: providers discover does not accept positional arguments. Usage: remnic bench providers discover [--json]"
     );
-    if (hasExactMatch) {
-      tiers.push("exact_match");
-      tierDetails.push({
-        tier: "exact_match",
-        latencyMs: d0,
-        resultsCount: r0.results.length
-      });
-      return { tiers, tierDetails };
-    }
+    process.exit(1);
   }
-  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 };
+  const discovered = await discoverAllProviders();
+  if (parsed.json) {
+    console.log(JSON.stringify(discovered, null, 2));
+    return;
+  }
+  if (discovered.length === 0) {
+    console.log("No local bench providers were discovered.");
+    return;
+  }
+  console.log("Discovered bench providers:");
+  for (const entry of discovered) {
+    console.log(`  ${entry.provider}`);
+    for (const model of entry.models) {
+      const capabilities = model.capabilities.join(", ");
+      const details = [
+        model.contextLength > 0 ? `context=${model.contextLength}` : void 0,
+        model.parameterCount ? `params=${model.parameterCount}` : void 0,
+        model.quantization ? `quant=${model.quantization}` : void 0,
+        capabilities.length > 0 ? `caps=${capabilities}` : void 0
+      ].filter((value) => Boolean(value));
+      console.log(
+        `    - ${model.id}${details.length > 0 ? ` (${details.join(", ")})` : ""}`
+      );
+    }
   }
-  tiers.push("no_results");
-  tierDetails.push({
-    tier: "no_results",
-    latencyMs: d0 + d1 + d2 + d3 + d4,
-    resultsCount: 0
-  });
-  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
-  };
 }
-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
-  };
+async function publishBenchPackageResults(parsed) {
+  if (parsed.benchmarks.length > 0) {
+    console.error(
+      "ERROR: publish does not accept positional result references. Usage: remnic bench publish --target remnic-ai [--results-dir <path>] [--output <path>] [--json]"
+    );
+    process.exit(1);
+  }
+  if (parsed.target !== "remnic-ai") {
+    console.error("ERROR: publish requires --target remnic-ai.");
+    process.exit(1);
+  }
+  const resultsDir = parsed.resultsDir ?? resolveBenchOutputDir();
+  const feed = await buildBenchmarkPublishFeed(resultsDir, parsed.target);
+  if (feed.benchmarks.length === 0) {
+    console.error(
+      `ERROR: no publishable benchmark results found in ${resultsDir}. remnic-ai requires stored full runs for published benchmarks.`
+    );
+    process.exit(1);
+  }
+  const outputPath = parsed.output ?? defaultBenchmarkPublishPath(parsed.target);
+  const writtenPath = await writeBenchmarkPublishFeed(feed, outputPath);
+  if (parsed.json) {
+    console.log(JSON.stringify({
+      target: parsed.target,
+      outputPath: writtenPath,
+      benchmarkCount: feed.benchmarks.length,
+      feed
+    }, null, 2));
+    return;
+  }
+  console.log(
+    `Published ${feed.benchmarks.length} benchmark entries for ${parsed.target} to ${writtenPath}`
+  );
 }
-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));
-    }
+async function runBenchViaPackage(parsed, benchmarkId) {
+  let benchModule;
+  try {
+    benchModule = await import("./dist-7DCVQLUB.js");
+  } catch {
+    return false;
   }
-  const totalDuration = hrTimeMs() - suiteStart;
-  const metrics = {};
-  for (const r of results) {
-    metrics[r.query] = r.latencyMs;
+  const definition = benchModule.getBenchmark?.(benchmarkId);
+  if (!definition?.runnerAvailable || !benchModule.runBenchmark || !benchModule.writeBenchmarkResult) {
+    return false;
   }
-  const report = generateReport(results, reportPath);
-  const baseline = loadBaseline(baselinePath);
-  const regressionResult = checkRegression(
-    metrics,
-    baseline,
-    regressionTolerance
+  if (definition.meta?.category === "ingestion") {
+    throw new Error(
+      `Benchmark "${benchmarkId}" requires an ingestion adapter which is not yet available via the CLI. Run ingestion benchmarks programmatically by passing an ingestionAdapter to runBenchmark().`
+    );
+  }
+  const createAdapter = parsed.quick ? benchModule.createLightweightAdapter : benchModule.createRemnicAdapter;
+  if (!createAdapter) {
+    return false;
+  }
+  const outputDir = resolveBenchOutputDir();
+  const datasetDir = resolveBenchDatasetDir(
+    benchmarkId,
+    parsed.quick,
+    parsed.datasetDir
   );
-  if (!baseline) {
-    saveBaseline(baselinePath, {
-      version: BASELINE_VERSION,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      metrics
-    });
+  if (!parsed.quick && !datasetDir) {
+    throw new Error(
+      `full benchmark runs for "${benchmarkId}" require dataset files. Run "remnic bench datasets download ${benchmarkId}" or pass --dataset-dir <path>.`
+    );
   }
-  return {
-    results,
-    report,
-    totalDurationMs: totalDuration,
-    regressions: regressionResult.regressions
-  };
-}
-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
+  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();
   }
-  return {
-    passed: regressions.every((r) => r.passed),
-    regressions
-  };
 }
-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");
+async function runCustomBenchViaPackage(parsed) {
+  let benchModule;
+  try {
+    benchModule = await import("./dist-7DCVQLUB.js");
+  } catch {
+    return false;
   }
-  return report;
-}
-
-// 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 {
+  if (!benchModule.runCustomBenchmarkFile || !benchModule.writeBenchmarkResult) {
+    return false;
+  }
+  const createAdapter = parsed.quick ? benchModule.createLightweightAdapter : benchModule.createRemnicAdapter;
+  if (!createAdapter) {
+    return false;
+  }
+  const outputDir = resolveBenchOutputDir();
+  const system = await createAdapter();
+  try {
+    const result = await benchModule.runCustomBenchmarkFile(parsed.custom, {
+      mode: parsed.quick ? "quick" : "full",
+      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();
   }
-  return void 0;
-}
-function firstSuccessfulCandidate(candidates, attempt) {
-  return firstSuccessfulResult(candidates, (candidate) => {
-    attempt(candidate);
-    return candidate;
-  });
-}
-
-// src/index.ts
-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");
 function resolveConfigPath(cliPath) {
   if (cliPath) return path2.resolve(cliPath);
   const envPath = readCompatEnv("REMNIC_CONFIG_PATH", "ENGRAM_CONFIG_PATH");
@@ -330,7 +1371,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 +1380,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 +1411,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 +1471,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-...");
@@ -417,68 +1486,568 @@ async function cmdStatus(json) {
     console.log(JSON.stringify({ running, pid: pid ?? null, pidFile: PID_FILE, logFile: LOG_FILE }));
     return;
   }
-  if (!running) {
-    console.log("Remnic server: stopped");
+  if (!running) {
+    console.log("Remnic server: stopped");
+    return;
+  }
+  console.log(`Remnic server: running${pid ? ` (pid ${pid})` : ""}`);
+  const port = inferPort();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e3);
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/engram/v1/health`, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      console.log(`Health: server responded with ${response.status} ${response.statusText}`);
+    } else {
+      const health = await response.json();
+      console.log(`Health: ${health.status ?? "ok"}`);
+    }
+  } catch {
+    console.log("Health: unable to reach server");
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+async function cmdQuery(queryText, json, explain) {
+  if (!queryText) {
+    console.error("Usage: remnic query <text>");
+    process.exit(1);
+  }
+  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 orchestrator = new Orchestrator(config);
+  await orchestrator.initialize();
+  await orchestrator.deferredReady;
+  const service = new EngramAccessService(orchestrator);
+  if (explain) {
+    const result2 = await runExplain(service, queryText);
+    if (json) {
+      console.log(JSON.stringify(result2, null, 2));
+    } else {
+      console.log(`Query: ${result2.query}`);
+      console.log(`Tiers used: ${result2.tiersUsed.join(" \u2192 ")}`);
+      console.log(`Total duration: ${result2.totalDurationMs}ms`);
+      for (const t of result2.tierResults) {
+        console.log(`  ${t.tier}: ${t.latencyMs}ms (${t.resultsCount} results)`);
+      }
+    }
+    return;
+  }
+  const result = await service.recall({ query: queryText, mode: "auto" });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const memories = result.memories ?? [];
+    if (memories.length === 0) {
+      console.log("No results.");
+      return;
+    }
+    for (const m of memories) {
+      console.log(`- ${m.content}`);
+    }
+  }
+}
+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();
+    await orchestrator2.deferredReady;
+    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();
+  await orchestrator.deferredReady;
+  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;
   }
-  console.log(`Remnic server: running${pid ? ` (pid ${pid})` : ""}`);
-  const port = inferPort();
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 3e3);
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/engram/v1/health`, {
-      signal: controller.signal
-    });
-    if (!response.ok) {
-      console.log(`Health: server responded with ${response.status} ${response.statusText}`);
-    } else {
-      const health = await response.json();
-      console.log(`Health: ${health.status ?? "ok"}`);
+  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)}`
+          );
+        }
+      }
     }
-  } catch {
-    console.log("Health: unable to reach server");
-  } finally {
-    clearTimeout(timeoutId);
   }
-}
-async function cmdQuery(queryText, json, explain) {
-  if (!queryText) {
-    console.error("Usage: remnic query <text>");
-    process.exit(1);
+  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 = 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);
-  await orchestrator.initialize();
-  const service = new EngramAccessService(orchestrator);
-  if (explain) {
-    const result2 = await runExplain(service, queryText);
-    if (json) {
-      console.log(JSON.stringify(result2, null, 2));
-    } else {
-      console.log(`Query: ${result2.query}`);
-      console.log(`Tiers used: ${result2.tiersUsed.join(" \u2192 ")}`);
-      console.log(`Total duration: ${result2.totalDurationMs}ms`);
-      for (const t of result2.tierResults) {
-        console.log(`  ${t.tier}: ${t.latencyMs}ms (${t.resultsCount} results)`);
+  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;
     }
-    return;
-  }
-  const result = await service.recall({ query: queryText, mode: "auto" });
-  if (json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    const memories = result.memories ?? [];
-    if (memories.length === 0) {
-      console.log("No results.");
-      return;
+    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;
     }
-    for (const m of memories) {
-      console.log(`- ${m.content}`);
+    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);
     }
   }
 }
@@ -492,7 +2061,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 +2071,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 +2082,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 +2367,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 +2386,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 +2730,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);
@@ -919,41 +2769,140 @@ async function cmdBenchmark(action, rest, json) {
       console.log("No baseline found. Run `remnic benchmark run` first.");
       return;
     }
-    const suite = await runBenchSuite(service, benchConfig);
-    const metrics = {};
-    for (const r of suite.results) {
-      metrics[r.query] = r.latencyMs;
-    }
-    const tolerance = benchConfig.regressionTolerance ?? 10;
-    const result = checkRegression(metrics, baseline, tolerance);
-    if (json) {
-      console.log(JSON.stringify(result, null, 2));
-    } else {
-      if (result.passed) {
-        console.log("No regressions detected.");
-      } else {
-        console.log("Regressions detected:");
-        for (const reg of result.regressions) {
-          if (!reg.passed) {
-            console.log(`  \u2717 ${reg.metric}: ${reg.currentValue}ms vs ${reg.baselineValue}ms baseline (+${((reg.currentValue - reg.baselineValue) / reg.baselineValue * 100).toFixed(1)}%)`);
-          }
-        }
-      }
+    const suite = await runBenchSuite(service, benchConfig);
+    const metrics = {};
+    for (const r of suite.results) {
+      metrics[r.query] = r.latencyMs;
+    }
+    const tolerance = benchConfig.regressionTolerance ?? 10;
+    const result = checkRegression(metrics, baseline, tolerance);
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      if (result.passed) {
+        console.log("No regressions detected.");
+      } else {
+        console.log("Regressions detected:");
+        for (const reg of result.regressions) {
+          if (!reg.passed) {
+            console.log(`  \u2717 ${reg.metric}: ${reg.currentValue}ms vs ${reg.baselineValue}ms baseline (+${((reg.currentValue - reg.baselineValue) / reg.baselineValue * 100).toFixed(1)}%)`);
+          }
+        }
+      }
+    }
+    if (!result.passed) {
+      process.exit(1);
+    }
+  } else if (action === "report") {
+    const reportPath = benchConfig.reportPath;
+    const suite = await runBenchSuite(service, { ...benchConfig, reportPath });
+    console.log(`Report saved to ${reportPath ?? "benchmarks/report.json"}`);
+    if (json) {
+      console.log(JSON.stringify(suite.report, null, 2));
+    }
+  } else {
+    console.log("Usage: remnic benchmark <run|check|report> [queries...] [--explain] [--baseline=<path>] [--report=<path>]");
+    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 === "compare") {
+    await compareBenchPackageResults(parsed);
+    return;
+  }
+  if (parsed.action === "results") {
+    await showBenchPackageResults(parsed);
+    return;
+  }
+  if (parsed.action === "baseline") {
+    await manageBenchBaselines(parsed);
+    return;
+  }
+  if (parsed.action === "export") {
+    await exportBenchPackageResult(parsed);
+    return;
+  }
+  if (parsed.action === "datasets") {
+    await manageBenchDatasets(parsed);
+    return;
+  }
+  if (parsed.action === "runs") {
+    await manageBenchRuns(parsed);
+    return;
+  }
+  if (parsed.action === "publish") {
+    await publishBenchPackageResults(parsed);
+    return;
+  }
+  if (parsed.action === "ui") {
+    await launchBenchUi(parsed.resultsDir ?? resolveBenchOutputDir());
+    return;
+  }
+  if (parsed.action === "providers") {
+    await discoverBenchProviders(parsed);
+    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}`);
     }
-    if (!result.passed) {
+    return;
+  }
+  if (parsed.custom) {
+    if (parsed.all || parsed.benchmarks.length > 0) {
+      console.error("ERROR: --custom cannot be combined with benchmark names or --all.");
       process.exit(1);
     }
-  } else if (action === "report") {
-    const reportPath = benchConfig.reportPath;
-    const suite = await runBenchSuite(service, { ...benchConfig, reportPath });
-    console.log(`Report saved to ${reportPath ?? "benchmarks/report.json"}`);
-    if (json) {
-      console.log(JSON.stringify(suite.report, null, 2));
+    const handledByPackage = await runCustomBenchViaPackage(parsed);
+    if (!handledByPackage) {
+      console.error(
+        "Benchmark runner not found. Expected a phase-1 @remnic/bench runtime export for custom benchmarks."
+      );
+      process.exit(1);
     }
-  } else {
-    console.log("Usage: remnic benchmark <run|check|report> [queries...] [--explain] [--baseline=<path>] [--report=<path>]");
+    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";
@@ -989,7 +2938,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 +2947,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 +2958,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 +2986,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 +3003,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 +3030,7 @@ function daemonUninstall() {
       } catch {
       }
       try {
-        fs2.unlinkSync(plistPath);
+        fs.unlinkSync(plistPath);
         removed = true;
         console.log(`Removed launchd service: ${plistPath}`);
       } catch {
@@ -1101,7 +3050,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 +3108,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 +3145,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 +3153,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 +3162,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 +3186,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 +3199,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 +3220,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 +3272,644 @@ 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;
+  }
+}
+function resolveRequiredValueFlag(args, flag) {
+  if (!hasFlag(args, flag)) return void 0;
+  const value = resolveFlagStrict(args, flag);
+  if (value === void 0) {
+    throw new Error(
+      `${flag} requires a value. Provide it as \`${flag} <value>\`, not as a bare flag.`
+    );
+  }
+  return value;
+}
+function parseTrainingExportArgs(rest, defaultMemoryDir) {
+  const format = resolveRequiredValueFlag(rest, "--format");
+  if (!format) {
+    throw new Error(
+      "--format <name> is required. Run `remnic training:export --help` for the list of registered adapters."
+    );
+  }
+  const dryRun = hasFlag(rest, "--dry-run");
+  const outputRaw = resolveRequiredValueFlag(rest, "--output") ?? resolveRequiredValueFlag(rest, "--out");
+  if (!outputRaw && !dryRun) {
+    throw new Error(
+      "--output <path> (or --out <path>) is required for training:export. Use --dry-run to print statistics without writing a file."
+    );
+  }
+  const output = outputRaw ? expandTilde(outputRaw) : "";
+  const memoryDirFlag = resolveRequiredValueFlag(rest, "--memory-dir");
+  const memoryDir = expandTilde(memoryDirFlag ?? defaultMemoryDir);
+  const since = resolveRequiredValueFlag(rest, "--since");
+  const until = resolveRequiredValueFlag(rest, "--until");
+  const minConfidenceRaw = resolveRequiredValueFlag(rest, "--min-confidence");
+  let minConfidence;
+  if (minConfidenceRaw !== void 0) {
+    const n = Number(minConfidenceRaw);
+    if (!Number.isFinite(n) || n < 0 || n > 1) {
+      throw new Error(
+        `Invalid --min-confidence value "${minConfidenceRaw}": expected a number in [0, 1].`
+      );
+    }
+    minConfidence = n;
+  }
+  const categoriesRaw = resolveRequiredValueFlag(rest, "--categories");
+  const categories = categoriesRaw ? categoriesRaw.split(",").map((c) => c.trim()).filter((c) => c.length > 0) : void 0;
+  const maxPairsRaw = resolveRequiredValueFlag(rest, "--max-pairs-per-record");
+  let maxPairsPerRecord;
+  if (maxPairsRaw !== void 0) {
+    const n = Number(maxPairsRaw);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error(
+        `Invalid --max-pairs-per-record value "${maxPairsRaw}": expected a positive integer.`
+      );
+    }
+    maxPairsPerRecord = n;
+  }
+  const includeEntities = hasFlag(rest, "--include-entities");
+  const synthesize = hasFlag(rest, "--synthesize");
+  const privacySweep = !hasFlag(rest, "--no-privacy-sweep");
+  return {
+    format,
+    output,
+    memoryDir,
+    since,
+    until,
+    minConfidence,
+    categories,
+    includeEntities,
+    synthesize,
+    maxPairsPerRecord,
+    privacySweep,
+    dryRun
+  };
+}
+async function runTrainingExport(args, stdout = process.stdout) {
+  ensureWecloneExportAdapterRegistered();
+  const adapter = getTrainingExportAdapter2(args.format);
+  if (!adapter) {
+    const registered = listTrainingExportAdapters();
+    const validList = registered.length > 0 ? `Valid formats: [${registered.join(", ")}]` : "No adapters are currently registered.";
+    throw new Error(
+      `Unknown training-export format "${args.format}". ${validList}`
+    );
+  }
+  if (!fs.existsSync(args.memoryDir)) {
+    throw new Error(
+      `--memory-dir "${args.memoryDir}" does not exist. Provide the path to an existing memory directory.`
+    );
+  }
+  if (!fs.statSync(args.memoryDir).isDirectory()) {
+    throw new Error(
+      `--memory-dir "${args.memoryDir}" is not a directory. Provide the path to a memory directory, not a file.`
+    );
+  }
+  let since;
+  if (args.since) since = parseStrictCliDate(args.since, "--since");
+  let until;
+  if (args.until) until = parseStrictCliDate(args.until, "--until");
+  const convertOptions = {
+    memoryDir: args.memoryDir,
+    since,
+    until,
+    minConfidence: args.minConfidence,
+    categories: args.categories,
+    includeEntities: args.includeEntities
+  };
+  let records = await convertMemoriesToRecords(convertOptions);
+  const recordsRead = records.length;
+  if (args.synthesize) {
+    records = synthesizeTrainingPairs(records, {
+      maxPairsPerRecord: args.maxPairsPerRecord
+    });
+  }
+  let redactedCount = 0;
+  if (args.privacySweep) {
+    const swept = sweepPii(records);
+    records = swept.cleanRecords;
+    redactedCount = swept.redactedCount;
+  }
+  if (args.dryRun) {
+    stdout.write(`Training export dry run
+`);
+    stdout.write(`Format: ${adapter.name}
+`);
+    stdout.write(`Records read: ${recordsRead}
+`);
+    stdout.write(`Records to write: ${records.length}
+`);
+    if (args.privacySweep) {
+      stdout.write(`Redacted records: ${redactedCount}
+`);
+    }
+    const cats = /* @__PURE__ */ new Map();
+    for (const r of records) {
+      const c = r.category ?? "unknown";
+      cats.set(c, (cats.get(c) ?? 0) + 1);
+    }
+    const sortedCats = [...cats.entries()].sort(
+      (a, b) => a[0].localeCompare(b[0])
+    );
+    for (const [cat, count] of sortedCats) {
+      stdout.write(`  ${cat}: ${count}
+`);
+    }
+    return {
+      recordsRead,
+      recordsWritten: 0,
+      redactedCount,
+      outputPath: null
+    };
+  }
+  if (!args.output) {
+    throw new Error(
+      "runTrainingExport: `output` is required when dryRun is false. Pass dryRun: true to skip file I/O."
+    );
+  }
+  const formatted = adapter.formatRecords(records);
+  const outDir = path2.dirname(args.output);
+  fs.mkdirSync(outDir, { recursive: true });
+  const tmpPath = `${args.output}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmpPath, formatted, "utf-8");
+  fs.renameSync(tmpPath, args.output);
+  stdout.write(
+    `Exported ${records.length} records to ${args.output} (${adapter.name} format)
+`
+  );
+  if (args.privacySweep && redactedCount > 0) {
+    stdout.write(`Privacy sweep redacted PII in ${redactedCount} record(s).
+`);
+  }
+  return {
+    recordsRead,
+    recordsWritten: records.length,
+    redactedCount,
+    outputPath: args.output
+  };
+}
 async function main(argv = process.argv.slice(2)) {
   const [command, ...rest] = argv;
   if (command !== "migrate") {
@@ -1356,7 +3962,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 +4057,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 +4065,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 +4135,106 @@ 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 "training:export": {
+      if (rest.includes("--help") || rest.includes("-h")) {
+        console.log(`
+remnic training:export \u2014 Export Remnic memories as fine-tuning datasets (issue #459)
+
+Usage:
+  remnic training:export --format <name> --output <path> [options]
+
+Required:
+  --format <name>              Registered adapter name (e.g. weclone)
+  --output <path> | --out      Path to write the dataset file
+
+Filters:
+  --memory-dir <path>          Memory directory (defaults to resolved memoryDir)
+  --since <YYYY-MM-DD[T...]>   Only include memories created at or after this date
+  --until <YYYY-MM-DD[T...]>   Only include memories created before this date (exclusive)
+  --min-confidence <0..1>      Inclusive lower bound on memory confidence
+  --categories <list>          Comma-separated category filter (fact,preference,...)
+  --include-entities           Also read from entities/ (off by default)
+
+Adapter options:
+  --synthesize                 Generate conversational Q/A pairs (WeClone-optimised)
+  --max-pairs-per-record <n>   When --synthesize, max pairs emitted per memory
+  --no-privacy-sweep           Skip the final PII redaction pass (default: on)
+
+Other:
+  --dry-run                    Print statistics only; do not write the file
+`);
+        break;
+      }
+      let parsed;
+      try {
+        parsed = parseTrainingExportArgs(rest, resolveMemoryDir());
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      try {
+        await runTrainingExport(parsed);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(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 +4249,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 +4262,39 @@ 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|datasets|runs|compare|results|baseline|export|publish|ui|providers> [benchmark...] [--quick] [--all] [--dataset-dir <path>] [--results-dir <path>] [--baselines-dir <path>] [--threshold <value>] [--detail] [--format <json|csv|html>] [--output <path>] [--target remnic-ai] [--json]
+    benchmark is kept as a compatibility alias. check/report remain under that alias.
+  remnic benchmark <list|run|datasets|runs|compare|results|baseline|export|publish|ui|providers|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
+  remnic training:export --format <name> --output <path> [options]
+    Export memories as a fine-tuning dataset (issue #459). Run
+    'remnic training:export --help' for the full option list.
 
 Options:
   --json    Output in JSON format
@@ -1577,5 +4313,17 @@ if (argv1Base.endsWith("remnic.ts") || argv1Base.endsWith("remnic.js") || argv1B
   });
 }
 export {
-  main
+  BENCHMARK_CATALOG,
+  TAXONOMY_RESOLVE_BOOLEAN_FLAGS,
+  buildBenchRunnerArgs,
+  getBenchUsageText,
+  hasFlag,
+  main,
+  parseBenchArgs,
+  parseConnectorConfig,
+  parseTrainingExportArgs,
+  resolveFlag,
+  runTrainingExport,
+  stripConfigArgv,
+  stripResolveFlags
 };