@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/bin/cli.js

@@ -0,0 +1,1076 @@
+#!/usr/bin/env node
+
+// src/bin/cli.ts
+import { existsSync, readFileSync, writeFileSync, readdirSync, rmSync } from "fs";
+import path from "path";
+import os from "os";
+var nodeVersion = parseInt(process.versions.node, 10);
+if (nodeVersion < 20) {
+  process.stderr.write(`
+exe-os requires Node.js 20 or later (you have ${process.version}).
+Install: https://nodejs.org/
+
+`);
+  process.exit(1);
+}
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  try {
+    const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    console.log(pkg.version);
+  } catch {
+    console.log("unknown");
+  }
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h") || args.includes("help")) {
+  let version = "unknown";
+  try {
+    const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    version = pkg.version;
+  } catch {
+  }
+  console.log(`
+exe-os v${version} \u2014 AI employee operating system
+
+Usage: exe-os <command>
+
+Commands:
+  setup          First-time setup (encryption, license, team)
+  update         Check for and install updates
+  cloud          Cloud sync setup and device linking
+  doctor         Diagnose installation health
+  support test   Verify support intake works
+  settings       Configure memory system settings
+  org phase      View/change orchestration phase
+  healthcheck    Check daemon and service health
+
+Session commands (run from a project folder):
+  exe1           Launch COO session #1
+  exe2           Launch COO session #2
+
+Options:
+  --help, -h     Show this help message
+  --version, -v  Show version
+
+Learn more: https://askexe.com/docs
+`);
+  process.exit(0);
+}
+if (args.includes("--global")) {
+  process.stderr.write(
+    "\x1B[33m[deprecated]\x1B[0m --global is deprecated. Use: exe-os claude install\n"
+  );
+  await runClaudeInstall();
+} else if (args.includes("--commands-only")) {
+  const { copySlashCommands, resolvePackageRoot } = await import("../installer-UAMA6ZVH.js");
+  try {
+    const packageRoot = resolvePackageRoot();
+    const result = await copySlashCommands(packageRoot);
+    if (result.copied > 0) {
+      process.stderr.write(
+        `exe-os: ${result.copied} slash command(s) updated
+`
+      );
+    }
+  } catch {
+  }
+} else if (args[0] === "claude") {
+  const sub = args[1];
+  switch (sub) {
+    case "install":
+      await runClaudeInstall();
+      break;
+    case "check":
+      await runClaudeCheck();
+      break;
+    case "mcp-doctor":
+      await runClaudeMcpDoctor();
+      break;
+    case "mcp":
+      if (args[2] === "doctor") {
+        await runClaudeMcpDoctor();
+      } else {
+        console.error("Usage: exe-os claude mcp-doctor");
+        process.exit(1);
+      }
+      break;
+    case "uninstall":
+      await runClaudeUninstall(args.slice(2));
+      break;
+    default:
+      await runClaudeInstall();
+      break;
+  }
+} else if (args[0] === "codex") {
+  const sub = args[1];
+  switch (sub) {
+    case "install":
+      await runCodexInstall();
+      break;
+    default:
+      await runCodexInstall();
+      break;
+  }
+} else if (args[0] === "opencode") {
+  const sub = args[1];
+  switch (sub) {
+    case "install":
+      await runOpenCodeInstall();
+      break;
+    default:
+      await runOpenCodeInstall();
+      break;
+  }
+} else if (args[0] === "org") {
+  const { main: runOrg } = await import("../exe-org-JRBBON5H.js");
+  await runOrg(args.slice(1));
+} else if (args[0] === "code-context") {
+  await runCodeContext(args.slice(1));
+} else if (args[0] === "jobs") {
+  const { cancelBackgroundJob, formatJobs, listBackgroundJobs } = await import("../background-jobs-VTOMOTNA.js");
+  const sub = args[1] ?? "status";
+  if (sub === "status" || sub === "list") {
+    console.log(formatJobs(listBackgroundJobs()));
+  } else if (sub === "cancel") {
+    const id = args[2];
+    if (!id) {
+      console.error("Usage: exe-os jobs cancel <job-id-or-pid>");
+      process.exit(1);
+    }
+    const job = cancelBackgroundJob(id);
+    if (!job) {
+      console.error(`No exe-os background job found for ${id}`);
+      process.exit(1);
+    }
+    console.log(`Cancelled ${job.name} (${job.id}).`);
+  } else {
+    console.error("Usage: exe-os jobs status | exe-os jobs cancel <job-id-or-pid>");
+    process.exit(1);
+  }
+} else if (args[0] === "key") {
+  const { main: runKey } = await import("../exe-key-OG35WPBA.js");
+  await runKey(args.slice(1));
+} else if (args[0] === "link") {
+  console.error("`exe-os link` has been removed from the customer command surface.");
+  console.error("Use `exe-os cloud link --show-full` to reveal the recovery phrase in your local Terminal.");
+  console.error("Use `exe-os setup` on a new device to paste/import that phrase.");
+  process.exitCode = 1;
+} else if (args[0] === "cloud") {
+  const sub = args[1];
+  if (sub === "sync") {
+    if (args.includes("--show-full") || args.includes("--local-terminal-only")) {
+      console.error("`exe-os cloud sync` never shows recovery phrases; it only syncs data.");
+      console.error("To reveal the full recovery phrase, run in your local Terminal:");
+      console.error("  exe-os cloud link --show-full");
+      process.exitCode = 1;
+    } else {
+      await runCloudSync();
+    }
+  } else {
+    process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+    const { main: runCloud } = await import("./exe-cloud.js");
+    await runCloud();
+  }
+} else if (args[0] === "support") {
+  const { main: runSupport } = await import("./exe-support.js");
+  await runSupport(args.slice(1));
+} else if (args[0] === "bulk-sync-postgres") {
+  const { main: runBulkSyncPostgres } = await import("./bulk-sync-postgres.js");
+  await runBulkSyncPostgres();
+} else if (args[0] === "backfill-conversations") {
+  const { backfillConversations } = await import("./backfill-conversations.js");
+  const opts = parseBackfillArgs(args.slice(1));
+  try {
+    const result = await backfillConversations(opts);
+    console.log(JSON.stringify(result, null, 2));
+  } catch (err) {
+    console.error("Backfill failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+} else if (args[0] === "backfill-metadata") {
+  const { backfillMetadata } = await import("../backfill-metadata-JRWUECUS.js");
+  let batchSize = 50;
+  let limit = 0;
+  let dryRun = false;
+  let entities = false;
+  const bmArgs = args.slice(1);
+  for (let i = 0; i < bmArgs.length; i++) {
+    const arg = bmArgs[i];
+    if (arg.startsWith("--batch-size=")) {
+      batchSize = parseInt(arg.split("=")[1], 10) || 50;
+    } else if (arg === "--batch-size" && bmArgs[i + 1]) {
+      batchSize = parseInt(bmArgs[++i], 10) || 50;
+    } else if (arg.startsWith("--limit=")) {
+      limit = parseInt(arg.split("=")[1], 10) || 0;
+    } else if (arg === "--limit" && bmArgs[i + 1]) {
+      limit = parseInt(bmArgs[++i], 10) || 0;
+    } else if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--entities") {
+      entities = true;
+    }
+  }
+  try {
+    const result = await backfillMetadata({ batchSize, limit, dryRun, entities, exportBatches: false, importDir: "", heuristic: false, stats: false });
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.failed > 0 ? 1 : 0);
+  } catch (err) {
+    console.error("Backfill failed:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+} else if (args[0] === "export") {
+  const { runExeExport } = await import("../exe-export-UZN6EFOR.js");
+  await runExeExport(args.slice(1));
+} else if (args[0] === "import") {
+  const { runExeImport } = await import("../exe-import-OSM3U36A.js");
+  await runExeImport(args.slice(1));
+} else if (args[0] === "import-history") {
+  const { runImportHistory } = await import("./import-history.js");
+  await runImportHistory(args.slice(1));
+} else if (args[0] === "send-message" || args[0] === "send_message") {
+  const target = args[1];
+  const msgParts = [];
+  let priority = "normal";
+  for (let i = 2; i < args.length; i++) {
+    if (args[i] === "--priority" && args[i + 1]) {
+      priority = args[i + 1];
+      i++;
+    } else {
+      msgParts.push(args[i]);
+    }
+  }
+  const message = msgParts.join(" ");
+  if (!target || !message) {
+    console.error("Usage: exe-os send-message <target-agent> <message> [--priority urgent]");
+    process.exit(1);
+  }
+  const { initStore } = await import("../lib/store.js");
+  await initStore();
+  const { sendMessage } = await import("../lib/messaging.js");
+  const { getActiveAgent } = await import("../active-agent-GJDG4CAW.js");
+  const { agentId } = getActiveAgent();
+  const result = await sendMessage({
+    fromAgent: agentId,
+    targetAgent: target,
+    content: message,
+    priority
+  });
+  console.log(`Message sent to ${target}: ${result.status}
+ID: ${result.id}`);
+} else if (args[0] === "rename") {
+  process.argv = [process.argv[0], process.argv[1], ...args.slice(1)];
+  const { main: runRename } = await import("./exe-rename.js");
+  await runRename();
+} else if (args[0] === "--activate" || args[0] === "activate") {
+  await runActivate(args[1]);
+} else if (args[0] === "doctor") {
+  if (args.includes("--drift")) {
+    const { runDrift } = await import("../exe-drift-2KHRPBUK.js");
+    await runDrift(args.slice(1));
+  } else {
+    const { runCcDoctor } = await import("./cc-doctor.js");
+    const { results, failed } = runCcDoctor();
+    console.log("\n  exe-os doctor\n");
+    for (const r of results) {
+      const icon = r.pass ? "\x1B[32m\u2713\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+      console.log(`  ${icon} ${r.name}: ${r.detail}`);
+    }
+    console.log(failed === 0 ? "\n  \x1B[32mAll checks passed\x1B[0m\n" : `
+  \x1B[31m${failed} issue(s) found\x1B[0m
+`);
+    process.exit(failed > 0 ? 1 : 0);
+  }
+} else if (args[0] === "backup") {
+  const sub = args[1];
+  const { listBackups, createBackup, restoreBackup } = await import("../db-backup-MSQKO6M5.js");
+  if (sub === "list" || !sub) {
+    const backups = listBackups();
+    if (backups.length === 0) {
+      console.log("No backups found.");
+    } else {
+      console.log(`
+  Available backups (${backups.length}):
+`);
+      for (const b of backups) {
+        const age = Math.round((Date.now() - b.date.getTime()) / 36e5);
+        console.log(`  ${b.name}  (${(b.size / 1024).toFixed(1)} KB, ${age}h ago)`);
+      }
+      console.log(`
+  Restore with: exe-os backup restore [name]
+`);
+    }
+  } else if (sub === "create") {
+    const reason = args[2] || "manual";
+    const result = createBackup(reason);
+    if (result) {
+      console.log(`Backup created: ${path.basename(result)}`);
+    } else {
+      console.error("No active database found to back up.");
+      process.exit(1);
+    }
+  } else if (sub === "restore") {
+    const backups = listBackups();
+    let target;
+    if (args[2]) {
+      const match = backups.find((b) => b.name === args[2] || b.name.includes(args[2]));
+      if (!match) {
+        console.error(`Backup not found: ${args[2]}`);
+        console.error("Run 'exe-os backup list' to see available backups.");
+        process.exit(1);
+      }
+      target = match.path;
+    }
+    const result = restoreBackup(target);
+    if (result) {
+      console.log(`Restored: ${result.restored}`);
+      if (result.preRestoreBackup) {
+        console.log(`Pre-restore snapshot saved: ${path.basename(result.preRestoreBackup)}`);
+      }
+      console.log("Restart the daemon for changes to take effect: exe-os daemon restart");
+    } else {
+      console.error("No backup available to restore.");
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown backup command: ${sub}`);
+    console.error("Usage: exe-os backup [list|create|restore]");
+    process.exit(1);
+  }
+} else if (args[0] === "setup" || args[0] === "-setup" || args[0] === "--setup") {
+  const { runSetupWizard } = await import("../setup-wizard-RBUTEZB2.js");
+  await runSetupWizard({ skipModel: args.includes("--skip-model") });
+} else if (args[0] === "update") {
+  const { runUpdate } = await import("./update.js");
+  await runUpdate(args.slice(1));
+} else if (args[0] === "stack-update") {
+  const { runStackUpdateCli } = await import("./stack-update.js");
+  await runStackUpdateCli(args.slice(1));
+} else if (args[0] === "verify-stack") {
+  const { runVerifyStack } = await import("./verify-stack.js");
+  const vsArgs = args.slice(1);
+  if (vsArgs.includes("--help") || vsArgs.includes("-h")) {
+    console.log(`
+Usage: exe-os verify-stack [--compose <path>] [--env <path>]
+
+Post-deploy verification \u2014 8 runtime checks after stack-update.
+`);
+    process.exit(0);
+  }
+  const composeIdx = vsArgs.indexOf("--compose");
+  const envIdx = vsArgs.indexOf("--env");
+  const opts = {};
+  if (composeIdx >= 0 && vsArgs[composeIdx + 1]) opts.composeFile = vsArgs[composeIdx + 1];
+  if (envIdx >= 0 && vsArgs[envIdx + 1]) opts.envFile = vsArgs[envIdx + 1];
+  const report = await runVerifyStack(opts);
+  const icons = { pass: "\u2705", fail: "\u274C", warn: "\u26A0\uFE0F ", skip: "\u23ED\uFE0F " };
+  console.log("\n\x1B[1mPost-Deploy Verification\x1B[0m\n");
+  for (const r of report.results) {
+    console.log(`  ${icons[r.status] ?? "?"} ${r.check}: ${r.message}`);
+  }
+  console.log(`
+  Pass: ${report.passed}  Fail: ${report.failed}  Warn: ${report.warned}  Skip: ${report.skipped}
+`);
+  process.exit(report.failed > 0 ? 1 : 0);
+} else if (args[0] === "snapshot") {
+  const { main: runSnapshot } = await import("../exe-snapshot-7TQIN7XI.js");
+  await runSnapshot(args.slice(1));
+} else if (args[0] === "boot") {
+  const { projectBoot, parseBootArgs } = await import("../project-boot-JIGOSGCN.js");
+  const bootOpts = parseBootArgs(args.slice(1));
+  console.log(await projectBoot(bootOpts));
+} else if (args[0] === "brand") {
+  const configIdx = args.indexOf("--config");
+  if (configIdx === -1 || !args[configIdx + 1]) {
+    const { loadBranding, BRANDING_PATH } = await import("../branding-I2TDZFUH.js");
+    const b = loadBranding();
+    console.log(`
+  Brand: ${b.name}`);
+    console.log(`  Primary: ${b.primaryColor}  Accent: ${b.accentColor}`);
+    if (b.domain) console.log(`  Domain: ${b.domain}`);
+    console.log(`  Config: ${BRANDING_PATH}
+`);
+  } else {
+    const configPath = args[configIdx + 1];
+    const { existsSync: ex, readFileSync: rf } = await import("fs");
+    if (!ex(configPath)) {
+      console.error(`
+  File not found: ${configPath}
+`);
+      process.exit(1);
+    }
+    try {
+      const raw = JSON.parse(rf(configPath, "utf-8"));
+      const { validateBranding, saveBranding } = await import("../branding-I2TDZFUH.js");
+      const result = validateBranding(raw);
+      if (!result.valid) {
+        console.error(`
+  Validation errors:
+${result.errors.map((e) => `    - ${e}`).join("\n")}
+`);
+        process.exit(1);
+      }
+      saveBranding(result.config);
+      console.log(`
+  Branding saved: ${result.config.name}`);
+      console.log(`  Primary: ${result.config.primaryColor}  Accent: ${result.config.accentColor}
+`);
+    } catch (err) {
+      console.error(`
+  Invalid JSON: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exit(1);
+    }
+  }
+} else if (args[0] === "registry-proxy") {
+  const { main: runRegistryProxy } = await import("./registry-proxy.js");
+  await runRegistryProxy(args.slice(1));
+} else if (args.includes("--tui") || args.includes("--demo") || args[0] === "tui") {
+  checkForUpdateOnBoot().catch(() => {
+  });
+  await import("../tui/App.js");
+} else {
+  const claudeDir = path.join(os.homedir(), ".claude");
+  const settingsPath = path.join(claudeDir, "settings.json");
+  const hasClaudeCode = existsSync(settingsPath) && (() => {
+    try {
+      const raw = readFileSync(settingsPath, "utf8");
+      return raw.includes("exe-os") || raw.includes("exe-mem");
+    } catch {
+      return false;
+    }
+  })();
+  if (hasClaudeCode) {
+    const { DEFAULT_COORDINATOR_TEMPLATE_NAME } = await import("../lib/employees.js");
+    let cooName = DEFAULT_COORDINATOR_TEMPLATE_NAME;
+    try {
+      const rosterPath = path.join(os.homedir(), ".exe-os", "exe-employees.json");
+      if (existsSync(rosterPath)) {
+        const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+        const coo = roster.find((e) => e.role === "COO");
+        if (coo) cooName = coo.name;
+      }
+    } catch {
+    }
+    console.log(`
+\x1B[1mexe-os\x1B[0m \u2014 AI Employee Operating System
+
+\x1B[33mMode 1 detected:\x1B[0m Claude Code integration is installed.
+cd into a project folder and run \x1B[1m${cooName}1\x1B[0m to boot your COO.
+
+\x1B[2mCommands:\x1B[0m
+  ${cooName}1                   Launch COO in project folder
+  exe-os update          Check for and install updates
+  exe-os setup           Re-run setup wizard
+  exe-os cloud status    Show cloud connection status
+  exe-os cloud sync      Run sync now (normally automatic)
+  exe-os cloud link      Show recovery phrase + cloud info for a new device
+  exe-os cloud reupload  Re-upload cloud backup after key rotation
+  exe-os key status      Check whether encrypted memory opens
+  exe-os key rotate      Guided key rotation + automatic cloud re-upload
+  exe-os key update      Update this device/server after key rotation
+  exe-os jobs status     Show background jobs/backfills
+  exe-os jobs cancel     Stop a background job safely
+  exe-os org phase       Show/change orchestration phase
+  exe-os org unlock executives  Move from COO mode to executive bench
+  exe-os org unlock parallel    Move to parallel execution org
+  exe-os claude check    Verify Claude Code integration
+  exe-os claude mcp-doctor  Diagnose Claude MCP tool visibility
+  exe-os tui             Launch TUI dashboard (Mode 2)
+  exe-os --help          Show all commands
+`);
+  } else {
+    checkForUpdateOnBoot().catch(() => {
+    });
+    await import("../tui/App.js");
+  }
+}
+async function runCodeContext(ccArgs) {
+  const { buildCodeContextIndex, getCodeContextStats, searchCodeContext } = await import("../code-context-index-KHUYATRB.js");
+  const sub = ccArgs[0] ?? "status";
+  const projectRoot = valueAfter(ccArgs, "--project-root") ?? process.cwd();
+  if (sub === "init" || sub === "index") {
+    const force = ccArgs.includes("--force") || ccArgs.includes("--refresh");
+    const index = buildCodeContextIndex({ projectRoot, force });
+    console.log(JSON.stringify({ projectRoot: index.projectRoot, branch: index.branch, indexedAt: index.indexedAt, files: Object.keys(index.files).length, symbols: Object.values(index.files).reduce((sum, f) => sum + f.symbols.length, 0), languageBreakdown: index.stats.languageBreakdown, rebuiltFiles: index.stats.rebuiltFiles, reusedFiles: index.stats.reusedFiles }, null, 2));
+    return;
+  }
+  if (sub === "status" || sub === "stats") {
+    console.log(JSON.stringify(getCodeContextStats({ projectRoot }), null, 2));
+    return;
+  }
+  if (sub === "search") {
+    const query = valueAfter(ccArgs, "--query") ?? positionalSearchQuery(ccArgs.slice(1));
+    if (!query) {
+      console.error("Usage: exe-os code-context search <query> [--limit N] [--offset N] [--language python] [--path 'src/**'] [--refresh]");
+      process.exit(1);
+    }
+    const languageFilters = [...valuesAfter(ccArgs, "--language") ?? [], ...valuesAfter(ccArgs, "--languages") ?? []];
+    const pathFilters = [...valuesAfter(ccArgs, "--path") ?? [], ...valuesAfter(ccArgs, "--paths") ?? []];
+    const results = searchCodeContext(query, {
+      projectRoot,
+      limit: numberAfter(ccArgs, "--limit") ?? 20,
+      offset: numberAfter(ccArgs, "--offset") ?? 0,
+      refreshIndex: ccArgs.includes("--refresh") || ccArgs.includes("--refresh-index"),
+      languages: languageFilters.length > 0 ? languageFilters : void 0,
+      paths: pathFilters.length > 0 ? pathFilters : void 0
+    });
+    console.log(JSON.stringify({ query, results }, null, 2));
+    return;
+  }
+  if (sub === "doctor") {
+    const stats = getCodeContextStats({ projectRoot });
+    console.log(JSON.stringify({ ok: stats.files > 0, ...stats }, null, 2));
+    process.exit(stats.files > 0 ? 0 : 1);
+  }
+  console.error("Usage: exe-os code-context init|index|status|stats|search|doctor");
+  process.exit(1);
+}
+function positionalSearchQuery(args2) {
+  const valueFlags = /* @__PURE__ */ new Set(["--project-root", "--limit", "--offset", "--language", "--languages", "--path", "--paths", "--query"]);
+  const parts = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (valueFlags.has(arg)) {
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--")) continue;
+    parts.push(arg);
+  }
+  return parts.join(" ").trim();
+}
+function valueAfter(args2, flag) {
+  const i = args2.indexOf(flag);
+  if (i >= 0) return args2[i + 1];
+  const prefixed = args2.find((arg) => arg.startsWith(`${flag}=`));
+  return prefixed?.slice(flag.length + 1);
+}
+function valuesAfter(args2, flag) {
+  const values = [];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (arg === flag && args2[i + 1]) values.push(args2[++i]);
+    else if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.length > 0 ? values.flatMap((v) => v.split(",").map((s) => s.trim()).filter(Boolean)) : void 0;
+}
+function numberAfter(args2, flag) {
+  const value = valueAfter(args2, flag);
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+async function runClaudeInstall() {
+  const { runInstaller } = await import("../installer-UAMA6ZVH.js");
+  try {
+    await runInstaller();
+  } catch (err) {
+    console.error(
+      "Installation failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  }
+}
+async function runOpenCodeInstall() {
+  const { runOpenCodeInstaller } = await import("../installer-OBYQ6O3C.js");
+  try {
+    await runOpenCodeInstaller();
+  } catch (err) {
+    console.error(
+      "OpenCode installation failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  }
+}
+async function runCodexInstall() {
+  const { runCodexInstaller } = await import("../installer-GMIVB2JS.js");
+  try {
+    await runCodexInstaller();
+  } catch (err) {
+    console.error(
+      "Codex hook installation failed:",
+      err instanceof Error ? err.message : String(err)
+    );
+    process.exit(1);
+  }
+}
+async function runClaudeCheck() {
+  const { detectMcpNameCollisions } = await import("../installer-UAMA6ZVH.js");
+  const claudeDir = path.join(os.homedir(), ".claude");
+  const settingsPath = path.join(claudeDir, "settings.json");
+  const claudeJsonPath = path.join(os.homedir(), ".claude.json");
+  let ok = true;
+  if (existsSync(settingsPath)) {
+    let settings;
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch {
+      console.log("\x1B[31m\u2717\x1B[0m settings.json is malformed (invalid JSON)");
+      ok = false;
+      settings = {};
+    }
+    const hasHooks = settings.hooks && Object.keys(settings.hooks).some((k) => {
+      const groups = settings.hooks[k];
+      return Array.isArray(groups) && groups.some((g) => {
+        const hooks = g.hooks;
+        if (!Array.isArray(hooks)) return false;
+        return hooks.some(
+          (h) => typeof h.command === "string" && h.command.includes("exe-os")
+        );
+      });
+    });
+    if (hasHooks) {
+      console.log("\x1B[32m\u2713\x1B[0m Hooks registered in settings.json");
+    } else {
+      console.log("\x1B[31m\u2717\x1B[0m No exe-os hooks found in settings.json");
+      ok = false;
+    }
+  } else {
+    console.log("\x1B[31m\u2717\x1B[0m settings.json not found");
+    ok = false;
+  }
+  if (existsSync(claudeJsonPath)) {
+    let claudeJson;
+    try {
+      claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf8"));
+    } catch {
+      console.log("\x1B[31m\u2717\x1B[0m claude.json is malformed (invalid JSON)");
+      ok = false;
+      claudeJson = {};
+    }
+    const hasMcp = claudeJson.mcpServers && (claudeJson.mcpServers["exe-mem"] || claudeJson.mcpServers["exe-os"]);
+    if (hasMcp) {
+      console.log("\x1B[32m\u2713\x1B[0m MCP server configured in claude.json");
+    } else {
+      console.log(
+        "\x1B[31m\u2717\x1B[0m No exe-os MCP server found in claude.json"
+      );
+      ok = false;
+    }
+  } else {
+    console.log("\x1B[31m\u2717\x1B[0m claude.json not found");
+    ok = false;
+  }
+  const collisions = detectMcpNameCollisions(os.homedir(), process.cwd());
+  const disabledCollisions = collisions.filter((c) => c.disabledInMcpJson);
+  if (disabledCollisions.length > 0) {
+    console.log("\x1B[31m\u2717\x1B[0m MCP name collision: disabled .mcp.json entries shadow project MCP servers");
+    for (const c of disabledCollisions) {
+      console.log(`  - ${c.serverName}: ${c.mcpJsonPath} shadows ~/.claude.json project ${c.projectPath}`);
+    }
+    console.log("  Fix: remove/rename the duplicate .mcp.json server entry, or use one MCP config source of truth.");
+    ok = false;
+  } else if (collisions.length > 0) {
+    console.log("\x1B[33m!\x1B[0m MCP server names duplicated between .mcp.json and project config");
+  } else {
+    console.log("\x1B[32m\u2713\x1B[0m No .mcp.json/project MCP name collisions detected");
+  }
+  const skillsDir = path.join(claudeDir, "skills");
+  if (existsSync(skillsDir)) {
+    console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
+  } else {
+    console.log("\x1B[31m\u2717\x1B[0m Slash skills directory missing");
+    ok = false;
+  }
+  if (!ok) {
+    console.log("\nRun \x1B[36mexe-os claude install\x1B[0m to fix.");
+    process.exit(1);
+  } else {
+    console.log("\nAll checks passed.");
+  }
+}
+async function runClaudeMcpDoctor() {
+  const { diagnoseClaudeMcpConfig, formatMcpDiagnosticReport } = await import("../mcp-diagnostics-5T5OZ52S.js");
+  const report = diagnoseClaudeMcpConfig(os.homedir(), process.cwd(), process.env);
+  console.log(formatMcpDiagnosticReport(report));
+  const hasError = report.issues.some((issue) => issue.severity === "error");
+  process.exit(hasError ? 1 : 0);
+}
+async function runClaudeUninstall(flags = []) {
+  const dryRun = flags.includes("--dry-run");
+  const purge = flags.includes("--purge");
+  const homeDir = os.homedir();
+  const claudeDir = path.join(homeDir, ".claude");
+  const settingsPath = path.join(claudeDir, "settings.json");
+  const claudeJsonPath = path.join(homeDir, ".claude.json");
+  const exeOsDir = path.join(homeDir, ".exe-os");
+  let removed = 0;
+  const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    } catch {
+      console.error("Your ~/.claude/settings.json appears malformed.");
+      if (purge) {
+        console.error("Skipping settings cleanup (--purge).");
+      } else {
+        console.error("Try running: exe-os claude install");
+        process.exit(1);
+      }
+    }
+    if (settings.hooks) {
+      for (const key of Object.keys(settings.hooks)) {
+        const groups = settings.hooks[key];
+        if (!Array.isArray(groups)) continue;
+        settings.hooks[key] = groups.map((g) => {
+          if (!Array.isArray(g.hooks)) return g;
+          return {
+            ...g,
+            hooks: g.hooks.filter(
+              (h) => !(typeof h.command === "string" && (h.command.includes("exe-os") || h.command.includes("askexenow") || h.command.includes("exe-mem")))
+            )
+          };
+        }).filter(
+          (g) => !Array.isArray(g.hooks) || g.hooks.length > 0
+        );
+        if (settings.hooks[key].length === 0) {
+          delete settings.hooks[key];
+        }
+      }
+      let permCount = 0;
+      if (Array.isArray(settings.permissions?.allow)) {
+        const before = settings.permissions.allow.length;
+        settings.permissions.allow = settings.permissions.allow.filter(
+          (p) => !p.startsWith("mcp__exe-mem__") && !p.startsWith("mcp__exe-os__")
+        );
+        permCount = before - settings.permissions.allow.length;
+      }
+      if (!dryRun) {
+        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      }
+      log("\u2713 Removed exe-os hooks from settings.json");
+      if (permCount > 0) log(`\u2713 Removed ${permCount} MCP permission entries`);
+      removed++;
+    }
+  }
+  if (existsSync(claudeJsonPath)) {
+    const raw = readFileSync(claudeJsonPath, "utf8");
+    if (raw.length > 1e6) {
+      console.error("claude.json exceeds 1 MB \u2014 skipping parse.");
+    } else {
+      let claudeJson;
+      try {
+        claudeJson = JSON.parse(raw);
+      } catch {
+        console.error("claude.json is malformed JSON \u2014 skipping.");
+        claudeJson = {};
+      }
+      if (claudeJson.mcpServers) {
+        let removedMcp = false;
+        for (const key of ["exe-mem", "exe-os"]) {
+          if (claudeJson.mcpServers[key]) {
+            if (!dryRun) delete claudeJson.mcpServers[key];
+            removedMcp = true;
+          }
+        }
+        if (removedMcp) {
+          if (!dryRun) {
+            writeFileSync(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+          }
+          log("\u2713 Removed exe-os MCP server from claude.json");
+          removed++;
+        }
+      }
+    }
+  }
+  const skillsDir = path.join(claudeDir, "skills");
+  if (existsSync(skillsDir)) {
+    let skillCount = 0;
+    try {
+      const entries = readdirSync(skillsDir);
+      for (const entry of entries) {
+        if (entry.startsWith("exe")) {
+          const fullPath = path.join(skillsDir, entry);
+          if (!dryRun) rmSync(fullPath, { recursive: true, force: true });
+          skillCount++;
+        }
+      }
+    } catch {
+    }
+    if (skillCount > 0) {
+      log(`\u2713 Removed ${skillCount} skill directories`);
+      removed++;
+    }
+  }
+  const claudeMdPath = path.join(claudeDir, "CLAUDE.md");
+  if (existsSync(claudeMdPath)) {
+    const content = readFileSync(claudeMdPath, "utf8");
+    const startMarker = "<!-- exe-os:orchestration-start -->";
+    const endMarker = "<!-- exe-os:orchestration-end -->";
+    const startIdx = content.indexOf(startMarker);
+    const endIdx = content.indexOf(endMarker);
+    if (startIdx !== -1 && endIdx !== -1) {
+      const cleaned = (content.slice(0, startIdx) + content.slice(endIdx + endMarker.length)).replace(/\n{3,}/g, "\n\n").trim() + "\n";
+      if (!dryRun) writeFileSync(claudeMdPath, cleaned);
+      log("\u2713 Removed orchestration block from CLAUDE.md");
+      removed++;
+    }
+  }
+  const agentsDir = path.join(claudeDir, "agents");
+  if (existsSync(agentsDir)) {
+    let agentCount = 0;
+    try {
+      const entries = readdirSync(agentsDir).filter((f) => f.endsWith(".md"));
+      let knownNames = /* @__PURE__ */ new Set();
+      const rosterPath = path.join(exeOsDir, "exe-employees.json");
+      if (existsSync(rosterPath)) {
+        try {
+          const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+          knownNames = new Set(roster.map((e) => e.name));
+        } catch {
+        }
+      }
+      for (const entry of entries) {
+        const name = entry.replace(/\.md$/, "");
+        if (knownNames.has(name)) {
+          if (!dryRun) rmSync(path.join(agentsDir, entry), { force: true });
+          agentCount++;
+        }
+      }
+    } catch {
+    }
+    if (agentCount > 0) {
+      log(`\u2713 Removed ${agentCount} agent identity files`);
+      removed++;
+    }
+  }
+  const projectsDir = path.join(claudeDir, "projects");
+  if (existsSync(projectsDir)) {
+    let projectCount = 0;
+    try {
+      const projects = readdirSync(projectsDir);
+      for (const proj of projects) {
+        const projSettings = path.join(projectsDir, proj, "settings.json");
+        if (!existsSync(projSettings)) continue;
+        try {
+          const pSettings = JSON.parse(readFileSync(projSettings, "utf8"));
+          let changed = false;
+          if (Array.isArray(pSettings.permissions?.allow)) {
+            const before = pSettings.permissions.allow.length;
+            pSettings.permissions.allow = pSettings.permissions.allow.filter(
+              (p) => !p.startsWith("mcp__exe-mem__") && !p.startsWith("mcp__exe-os__")
+            );
+            if (pSettings.permissions.allow.length < before) changed = true;
+          }
+          if (changed && !dryRun) {
+            writeFileSync(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
+          }
+          if (changed) projectCount++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    if (projectCount > 0) {
+      log(`\u2713 Cleaned exe-os entries from ${projectCount} project settings`);
+      removed++;
+    }
+  }
+  try {
+    const { execSync } = await import("child_process");
+    const findExeBin = () => {
+      try {
+        return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+      } catch {
+        return null;
+      }
+    };
+    const exeBinPath = findExeBin();
+    if (!exeBinPath) throw new Error("exe-os not found in PATH");
+    const binDir = path.dirname(exeBinPath);
+    let symlinkCount = 0;
+    const rosterPath = path.join(exeOsDir, "exe-employees.json");
+    if (existsSync(rosterPath)) {
+      const roster = JSON.parse(readFileSync(rosterPath, "utf8"));
+      const { DEFAULT_COORDINATOR_TEMPLATE_NAME } = await import("../lib/employees.js");
+      const coordinatorName = roster.find((e) => e.role?.toLowerCase() === "coo")?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+      for (const emp of roster) {
+        if (emp.name === coordinatorName) continue;
+        for (const suffix of ["", "-opencode"]) {
+          const linkPath = path.join(binDir, `${emp.name}${suffix}`);
+          if (existsSync(linkPath)) {
+            if (!dryRun) rmSync(linkPath, { force: true });
+            symlinkCount++;
+          }
+        }
+      }
+    }
+    if (symlinkCount > 0) {
+      log(`\u2713 Removed ${symlinkCount} employee symlinks`);
+      removed++;
+    }
+  } catch {
+  }
+  if (purge && existsSync(exeOsDir)) {
+    if (!dryRun) {
+      process.stdout.write("\x1B[33m\u26A0 This will delete all memories, identities, and agent data.\x1B[0m\n");
+      process.stdout.write("  Removing ~/.exe-os...\n");
+      rmSync(exeOsDir, { recursive: true, force: true });
+    }
+    log("\u2713 Purged ~/.exe-os data directory");
+    removed++;
+  }
+  if (removed === 0) {
+    console.log("Nothing to remove \u2014 exe-os was not installed.");
+  } else {
+    if (dryRun) {
+      console.log("\nDry run complete. Re-run without --dry-run to apply.");
+    } else {
+      console.log("\nDone. Run \x1B[36mexe-os claude install\x1B[0m to reinstall.");
+    }
+  }
+}
+async function checkForUpdateOnBoot() {
+  try {
+    const { loadConfig } = await import("../lib/config.js");
+    const config = await loadConfig();
+    if (!config.autoUpdate.checkOnBoot) return;
+    const { checkForUpdate } = await import("./update.js");
+    const packageRoot = path.resolve(
+      new URL("../..", import.meta.url).pathname
+    );
+    const result = checkForUpdate(packageRoot);
+    if (result.updateAvailable) {
+      process.stderr.write(
+        `\x1B[33m[update]\x1B[0m exe-os v${result.remoteVersion} available (current: v${result.localVersion}). Run \x1B[36mexe-os update\x1B[0m to upgrade.
+`
+      );
+    }
+  } catch {
+  }
+}
+async function runActivate(key) {
+  if (!key) {
+    process.stderr.write("Usage: exe-os --activate <license-key>\n");
+    process.exit(1);
+  }
+  const { saveLicense, mirrorLicenseKey, validateLicense } = await import("../lib/license.js");
+  const { loadEmployees, saveEmployees, addEmployee, registerBinSymlinks } = await import("../lib/employees.js");
+  const { getTemplateByRole } = await import("../lib/employee-templates.js");
+  const { getTemplate: getIdentityTemplate } = await import("../lib/identity-templates.js");
+  const { identityPath } = await import("../lib/identity.js");
+  const { createInterface } = await import("readline");
+  const fs = await import("fs");
+  saveLicense(key);
+  mirrorLicenseKey(key);
+  try {
+    const license = await validateLicense(key);
+    if (!license.valid && license.error === "offline") {
+      console.log("\u26A0 Activated in offline mode \u2014 will verify when connected");
+    } else if (!license.valid) {
+      process.stderr.write(`License invalid: ${license.plan || "unknown"}
+`);
+      process.exit(1);
+    } else {
+      const planLabel = license.plan === "pro" ? "Solopreneur" : license.plan.charAt(0).toUpperCase() + license.plan.slice(1);
+      console.log(`Plan activated: ${planLabel}`);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (prompt) => new Promise((resolve) => rl.question(prompt, (a) => resolve(a.trim())));
+    let employees = await loadEmployees();
+    const existingNames = new Set(employees.map((e) => e.name));
+    const createSpecialist = async (role, identityKey) => {
+      const template = getTemplateByRole(role);
+      if (!template) return;
+      const defaultName = template.name;
+      if (existingNames.has(defaultName)) return;
+      const create = await ask(`Create your ${role}? [Y/n]: `);
+      if (create.toLowerCase() === "n") return;
+      const nameInput = await ask(`Name your ${role} [${defaultName}]: `);
+      const name = nameInput || defaultName;
+      const { systemPrompt: _templatePrompt, ...templateMeta } = template;
+      const emp = { ...templateMeta, name, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+      employees = addEmployee(employees, emp);
+      await saveEmployees(employees);
+      registerBinSymlinks(name);
+      existingNames.add(name);
+      const idTemplate = getIdentityTemplate(identityKey);
+      if (idTemplate) {
+        const idPath = identityPath(name);
+        const dir = path.dirname(idPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(idPath, idTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`), "utf-8");
+      }
+      console.log(`Created: ${name} (${role})`);
+    };
+    await createSpecialist("CTO", "cto");
+    await createSpecialist("CMO", "cmo");
+    rl.close();
+    console.log(`${employees.length} employees active.`);
+  } catch (err) {
+    process.stderr.write(`Activation failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+}
+async function runCloudSync() {
+  const { loadConfig } = await import("../lib/config.js");
+  const config = await loadConfig();
+  if (!config.cloud?.apiKey) {
+    console.error("Cloud sync is not configured. Run \x1B[36mexe-os cloud\x1B[0m to set up.");
+    process.exit(1);
+  }
+  const { initStore, disposeStore } = await import("../lib/store.js");
+  const { cloudSync } = await import("../lib/cloud-sync.js");
+  const { getMasterKey } = await import("../lib/keychain.js");
+  const { initSyncCrypto } = await import("../lib/crypto.js");
+  await initStore();
+  const masterKey = await getMasterKey();
+  if (masterKey) {
+    initSyncCrypto(masterKey);
+  } else {
+    console.error("No encryption key found. Run \x1B[36mexe-os setup\x1B[0m first.");
+    await disposeStore();
+    process.exit(1);
+  }
+  console.log("Syncing with Exe Cloud now... (Normally this runs automatically in the background.)");
+  try {
+    const result = await cloudSync(config.cloud);
+    console.log("");
+    console.log(`  Active memories: ${result.totalMemories}  (\u2191 ${result.pushed} syncable rows pushed, \u2193 ${result.pulled} pulled)`);
+    console.log(`  Behaviors:      ${result.behaviors.pushed} total  (\u2193 ${result.behaviors.pulled} pulled)`);
+    console.log(`  Roster:         ${result.roster.employees} employees, ${result.roster.identities} identities`);
+    console.log(`  Tasks:          ${result.tasks.pushed} total  (\u2193 ${result.tasks.pulled} pulled)`);
+    console.log(`  Conversations:  ${result.conversations.pushed} total  (\u2193 ${result.conversations.pulled} pulled)`);
+    console.log(`  Documents:      ${result.documents.pushed} total  (\u2193 ${result.documents.pulled} pulled)`);
+    console.log(`  GraphRAG:       ${result.graphrag.pushed} entities`);
+    console.log("\n\x1B[32mSync complete.\x1B[0m");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("Cloud sync is blocked because this device rotated")) {
+      console.error("\nCloud sync is blocked for safety.");
+      console.error("This device changed its memory encryption key, so Exe Cloud must be re-uploaded with the new key first.");
+      console.error("Run: exe-os cloud reupload");
+    } else {
+      console.error(`Sync failed: ${message}`);
+    }
+    process.exit(1);
+  } finally {
+    await disposeStore();
+  }
+}
+function parseBackfillArgs(argv) {
+  let days = 30;
+  let projectFilter;
+  let dryRun = false;
+  for (let i = 0; i < argv.length; i++) {
+    switch (argv[i]) {
+      case "--days":
+        days = parseInt(argv[++i] ?? "30", 10) || 30;
+        break;
+      case "--project":
+        projectFilter = argv[++i] ?? void 0;
+        break;
+      case "--dry-run":
+        dryRun = true;
+        break;
+    }
+  }
+  return { days, projectFilter, dryRun };
+}