mover-os 4.3.0 → 4.3.2

package/install.js

@@ -12,6 +12,7 @@ const readline = require("readline");
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
+const crypto = require("crypto");
 const { execSync } = require("child_process");
 
 const VERSION = "4";
@@ -94,10 +95,18 @@ const LOGO = [
   "              ╚═════╝ ╚══════╝",
 ];
 
-function printHeader() {
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function printHeader(animate = IS_TTY) {
   ln();
-  for (const line of LOGO) {
-    ln(gradient(line));
+  if (animate) {
+    // Animated logo reveal — line by line with gradient cascade
+    for (let i = 0; i < LOGO.length; i++) {
+      ln(gradient(LOGO[i]));
+      await sleep(30);
+    }
+  } else {
+    for (const line of LOGO) ln(gradient(line));
   }
   ln();
   ln(`  ${dim(`v${VERSION}`)}  ${gray("the agentic operating system for obsidian")}`);
@@ -106,6 +115,60 @@ function printHeader() {
   ln();
 }
 
+// ─── Enhanced TUI utilities ─────────────────────────────────────────────────
+
+// Progress bar with label and percentage
+function progressBar(current, total, width = 30, label = "") {
+  const pct = Math.min(1, current / total);
+  const filled = Math.round(pct * width);
+  const empty = width - filled;
+  const bar = `${S.green}${"█".repeat(filled)}${S.gray}${"░".repeat(empty)}${S.reset}`;
+  const pctStr = `${Math.round(pct * 100)}%`.padStart(4);
+  return `${bar} ${dim(pctStr)}${label ? ` ${dim(label)}` : ""}`;
+}
+
+// Box frame for summaries
+function box(lines, { title = "", color = S.cyan, width = 50 } = {}) {
+  const top = title
+    ? `${color}╭─ ${S.bold}${title}${S.reset}${color} ${"─".repeat(Math.max(0, width - title.length - 4))}╮${S.reset}`
+    : `${color}╭${"─".repeat(width)}╮${S.reset}`;
+  ln(top);
+  for (const l of lines) {
+    const stripped = strip(l);
+    const pad = Math.max(0, width - 2 - stripped.length);
+    ln(`${color}│${S.reset} ${l}${" ".repeat(pad)} ${color}│${S.reset}`);
+  }
+  ln(`${color}╰${"─".repeat(width)}╯${S.reset}`);
+}
+
+// Typewriter effect for important messages
+async function typewriter(text, delay = 15) {
+  if (!IS_TTY) { ln(text); return; }
+  for (const ch of text) {
+    w(ch);
+    if (ch !== " ") await sleep(delay);
+  }
+  ln();
+}
+
+// Section header with animated line
+function sectionHeader(text) {
+  ln();
+  ln(`${S.cyan}┌─${S.reset} ${S.bold}${text}${S.reset}`);
+  ln(`${S.cyan}│${S.reset}`);
+}
+
+// Section footer
+function sectionEnd() {
+  ln(`${S.cyan}└${S.reset}`);
+}
+
+// Status line with icon
+function statusLine(icon, label, detail = "") {
+  const iconMap = { ok: `${S.green}✓${S.reset}`, warn: `${S.yellow}○${S.reset}`, fail: `${S.red}✗${S.reset}`, info: `${S.cyan}●${S.reset}`, dim: `${S.gray}·${S.reset}` };
+  barLn(`${iconMap[icon] || icon} ${label}${detail ? `  ${dim(detail)}` : ""}`);
+}
+
 // ─── Clack-style frame ──────────────────────────────────────────────────────
 const BAR_COLOR = S.cyan;
 const bar = () => w(`${BAR_COLOR}│${S.reset}`);
@@ -473,27 +536,65 @@ async function downloadPayload(key) {
 }
 
 // ─── CLI ─────────────────────────────────────────────────────────────────────
+// ─── CLI Commands ────────────────────────────────────────────────────────────
+const CLI_COMMANDS = {
+  install:  { desc: "Full interactive install",                  alias: [] },
+  update:   { desc: "Update all agents",                         alias: ["-u"] },
+  doctor:   { desc: "Health check across all installed agents",  alias: [] },
+  pulse:    { desc: "Terminal dashboard — energy, tasks, streaks",alias: [] },
+  warm:     { desc: "Pre-warm an AI session with context",       alias: [] },
+  capture:  { desc: "Quick capture — tasks, links, ideas",       alias: [] },
+  who:      { desc: "Entity memory lookup",                      alias: [] },
+  diff:     { desc: "Engine file evolution viewer",              alias: [] },
+  sync:     { desc: "Cross-agent synchronization",               alias: [] },
+  replay:   { desc: "Session replay from Daily Notes",           alias: [] },
+  context:  { desc: "Debug what each agent sees",                alias: [] },
+  settings: { desc: "View/edit config",                          alias: [] },
+  backup:   { desc: "Manual backup wizard",                      alias: [] },
+  restore:  { desc: "Restore from backup",                       alias: [] },
+  test:     { desc: "Run integration tests (dev)",               alias: [], hidden: true },
+};
+
 function parseArgs() {
   const args = process.argv.slice(2);
-  const opts = { vault: "", key: "", update: false };
+  const opts = { command: "", vault: "", key: "", rest: [] };
+
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--vault" && args[i + 1]) opts.vault = args[++i];
-    else if (args[i] === "--key" && args[i + 1]) opts.key = args[++i];
-    else if (args[i] === "--update" || args[i] === "-u") opts.update = true;
-    else if (args[i] === "--help" || args[i] === "-h") {
+    const a = args[i];
+    // Named flags
+    if (a === "--vault" && args[i + 1]) { opts.vault = args[++i]; continue; }
+    if (a === "--key" && args[i + 1]) { opts.key = args[++i]; continue; }
+    // Backward compat: --update / -u → command 'update'
+    if (a === "--update" || a === "-u") { opts.command = "update"; continue; }
+    if (a === "--help" || a === "-h") {
+      ln();
+      ln(`  ${bold("moveros")} ${dim("— the Mover OS companion CLI")}`);
       ln();
-      ln(`  ${bold("mover os")} ${dim("installer")}`);
+      ln(`  ${dim("Usage")}   moveros [command] [options]`);
       ln();
-      ln(`  ${dim("Usage")}   npx moveros`);
+      ln(`  ${dim("Commands")}`);
+      for (const [cmd, meta] of Object.entries(CLI_COMMANDS)) {
+        if (meta.hidden) continue;
+        ln(`    ${cmd.padEnd(12)}${dim(meta.desc)}`);
+      }
       ln();
       ln(`  ${dim("Options")}`);
       ln(`    --key KEY       License key (skip interactive prompt)`);
       ln(`    --vault PATH    Obsidian vault path (skip detection)`);
-      ln(`    --update, -u    Quick update (auto-detect vault + agents, no prompts)`);
+      ln(`    --update, -u    Quick update (backward compat)`);
+      ln();
+      ln(`  ${dim("Run")} moveros ${dim("with no args for interactive menu")}`);
       ln();
       process.exit(0);
     }
+    // Positional: first non-flag arg is the command
+    if (!opts.command && !a.startsWith("-") && CLI_COMMANDS[a]) {
+      opts.command = a;
+    } else {
+      opts.rest.push(a);
+    }
   }
+
   return opts;
 }
 
@@ -914,74 +1015,225 @@ async function runUninstall(vaultPath) {
 }
 
 // ─── Agent definitions ──────────────────────────────────────────────────────
-const AGENTS = [
-  {
-    id: "claude-code",
+// ─── Agent Registry ─────────────────────────────────────────────────────────
+// Data-driven agent configuration. 14 user-selectable agents → 16 install targets.
+// Each entry defines: detection, rules destination, skills destination,
+// commands destination + format, hooks config.
+//
+// Selection → targets mapping:
+//   "Gemini CLI + Antigravity" = 1 selection → 2 targets (gemini-cli, antigravity)
+//   Everything else = 1 selection → 1 target
+//
+// Tiers:
+//   Full    = rules + skills + commands + hooks
+//   Enhanced = rules + skills + commands (no hooks)
+//   Basic+  = rules + commands (no skills)
+//   Basic   = rules only
+
+const H = os.homedir();
+
+const AGENT_REGISTRY = {
+  // ── Full Tier ──────────────────────────────────────────────────────────────
+  "claude-code": {
     name: "Claude Code",
-    tier: "Full integration — rules, 22 commands, skills, 6 hooks",
-    detect: () => cmdExists("claude") || fs.existsSync(path.join(os.homedir(), ".claude")),
+    tier: "full",
+    tierDesc: "Rules, 23 commands, skills, 6 hooks",
+    detect: () => cmdExists("claude") || fs.existsSync(path.join(H, ".claude")),
+    rules: { type: "link", dest: () => path.join(H, ".claude", "CLAUDE.md"), header: "# Mover OS Global Rules" },
+    skills: { dest: () => path.join(H, ".claude", "skills") },
+    commands: { format: "md", dest: () => path.join(H, ".claude", "commands") },
+    hooks: { type: "claude-settings" },
   },
-  {
-    id: "cursor",
+  "cursor": {
     name: "Cursor",
-    tier: "Rules, commands, skills, hooks",
-    detect: () => fs.existsSync(path.join(os.homedir(), ".cursor")) || cmdExists("cursor"),
+    tier: "full",
+    tierDesc: "Rules (.mdc), commands, skills, hooks",
+    detect: () => fs.existsSync(path.join(H, ".cursor")) || cmdExists("cursor"),
+    rules: {
+      type: "mdc",
+      dest: (vault) => path.join(vault || ".", ".cursor", "rules", "mover-os.mdc"),
+      globalDest: () => path.join(H, ".cursor", "rules", "mover-os.mdc"),
+      header: "# Cursor Project Rules",
+    },
+    skills: { dest: () => path.join(H, ".cursor", "skills") },
+    commands: { format: "md", dest: () => path.join(H, ".cursor", "commands") },
+    hooks: { type: "cursor-hooks-json", dest: (vault) => path.join(vault || ".", ".cursor", "hooks.json") },
   },
-  {
-    id: "cline",
+  "cline": {
     name: "Cline",
-    tier: "Rules, skills, hooks",
-    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "saoudrizwan.claude-dev-*"),
+    tier: "full",
+    tierDesc: "Rules, skills, hooks",
+    detect: () => globDirExists(path.join(H, ".vscode", "extensions"), "saoudrizwan.claude-dev-*"),
+    rules: { type: "copy", dest: (vault) => path.join(vault || ".", ".clinerules", "mover-os.md") },
+    skills: { dest: (vault) => path.join(vault || ".", ".cline", "skills") },
+    commands: null,
+    hooks: null,
   },
-  {
-    id: "windsurf",
+  "windsurf": {
     name: "Windsurf",
-    tier: "Rules, skills, workflows",
-    detect: () => fs.existsSync(path.join(os.homedir(), ".windsurf")) || cmdExists("windsurf"),
+    tier: "full",
+    tierDesc: "Rules, workflows, skills, hooks",
+    detect: () => fs.existsSync(path.join(H, ".codeium")) || cmdExists("windsurf"),
+    rules: {
+      type: "windsurf-rule",
+      dest: (vault) => path.join(vault || ".", ".windsurf", "rules", "mover-os.md"),
+      header: "# Windsurf Rules",
+    },
+    skills: { dest: () => path.join(H, ".codeium", "windsurf", "skills") },
+    commands: { format: "md", dest: (vault) => path.join(vault || ".", ".windsurf", "workflows") },
+    hooks: { type: "windsurf-hooks-json", dest: (vault) => path.join(vault || ".", ".windsurf", "hooks.json") },
   },
-  {
-    id: "gemini-cli",
+  "gemini-cli": {
     name: "Gemini CLI",
-    tier: "Rules, skills, commands",
-    detect: () => cmdExists("gemini") || fs.existsSync(path.join(os.homedir(), ".gemini", "settings.json")),
+    tier: "full",
+    tierDesc: "Rules, .toml commands, skills, hooks",
+    detect: () => cmdExists("gemini") || fs.existsSync(path.join(H, ".gemini", "settings.json")),
+    sharedRulesFile: "gemini-md",
+    rules: { type: "link", dest: () => path.join(H, ".gemini", "GEMINI.md"), header: "# Gemini CLI Rules" },
+    skills: { dest: () => path.join(H, ".gemini", "skills") },
+    commands: { format: "toml", dest: () => path.join(H, ".gemini", "commands") },
+    hooks: { type: "gemini-settings-json", dest: () => path.join(H, ".gemini", "settings.json") },
   },
-  {
-    id: "copilot",
+  "copilot": {
     name: "GitHub Copilot",
-    tier: "Rules, skills",
+    tier: "full",
+    tierDesc: "Rules, .prompt.md commands, skills",
     detect: () => cmdExists("gh"),
+    rules: { type: "copy", dest: (vault) => path.join(vault || ".", ".github", "copilot-instructions.md"), header: "# Copilot Instructions" },
+    skills: { dest: (vault) => path.join(vault || ".", ".github", "skills") },
+    commands: { format: "prompt-md", dest: (vault) => path.join(vault || ".", ".github", "prompts") },
+    hooks: null,
   },
-  {
-    id: "codex",
+  "amazon-q": {
+    name: "Amazon Q Developer",
+    tier: "full",
+    tierDesc: "Rules, JSON agent commands, hooks",
+    detect: () => cmdExists("q") || fs.existsSync(path.join(H, ".aws", "amazonq")),
+    rules: { type: "copy", dest: (vault) => path.join(vault || ".", ".amazonq", "rules", "mover-os.md") },
+    skills: null,
+    commands: { format: "amazon-q-json", dest: () => path.join(H, ".aws", "amazonq", "cli-agents") },
+    hooks: null,
+  },
+  "opencode": {
+    name: "OpenCode",
+    tier: "full",
+    tierDesc: "AGENTS.md, agents, commands",
+    detect: () => cmdExists("opencode") || fs.existsSync(path.join(".", "opencode.json")),
+    sharedRulesFile: "agents-md",
+    rules: { type: "agents-md", dest: (vault) => path.join(vault || ".", "AGENTS.md") },
+    skills: { dest: (vault) => path.join(vault || ".", ".opencode", "skills") },
+    commands: { format: "opencode-json", dest: (vault) => path.join(vault || ".", "opencode.json") },
+    hooks: null,
+  },
+  "kilo-code": {
+    name: "Kilo Code",
+    tier: "full",
+    tierDesc: "Rules, skills, commands, modes",
+    detect: () => globDirExists(path.join(H, ".vscode", "extensions"), "kilocode.kilo-code-*"),
+    rules: { type: "copy", dest: (vault) => path.join(vault || ".", ".kilocode", "rules", "mover-os.md") },
+    skills: { dest: (vault) => path.join(vault || ".", ".kilocode", "skills") },
+    commands: { format: "md", dest: (vault) => path.join(vault || ".", ".kilocode", "commands") },
+    hooks: null,
+  },
+
+  // ── Enhanced Tier ──────────────────────────────────────────────────────────
+  "codex": {
     name: "Codex",
-    tier: "Rules, skills",
-    detect: () => cmdExists("codex") || fs.existsSync(path.join(os.homedir(), ".codex")),
+    tier: "enhanced",
+    tierDesc: "AGENTS.md, skills (skills = commands)",
+    detect: () => cmdExists("codex") || fs.existsSync(path.join(H, ".codex")),
+    rules: { type: "agents-md", dest: () => path.join(H, ".codex", "AGENTS.md") },
+    skills: { dest: () => path.join(H, ".codex", "skills") },
+    commands: null,
+    hooks: null,
   },
-  // Hidden agents: install functions preserved but not shown in selection UI.
-  // Vault-root AGENTS.md provides basic rules for these agents.
-  {
-    id: "antigravity",
+  "antigravity": {
     name: "Antigravity",
-    tier: "Rules, skills, workflows",
-    detect: () => fs.existsSync(path.join(os.homedir(), ".gemini", "antigravity")),
+    tier: "enhanced",
+    tierDesc: "Rules (shared GEMINI.md), workflows, skills",
+    detect: () => fs.existsSync(path.join(H, ".gemini", "antigravity")),
+    sharedRulesFile: "gemini-md",
+    rules: { type: "link", dest: () => path.join(H, ".gemini", "GEMINI.md"), header: "# Antigravity Rules" },
+    skills: { dest: () => path.join(H, ".gemini", "antigravity", "skills") },
+    commands: { format: "md", dest: () => path.join(H, ".gemini", "antigravity", "global_workflows") },
+    hooks: null,
   },
-  // Hidden agents: install functions preserved but not shown in selection UI.
-  {
-    id: "openclaw",
-    name: "OpenClaw",
-    tier: "Rules, skills",
-    hidden: true,
-    detect: () => fs.existsSync(path.join(os.homedir(), ".openclaw")) || cmdExists("openclaw"),
+  "amp": {
+    name: "Amp (Sourcegraph)",
+    tier: "enhanced",
+    tierDesc: "AGENTS.md, skills",
+    detect: () => cmdExists("amp") || fs.existsSync(path.join(H, ".config", "agents")),
+    sharedRulesFile: "agents-md",
+    rules: { type: "agents-md", dest: (vault) => path.join(vault || ".", "AGENTS.md") },
+    skills: { dest: (vault) => path.join(vault || ".", ".agents", "skills") },
+    commands: null,
+    hooks: null,
   },
-  {
-    id: "roo-code",
+  "roo-code": {
     name: "Roo Code",
-    tier: "Rules, skills",
-    hidden: true,
-    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "rooveterinaryinc.roo-cline-*"),
+    tier: "enhanced",
+    tierDesc: "Rules, skills, commands",
+    detect: () => globDirExists(path.join(H, ".vscode", "extensions"), "rooveterinaryinc.roo-cline-*"),
+    rules: { type: "copy", dest: (vault) => path.join(vault || ".", ".roo", "rules", "mover-os.md") },
+    skills: { dest: (vault) => path.join(vault || ".", ".roo", "skills") },
+    commands: { format: "md", dest: (vault) => path.join(vault || ".", ".roo", "commands") },
+    hooks: null,
   },
+
+  // ── Basic+ Tier ────────────────────────────────────────────────────────────
+  "continue": {
+    name: "Continue.dev",
+    tier: "basic+",
+    tierDesc: "Rules (.md), .prompt commands",
+    detect: () => fs.existsSync(path.join(H, ".continue")) || fs.existsSync(path.join(".", ".continue")),
+    rules: {
+      type: "continue-rule",
+      dest: (vault) => path.join(vault || ".", ".continue", "rules", "mover-os.md"),
+    },
+    skills: null,
+    commands: { format: "continue-prompt", dest: (vault) => path.join(vault || ".", ".continue", "prompts") },
+    hooks: null,
+  },
+
+  // ── Basic Tier ─────────────────────────────────────────────────────────────
+  "aider": {
+    name: "Aider",
+    tier: "basic",
+    tierDesc: "CONVENTIONS.md (rules only)",
+    detect: () => cmdExists("aider"),
+    rules: { type: "conventions-md", dest: (vault) => path.join(vault || ".", "CONVENTIONS.md") },
+    skills: null,
+    commands: null,
+    hooks: null,
+  },
+};
+
+// User-selectable agents (14 selections). Each maps to 1+ install targets.
+const AGENT_SELECTIONS = [
+  { id: "claude-code",   targets: ["claude-code"],   name: "Claude Code" },
+  { id: "cursor",        targets: ["cursor"],         name: "Cursor" },
+  { id: "cline",         targets: ["cline"],          name: "Cline" },
+  { id: "windsurf",      targets: ["windsurf"],       name: "Windsurf" },
+  { id: "gemini-cli",    targets: ["gemini-cli", "antigravity"], name: "Gemini CLI + Antigravity" },
+  { id: "copilot",       targets: ["copilot"],        name: "GitHub Copilot" },
+  { id: "codex",         targets: ["codex"],          name: "Codex" },
+  { id: "amazon-q",      targets: ["amazon-q"],       name: "Amazon Q Developer" },
+  { id: "opencode",      targets: ["opencode"],       name: "OpenCode" },
+  { id: "kilo-code",     targets: ["kilo-code"],      name: "Kilo Code" },
+  { id: "amp",           targets: ["amp"],            name: "Amp (Sourcegraph)" },
+  { id: "roo-code",      targets: ["roo-code"],       name: "Roo Code" },
+  { id: "continue",      targets: ["continue"],       name: "Continue.dev" },
+  { id: "aider",         targets: ["aider"],          name: "Aider" },
 ];
 
+// Backward compat: AGENTS array used by existing detectChanges() and update flow
+const AGENTS = AGENT_SELECTIONS.map((s) => ({
+  id: s.id,
+  name: s.name,
+  tier: AGENT_REGISTRY[s.targets[0]].tierDesc,
+  detect: AGENT_REGISTRY[s.targets[0]].detect,
+}));
+
 // ─── Utility functions ──────────────────────────────────────────────────────
 function cmdExists(cmd) {
   try {
@@ -1184,41 +1436,10 @@ Sunday: /review-week first
 New project: /ignite → [WORK]
 Stuck: /debug-resistance
 \`\`\`
-`;
-}
-
-// ─── SOUL.md generator (OpenClaw) ───────────────────────────────────────────
-function generateSoulMd() {
-  return `# SOUL.md — Mover OS
 
-> You are not a chatbot. You are a co-founder who happens to live inside a terminal.
+## CLI Utility
 
-## Core Truths
-
-- Be genuinely helpful, not performatively helpful. If the answer is "don't build that," say it.
-- Have opinions. "It depends" is a cop-out. Pick a direction, defend it, change your mind if the user makes a better case.
-- Be resourceful before asking. Exhaust what you can figure out, then ask sharp questions — not broad ones.
-- Earn trust through competence, not compliance. Nobody respects a yes-man.
-
-## The Vibe
-
-- Talk like a co-founder who's been in the trenches, not a consultant billing by the hour.
-- One sharp sentence beats three careful ones. Say what you mean.
-- When you're wrong, don't grovel. Name it, fix it, move. Apologies waste both your time.
-- Match intensity to stakes. Casual for small tasks. Locked in for architecture. Blunt for bad ideas.
-
-## Boundaries
-
-- Never hedge to avoid being wrong. Pick a position.
-- Never pretend all approaches are equally valid when one is clearly better.
-- Never pad output to look thorough. Substance only.
-- Never be artificially enthusiastic about bad ideas.
-
-## Continuity
-
-- You start fresh each session but the files are your memory. Read them, trust them, build on them.
-- If something changed between sessions and you don't understand why, ask — don't assume.
-- The user corrects you to make you better. Take corrections seriously and encode them.
+\`moveros\` provides system-level terminal operations: pulse (dashboard), warm (pre-warm sessions), sync (update agents), doctor (health check), who (entity lookup), capture (quick inbox). Use native agent capabilities first — the CLI supplements, never replaces.
 `;
 }
 
@@ -1340,6 +1561,8 @@ function writeMoverConfig(vaultPath, agentIds, licenseKey) {
     vaultPath: vaultPath,
     agents: agentIds,
     feedbackWebhook: "https://moveros.dev/api/feedback",
+    track_food: true,
+    track_sleep: true,
     installedAt: new Date().toISOString(),
   };
   if (licenseKey) config.licenseKey = licenseKey;
@@ -1349,6 +1572,9 @@ function writeMoverConfig(vaultPath, agentIds, licenseKey) {
       const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
       if (existing.installedAt) config.installedAt = existing.installedAt;
       if (existing.licenseKey && !licenseKey) config.licenseKey = existing.licenseKey;
+      if (existing.feedbackWebhook) config.feedbackWebhook = existing.feedbackWebhook;
+      if (existing.track_food !== undefined) config.track_food = existing.track_food;
+      if (existing.track_sleep !== undefined) config.track_sleep = existing.track_sleep;
       config.updatedAt = new Date().toISOString();
     } catch {}
   }
@@ -1519,17 +1745,168 @@ function installRules(bundleDir, destPath, agentId) {
   return true;
 }
 
+// ─── Format Converters (workflow .md → agent-specific formats) ───────────────
+// Source of truth: src/workflows/*.md (Claude Code format with YAML frontmatter)
+// Each converter takes workflow metadata and produces the target format.
+
+function parseWorkflowMd(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const name = path.basename(filePath, ".md");
+  let description = "";
+  let body = content;
+
+  // Extract YAML frontmatter
+  if (content.startsWith("---")) {
+    const endIdx = content.indexOf("\n---", 3);
+    if (endIdx > 0) {
+      const front = content.substring(3, endIdx).trim();
+      body = content.substring(endIdx + 4).trim();
+      const descMatch = front.match(/description:\s*(.+)/);
+      if (descMatch) description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+  }
+
+  // Fallback: first non-empty, non-heading line
+  if (!description) {
+    const lines = body.split("\n");
+    for (const l of lines) {
+      const t = l.trim();
+      if (t && !t.startsWith("#") && !t.startsWith(">") && !t.startsWith("---")) {
+        description = t.substring(0, 120);
+        break;
+      }
+    }
+  }
+
+  return { name, description, body, filePath };
+}
+
+// Gemini CLI: .md → .toml
+function mdToToml(wf) {
+  const desc = wf.description.replace(/"/g, '\\"');
+  const prompt = wf.body.replace(/\\/g, "\\\\").replace(/"""/g, '\\"""');
+  return `# Mover OS — /${wf.name}\ndescription = "${desc}"\n\nprompt = """\n${prompt}\n"""\n`;
+}
+
+// Copilot: .md → .prompt.md (YAML frontmatter with mode: agent)
+function mdToCopilotPrompt(wf) {
+  return `---\nmode: agent\ndescription: "${wf.description.replace(/"/g, '\\"')}"\n---\n\n${wf.body}\n`;
+}
+
+// Continue.dev: .md → .prompt (YAML frontmatter with invokable: true)
+function mdToContinuePrompt(wf) {
+  return `---\nname: ${wf.name}\ndescription: "${wf.description.replace(/"/g, '\\"')}"\ninvokable: true\n---\n\n${wf.body}\n`;
+}
+
+// Cursor: .md → .mdc (MDC frontmatter format)
+function mdToMdc(wf) {
+  return `---\ndescription: "${wf.description.replace(/"/g, '\\"')}"\nglobs:\nalwaysApply: false\n---\n\n${wf.body}\n`;
+}
+
+// Amazon Q: .md → .json (CLI agent definition)
+function mdToAmazonQAgent(wf) {
+  return JSON.stringify({
+    name: wf.name,
+    description: wf.description,
+    prompt: wf.body,
+    model: "claude-sonnet-4-20250514",
+  }, null, 2) + "\n";
+}
+
+// Codex: workflow .md → SKILL.md (skills ARE commands in Codex)
+function mdToCodexSkill(wf) {
+  return `---\nname: ${wf.name}\ndescription: "${wf.description.replace(/"/g, '\\"')}"\n---\n\n${wf.body}\n`;
+}
+
+// Windsurf: .md rule → .md with trigger_type frontmatter
+function mdToWindsurfRule(content, name) {
+  const front = `---\ntrigger_type: always_on\ndescription: "Mover OS system rules"\n---\n\n`;
+  return front + content;
+}
+
+// Install workflows with format conversion
+function installWorkflowsConverted(bundleDir, destDir, format, selectedWorkflows) {
+  const srcDir = path.join(bundleDir, "src", "workflows");
+  if (!fs.existsSync(srcDir)) return 0;
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const converters = {
+    "md": null, // identity — handled by installWorkflows()
+    "toml": { fn: mdToToml, ext: ".toml" },
+    "prompt-md": { fn: mdToCopilotPrompt, ext: ".prompt.md" },
+    "continue-prompt": { fn: mdToContinuePrompt, ext: ".prompt" },
+    "amazon-q-json": { fn: mdToAmazonQAgent, ext: ".json" },
+    "codex-skill": { fn: mdToCodexSkill, ext: "/SKILL.md", dir: true },
+    "mdc": { fn: mdToMdc, ext: ".mdc" },
+  };
+
+  const conv = converters[format];
+  if (!conv) return 0;
+
+  let count = 0;
+  for (const file of fs.readdirSync(srcDir).filter((f) => f.endsWith(".md"))) {
+    if (selectedWorkflows && !selectedWorkflows.has(file)) continue;
+    const wf = parseWorkflowMd(path.join(srcDir, file));
+    const converted = conv.fn(wf);
+    if (conv.dir) {
+      // Directory-based output (e.g., Codex: morning/SKILL.md)
+      const skillDir = path.join(destDir, wf.name);
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(path.join(skillDir, "SKILL.md"), converted, "utf8");
+    } else {
+      fs.writeFileSync(path.join(destDir, wf.name + conv.ext), converted, "utf8");
+    }
+    count++;
+  }
+  return count;
+}
+
+function computeSkillHash(dirPath) {
+  const hash = crypto.createHash("sha256");
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const full = path.join(dirPath, entry.name);
+    if (entry.isFile()) {
+      hash.update(entry.name);
+      hash.update(fs.readFileSync(full));
+    } else if (entry.isDirectory()) {
+      hash.update(entry.name + "/");
+      hash.update(computeSkillHash(full));
+    }
+  }
+  return hash.digest("hex");
+}
+
 function installSkillPacks(bundleDir, destDir, selectedCategories) {
   const skills = findSkills(bundleDir);
   fs.mkdirSync(destDir, { recursive: true });
   const installedNames = new Set();
   let count = 0;
+  let skipped = 0;
+
+  // Load existing manifest for change detection
+  const manifestPath = path.join(destDir, ".skill-manifest.json");
+  let manifest = { skills: {} };
+  try {
+    if (fs.existsSync(manifestPath)) manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  } catch {}
+
   for (const skill of skills) {
     // Filter by category if categories were selected (tools always installed)
     if (selectedCategories && skill.category !== "tools" && !selectedCategories.has(skill.category)) continue;
     const dest = path.join(destDir, skill.name);
+
+    // Skip unchanged skills
+    const sourceHash = computeSkillHash(skill.path);
+    if (manifest.skills[skill.name]?.hash === sourceHash && fs.existsSync(dest)) {
+      installedNames.add(skill.name);
+      skipped++;
+      continue;
+    }
+
     if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
     copyDirRecursive(skill.path, dest);
+    manifest.skills[skill.name] = { hash: sourceHash, installedAt: new Date().toISOString() };
     installedNames.add(skill.name);
     count++;
   }
@@ -1549,6 +1926,11 @@ function installSkillPacks(bundleDir, destDir, selectedCategories) {
       }
     } catch (e) { /* skip */ }
   }
+
+  // Write manifest for next run's change detection
+  try { fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n"); } catch {}
+
+  if (skipped > 0) ln(`  ${dim(`${skipped} skills unchanged, skipped`)}`);
   return count;
 }
 
@@ -1674,15 +2056,43 @@ function installCursor(bundleDir, vaultPath, skillOpts) {
   const steps = [];
 
   if (!skillOpts?.skipRules) {
-    if (vaultPath) {
-      if (installRules(bundleDir, path.join(vaultPath, ".cursorrules"), "cursor")) steps.push("rules");
-    }
-
-    const cursorRulesDir = path.join(home, ".cursor", "rules");
-    fs.mkdirSync(cursorRulesDir, { recursive: true });
+    // V5 FIX: Use .cursor/rules/*.mdc (not legacy .cursorrules)
+    // MDC format: YAML frontmatter with description, globs, alwaysApply
+    const rulesDir = vaultPath
+      ? path.join(vaultPath, ".cursor", "rules")
+      : path.join(home, ".cursor", "rules");
+    fs.mkdirSync(rulesDir, { recursive: true });
     const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
     if (fs.existsSync(src)) {
-      linkOrCopy(src, path.join(cursorRulesDir, "mover-os.mdc"));
+      let content = fs.readFileSync(src, "utf8");
+      content = content.replace(/^# Mover OS Global Rules/m, "# Cursor Project Rules");
+      // Strip Claude-specific S10.5
+      content = content.replace(/## 10\.5 Subagents[\s\S]*?(?=\n---\n)/m, "");
+      // Add MDC frontmatter
+      const mdc = `---\ndescription: "Mover OS system rules — coding conventions, workflows, and project integrity"\nglobs:\nalwaysApply: true\n---\n\n${content}`;
+      const destPath = path.join(rulesDir, "mover-os.mdc");
+      // Preserve user customizations
+      const customizations = extractCustomizations(destPath);
+      let finalContent = mdc;
+      if (customizations) {
+        finalContent += `\n${RULES_SENTINEL} — Everything below this line is preserved during updates -->\n\n${customizations}\n`;
+      }
+      fs.writeFileSync(destPath, finalContent, "utf8");
+      steps.push("rules (.mdc)");
+    }
+
+    // Clean legacy .cursorrules if it exists
+    if (vaultPath) {
+      const legacy = path.join(vaultPath, ".cursorrules");
+      if (fs.existsSync(legacy)) {
+        try {
+          const legacyContent = fs.readFileSync(legacy, "utf8");
+          if (legacyContent.includes("Mover OS") || legacyContent.includes("MOVER_OS")) {
+            fs.unlinkSync(legacy);
+            ln(`  ${dim("Cleaned legacy .cursorrules")}`);
+          }
+        } catch {}
+      }
     }
   }
 
@@ -1727,12 +2137,16 @@ function installCodex(bundleDir, vaultPath, skillOpts) {
 
   const codexDir = path.join(home, ".codex");
   fs.mkdirSync(codexDir, { recursive: true });
-  // Codex CLI uses AGENTS.md content, not raw Global Rules (too large, wrong format)
-  fs.writeFileSync(path.join(codexDir, "instructions.md"), generateAgentsMd(), "utf8");
-  steps.push("rules");
+  // Codex CLI uses AGENTS.md (not instructions.md, not raw Global Rules)
+  fs.writeFileSync(path.join(codexDir, "AGENTS.md"), generateAgentsMd(), "utf8");
+  steps.push("AGENTS.md");
+
+  // V5 FIX: In Codex, skills ARE commands — install workflows as SKILL.md dirs
+  const skillsDir = path.join(codexDir, "skills");
+  const wfCount = installWorkflowsConverted(bundleDir, skillsDir, "codex-skill", skillOpts?.workflows);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
 
   if (skillOpts && skillOpts.install) {
-    const skillsDir = path.join(codexDir, "skills");
     const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
     if (skCount > 0) steps.push(`${skCount} skills`);
   }
@@ -1744,7 +2158,23 @@ function installWindsurf(bundleDir, vaultPath, skillOpts) {
   const home = os.homedir();
   const steps = [];
   if (vaultPath) {
-    if (installRules(bundleDir, path.join(vaultPath, ".windsurfrules"), "windsurf")) steps.push("rules");
+    // V5 FIX: Write to .windsurf/rules/ dir AND legacy .windsurfrules for compatibility
+    const wsDir = path.join(vaultPath, ".windsurf");
+    const rulesDir = path.join(wsDir, "rules");
+    fs.mkdirSync(rulesDir, { recursive: true });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      // Primary: .windsurf/rules/mover-os.md
+      fs.copyFileSync(src, path.join(rulesDir, "mover-os.md"));
+      // Legacy: .windsurfrules (some Windsurf versions still read this)
+      if (installRules(bundleDir, path.join(vaultPath, ".windsurfrules"), "windsurf")) {}
+      steps.push("rules");
+    }
+
+    // V5 FIX: Install workflows as .md commands
+    const wfDir = path.join(wsDir, "workflows");
+    const wfCount = installWorkflows(bundleDir, wfDir, skillOpts?.workflows);
+    if (wfCount > 0) steps.push(`${wfCount} workflows`);
   }
 
   if (skillOpts && skillOpts.install) {
@@ -1756,37 +2186,7 @@ function installWindsurf(bundleDir, vaultPath, skillOpts) {
   return steps;
 }
 
-function installOpenClaw(bundleDir, vaultPath, skillOpts) {
-  const home = os.homedir();
-  const workspace = path.join(home, ".openclaw", "workspace");
-  const steps = [];
-
-  fs.mkdirSync(path.join(workspace, "skills"), { recursive: true });
-  fs.mkdirSync(path.join(workspace, "memory"), { recursive: true });
-
-  fs.writeFileSync(path.join(workspace, "AGENTS.md"), generateAgentsMd(), "utf8");
-  steps.push("AGENTS.md");
-
-  fs.writeFileSync(path.join(workspace, "SOUL.md"), generateSoulMd(), "utf8");
-  steps.push("SOUL.md");
-
-  const userMd = path.join(workspace, "USER.md");
-  if (!fs.existsSync(userMd)) {
-    fs.writeFileSync(
-      userMd,
-      `# USER.md\n\n> Run \`/setup\` in Mover OS to populate this file with your Identity and Strategy.\n\n## Identity\n<!-- Populated by /setup -->\n\n## Strategy\n<!-- Populated by /setup -->\n\n## Assets\n<!-- Populated by /setup -->\n`,
-      "utf8"
-    );
-    steps.push("USER.md");
-  }
-
-  if (skillOpts && skillOpts.install) {
-    const skCount = installSkillPacks(bundleDir, path.join(workspace, "skills"), skillOpts.categories);
-    if (skCount > 0) steps.push(`${skCount} skills`);
-  }
-
-  return steps;
-}
+// OpenClaw removed in V5 — unverifiable
 
 function installGeminiCli(bundleDir, vaultPath, skillOpts, writtenFiles) {
   const home = os.homedir();
@@ -1802,6 +2202,11 @@ function installGeminiCli(bundleDir, vaultPath, skillOpts, writtenFiles) {
     steps.push("rules (shared)");
   }
 
+  // V5 FIX: Install commands as .toml files
+  const cmdsDir = path.join(geminiDir, "commands");
+  const wfCount = installWorkflowsConverted(bundleDir, cmdsDir, "toml", skillOpts?.workflows);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
+
   if (skillOpts && skillOpts.install) {
     const skCount = installSkillPacks(bundleDir, path.join(geminiDir, "skills"), skillOpts.categories);
     if (skCount > 0) steps.push(`${skCount} skills`);
@@ -1848,6 +2253,11 @@ function installRooCode(bundleDir, vaultPath, skillOpts) {
       steps.push("rules");
     }
 
+    // V5 FIX: Install commands as .md files
+    const cmdsDir = path.join(vaultPath, ".roo", "commands");
+    const wfCount = installWorkflows(bundleDir, cmdsDir, skillOpts?.workflows);
+    if (wfCount > 0) steps.push(`${wfCount} commands`);
+
     if (skillOpts && skillOpts.install) {
       const skillsDir = path.join(vaultPath, ".roo", "skills");
       const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
@@ -1868,6 +2278,11 @@ function installCopilot(bundleDir, vaultPath, skillOpts) {
       steps.push("rules");
     }
 
+    // V5 FIX: Install commands as .prompt.md files
+    const promptsDir = path.join(ghDir, "prompts");
+    const wfCount = installWorkflowsConverted(bundleDir, promptsDir, "prompt-md", skillOpts?.workflows);
+    if (wfCount > 0) steps.push(`${wfCount} commands`);
+
     if (skillOpts && skillOpts.install) {
       const skillsDir = path.join(ghDir, "skills");
       const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
@@ -1883,13 +2298,98 @@ const AGENT_INSTALLERS = {
   cline: installCline,
   codex: installCodex,
   windsurf: installWindsurf,
-  openclaw: installOpenClaw,
   "gemini-cli": installGeminiCli,
   antigravity: installAntigravity,
   "roo-code": installRooCode,
   copilot: installCopilot,
+  // New agents — use universal installer (delegates to per-agent functions for existing,
+  // falls back to registry-driven install for new agents)
+  "amazon-q": installFromRegistry,
+  "opencode": installFromRegistry,
+  "kilo-code": installFromRegistry,
+  "amp": installFromRegistry,
+  "continue": installFromRegistry,
+  "aider": installFromRegistry,
 };
 
+// ─── Registry-driven universal installer (for new agents) ────────────────────
+function installFromRegistry(bundleDir, vaultPath, skillOpts, writtenFiles, id) {
+  const reg = AGENT_REGISTRY[id];
+  if (!reg) return [];
+  const steps = [];
+
+  // Rules
+  if (reg.rules && !skillOpts?.skipRules) {
+    const destPath = reg.rules.dest(vaultPath);
+    if (reg.rules.type === "agents-md") {
+      const sharedKey = reg.sharedRulesFile || id;
+      if (!writtenFiles || !writtenFiles.has(destPath)) {
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        fs.writeFileSync(destPath, generateAgentsMd(), "utf8");
+        if (writtenFiles) writtenFiles.add(destPath);
+        steps.push("AGENTS.md");
+      } else {
+        steps.push("AGENTS.md (shared)");
+      }
+    } else if (reg.rules.type === "conventions-md") {
+      // Aider: shorter rules file
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+      if (fs.existsSync(src)) {
+        let content = fs.readFileSync(src, "utf8");
+        // Aider gets a trimmed version — keep sections 0-4 only
+        const s5idx = content.indexOf("\n## 5.");
+        if (s5idx > 0) content = content.substring(0, s5idx);
+        content = "# CONVENTIONS.md\n\n" + content.replace(/^# Mover OS Global Rules/m, "").trim() + "\n";
+        fs.writeFileSync(destPath, content, "utf8");
+        steps.push("CONVENTIONS.md");
+      }
+    } else if (reg.rules.type === "continue-rule") {
+      // Continue.dev: .md with YAML frontmatter (alwaysApply: true)
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+      if (fs.existsSync(src)) {
+        let content = fs.readFileSync(src, "utf8");
+        content = content.replace(/^# Mover OS Global Rules/m, "");
+        const front = `---\nname: Mover OS Rules\nglobs: "**/*"\nalwaysApply: true\n---\n\n`;
+        fs.writeFileSync(destPath, front + content.trim() + "\n", "utf8");
+        steps.push("rules");
+      }
+    } else {
+      // Standard copy
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      if (installRules(bundleDir, destPath, id)) steps.push("rules");
+    }
+  }
+
+  // Skills
+  if (reg.skills && skillOpts && skillOpts.install) {
+    const skillsDir = reg.skills.dest(vaultPath);
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  // Commands (with format conversion)
+  if (reg.commands && !skillOpts?.skipCommands) {
+    const cmdDest = reg.commands.dest(vaultPath);
+    const fmt = reg.commands.format;
+    if (fmt === "md") {
+      // Direct .md copy (same as Claude Code)
+      const wfCount = installWorkflows(bundleDir, cmdDest, skillOpts?.workflows);
+      if (wfCount > 0) steps.push(`${wfCount} commands`);
+    } else if (fmt === "opencode-json") {
+      // OpenCode: commands go into opencode.json (merge, don't overwrite)
+      // Skip for now — requires config file merge logic
+    } else {
+      // All other formats: convert .md → target format
+      const wfCount = installWorkflowsConverted(bundleDir, cmdDest, fmt, skillOpts?.workflows);
+      if (wfCount > 0) steps.push(`${wfCount} commands`);
+    }
+  }
+
+  return steps;
+}
+
 // ─── Pre-flight checks ──────────────────────────────────────────────────────
 function preflight() {
   const issues = [];
@@ -1928,6 +2428,936 @@ function preflight() {
   return issues;
 }
 
+// ─── CLI Command Handlers (stubs — implemented progressively) ────────────────
+const CLI_HANDLERS = {
+  pulse:    async (opts) => { await cmdPulse(opts); },
+  warm:     async (opts) => { await cmdWarm(opts); },
+  capture:  async (opts) => { await cmdCapture(opts); },
+  who:      async (opts) => { await cmdWho(opts); },
+  diff:     async (opts) => { await cmdDiff(opts); },
+  sync:     async (opts) => { await cmdSync(opts); },
+  replay:   async (opts) => { await cmdReplay(opts); },
+  context:  async (opts) => { await cmdContext(opts); },
+  settings: async (opts) => { await cmdSettings(opts); },
+  backup:   async (opts) => { await cmdBackup(opts); },
+  restore:  async (opts) => { await cmdRestore(opts); },
+  doctor:   async (opts) => { await cmdDoctor(opts); },
+  test:     async (opts) => { await cmdTest(opts); },
+};
+
+// ─── moveros doctor ─────────────────────────────────────────────────────────
+async function cmdDoctor(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) {
+    barLn(red("No Mover OS vault found. Use: moveros doctor --vault /path"));
+    return;
+  }
+  const home = os.homedir();
+  barLn(bold("  Health Check"));
+  barLn();
+
+  // Vault structure
+  const paraDirs = ["00_Inbox", "01_Projects", "02_Areas", "03_Library", "04_Archives"];
+  let paraOk = 0;
+  for (const d of paraDirs) {
+    if (fs.existsSync(path.join(vault, d))) paraOk++;
+  }
+  statusLine(paraOk === paraDirs.length ? "ok" : "warn", "Vault structure", `${paraOk}/${paraDirs.length} PARA folders`);
+
+  // Engine files
+  const engineFiles = ["Identity_Prime.md", "Strategy.md", "Active_Context.md", "Goals.md", "Mover_Dossier.md", "Auto_Learnings.md"];
+  const engineDir = path.join(vault, "02_Areas", "Engine");
+  let engOk = 0;
+  for (const f of engineFiles) {
+    if (fs.existsSync(path.join(engineDir, f))) engOk++;
+  }
+  statusLine(engOk >= 4 ? "ok" : engOk >= 2 ? "warn" : "fail", "Engine files", `${engOk}/${engineFiles.length} present`);
+
+  // Version
+  const vf = path.join(vault, ".mover-version");
+  const ver = fs.existsSync(vf) ? fs.readFileSync(vf, "utf8").trim() : null;
+  statusLine(ver ? "ok" : "warn", "Version", ver || "not stamped");
+
+  // Config
+  const cfg = path.join(home, ".mover", "config.json");
+  statusLine(fs.existsSync(cfg) ? "ok" : "warn", "Config", fs.existsSync(cfg) ? cfg : "missing");
+
+  // Per-agent checks
+  barLn();
+  barLn(dim("  Agents:"));
+  const cfgData = fs.existsSync(cfg) ? JSON.parse(fs.readFileSync(cfg, "utf8")) : {};
+  const installedAgents = cfgData.agents || [];
+  if (installedAgents.length === 0) {
+    barLn(dim("    No agents recorded in config."));
+  }
+  for (const agentId of installedAgents) {
+    const reg = AGENT_REGISTRY[agentId];
+    if (!reg) { statusLine("warn", `  ${agentId}`, "unknown agent"); continue; }
+    const checks = [];
+    // Rules
+    if (reg.rules) {
+      const rp = reg.rules.dest(vault);
+      checks.push(fs.existsSync(rp) ? "rules" : dim("rules missing"));
+    }
+    // Skills
+    if (reg.skills) {
+      const sp = reg.skills.dest(vault);
+      const hasSkills = fs.existsSync(sp) && fs.readdirSync(sp).length > 0;
+      checks.push(hasSkills ? "skills" : dim("no skills"));
+    }
+    // Commands
+    if (reg.commands) {
+      const cp = reg.commands.dest(vault);
+      const hasCmds = fs.existsSync(cp) && fs.readdirSync(cp).length > 0;
+      checks.push(hasCmds ? "commands" : dim("no commands"));
+    }
+    const allOk = checks.every((c) => !c.includes("missing"));
+    statusLine(allOk ? "ok" : "warn", `  ${reg.name}`, checks.join(", "));
+  }
+
+  // Git
+  barLn();
+  const hasGit = fs.existsSync(path.join(vault, ".git"));
+  statusLine(hasGit ? "ok" : "info", "Git", hasGit ? "initialized" : "not a git repo");
+
+  barLn();
+  barLn(dim("  Run moveros install or moveros update to fix any issues."));
+}
+
+// ─── moveros pulse ──────────────────────────────────────────────────────────
+async function cmdPulse(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) {
+    barLn(red("No vault found. Use: moveros pulse --vault /path"));
+    return;
+  }
+  const engineDir = path.join(vault, "02_Areas", "Engine");
+
+  barLn(bold("  Pulse"));
+  barLn();
+
+  // Energy + Focus from Active_Context
+  const acPath = path.join(engineDir, "Active_Context.md");
+  let energy = "?", focus = "?", blockers = [];
+  if (fs.existsSync(acPath)) {
+    const ac = fs.readFileSync(acPath, "utf8");
+    const energyMatch = ac.match(/\*\*Energy:\*\*\s*(.+)/i) || ac.match(/Energy:\s*(.+)/i);
+    if (energyMatch) energy = energyMatch[1].trim();
+    const focusMatch = ac.match(/\*\*Focus:\*\*\s*(.+)/i) || ac.match(/Single Test:\s*(.+)/i);
+    if (focusMatch) focus = focusMatch[1].trim();
+    // Blockers
+    const blockerSection = ac.match(/##.*Blocker[s]?[\s\S]*?(?=\n##|\n---|\Z)/i);
+    if (blockerSection) {
+      const lines = blockerSection[0].split("\n").filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*"));
+      blockers = lines.map((l) => l.replace(/^[\s*-]+/, "").trim()).filter(Boolean).slice(0, 3);
+    }
+  }
+  statusLine("info", "Energy", energy);
+  statusLine("info", "Focus", focus.substring(0, 60));
+  if (blockers.length > 0) {
+    statusLine("warn", "Blockers", blockers[0]);
+    for (let i = 1; i < blockers.length; i++) barLn(`           ${dim(blockers[i])}`);
+  } else {
+    statusLine("ok", "Blockers", "none");
+  }
+
+  // Today's tasks from Daily Note
+  barLn();
+  const now = new Date();
+  const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const month = ymd.substring(0, 7);
+  const dailyPath = path.join(engineDir, "Dailies", month, `Daily - ${ymd}.md`);
+  if (fs.existsSync(dailyPath)) {
+    const daily = fs.readFileSync(dailyPath, "utf8");
+    const taskSection = daily.match(/##\s*Tasks[\s\S]*?(?=\n##|\n---)/i);
+    if (taskSection) {
+      const tasks = taskSection[0].split("\n").filter((l) => /^\s*-\s*\[[ x~]\]/.test(l));
+      const done = tasks.filter((t) => /\[x\]|\[~\]/.test(t)).length;
+      const total = tasks.length;
+      barLn(`  ${progressBar(done, total, 25, "Tasks")}`);
+    }
+  } else {
+    barLn(dim("  No Daily Note for today."));
+  }
+
+  // Active projects — scan plan.md files
+  barLn();
+  const projectsDir = path.join(vault, "01_Projects");
+  if (fs.existsSync(projectsDir)) {
+    const projects = fs.readdirSync(projectsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .slice(0, 5);
+    if (projects.length > 0) {
+      barLn(dim("  Active Projects:"));
+      for (const p of projects) {
+        const planPath = path.join(projectsDir, p.name, "dev", "plan.md");
+        if (fs.existsSync(planPath)) {
+          const plan = fs.readFileSync(planPath, "utf8");
+          const tasks = plan.match(/^\s*-\s*\[[ x~]\]/gm) || [];
+          const done = (plan.match(/^\s*-\s*\[x\]/gm) || []).length;
+          barLn(`    ${p.name.padEnd(25)} ${progressBar(done, tasks.length, 15)}`);
+        } else {
+          barLn(`    ${dim(p.name)}`);
+        }
+      }
+    }
+  }
+
+  // Streaks
+  barLn();
+  const dailiesDir = path.join(engineDir, "Dailies");
+  if (fs.existsSync(dailiesDir)) {
+    let streak = 0;
+    const d = new Date();
+    for (let i = 0; i < 30; i++) {
+      const check = new Date(d);
+      check.setDate(check.getDate() - i);
+      const cy = `${check.getFullYear()}-${String(check.getMonth() + 1).padStart(2, "0")}-${String(check.getDate()).padStart(2, "0")}`;
+      const cm = cy.substring(0, 7);
+      if (fs.existsSync(path.join(dailiesDir, cm, `Daily - ${cy}.md`))) {
+        streak++;
+      } else if (i > 0) break; // allow today to be missing
+    }
+    statusLine(streak >= 3 ? "ok" : "info", "Daily streak", `${streak} day${streak !== 1 ? "s" : ""}`);
+  }
+
+  // Last session log time
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  if (fs.existsSync(cfgPath)) {
+    try {
+      const cfgData = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      if (cfgData.lastLog) {
+        const ago = Math.round((Date.now() - new Date(cfgData.lastLog).getTime()) / 3600000);
+        statusLine(ago < 8 ? "ok" : ago < 24 ? "info" : "warn", "Last /log", `${ago}h ago`);
+      }
+    } catch {}
+  }
+  barLn();
+}
+
+// ─── moveros warm ───────────────────────────────────────────────────────────
+async function cmdWarm(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+  const agent = opts.rest[0] || "claude";
+  const engineDir = path.join(vault, "02_Areas", "Engine");
+  const home = os.homedir();
+
+  // Build context primer
+  const sections = [];
+  sections.push("# Session Context Primer");
+  sections.push(`Generated: ${new Date().toISOString()}\n`);
+
+  // Active Context snapshot
+  const acPath = path.join(engineDir, "Active_Context.md");
+  if (fs.existsSync(acPath)) {
+    const ac = fs.readFileSync(acPath, "utf8");
+    // Extract key sections (first 2000 chars)
+    sections.push("## Active Context\n" + ac.substring(0, 2000));
+  }
+
+  // Current project state
+  const cwd = process.cwd();
+  const planPath = path.join(cwd, "dev", "plan.md");
+  if (fs.existsSync(planPath)) {
+    const plan = fs.readFileSync(planPath, "utf8");
+    // Find last active phase
+    const phases = plan.match(/### Phase \d+[\s\S]*?(?=### Phase|\Z)/g);
+    if (phases) {
+      const active = phases[phases.length - 1].substring(0, 1500);
+      sections.push("## Current Plan (last phase)\n" + active);
+    }
+  }
+
+  // Today's daily note tasks
+  const now = new Date();
+  const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const dailyPath = path.join(engineDir, "Dailies", ymd.substring(0, 7), `Daily - ${ymd}.md`);
+  if (fs.existsSync(dailyPath)) {
+    const daily = fs.readFileSync(dailyPath, "utf8");
+    const taskSection = daily.match(/##\s*Tasks[\s\S]*?(?=\n##)/i);
+    if (taskSection) sections.push("## Today's Tasks\n" + taskSection[0]);
+  }
+
+  const primer = sections.join("\n\n---\n\n") + "\n";
+
+  // Write to agent-specific location
+  const targets = {
+    claude: path.join(home, ".claude", "tmp", "session-primer.md"),
+    cursor: path.join(vault, ".cursor", "rules", "session-primer.mdc"),
+    gemini: path.join(home, ".gemini", "session-primer.md"),
+    codex: path.join(home, ".codex", "skills", "session-primer", "SKILL.md"),
+    windsurf: path.join(vault, ".windsurf", "rules", "session-primer.md"),
+    cline: path.join(vault, ".clinerules", "session-primer.md"),
+  };
+
+  const dest = targets[agent] || targets.claude;
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+  let content = primer;
+  if (agent === "cursor") {
+    content = `---\ndescription: "Session context primer — auto-generated by moveros warm"\nglobs:\nalwaysApply: true\n---\n\n${primer}`;
+  } else if (agent === "codex") {
+    content = `---\nname: session-primer\ndescription: "Auto-generated session context from moveros warm"\n---\n\n${primer}`;
+  }
+
+  fs.writeFileSync(dest, content, "utf8");
+  statusLine("ok", "Warm", `${agent} primer written`);
+  barLn(dim(`  ${dest}`));
+  barLn();
+}
+
+// ─── moveros capture ────────────────────────────────────────────────────────
+async function cmdCapture(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+
+  const now = new Date();
+  const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  const ts = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+  const capturePath = path.join(vault, "00_Inbox", `Capture - ${ymd}.md`);
+
+  // Determine type from flags
+  let type = null, content = "";
+  const rest = opts.rest;
+  if (rest.includes("--task")) { type = "task"; rest.splice(rest.indexOf("--task"), 1); }
+  else if (rest.includes("--link")) { type = "link"; rest.splice(rest.indexOf("--link"), 1); }
+  else if (rest.includes("--idea")) { type = "idea"; rest.splice(rest.indexOf("--idea"), 1); }
+  else if (rest.includes("--dump")) { type = "dump"; rest.splice(rest.indexOf("--dump"), 1); }
+
+  content = rest.join(" ").trim();
+
+  // Check for stdin pipe
+  if (!content && !process.stdin.isTTY) {
+    content = fs.readFileSync(0, "utf8").trim();
+    if (!type) type = "dump";
+  }
+
+  // Interactive if no content
+  if (!content) {
+    if (!type) {
+      barLn(bold("  Quick Capture"));
+      barLn();
+      type = await interactiveSelect([
+        { id: "task", name: "Task", tier: "Something to do" },
+        { id: "idea", name: "Idea", tier: "Something to think about" },
+        { id: "link", name: "Link", tier: "URL with optional note" },
+        { id: "dump", name: "Brain dump", tier: "Free-form text" },
+      ], { multi: false });
+    }
+    content = await textInput({ label: `Enter ${type}:` });
+  }
+  if (!type) type = "task";
+
+  if (!content) { barLn(yellow("Nothing to capture.")); return; }
+
+  // Format entry
+  let entry;
+  if (type === "task") entry = `- [ ] ${content}  *(${ts})*`;
+  else if (type === "link") entry = `- [${content.startsWith("http") ? "Link" : content.split(" ")[0]}](${content.split(" ")[0]}) ${content.split(" ").slice(1).join(" ")}  *(${ts})*`;
+  else if (type === "idea") entry = `- **Idea:** ${content}  *(${ts})*`;
+  else entry = `- ${content}  *(${ts})*`;
+
+  // Append to capture file
+  fs.mkdirSync(path.dirname(capturePath), { recursive: true });
+  if (!fs.existsSync(capturePath)) {
+    fs.writeFileSync(capturePath, `# Capture — ${ymd}\n\n${entry}\n`, "utf8");
+  } else {
+    fs.appendFileSync(capturePath, `${entry}\n`, "utf8");
+  }
+
+  statusLine("ok", "Captured", `${type} → 00_Inbox/`);
+  barLn(dim(`  ${entry}`));
+  barLn();
+}
+
+// ─── moveros who ────────────────────────────────────────────────────────────
+async function cmdWho(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+
+  const name = opts.rest.join(" ").trim();
+  if (!name) { barLn(yellow("Usage: moveros who <name>")); return; }
+
+  const entitiesDir = path.join(vault, "03_Library", "Entities");
+  const subdirs = ["People", "Organizations", "Places"];
+  const results = [];
+
+  for (const sub of subdirs) {
+    const dir = path.join(entitiesDir, sub);
+    if (!fs.existsSync(dir)) continue;
+    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+      if (file.toLowerCase().includes(name.toLowerCase())) {
+        const content = fs.readFileSync(path.join(dir, file), "utf8");
+        results.push({ file, sub, content });
+      }
+    }
+  }
+
+  if (results.length === 0) {
+    barLn(yellow(`  No entity found for "${name}".`));
+    barLn();
+    const create = await interactiveSelect([
+      { id: "yes", name: "Create stub", tier: `Creates ${name}.md in People/` },
+      { id: "no", name: "Skip", tier: "" },
+    ], { multi: false });
+    if (create === "yes") {
+      const peopleDir = path.join(entitiesDir, "People");
+      fs.mkdirSync(peopleDir, { recursive: true });
+      const stub = `# ${name}\n\n**Type:** Person\n**Last Contact:** ${new Date().toISOString().split("T")[0]}\n\n## Context\n\n- \n\n## Notes\n\n- \n`;
+      fs.writeFileSync(path.join(peopleDir, `${name}.md`), stub, "utf8");
+      statusLine("ok", "Created", `${name}.md in Entities/People/`);
+    }
+    return;
+  }
+
+  barLn(bold(`  ${name}`));
+  barLn();
+  for (const r of results) {
+    barLn(dim(`  ${r.sub}/${r.file}`));
+    // Show first 15 lines of content
+    const lines = r.content.split("\n").slice(0, 15);
+    for (const l of lines) barLn(`  ${l}`);
+    barLn();
+  }
+}
+
+// ─── moveros diff ───────────────────────────────────────────────────────────
+async function cmdDiff(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+  if (!cmdExists("git")) { barLn(red("Git required for moveros diff.")); return; }
+
+  const target = opts.rest[0] || "strategy";
+  const days = parseInt(opts.rest.find((a) => a.startsWith("--days="))?.split("=")[1] || "30", 10);
+
+  const fileMap = {
+    strategy: "02_Areas/Engine/Strategy.md",
+    identity: "02_Areas/Engine/Identity_Prime.md",
+    goals: "02_Areas/Engine/Goals.md",
+    dossier: "02_Areas/Engine/Mover_Dossier.md",
+    context: "02_Areas/Engine/Active_Context.md",
+  };
+
+  const relPath = fileMap[target.toLowerCase()] || target;
+  const fullPath = path.join(vault, relPath);
+  if (!fs.existsSync(fullPath)) {
+    barLn(yellow(`  File not found: ${relPath}`));
+    return;
+  }
+
+  barLn(bold(`  ${path.basename(relPath)} — last ${days} days`));
+  barLn();
+
+  try {
+    const log = execSync(
+      `git log --since="${days} days ago" --oneline --follow -- "${relPath}"`,
+      { cwd: vault, encoding: "utf8", timeout: 10000 }
+    ).trim();
+
+    if (!log) {
+      barLn(dim("  No changes in the last " + days + " days."));
+    } else {
+      const commits = log.split("\n");
+      for (const c of commits.slice(0, 15)) {
+        const [hash, ...msg] = c.split(" ");
+        barLn(`  ${cyan(hash)} ${msg.join(" ")}`);
+      }
+      if (commits.length > 15) barLn(dim(`  ...and ${commits.length - 15} more`));
+    }
+  } catch {
+    barLn(dim("  Not a git repo or no history available."));
+  }
+  barLn();
+}
+
+// ─── moveros sync ───────────────────────────────────────────────────────────
+async function cmdSync(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+  const apply = opts.rest.includes("--apply");
+  const home = os.homedir();
+
+  barLn(bold("  Agent Sync"));
+  barLn();
+
+  // Read installed agents
+  const cfgPath = path.join(home, ".mover", "config.json");
+  if (!fs.existsSync(cfgPath)) { barLn(yellow("  No config found. Run moveros install first.")); return; }
+  const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+  const agents = cfg.agents || [];
+
+  if (agents.length === 0) { barLn(dim("  No agents installed.")); return; }
+
+  // Find bundle dir (where src/ lives)
+  let bundleDir = null;
+  const candidates = [
+    process.cwd(),
+    path.join(vault, "01_Projects", "Mover OS Bundle"),
+    __dirname,
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(path.join(c, "src", "workflows"))) { bundleDir = c; break; }
+  }
+  if (!bundleDir) { barLn(yellow("  Can't find Mover OS source. Run from the bundle directory.")); return; }
+
+  // Compare source hash vs installed for each agent
+  const srcRulesHash = (() => {
+    const p = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    return fs.existsSync(p) ? crypto.createHash("sha256").update(fs.readFileSync(p)).digest("hex").substring(0, 8) : null;
+  })();
+
+  let staleCount = 0;
+  for (const agentId of agents) {
+    const reg = AGENT_REGISTRY[agentId];
+    if (!reg) continue;
+
+    let status = "current";
+    if (reg.rules) {
+      const dest = reg.rules.dest(vault);
+      if (!fs.existsSync(dest)) {
+        status = "missing";
+      } else if (srcRulesHash) {
+        const installed = crypto.createHash("sha256").update(fs.readFileSync(dest)).digest("hex").substring(0, 8);
+        // Rules get transformed, so direct hash won't match — check by file size as heuristic
+        const srcSize = fs.statSync(path.join(bundleDir, "src", "system", "Mover_Global_Rules.md")).size;
+        const dstSize = fs.statSync(dest).size;
+        if (Math.abs(srcSize - dstSize) > srcSize * 0.1) status = "stale";
+      }
+    }
+
+    const icon = status === "current" ? "ok" : status === "stale" ? "warn" : "fail";
+    statusLine(icon, `  ${reg.name}`, status);
+    if (status !== "current") staleCount++;
+  }
+
+  barLn();
+  if (staleCount === 0) {
+    barLn(green("  All agents up to date."));
+  } else if (apply) {
+    barLn(dim("  Updating stale agents..."));
+    const writtenFiles = new Set();
+    const skillOpts = { install: true, categories: null, workflows: null };
+    for (const agentId of agents) {
+      const fn = AGENT_INSTALLERS[agentId];
+      if (fn) fn(bundleDir, vault, skillOpts, writtenFiles, agentId);
+    }
+    barLn(green(`  Updated ${staleCount} agent(s).`));
+  } else {
+    barLn(dim(`  ${staleCount} agent(s) need updating. Run: moveros sync --apply`));
+  }
+  barLn();
+}
+
+// ─── moveros replay ─────────────────────────────────────────────────────────
+async function cmdReplay(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+
+  let dateStr = opts.rest.find((a) => a.startsWith("--date="))?.split("=")[1];
+  if (!dateStr) {
+    const now = new Date();
+    dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  }
+  const month = dateStr.substring(0, 7);
+  const dailyPath = path.join(vault, "02_Areas", "Engine", "Dailies", month, `Daily - ${dateStr}.md`);
+
+  barLn(bold(`  Session Replay — ${dateStr}`));
+  barLn();
+
+  if (!fs.existsSync(dailyPath)) {
+    barLn(yellow(`  No Daily Note for ${dateStr}.`));
+    return;
+  }
+
+  const daily = fs.readFileSync(dailyPath, "utf8");
+
+  // Extract session log entries
+  const logMatch = daily.match(/##\s*Session Log[\s\S]*?(?=\n## [^#]|\Z)/i);
+  if (!logMatch) {
+    barLn(dim("  No session log found in this Daily Note."));
+    return;
+  }
+
+  // Parse session blocks
+  const sessions = logMatch[0].split(/\n### /).filter(Boolean).slice(1);
+  barLn(dim(`  ${sessions.length} session(s) logged`));
+  barLn();
+
+  for (const session of sessions) {
+    const firstLine = session.split("\n")[0];
+    barLn(`  ${cyan("###")} ${firstLine}`);
+    const lines = session.split("\n").slice(1, 8);
+    for (const l of lines) {
+      if (l.trim()) barLn(`  ${l}`);
+    }
+    barLn();
+  }
+
+  // Task summary
+  const taskSection = daily.match(/##\s*Tasks[\s\S]*?(?=\n##)/i);
+  if (taskSection) {
+    const tasks = taskSection[0].split("\n").filter((l) => /^\s*-\s*\[[ x~]\]/.test(l));
+    const done = tasks.filter((t) => /\[x\]|\[~\]/.test(t)).length;
+    barLn(`  ${progressBar(done, tasks.length, 25, "Completion")}`);
+    barLn();
+  }
+}
+
+// ─── moveros context ────────────────────────────────────────────────────────
+async function cmdContext(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+
+  const target = opts.rest[0];
+  const home = os.homedir();
+
+  if (!target) {
+    // Show all agents
+    barLn(bold("  Agent Context Overview"));
+    barLn();
+    const cfgPath = path.join(home, ".mover", "config.json");
+    const agents = fs.existsSync(cfgPath)
+      ? (JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || [])
+      : [];
+
+    for (const agentId of agents) {
+      const reg = AGENT_REGISTRY[agentId];
+      if (!reg) continue;
+      let totalBytes = 0, fileCount = 0;
+
+      const countDir = (dir) => {
+        if (!fs.existsSync(dir)) return;
+        try {
+          for (const f of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (f.isFile()) { totalBytes += fs.statSync(path.join(dir, f.name)).size; fileCount++; }
+            else if (f.isDirectory()) countDir(path.join(dir, f.name));
+          }
+        } catch {}
+      };
+
+      if (reg.rules) { const rp = reg.rules.dest(vault); if (fs.existsSync(rp)) { totalBytes += fs.statSync(rp).size; fileCount++; } }
+      if (reg.skills) countDir(reg.skills.dest(vault));
+      if (reg.commands) countDir(reg.commands.dest(vault));
+
+      const tokens = Math.round(totalBytes / 4); // rough estimate: 4 bytes per token
+      const kb = (totalBytes / 1024).toFixed(1);
+      barLn(`  ${reg.name.padEnd(20)} ${String(fileCount).padStart(3)} files  ${String(kb).padStart(6)} KB  ~${tokens.toLocaleString()} tokens`);
+    }
+    barLn();
+    return;
+  }
+
+  // Detailed view for specific agent
+  const reg = AGENT_REGISTRY[target] || Object.values(AGENT_REGISTRY).find((r) => r.name.toLowerCase().includes(target.toLowerCase()));
+  if (!reg) { barLn(yellow(`  Unknown agent: ${target}`)); return; }
+
+  barLn(bold(`  ${reg.name} Context`));
+  barLn();
+
+  if (reg.rules) {
+    const rp = reg.rules.dest(vault);
+    if (fs.existsSync(rp)) {
+      const size = fs.statSync(rp).size;
+      statusLine("ok", "Rules", `${(size / 1024).toFixed(1)} KB  ${rp}`);
+    } else {
+      statusLine("fail", "Rules", "not found");
+    }
+  }
+
+  if (reg.skills) {
+    const sp = reg.skills.dest(vault);
+    if (fs.existsSync(sp)) {
+      const skills = fs.readdirSync(sp, { withFileTypes: true }).filter((d) => d.isDirectory());
+      let totalChars = 0;
+      for (const sk of skills) {
+        const sm = path.join(sp, sk.name, "SKILL.md");
+        if (fs.existsSync(sm)) totalChars += fs.statSync(sm).size;
+      }
+      statusLine("ok", "Skills", `${skills.length} packs  ${(totalChars / 1024).toFixed(1)} KB descriptions`);
+    } else {
+      statusLine("info", "Skills", "none installed");
+    }
+  }
+
+  if (reg.commands) {
+    const cp = reg.commands.dest(vault);
+    if (fs.existsSync(cp)) {
+      const files = fs.readdirSync(cp).filter((f) => !f.startsWith("."));
+      statusLine("ok", "Commands", `${files.length} files`);
+    } else {
+      statusLine("info", "Commands", "none installed");
+    }
+  }
+  barLn();
+}
+
+// ─── moveros settings ───────────────────────────────────────────────────────
+async function cmdSettings(opts) {
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+
+  if (!fs.existsSync(cfgPath)) {
+    barLn(yellow("  No config found. Run moveros install first."));
+    return;
+  }
+
+  const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+
+  // moveros settings set <key> <value>
+  if (opts.rest[0] === "set" && opts.rest[1]) {
+    const key = opts.rest[1];
+    let val = opts.rest.slice(2).join(" ");
+    // Auto-type conversion
+    if (val === "true") val = true;
+    else if (val === "false") val = false;
+    else if (/^\d+$/.test(val)) val = parseInt(val, 10);
+
+    if (!cfg.settings) cfg.settings = {};
+    cfg.settings[key] = val;
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    statusLine("ok", "Set", `${key} = ${JSON.stringify(val)}`);
+    return;
+  }
+
+  // Show all settings
+  barLn(bold("  Settings"));
+  barLn();
+  barLn(`  ${dim("Vault:")}   ${cfg.vaultPath || dim("not set")}`);
+  barLn(`  ${dim("Key:")}     ${cfg.licenseKey ? cyan(cfg.licenseKey.substring(0, 12) + "...") : dim("not set")}`);
+  barLn(`  ${dim("Agents:")}  ${(cfg.agents || []).join(", ") || dim("none")}`);
+  barLn(`  ${dim("Version:")} ${cfg.version || dim("unknown")}`);
+  barLn();
+  if (cfg.settings) {
+    barLn(dim("  Custom:"));
+    for (const [k, v] of Object.entries(cfg.settings)) {
+      barLn(`    ${k}: ${JSON.stringify(v)}`);
+    }
+    barLn();
+  }
+  barLn(dim("  Edit: moveros settings set <key> <value>"));
+  barLn(dim(`  File: ${cfgPath}`));
+  barLn();
+}
+
+// ─── moveros backup ─────────────────────────────────────────────────────────
+async function cmdBackup(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+  const home = os.homedir();
+
+  barLn(bold("  Backup"));
+  barLn();
+
+  const items = [
+    { id: "engine", name: "Engine files", tier: "Identity, Strategy, Goals, Context, etc." },
+    { id: "areas", name: "Full Areas folder", tier: "Everything in 02_Areas/" },
+    { id: "agents", name: "Agent configs", tier: "Rules, skills, commands from all agents" },
+  ];
+
+  const choices = await interactiveSelect(items, { multi: true, preSelected: ["engine"] });
+  if (choices.length === 0) { barLn(dim("  Cancelled.")); return; }
+
+  const now = new Date();
+  const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}_${String(now.getHours()).padStart(2, "0")}${String(now.getMinutes()).padStart(2, "0")}`;
+  const backupDir = path.join(vault, "04_Archives", `Backup_${ts}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+
+  const manifest = { timestamp: now.toISOString(), type: "manual", trigger: "moveros backup", categories: choices, files: {} };
+
+  if (choices.includes("engine")) {
+    const engineDir = path.join(vault, "02_Areas", "Engine");
+    const engBackup = path.join(backupDir, "engine");
+    fs.mkdirSync(engBackup, { recursive: true });
+    let count = 0;
+    manifest.files.engine = [];
+    if (fs.existsSync(engineDir)) {
+      for (const f of fs.readdirSync(engineDir).filter((f) => fs.statSync(path.join(engineDir, f)).isFile())) {
+        fs.copyFileSync(path.join(engineDir, f), path.join(engBackup, f));
+        manifest.files.engine.push(f);
+        count++;
+      }
+    }
+    statusLine("ok", "Engine", `${count} files`);
+  }
+
+  if (choices.includes("areas")) {
+    const areasBackup = path.join(backupDir, "areas");
+    copyDirRecursive(path.join(vault, "02_Areas"), areasBackup);
+    manifest.files.areas = true;
+    statusLine("ok", "Areas", "full copy");
+  }
+
+  if (choices.includes("agents")) {
+    const cfgPath = path.join(home, ".mover", "config.json");
+    const agents = fs.existsSync(cfgPath) ? (JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || []) : [];
+    const agentsBackup = path.join(backupDir, "agents");
+    manifest.files.agents = {};
+    let agentCount = 0;
+
+    for (const agentId of agents) {
+      const reg = AGENT_REGISTRY[agentId];
+      if (!reg) continue;
+      const agentDir = path.join(agentsBackup, agentId);
+      let backed = false;
+
+      const safeCopy = (src, label) => {
+        try {
+          if (!fs.existsSync(src)) return;
+          const stat = fs.statSync(src);
+          const dst = path.join(agentDir, label);
+          if (stat.isDirectory()) { copyDirRecursive(src, dst); }
+          else { fs.mkdirSync(agentDir, { recursive: true }); fs.copyFileSync(src, dst); }
+          backed = true;
+        } catch {}
+      };
+
+      if (reg.rules) safeCopy(reg.rules.dest(vault), "rules");
+      if (reg.skills) safeCopy(reg.skills.dest(vault), "skills");
+      if (reg.commands) safeCopy(reg.commands.dest(vault), "commands");
+
+      if (backed) { agentCount++; manifest.files.agents[agentId] = true; }
+    }
+    statusLine("ok", "Agents", `${agentCount} agent(s)`);
+  }
+
+  // Write manifest
+  fs.writeFileSync(path.join(backupDir, ".backup-manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
+
+  barLn();
+  barLn(green(`  Backup saved to 04_Archives/Backup_${ts}/`));
+
+  // Retention check
+  const archivesDir = path.join(vault, "04_Archives");
+  const backups = fs.readdirSync(archivesDir)
+    .filter((d) => d.startsWith("Backup_") || d.startsWith("Engine_Backup_") || d.startsWith("Areas_Backup_") || d.startsWith("Agent_Backup_"))
+    .sort();
+  if (backups.length > 5) {
+    barLn(dim(`  ${backups.length} backups found. Consider cleaning old ones.`));
+  }
+  barLn();
+}
+
+// ─── moveros restore ────────────────────────────────────────────────────────
+async function cmdRestore(opts) {
+  const vault = resolveVaultPath(opts.vault);
+  if (!vault) { barLn(red("No vault found.")); return; }
+
+  const archivesDir = path.join(vault, "04_Archives");
+  if (!fs.existsSync(archivesDir)) { barLn(yellow("  No archives found.")); return; }
+
+  const backups = fs.readdirSync(archivesDir)
+    .filter((d) => {
+      const full = path.join(archivesDir, d);
+      return fs.statSync(full).isDirectory() && (d.startsWith("Backup_") || d.startsWith("Engine_Backup_"));
+    })
+    .sort()
+    .reverse();
+
+  if (backups.length === 0) { barLn(yellow("  No backups found.")); return; }
+
+  barLn(bold("  Restore"));
+  barLn();
+
+  // List available backups
+  const items = backups.slice(0, 10).map((b, i) => {
+    const mPath = path.join(archivesDir, b, ".backup-manifest.json");
+    let detail = "";
+    if (fs.existsSync(mPath)) {
+      try {
+        const m = JSON.parse(fs.readFileSync(mPath, "utf8"));
+        detail = (m.categories || []).join(", ");
+      } catch {}
+    }
+    return { id: b, name: b, tier: detail || dim("legacy backup") };
+  });
+
+  const selected = await interactiveSelect(items, { multi: false });
+  if (!selected) { barLn(dim("  Cancelled.")); return; }
+
+  const backupPath = path.join(archivesDir, selected);
+
+  // Check for engine dir in backup
+  const engPath = path.join(backupPath, "engine");
+  if (fs.existsSync(engPath)) {
+    const engineDir = path.join(vault, "02_Areas", "Engine");
+    let restored = 0;
+    for (const f of fs.readdirSync(engPath).filter((f) => fs.statSync(path.join(engPath, f)).isFile())) {
+      fs.copyFileSync(path.join(engPath, f), path.join(engineDir, f));
+      restored++;
+    }
+    statusLine("ok", "Engine", `${restored} files restored`);
+  } else {
+    // Legacy backup format (files directly in backup dir)
+    const engineDir = path.join(vault, "02_Areas", "Engine");
+    let restored = 0;
+    for (const f of fs.readdirSync(backupPath).filter((f) => f.endsWith(".md") && f !== ".backup-manifest.json")) {
+      fs.copyFileSync(path.join(backupPath, f), path.join(engineDir, f));
+      restored++;
+    }
+    if (restored > 0) statusLine("ok", "Engine", `${restored} files restored`);
+  }
+
+  barLn();
+  barLn(green(`  Restored from ${selected}`));
+  barLn();
+}
+
+// ─── moveros test (dev only) ────────────────────────────────────────────────
+async function cmdTest(opts) { barLn(yellow("moveros test — not yet implemented.")); }
+
+// ─── Interactive Main Menu ────────────────────────────────────────────────────
+async function cmdMainMenu() {
+  const categories = [
+    { header: "Setup", cmds: ["install", "update"] },
+    { header: "Dashboard", cmds: ["pulse", "replay", "diff"] },
+    { header: "Agents", cmds: ["doctor", "sync", "context", "warm"] },
+    { header: "Capture", cmds: ["capture", "who"] },
+    { header: "System", cmds: ["settings", "backup", "restore"] },
+  ];
+
+  const menuItems = [];
+  for (const cat of categories) {
+    for (const cmd of cat.cmds) {
+      const meta = CLI_COMMANDS[cmd];
+      if (!meta || meta.hidden) continue;
+      menuItems.push({
+        id: cmd,
+        name: `${cmd.padEnd(12)} ${dim(meta.desc)}`,
+        tier: `${cat.header}`,
+      });
+    }
+  }
+
+  question(`${bold("moveros")} ${dim("— choose a command")}`);
+  barLn();
+  const choice = await interactiveSelect(menuItems);
+  if (!choice) {
+    outro(dim("Cancelled."));
+    process.exit(0);
+  }
+  return choice;
+}
+
+// ─── Vault Resolution Helper ─────────────────────────────────────────────────
+function resolveVaultPath(explicitVault) {
+  if (explicitVault) {
+    let v = explicitVault;
+    if (v.startsWith("~")) v = path.join(os.homedir(), v.slice(1));
+    return path.resolve(v);
+  }
+  // Try config.json
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  if (fs.existsSync(cfgPath)) {
+    try {
+      const v = JSON.parse(fs.readFileSync(cfgPath, "utf8")).vaultPath;
+      if (v && fs.existsSync(v)) return v;
+    } catch {}
+  }
+  // Try Obsidian detection
+  const obsVaults = detectObsidianVaults();
+  return obsVaults.find((p) => fs.existsSync(path.join(p, ".mover-version"))) || null;
+}
+
 // ─── Main ───────────────────────────────────────────────────────────────────
 async function main() {
   const opts = parseArgs();
@@ -1935,9 +3365,27 @@ async function main() {
   const startTime = Date.now();
 
   // ── Intro ──
-  printHeader();
+  await printHeader();
+
+  // ── Route: no command → interactive menu ──
+  if (!opts.command) {
+    opts.command = await cmdMainMenu();
+  }
 
-  // ── Pre-flight ──
+  // ── Route: CLI commands that don't need pre-flight ──
+  const lightCommands = ["pulse", "warm", "capture", "who", "diff", "sync", "replay", "context", "settings", "backup", "restore", "doctor", "test"];
+  if (lightCommands.includes(opts.command)) {
+    const handler = CLI_HANDLERS[opts.command];
+    if (handler) {
+      await handler(opts);
+    } else {
+      barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
+      barLn(dim("Coming soon in a future update."));
+    }
+    return;
+  }
+
+  // ── Pre-flight (install + update only) ──
   barLn(gray("Pre-flight"));
   barLn();
   const checks = preflight();
@@ -1952,8 +3400,8 @@ async function main() {
     process.exit(1);
   }
 
-  // ── Headless quick update (--update flag) ──
-  if (opts.update) {
+  // ── Headless quick update ──
+  if (opts.command === "update") {
     // Validate stored key
     let updateKey = opts.key;
     if (!updateKey) {
@@ -2028,7 +3476,6 @@ async function main() {
     // Apply all changes
     barLn(bold("Updating..."));
     barLn();
-    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
     // Vault structure
     createVaultStructure(vaultPath);
@@ -2043,10 +3490,7 @@ async function main() {
       const fn = AGENT_INSTALLERS[agent.id];
       if (!fn) continue;
       const sp = spinner(agent.name);
-      const usesWrittenFiles = agent.id === "antigravity" || agent.id === "gemini-cli";
-      const steps = usesWrittenFiles
-        ? fn(bundleDir, vaultPath, skillOpts, writtenFiles)
-        : fn(bundleDir, vaultPath, skillOpts);
+      const steps = fn(bundleDir, vaultPath, skillOpts, writtenFiles, agent.id);
       await sleep(200);
       if (steps.length > 0) {
         sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
@@ -2080,6 +3524,7 @@ async function main() {
   }
 
   if (!key) {
+    let validated = false;
     let attempts = 0;
     while (attempts < 3) {
       key = await textInput({
@@ -2093,6 +3538,7 @@ async function main() {
       if (valid) {
         sp.stop(green("License verified"));
         await activateKey(key);
+        validated = true;
         break;
       }
 
@@ -2105,7 +3551,7 @@ async function main() {
       }
     }
 
-    if (!await validateKey(key)) {
+    if (!validated) {
       barLn(red("Invalid license key."));
       barLn();
       barLn(dim("Get a key at https://moveros.dev"));
@@ -2309,10 +3755,9 @@ async function main() {
             { src: path.join(home, ".claude", "hooks"), label: "hooks" },
           ],
           cursor: [
-            { src: path.join(home, ".cursor", "rules"), label: "rules" },
+            { src: path.join(vaultPath, ".cursor", "rules"), label: "rules" },
             { src: path.join(home, ".cursor", "commands"), label: "commands" },
             { src: path.join(home, ".cursor", "skills"), label: "skills" },
-            { src: path.join(vaultPath, ".cursorrules"), label: ".cursorrules" },
           ],
           cline: [
             { src: path.join(vaultPath, ".clinerules"), label: ".clinerules" },
@@ -2320,10 +3765,13 @@ async function main() {
           ],
           windsurf: [
             { src: path.join(vaultPath, ".windsurfrules"), label: ".windsurfrules" },
+            { src: path.join(vaultPath, ".windsurf", "rules"), label: "rules" },
+            { src: path.join(vaultPath, ".windsurf", "workflows"), label: "workflows" },
             { src: path.join(home, ".windsurf", "skills"), label: "skills" },
           ],
           "gemini-cli": [
             { src: path.join(home, ".gemini", "GEMINI.md"), label: "GEMINI.md" },
+            { src: path.join(home, ".gemini", "commands"), label: "commands" },
             { src: path.join(home, ".gemini", "skills"), label: "skills" },
           ],
           antigravity: [
@@ -2333,19 +3781,42 @@ async function main() {
           ],
           copilot: [
             { src: path.join(vaultPath, ".github", "copilot-instructions.md"), label: "copilot-instructions.md" },
+            { src: path.join(vaultPath, ".github", "prompts"), label: "prompts" },
             { src: path.join(vaultPath, ".github", "skills"), label: "skills" },
           ],
           codex: [
-            { src: path.join(home, ".codex", "instructions.md"), label: "instructions.md" },
+            { src: path.join(home, ".codex", "AGENTS.md"), label: "AGENTS.md" },
             { src: path.join(home, ".codex", "skills"), label: "skills" },
           ],
-          openclaw: [
-            { src: path.join(home, ".openclaw", "workspace"), label: "workspace" },
-          ],
           "roo-code": [
             { src: path.join(vaultPath, ".roo", "rules"), label: "rules" },
+            { src: path.join(vaultPath, ".roo", "commands"), label: "commands" },
             { src: path.join(vaultPath, ".roo", "skills"), label: "skills" },
           ],
+          "amazon-q": [
+            { src: path.join(vaultPath, ".amazonq", "rules"), label: "rules" },
+            { src: path.join(home, ".aws", "amazonq", "cli-agents"), label: "cli-agents" },
+          ],
+          "kilo-code": [
+            { src: path.join(vaultPath, ".kilocode", "rules"), label: "rules" },
+            { src: path.join(vaultPath, ".kilocode", "skills"), label: "skills" },
+            { src: path.join(vaultPath, ".kilocode", "commands"), label: "commands" },
+          ],
+          amp: [
+            { src: path.join(vaultPath, "AGENTS.md"), label: "AGENTS.md" },
+            { src: path.join(vaultPath, ".agents", "skills"), label: "skills" },
+          ],
+          "continue": [
+            { src: path.join(vaultPath, ".continue", "rules"), label: "rules" },
+            { src: path.join(vaultPath, ".continue", "prompts"), label: "prompts" },
+          ],
+          opencode: [
+            { src: path.join(vaultPath, "AGENTS.md"), label: "AGENTS.md" },
+            { src: path.join(vaultPath, ".opencode", "agents"), label: "agents" },
+          ],
+          aider: [
+            { src: path.join(vaultPath, "CONVENTIONS.md"), label: "CONVENTIONS.md" },
+          ],
         };
 
         let agentsBacked = 0;
@@ -2566,7 +4037,6 @@ async function main() {
   barLn();
 
   let totalSteps = 0;
-  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
   // 0. Legacy cleanup (remove files from older installer versions)
   const legacyPaths = [
@@ -2621,25 +4091,30 @@ async function main() {
   const writtenFiles = new Set(); // Track shared files to avoid double-writes (e.g. GEMINI.md)
   const skillOpts = { install: installSkills, categories: selectedCategories, statusLine: installStatusLine, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates };
   for (const agent of selectedAgents) {
-    const fn = AGENT_INSTALLERS[agent.id];
-    if (!fn) continue;
-    sp = spinner(agent.name);
-    const usesWrittenFiles = agent.id === "antigravity" || agent.id === "gemini-cli";
-    const steps = usesWrittenFiles
-      ? fn(bundleDir, vaultPath, skillOpts, writtenFiles)
-      : fn(bundleDir, vaultPath, skillOpts);
-    await sleep(250);
-    if (steps.length > 0) {
-      sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
-      totalSteps++;
-    } else {
-      sp.stop(`${agent.name}  ${dim("configured")}`);
-      totalSteps++;
+    // Expand selections to targets (e.g. "gemini-cli" → ["gemini-cli", "antigravity"])
+    const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+    const targets = sel ? sel.targets : [agent.id];
+    for (const targetId of targets) {
+      const fn = AGENT_INSTALLERS[targetId];
+      if (!fn) continue;
+      const targetReg = AGENT_REGISTRY[targetId];
+      const displayName = targetReg ? targetReg.name : agent.name;
+      sp = spinner(displayName);
+      const steps = fn(bundleDir, vaultPath, skillOpts, writtenFiles, targetId);
+      await sleep(250);
+      if (steps.length > 0) {
+        sp.stop(`${displayName}  ${dim(steps.join(", "))}`);
+        totalSteps++;
+      } else {
+        sp.stop(`${displayName}  ${dim("configured")}`);
+        totalSteps++;
+      }
     }
   }
 
-  // 5. AGENTS.md — only for agents that need it (consolidated write)
-  const needsAgentsMd = selectedAgents.some((a) => ["codex"].includes(a.id));
+  // 5. AGENTS.md at vault root — for agents that share it (Codex writes to ~/.codex/)
+  const agentsMdAtRoot = ["opencode", "amp"];
+  const needsAgentsMd = selectedAgents.some((a) => agentsMdAtRoot.includes(a.id));
   if (needsAgentsMd) {
     fs.writeFileSync(path.join(vaultPath, "AGENTS.md"), generateAgentsMd(), "utf8");
     sp = spinner("AGENTS.md");