@remnic/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1581 @@
+// src/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import * as childProcess from "child_process";
+import {
+  parseConfig,
+  Orchestrator,
+  EngramAccessService,
+  initLogger,
+  onboard,
+  curate,
+  listReviewItems,
+  performReview,
+  syncChanges,
+  watchForChanges,
+  findDuplicates,
+  listConnectors,
+  installConnector,
+  removeConnector,
+  doctorConnector,
+  generateToken,
+  listTokens,
+  revokeToken,
+  listSpaces,
+  getActiveSpace,
+  createSpace,
+  deleteSpace,
+  switchSpace,
+  pushToSpace,
+  pullFromSpace,
+  shareSpace,
+  promoteSpace,
+  getAuditLog,
+  getManifestPath,
+  generateContextTree,
+  migrateFromEngram,
+  rollbackFromEngramMigration
+} from "@remnic/core";
+
+// ../bench/src/benchmark.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_BASELINE_PATH = path.join(
+  process.cwd(),
+  "benchmarks",
+  "baseline.json"
+);
+var DEFAULT_REPORT_PATH = path.join(
+  process.cwd(),
+  "benchmarks",
+  "report.json"
+);
+var BASELINE_VERSION = 1;
+var DEFAULT_QUERIES = [
+  "What is the storage?",
+  "How do I access storage?",
+  "What categories exist?",
+  "How is memory organized?",
+  "What is the recall budget?",
+  "What is the extraction pipeline?",
+  "What facts are stored about the project?",
+  "What is the architecture?"
+];
+var DEFAULT_TOLERANCE = 10;
+function hrTimeMs() {
+  const [s, ns] = process.hrtime();
+  return s * 1e3 + Math.round(ns / 1e6);
+}
+function loadBaseline(baselinePath) {
+  const p = baselinePath ?? DEFAULT_BASELINE_PATH;
+  if (!fs.existsSync(p)) return void 0;
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+    if (raw.version !== BASELINE_VERSION) {
+      console.warn(
+        `Baseline version mismatch: expected ${BASELINE_VERSION}, got ${raw.version}`
+      );
+    }
+    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())
+    );
+    if (hasExactMatch) {
+      tiers.push("exact_match");
+      tierDetails.push({
+        tier: "exact_match",
+        latencyMs: d0,
+        resultsCount: r0.results.length
+      });
+      return { tiers, tierDetails };
+    }
+  }
+  const t1 = hrTimeMs();
+  const r1 = await service.recall({ query, mode: "auto" });
+  const d1 = hrTimeMs() - t1;
+  const queryWords = query.toLowerCase().split(/\s+/).filter((w) => w.length > 2);
+  const hasKeywordMatch = (r1.results ?? []).some(
+    (m) => queryWords.some((kw) => m.preview.toLowerCase().includes(kw))
+  );
+  if (hasKeywordMatch) {
+    tiers.push("category_match");
+    tierDetails.push({
+      tier: "category_match",
+      latencyMs: d1,
+      resultsCount: r1.results.length
+    });
+    return { tiers, tierDetails };
+  }
+  const t2 = hrTimeMs();
+  const r2 = await service.recall({ query, mode: "auto" });
+  const d2 = hrTimeMs() - t2;
+  const tagged = (r2.results ?? []).filter((m) => m.tags && m.tags.length > 0);
+  if (tagged.length > 0) {
+    tiers.push("high_confidence");
+    tierDetails.push({
+      tier: "high_confidence",
+      latencyMs: d2,
+      resultsCount: tagged.length
+    });
+    return { tiers, tierDetails };
+  }
+  const t3 = hrTimeMs();
+  const r3 = await service.recall({ query, mode: "auto" });
+  const d3 = hrTimeMs() - t3;
+  if (r3.results && r3.results.length > 0) {
+    tiers.push("semantic_search");
+    tierDetails.push({
+      tier: "semantic_search",
+      latencyMs: d3,
+      resultsCount: r3.results.length
+    });
+    return { tiers, tierDetails };
+  }
+  const t4 = hrTimeMs();
+  const r4 = await service.recall({ query, mode: "full" });
+  const d4 = hrTimeMs() - t4;
+  if (r4.results && r4.results.length > 0) {
+    tiers.push("full_search");
+    tierDetails.push({
+      tier: "full_search",
+      latencyMs: d4,
+      resultsCount: r4.results.length
+    });
+    return { tiers, tierDetails };
+  }
+  tiers.push("no_results");
+  tierDetails.push({
+    tier: "no_results",
+    latencyMs: d0 + d1 + d2 + d3 + d4,
+    resultsCount: 0
+  });
+  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 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));
+    }
+  }
+  const totalDuration = hrTimeMs() - suiteStart;
+  const metrics = {};
+  for (const r of results) {
+    metrics[r.query] = r.latencyMs;
+  }
+  const report = generateReport(results, reportPath);
+  const baseline = loadBaseline(baselinePath);
+  const regressionResult = checkRegression(
+    metrics,
+    baseline,
+    regressionTolerance
+  );
+  if (!baseline) {
+    saveBaseline(baselinePath, {
+      version: BASELINE_VERSION,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metrics
+    });
+  }
+  return {
+    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
+    });
+  }
+  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");
+  }
+  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 {
+    }
+  }
+  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");
+  if (envPath) return path2.resolve(envPath);
+  const candidates = [
+    path2.join(process.cwd(), "remnic.config.json"),
+    path2.join(process.cwd(), "engram.config.json"),
+    path2.join(resolveHomeDir(), ".config", "remnic", "config.json"),
+    path2.join(resolveHomeDir(), ".config", "engram", "config.json")
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) return candidate;
+  }
+  return path2.join(resolveHomeDir(), ".config", "remnic", "config.json");
+}
+function resolveMemoryDir() {
+  const configMemoryDir = (() => {
+    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 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;
+    return openclawPath;
+  })();
+  const manifestPath = getManifestPath();
+  if (fs2.existsSync(manifestPath)) {
+    try {
+      const active = getActiveSpace();
+      if (active?.memoryDir) {
+        if (!fs2.existsSync(active.memoryDir)) {
+          fs2.mkdirSync(active.memoryDir, { recursive: true });
+        }
+        return active.memoryDir;
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("not found")) {
+        console.error(`Error: failed to resolve active space from ${manifestPath}: ${msg}`);
+        process.exit(1);
+      }
+    }
+  }
+  return configMemoryDir;
+}
+function resolveFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+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;
+    }
+  }
+  return config;
+}
+function cmdInit() {
+  const configPath = path2.join(process.cwd(), "remnic.config.json");
+  if (fs2.existsSync(configPath)) {
+    console.log(`Config already exists: ${configPath}`);
+    return;
+  }
+  const template = {
+    remnic: {
+      openaiApiKey: "${OPENAI_API_KEY}",
+      memoryDir: path2.join(process.cwd(), ".remnic", "memory"),
+      memoryOsPreset: "balanced"
+    },
+    server: {
+      host: "127.0.0.1",
+      port: 4318,
+      authToken: "${REMNIC_AUTH_TOKEN}"
+    }
+  };
+  fs2.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-...");
+  console.log("  export REMNIC_AUTH_TOKEN=$(openssl rand -hex 32)");
+  console.log("  # ENGRAM_AUTH_TOKEN is still accepted during v1.x");
+  console.log("\nThen start the server:");
+  console.log("  npx remnic-server");
+}
+async function cmdStatus(json) {
+  const { running, pid } = isServiceRunning();
+  if (json) {
+    console.log(JSON.stringify({ running, pid: pid ?? null, pidFile: PID_FILE, logFile: LOG_FILE }));
+    return;
+  }
+  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 = fs2.existsSync(configPath) ? JSON.parse(fs2.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)`);
+      }
+    }
+    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}`);
+    }
+  }
+}
+function cmdDoctor() {
+  const checks = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  checks.push({
+    name: "Node.js version",
+    ok: nodeMajor >= 22,
+    detail: `${nodeVersion} (requires >= 22.12.0)`
+  });
+  const configPath = resolveConfigPath();
+  const configExists = fs2.existsSync(configPath);
+  checks.push({ name: "Config file", ok: configExists, detail: configPath });
+  const hasApiKey = !!process.env.OPENAI_API_KEY;
+  checks.push({
+    name: "OPENAI_API_KEY",
+    ok: hasApiKey,
+    detail: hasApiKey ? "set" : "not set (extraction will not work)"
+  });
+  const memoryDir = resolveMemoryDir();
+  try {
+    fs2.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}` });
+  }
+  const svcState = isServiceRunning();
+  checks.push({
+    name: "Server daemon",
+    ok: svcState.running,
+    detail: svcState.running ? `running${svcState.pid ? ` (pid ${svcState.pid})` : ""}` : "stopped"
+  });
+  for (const check of checks) {
+    const icon = check.ok ? "\u2713" : "\u2717";
+    console.log(`  ${icon} ${check.name}: ${check.detail}`);
+  }
+}
+function cmdConfig() {
+  const configPath = resolveConfigPath();
+  if (!fs2.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 redacted = rawConfig.replace(
+    /("(?:openaiApiKey|localLlmApiKey|authToken|apiKey|remoteSearchApiKey|meilisearchApiKey|opikApiKey)"\s*:\s*")([^"]*)(")/g,
+    "$1[REDACTED]$3"
+  );
+  console.log(redacted);
+}
+async function cmdMigrate(json, rollback) {
+  if (rollback) {
+    const result2 = await rollbackFromEngramMigration({ quiet: json });
+    if (json) {
+      console.log(JSON.stringify(result2, null, 2));
+      return;
+    }
+    if (result2.restored.length === 0 && result2.removed.length === 0) {
+      console.log("No migration rollback state found.");
+      return;
+    }
+    console.log("Rollback complete.");
+    if (result2.restored.length > 0) {
+      console.log(`  Restored: ${result2.restored.length}`);
+    }
+    if (result2.removed.length > 0) {
+      console.log(`  Removed: ${result2.removed.length}`);
+    }
+    return;
+  }
+  const result = await migrateFromEngram({ quiet: json });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  if (result.status === "fresh-install") {
+    console.log("No Engram install found. Nothing to migrate.");
+    return;
+  }
+  if (result.status === "already-migrated") {
+    console.log("Migration already completed.");
+    return;
+  }
+  console.log("Migration complete.");
+  console.log(`  Copied: ${result.copied.length}`);
+  console.log(`  Tokens rewritten: ${result.tokensRegenerated}`);
+  console.log(`  Services updated: ${result.servicesReinstalled.length}`);
+  console.log(`  Rollback: ${result.rollbackCommand}`);
+}
+function cmdOnboard(dirPath, json) {
+  const directory = path2.resolve(dirPath || process.cwd());
+  const result = onboard({ directory });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Shape: ${result.shape}`);
+  console.log(`Languages: ${result.languages.map((l) => `${l.language} (${(l.confidence * 100).toFixed(0)}%)`).join(", ")}`);
+  console.log(`Docs: ${result.docs.length} file(s)`);
+  console.log(result.docs.map((s) => `  ${s.kind} (${s.size} bytes)`).join("\n"));
+  console.log(`Plan: ${result.plan.priorityFiles.length} priority, ${result.plan.estimatedFiles} total files`);
+  console.log(`
+Suggested namespace: ${result.plan.suggestedNamespace}`);
+  console.log(`Total files: ${result.totalFiles}`);
+  console.log(`Duration: ${result.durationMs}ms`);
+}
+async function cmdCurate(targetPath, json) {
+  const memoryDir = resolveMemoryDir();
+  const result = await curate({
+    targetPath: path2.resolve(targetPath),
+    memoryDir,
+    source: "curation",
+    checkDuplicates: true,
+    checkContradictions: true
+  });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Files: ${result.filesProcessed} processed, ${result.filesSkipped} skipped`);
+  console.log(`Statements: ${result.statements.length}`);
+  if (result.duplicates.length > 0) console.log(`Duplicates: ${result.duplicates.length}`);
+  if (result.contradictions.length > 0) console.log(`Contradictions: ${result.contradictions.length}`);
+  console.log(`Written: ${result.written.length}`);
+  console.log(`Duration: ${result.durationMs}ms`);
+}
+function cmdReview(action, rest) {
+  const memoryDir = resolveMemoryDir();
+  if (action === "list") {
+    const result = listReviewItems({ memoryDir });
+    if (result.items.length === 0) {
+      console.log("No items pending review.");
+      return;
+    }
+    for (const item of result.items) {
+      console.log(`[${item.reviewReason}] ${item.id} ${item.content.slice(0, 80)}${item.content.length > 80 ? "..." : ""}`);
+      console.log(`  Confidence: ${item.confidence} | Category: ${item.category}`);
+      console.log(`  Source: ${item.source} | Created: ${item.created}`);
+    }
+    return;
+  }
+  if (action === "approve" || action === "dismiss" || action === "flag") {
+    const id = rest[0];
+    if (!id) {
+      console.error("Usage: remnic review <approve|dismiss|flag> <id>");
+      process.exit(1);
+    }
+    const result = performReview(memoryDir, id, action);
+    console.log(result.message);
+  } else {
+    console.log("Usage: remnic review <list|approve|dismiss|flag> [id]");
+    process.exit(1);
+  }
+}
+function cmdSync(action, rest, json) {
+  const sourceIdx = rest.indexOf("--source");
+  const sourceDir = sourceIdx >= 0 && rest[sourceIdx + 1] ? rest[sourceIdx + 1] : ".";
+  const memoryDir = resolveMemoryDir();
+  if (action === "run") {
+    const result = syncChanges({ sourceDir, memoryDir });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Scanned: ${result.scanned}`);
+      console.log(`Added: ${result.added.length}`);
+      console.log(`Modified: ${result.changed.filter((c) => c.type === "modified").length}`);
+      console.log(`Deleted: ${result.deleted.length}`);
+      console.log(`Unchanged: ${result.unchanged}`);
+      console.log(`Duration: ${result.durationMs}ms`);
+    }
+  } else if (action === "watch") {
+    const { stop } = watchForChanges(
+      { sourceDir, memoryDir },
+      (changes) => {
+        console.log(`Changed: ${changes.length} file(s)`);
+        for (const c of changes) {
+          console.log(`  [${c.type}] ${c.relativePath}`);
+        }
+      }
+    );
+    console.log("Watching... (Ctrl+C to stop)");
+    process.on("SIGINT", () => {
+      stop();
+      console.log("Stopped watching.");
+    });
+  } else {
+    console.log("Usage: remnic sync <run|watch> [--source <dir>]");
+    process.exit(1);
+  }
+}
+function cmdDedup(json) {
+  const memoryDir = resolveMemoryDir();
+  const result = findDuplicates({ memoryDir });
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Scanned: ${result.scanned} memories`);
+  console.log(`Found ${result.duplicates.length} duplicate pairs`);
+  for (const dup of result.duplicates) {
+    console.log(`  [${dup.action}] ${dup.left.content.slice(0, 60)}...`);
+    console.log(`    vs: ${dup.right.content.slice(0, 60)}...`);
+    console.log(`    Similarity: ${(dup.similarity * 100).toFixed(2)}%`);
+  }
+  console.log(`Duration: ${result.durationMs}ms`);
+}
+async function cmdConnectors(action, rest, json) {
+  const nonFlagArgs = rest.filter((a) => !a.startsWith("--"));
+  const connectorId = nonFlagArgs[0];
+  if (action === "list") {
+    const { installed, available } = listConnectors();
+    if (json) {
+      console.log(JSON.stringify({ installed, available }, null, 2));
+    } else {
+      console.log("Available connectors:");
+      for (const c of available) {
+        const icon = c.installed ? "\u2713" : "\u25CB";
+        console.log(`  ${icon} ${c.id.padEnd(22)} ${c.name} v${c.version} \u2014 ${c.description}`);
+      }
+    }
+  } else if (action === "install") {
+    if (!connectorId) {
+      console.error("Usage: remnic connectors install <id>");
+      process.exit(1);
+    }
+    const result = installConnector({
+      connectorId,
+      config: parseConnectorConfig(rest),
+      force: rest.includes("--force")
+    });
+    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}`);
+  } else if (action === "remove") {
+    if (!connectorId) {
+      console.error("Usage: remnic connectors remove <id>");
+      process.exit(1);
+    }
+    const result = removeConnector(connectorId);
+    console.log(result.message);
+  } else if (action === "doctor") {
+    if (!connectorId) {
+      console.error("Usage: remnic connectors doctor <id>");
+      process.exit(1);
+    }
+    const result = await doctorConnector(connectorId);
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      for (const check of result.checks) {
+        const icon = check.ok ? "\u2713" : "\u2717";
+        console.log(`  ${icon} ${check.name}: ${check.detail}`);
+      }
+      console.log(result.healthy ? "\nConnector healthy" : "\nConnector has issues");
+    }
+  } else {
+    console.log("Usage: remnic connectors <list|install|remove|doctor> [id]");
+    process.exit(1);
+  }
+}
+async function cmdSpace(action, rest, json) {
+  const nonFlagArgs = rest.filter((a) => !a.startsWith("--"));
+  if (action === "list") {
+    const spaces = listSpaces();
+    if (json) {
+      console.log(JSON.stringify(spaces, null, 2));
+    } else {
+      const active = getActiveSpace();
+      for (const s of spaces) {
+        const icon = s.id === active.id ? "\u25CF" : "\u25CB";
+        console.log(`  ${icon} ${s.name} (${s.kind}) \u2014 ${s.memoryDir}`);
+      }
+    }
+  } else if (action === "switch") {
+    const spaceId = nonFlagArgs[0];
+    if (!spaceId) {
+      console.error("Usage: remnic space switch <id>");
+      process.exit(1);
+    }
+    const result = switchSpace(spaceId);
+    console.log(result.message);
+  } else if (action === "create") {
+    const parentIdx = rest.indexOf("--parent");
+    const parentSpaceId = parentIdx >= 0 && rest[parentIdx + 1] ? rest[parentIdx + 1] : void 0;
+    const positionals = [];
+    for (let i = 0; i < rest.length; i++) {
+      if (rest[i] === "--parent") {
+        i++;
+        continue;
+      }
+      if (rest[i].startsWith("--")) continue;
+      positionals.push(rest[i]);
+    }
+    const name = positionals[0];
+    const rawKind = positionals[1] ?? "project";
+    const validKinds = ["personal", "project", "team"];
+    if (!validKinds.includes(rawKind)) {
+      console.error(`Invalid kind "${rawKind}". Must be one of: ${validKinds.join(", ")}`);
+      process.exit(1);
+    }
+    const kind = rawKind;
+    if (!name) {
+      console.error("Usage: remnic space create <name> [personal|project|team] [--parent <id>]");
+      process.exit(1);
+    }
+    const space = createSpace({ name, kind, parentSpaceId });
+    if (json) {
+      console.log(JSON.stringify(space, null, 2));
+    } else {
+      console.log(`Created space "${space.name}" (${space.id})`);
+      console.log(`  Kind: ${space.kind}`);
+      console.log(`  Dir: ${space.memoryDir}`);
+    }
+  } else if (action === "delete") {
+    const spaceId = nonFlagArgs[0];
+    if (!spaceId) {
+      console.error("Usage: remnic space delete <id>");
+      process.exit(1);
+    }
+    deleteSpace(spaceId);
+    console.log(`Deleted space "${spaceId}"`);
+  } else if (action === "push") {
+    const sourceId = nonFlagArgs[0];
+    const targetId = nonFlagArgs[1];
+    if (!sourceId || !targetId) {
+      console.error("Usage: remnic space push <source> <target>");
+      process.exit(1);
+    }
+    const result = pushToSpace(sourceId, targetId, { force: rest.includes("--force") });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Pushed ${result.memoriesPushed} memories`);
+      if (result.conflicts.length > 0) console.log(`Conflicts: ${result.conflicts.length}`);
+      console.log(`Duration: ${result.durationMs}ms`);
+    }
+  } else if (action === "pull") {
+    const sourceId = nonFlagArgs[0];
+    const targetId = nonFlagArgs[1];
+    if (!sourceId || !targetId) {
+      console.error("Usage: remnic space pull <source> <target>");
+      process.exit(1);
+    }
+    const result = pullFromSpace(sourceId, targetId, { force: rest.includes("--force") });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Pulled ${result.memoriesPulled} memories`);
+      if (result.conflicts.length > 0) console.log(`Conflicts: ${result.conflicts.length}`);
+      console.log(`Duration: ${result.durationMs}ms`);
+    }
+  } else if (action === "share") {
+    const spaceId = nonFlagArgs[0];
+    const members = nonFlagArgs.slice(1);
+    if (!spaceId || members.length === 0) {
+      console.error("Usage: remnic space share <id> <member1> [member2 ...]");
+      process.exit(1);
+    }
+    const result = shareSpace(spaceId, members);
+    console.log(result.message);
+  } else if (action === "promote") {
+    const sourceId = nonFlagArgs[0];
+    const targetId = nonFlagArgs[1];
+    if (!sourceId || !targetId) {
+      console.error("Usage: remnic space promote <source> <target>");
+      process.exit(1);
+    }
+    const result = promoteSpace(sourceId, targetId, {
+      force: rest.includes("--force"),
+      forceOverwrite: rest.includes("--force-overwrite")
+    });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`Promoted ${result.memoriesPromoted} memories`);
+      if (result.conflicts.length > 0) console.log(`Conflicts: ${result.conflicts.length}`);
+      console.log(`Duration: ${result.durationMs}ms`);
+    }
+  } else if (action === "audit") {
+    const entries = getAuditLog();
+    if (json) {
+      console.log(JSON.stringify(entries, null, 2));
+    } else {
+      if (entries.length === 0) {
+        console.log("No audit entries.");
+      } else {
+        for (const e of entries.slice(-50)) {
+          console.log(`[${e.timestamp}] ${e.action} ${e.details}`);
+        }
+      }
+    }
+  } else {
+    console.log("Usage: remnic space <list|switch|create|delete|push|pull|share|promote|audit>");
+    process.exit(1);
+  }
+}
+async function cmdBenchmark(action, rest, json) {
+  initLogger();
+  const configPath = resolveConfigPath();
+  const raw = fs2.existsSync(configPath) ? JSON.parse(fs2.readFileSync(configPath, "utf8")) : {};
+  const remnicCfg = raw.remnic ?? raw.engram ?? raw;
+  const config = parseConfig(remnicCfg);
+  const orchestrator = new Orchestrator(config);
+  const service = new EngramAccessService(orchestrator);
+  const benchConfig = {
+    queries: rest.filter((a) => !a.startsWith("--")).length > 0 ? rest.filter((a) => !a.startsWith("--")) : void 0,
+    explain: rest.includes("--explain"),
+    baselinePath: rest.find((a) => a.startsWith("--baseline="))?.slice("--baseline=".length),
+    reportPath: rest.find((a) => a.startsWith("--report="))?.slice("--report=".length)
+  };
+  if (action === "run") {
+    const suite = await runBenchSuite(service, benchConfig);
+    if (json) {
+      console.log(JSON.stringify(suite, null, 2));
+    } else {
+      console.log(`Benchmark suite completed in ${suite.totalDurationMs}ms`);
+      for (const r of suite.results) {
+        const tiers = r.tiersUsed.join(" \u2192 ");
+        console.log(`  ${r.query}: ${r.latencyMs}ms (${r.resultsCount} results) [${tiers}]`);
+      }
+      if (suite.regressions.length > 0) {
+        console.log("\nRegressions:");
+        for (const reg of suite.regressions) {
+          const icon = reg.passed ? "\u2713" : "\u2717";
+          console.log(`  ${icon} ${reg.metric}: ${reg.currentValue}ms (baseline: ${reg.baselineValue}ms, tolerance: ${reg.tolerance}%)`);
+        }
+      }
+    }
+  } else if (action === "check") {
+    const baselinePath = benchConfig.baselinePath;
+    const baseline = loadBaseline(baselinePath);
+    if (!baseline) {
+      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)}%)`);
+          }
+        }
+      }
+    }
+    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);
+  }
+}
+var LOGS_DIR = path2.join(PID_DIR, "logs");
+var LAUNCHD_LABEL = "ai.remnic.daemon";
+var LEGACY_LAUNCHD_LABEL = "ai.engram.daemon";
+var LAUNCHD_PLIST_PATH = path2.join(
+  resolveHomeDir(),
+  "Library",
+  "LaunchAgents",
+  `${LAUNCHD_LABEL}.plist`
+);
+var LEGACY_LAUNCHD_PLIST_PATH = path2.join(
+  resolveHomeDir(),
+  "Library",
+  "LaunchAgents",
+  `${LEGACY_LAUNCHD_LABEL}.plist`
+);
+var SYSTEMD_SERVICE = "remnic.service";
+var LEGACY_SYSTEMD_SERVICE = "engram.service";
+var SYSTEMD_UNIT_PATH = path2.join(
+  resolveHomeDir(),
+  ".config",
+  "systemd",
+  "user",
+  SYSTEMD_SERVICE
+);
+var LEGACY_SYSTEMD_UNIT_PATH = path2.join(
+  resolveHomeDir(),
+  ".config",
+  "systemd",
+  "user",
+  LEGACY_SYSTEMD_SERVICE
+);
+function readPid() {
+  for (const file of [PID_FILE, LEGACY_PID_FILE]) {
+    try {
+      return parseInt(fs2.readFileSync(file, "utf8").trim(), 10);
+    } catch {
+    }
+  }
+  return void 0;
+}
+function inferPort() {
+  try {
+    const configPath = resolveConfigPath();
+    const raw = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+    return raw.server?.port ?? 4318;
+  } catch {
+    return 4318;
+  }
+}
+function resolveNodePath() {
+  return process.execPath;
+}
+function resolveServerBin() {
+  const distPath = path2.resolve(import.meta.dirname, "../../remnic-server/dist/index.js");
+  if (fs2.existsSync(distPath)) return distPath;
+  const srcPath = path2.resolve(import.meta.dirname, "../../remnic-server/src/index.ts");
+  return srcPath;
+}
+function isMacOS() {
+  return process.platform === "darwin";
+}
+function isLinux() {
+  return process.platform === "linux";
+}
+function renderTemplate(templateContent, vars) {
+  let result = templateContent;
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replaceAll(`{{${key}}}`, value);
+  }
+  return result;
+}
+function daemonInstall() {
+  const home = resolveHomeDir();
+  const nodePath = resolveNodePath();
+  const serverBin = resolveServerBin();
+  if (serverBin.endsWith(".ts")) {
+    console.error("Error: @remnic/server has not been built. Run 'pnpm run build --filter=@remnic/server' first.");
+    console.error(`  Expected: ${path2.resolve(import.meta.dirname, "../../remnic-server/dist/index.js")}`);
+    console.error(`  Found:    ${serverBin} (TypeScript source \u2014 not loadable by node)`);
+    process.exit(1);
+  }
+  const vars = { HOME: home, NODE_PATH: nodePath, REMNIC_SERVER_BIN: serverBin };
+  fs2.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 plist = renderTemplate(template, vars);
+    fs2.mkdirSync(path2.dirname(LAUNCHD_PLIST_PATH), { recursive: true });
+    fs2.writeFileSync(LAUNCHD_PLIST_PATH, plist);
+    try {
+      childProcess.execSync(`launchctl load -w "${LAUNCHD_PLIST_PATH}"`, { stdio: "pipe" });
+    } catch {
+    }
+    console.log(`Installed launchd service: ${LAUNCHD_PLIST_PATH}`);
+    console.log(`  Label: ${LAUNCHD_LABEL}`);
+    console.log(`  RunAtLoad: true, KeepAlive: true`);
+    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 unit = renderTemplate(template, vars);
+    fs2.mkdirSync(path2.dirname(SYSTEMD_UNIT_PATH), { recursive: true });
+    fs2.writeFileSync(SYSTEMD_UNIT_PATH, unit);
+    try {
+      childProcess.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+      childProcess.execSync(`systemctl --user enable ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+      childProcess.execSync(`systemctl --user start ${SYSTEMD_SERVICE}`, { stdio: "pipe" });
+    } catch {
+    }
+    console.log(`Installed systemd user service: ${SYSTEMD_UNIT_PATH}`);
+    console.log(`  Restart: on-failure, WantedBy: default.target`);
+    console.log(`  Logs: ${LOGS_DIR}/daemon.log`);
+  } else {
+    console.error(`Unsupported platform: ${process.platform}. Use 'remnic daemon start' for manual mode.`);
+    process.exit(1);
+  }
+}
+function daemonUninstall() {
+  if (isMacOS()) {
+    let removed = false;
+    for (const plistPath of [LAUNCHD_PLIST_PATH, LEGACY_LAUNCHD_PLIST_PATH]) {
+      try {
+        childProcess.execSync(`launchctl unload "${plistPath}"`, { stdio: "pipe" });
+      } catch {
+      }
+      try {
+        fs2.unlinkSync(plistPath);
+        removed = true;
+        console.log(`Removed launchd service: ${plistPath}`);
+      } catch {
+      }
+    }
+    if (!removed) {
+      console.log("Launchd plist not found \u2014 nothing to remove.");
+    }
+  } else if (isLinux()) {
+    for (const serviceName of [SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE]) {
+      try {
+        childProcess.execSync(`systemctl --user stop ${serviceName}`, { stdio: "pipe" });
+        childProcess.execSync(`systemctl --user disable ${serviceName}`, { stdio: "pipe" });
+      } catch {
+      }
+    }
+    let removed = false;
+    for (const unitPath of [SYSTEMD_UNIT_PATH, LEGACY_SYSTEMD_UNIT_PATH]) {
+      try {
+        fs2.unlinkSync(unitPath);
+        removed = true;
+        console.log(`Removed systemd service: ${unitPath}`);
+      } catch {
+      }
+    }
+    if (removed) {
+      try {
+        childProcess.execSync("systemctl --user daemon-reload", { stdio: "pipe" });
+      } catch {
+      }
+    } else {
+      console.log("Systemd unit not found \u2014 nothing to remove.");
+    }
+  } else {
+    console.error(`Unsupported platform: ${process.platform}.`);
+    process.exit(1);
+  }
+  daemonStop();
+}
+function isServiceRunning() {
+  const pidFromFile = readPid();
+  if (pidFromFile) {
+    try {
+      process.kill(pidFromFile, 0);
+      return { running: true, pid: pidFromFile };
+    } catch {
+    }
+  }
+  if (isMacOS()) {
+    const status = firstSuccessfulResult([LAUNCHD_LABEL, LEGACY_LAUNCHD_LABEL], (label) => {
+      const out = childProcess.execSync(`launchctl list ${label} 2>/dev/null`, { encoding: "utf8" });
+      const pidMatch = out.match(/"PID"\s*=\s*(\d+)/);
+      if (pidMatch) return { running: true, pid: parseInt(pidMatch[1], 10) };
+      return out.includes('"PID"') ? { running: true } : void 0;
+    });
+    if (status) return status;
+  } else if (isLinux()) {
+    const status = firstSuccessfulResult([SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE], (serviceName) => {
+      const out = childProcess.execSync(`systemctl --user is-active ${serviceName} 2>/dev/null`, {
+        encoding: "utf8"
+      }).trim();
+      if (out !== "active") return void 0;
+      try {
+        const pidOut = childProcess.execSync(
+          `systemctl --user show ${serviceName} --property=MainPID --value`,
+          { encoding: "utf8" }
+        ).trim();
+        const spid = parseInt(pidOut, 10);
+        if (spid > 0) return { running: true, pid: spid };
+      } catch {
+      }
+      return { running: true };
+    });
+    if (status) return status;
+  }
+  return { running: false };
+}
+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;
+  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}`);
+}
+function daemonStart() {
+  const svc = isServiceRunning();
+  if (svc.running) {
+    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))) {
+    const label = firstSuccessfulCandidate([LAUNCHD_LABEL, LEGACY_LAUNCHD_LABEL], (candidate) => {
+      childProcess.execSync(`launchctl start ${candidate} 2>/dev/null`, { stdio: "pipe" });
+    });
+    if (label) {
+      console.log(`Started remnic daemon via launchd (${label})`);
+      return;
+    }
+  } else if (isLinux() && (fs2.existsSync(SYSTEMD_UNIT_PATH) || fs2.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
+    const serviceName = firstSuccessfulCandidate([SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE], (candidate) => {
+      childProcess.execSync(`systemctl --user start ${candidate}`, { stdio: "pipe" });
+    });
+    if (serviceName) {
+      console.log(`Started remnic daemon via systemd (${serviceName})`);
+      return;
+    }
+  }
+  fs2.mkdirSync(PID_DIR, { recursive: true });
+  fs2.mkdirSync(LOGS_DIR, { recursive: true });
+  const logStream = fs2.openSync(LOG_FILE, "a");
+  const serverBin = resolveServerBin();
+  const isSource = serverBin.endsWith(".ts");
+  let cmd;
+  let args;
+  if (isSource) {
+    cmd = "npx";
+    args = ["tsx", serverBin];
+  } else {
+    cmd = process.execPath;
+    args = [serverBin];
+  }
+  const child = childProcess.spawn(cmd, args, {
+    detached: true,
+    stdio: ["ignore", logStream, logStream],
+    env: {
+      ...process.env,
+      REMNIC_DAEMON: "1",
+      ENGRAM_DAEMON: process.env.ENGRAM_DAEMON ?? "1"
+    }
+  });
+  child.unref();
+  fs2.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))) {
+    const label = firstSuccessfulCandidate([LAUNCHD_LABEL, LEGACY_LAUNCHD_LABEL], (candidate) => {
+      childProcess.execSync(`launchctl stop ${candidate} 2>/dev/null`, { stdio: "pipe" });
+    });
+    if (label) {
+      console.log(`Stopped remnic daemon via launchd (${label})`);
+      return;
+    }
+  } else if (isLinux() && (fs2.existsSync(SYSTEMD_UNIT_PATH) || fs2.existsSync(LEGACY_SYSTEMD_UNIT_PATH))) {
+    const serviceName = firstSuccessfulCandidate([SYSTEMD_SERVICE, LEGACY_SYSTEMD_SERVICE], (candidate) => {
+      childProcess.execSync(`systemctl --user stop ${candidate}`, { stdio: "pipe" });
+    });
+    if (serviceName) {
+      console.log(`Stopped remnic daemon via systemd (${serviceName})`);
+      return;
+    }
+  }
+  const pid = readPid();
+  if (!pid) {
+    console.log("Not running");
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`Stopped remnic server (pid ${pid})`);
+  } catch {
+    console.log("Process not found (cleaning up PID file)");
+  }
+  try {
+    fs2.unlinkSync(PID_FILE);
+  } catch {
+  }
+  try {
+    fs2.unlinkSync(LEGACY_PID_FILE);
+  } catch {
+  }
+}
+function daemonRestart() {
+  daemonStop();
+  setTimeout(() => daemonStart(), 1e3);
+}
+function cmdTokenGenerate(connector) {
+  if (!connector) {
+    console.error("Usage: remnic token generate <connector-id>");
+    console.error("  e.g.: remnic token generate claude-code");
+    process.exit(1);
+  }
+  const entry = generateToken(connector);
+  console.log(`Generated token for ${connector}:`);
+  console.log(`  Token:   ${entry.token}`);
+  console.log(`  Created: ${entry.createdAt}`);
+  console.log(`
+Use this token as the Bearer token when connecting from ${connector}.`);
+}
+function cmdTokenList(json) {
+  const tokens = listTokens();
+  if (json) {
+    console.log(JSON.stringify(tokens, null, 2));
+    return;
+  }
+  if (tokens.length === 0) {
+    console.log("No tokens. Generate one with: remnic token generate <connector-id>");
+    return;
+  }
+  console.log("Connector tokens:");
+  for (const t of tokens) {
+    const masked = t.token.slice(0, 20) + "\u2026";
+    console.log(`  ${t.connector.padEnd(16)} ${masked}  (created ${t.createdAt})`);
+  }
+}
+function cmdTokenRevoke(connector) {
+  if (!connector) {
+    console.error("Usage: remnic token revoke <connector-id>");
+    process.exit(1);
+  }
+  if (revokeToken(connector)) {
+    console.log(`Revoked token for ${connector}`);
+  } else {
+    console.log(`No token found for ${connector}`);
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  const [command, ...rest] = argv;
+  if (command !== "migrate") {
+    await migrateFromEngram();
+  }
+  switch (command) {
+    case "init":
+      cmdInit();
+      break;
+    case "migrate": {
+      const json = rest.includes("--json");
+      const rollback = rest.includes("--rollback");
+      await cmdMigrate(json, rollback);
+      break;
+    }
+    case "status": {
+      const json = rest.includes("--json");
+      await cmdStatus(json);
+      break;
+    }
+    case "query": {
+      const json = rest.includes("--json");
+      const explain = rest.includes("--explain");
+      const queryText = rest.filter((a) => !a.startsWith("--")).join(" ");
+      await cmdQuery(queryText, json, explain);
+      break;
+    }
+    case "doctor":
+      cmdDoctor();
+      break;
+    case "config":
+      cmdConfig();
+      break;
+    case "daemon": {
+      const action = rest[0];
+      switch (action) {
+        case "start":
+          daemonStart();
+          break;
+        case "stop":
+          daemonStop();
+          break;
+        case "restart":
+          daemonRestart();
+          break;
+        case "install":
+          daemonInstall();
+          break;
+        case "uninstall":
+          daemonUninstall();
+          break;
+        case "status":
+          daemonStatus();
+          break;
+        default:
+          console.log("Usage: remnic daemon <start|stop|restart|install|uninstall|status>");
+          process.exit(1);
+      }
+      break;
+    }
+    case "token": {
+      const action = rest[0];
+      const json = rest.includes("--json");
+      switch (action) {
+        case "generate":
+          cmdTokenGenerate(rest[1]);
+          break;
+        case "list":
+          cmdTokenList(json);
+          break;
+        case "revoke":
+          cmdTokenRevoke(rest[1]);
+          break;
+        default:
+          console.log("Usage: remnic token <generate|list|revoke> [connector-id] [--json]");
+          process.exit(1);
+      }
+      break;
+    }
+    case "tree": {
+      const subAction = rest[0];
+      const json = rest.includes("--json");
+      const outputDir = resolveFlag(rest, "--output") ?? path2.join(process.cwd(), ".remnic", "context-tree");
+      const categoriesFlag = resolveFlag(rest, "--categories");
+      const categories = categoriesFlag ? categoriesFlag.split(",") : void 0;
+      const maxPerCategoryRaw = resolveFlag(rest, "--max-per-category");
+      let maxPerCategory;
+      if (maxPerCategoryRaw !== void 0) {
+        maxPerCategory = parseInt(maxPerCategoryRaw, 10);
+        if (!Number.isFinite(maxPerCategory) || maxPerCategory < 1) {
+          console.error(`Invalid --max-per-category: ${maxPerCategoryRaw}`);
+          process.exit(1);
+        }
+      }
+      if (subAction === "generate") {
+        const result = await generateContextTree({
+          memoryDir: resolveMemoryDir(),
+          outputDir,
+          categories,
+          maxPerCategory,
+          includeEntities: !rest.includes("--no-entities"),
+          includeQuestions: !rest.includes("--no-questions")
+        });
+        if (json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(`Context tree generated at ${result.outputDir}`);
+          console.log(`  Nodes: ${result.nodesGenerated} generated, ${result.nodesSkipped} skipped`);
+          for (const [cat, count] of Object.entries(result.categories)) {
+            console.log(`  ${cat}: ${count}`);
+          }
+          console.log(`  Duration: ${result.durationMs}ms`);
+        }
+      } else if (subAction === "watch") {
+        const memoryDir = resolveMemoryDir();
+        console.log(`Watching ${memoryDir} for changes\u2026`);
+        console.log(`Output: ${outputDir}`);
+        console.log("Press Ctrl+C to stop.\n");
+        const initial = await generateContextTree({
+          memoryDir,
+          outputDir,
+          categories,
+          maxPerCategory,
+          includeEntities: !rest.includes("--no-entities"),
+          includeQuestions: !rest.includes("--no-questions")
+        });
+        console.log(`Initial: ${initial.nodesGenerated} nodes (${initial.durationMs}ms)`);
+        let debounceTimer = null;
+        const rebuild = () => {
+          if (debounceTimer) clearTimeout(debounceTimer);
+          debounceTimer = setTimeout(async () => {
+            const t0 = Date.now();
+            try {
+              const result = await generateContextTree({
+                memoryDir,
+                outputDir,
+                categories,
+                maxPerCategory,
+                includeEntities: !rest.includes("--no-entities"),
+                includeQuestions: !rest.includes("--no-questions")
+              });
+              console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] Rebuilt: ${result.nodesGenerated} nodes (${Date.now() - t0}ms)`);
+            } catch (err) {
+              console.error(`[${(/* @__PURE__ */ new Date()).toISOString()}] Rebuild failed:`, err instanceof Error ? err.message : err);
+            }
+          }, 500);
+        };
+        fs2.watch(memoryDir, { recursive: true }, (_event, filename) => {
+          if (filename && filename.startsWith(".")) return;
+          rebuild();
+        });
+        await new Promise(() => {
+        });
+      } else if (subAction === "validate") {
+        const treeDir = outputDir;
+        if (!fs2.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)) {
+          console.error(`INDEX.md missing in ${treeDir}. Tree may be corrupt \u2014 regenerate.`);
+          process.exit(1);
+        }
+        console.log(`Context tree at ${treeDir} is valid.`);
+      } else {
+        console.log(`Usage: remnic tree <generate|watch|validate>
+  generate                Generate context tree from memory
+  watch                   Watch memory dir and regenerate on changes
+  validate                Check that context tree exists and is valid
+
+Options:
+  --output <dir>          Output directory (default: .remnic/context-tree)
+  --categories <list>     Comma-separated categories to include
+  --max-per-category <n>  Max nodes per category
+  --no-entities           Exclude entity nodes
+  --no-questions          Exclude question nodes
+  --json                  JSON output (generate only)`);
+      }
+      break;
+    }
+    case "onboard": {
+      const dir = rest[0] ?? ".";
+      const json = rest.includes("--json");
+      cmdOnboard(dir, json);
+      break;
+    }
+    case "curate": {
+      const targetPath = rest[0];
+      const json = rest.includes("--json");
+      if (!targetPath) {
+        console.error("Usage: remnic curate <path>");
+        process.exit(1);
+      }
+      await cmdCurate(targetPath, json);
+      break;
+    }
+    case "review": {
+      const action = rest[0] ?? "list";
+      cmdReview(action, rest.slice(1));
+      break;
+    }
+    case "sync": {
+      const action = rest[0] ?? "run";
+      const json = rest.includes("--json");
+      cmdSync(action, rest.slice(1), json);
+      break;
+    }
+    case "dedup": {
+      const json = rest.includes("--json");
+      cmdDedup(json);
+      break;
+    }
+    case "connectors": {
+      const action = rest[0] ?? "list";
+      const json = rest.includes("--json");
+      await cmdConnectors(action, rest.slice(1), json);
+      break;
+    }
+    case "space": {
+      const action = rest[0] ?? "list";
+      const json = rest.includes("--json");
+      await cmdSpace(action, rest.slice(1), json);
+      break;
+    }
+    case "benchmark": {
+      const action = rest[0] ?? "run";
+      const json = rest.includes("--json");
+      await cmdBenchmark(action, rest.slice(1), json);
+      break;
+    }
+    default:
+      console.log(`
+remnic \u2014 Remnic memory CLI
+
+Usage:
+  remnic init                  Create config file
+  remnic migrate [--rollback] [--json]  Run or undo first-run Engram migration
+  remnic status [--json]       Show server status
+  remnic query <text> [--json] [--explain] Query memories (use --explain for tier breakdown)
+
+  remnic doctor                Run diagnostics
+  remnic config                Show current config
+  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
+  remnic onboard [dir] [--json]     Onboard project directory
+  remnic curate <path> [--json]  Curate files into memory
+  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 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>]
+
+Options:
+  --json    Output in JSON format
+  --help    Show this help
+`);
+      break;
+  }
+}
+var argv1 = process.argv[1] ?? "";
+var argv1Base = argv1.replace(/\\/g, "/");
+if (argv1Base.endsWith("remnic.ts") || argv1Base.endsWith("remnic.js") || argv1Base.endsWith("engram.ts") || argv1Base.endsWith("engram.js") || argv1Base.endsWith("/remnic") || argv1Base.endsWith("/engram") || argv1Base.includes("packages/remnic-cli/src/index.") || process.env.REMNIC_CLI_BIN === "1" || process.env.ENGRAM_CLI_BIN === "1") {
+  main().catch((err) => {
+    process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+export {
+  main
+};