mover-os 4.0.0

package/install.js

@@ -0,0 +1,1424 @@
+#!/usr/bin/env node
+// ══════════════════════════════════════════════════════════════════════════════
+// Mover OS — Interactive TUI Installer
+// Zero dependencies. Node.js 18+.
+//
+// Usage:
+//   npx install-mover-os
+//   npx install-mover-os --key YOUR_KEY --vault ~/vault
+// ══════════════════════════════════════════════════════════════════════════════
+
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const VERSION = "4";
+
+// ─── ANSI ────────────────────────────────────────────────────────────────────
+const IS_TTY = process.stdout.isTTY && process.stdin.isTTY;
+const S = IS_TTY
+  ? {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      italic: "\x1b[3m",
+      underline: "\x1b[4m",
+      green: "\x1b[32m",
+      yellow: "\x1b[33m",
+      cyan: "\x1b[36m",
+      red: "\x1b[31m",
+      magenta: "\x1b[35m",
+      blue: "\x1b[34m",
+      white: "\x1b[37m",
+      gray: "\x1b[90m",
+      inverse: "\x1b[7m",
+      hide: "\x1b[?25l",
+      show: "\x1b[?25h",
+      // 256-color for gradient
+      fg: (n) => `\x1b[38;5;${n}m`,
+    }
+  : {
+      reset: "", bold: "", dim: "", italic: "", underline: "",
+      green: "", yellow: "", cyan: "", red: "", magenta: "", blue: "",
+      white: "", gray: "", inverse: "", hide: "", show: "",
+      fg: () => "",
+    };
+
+const w = (s) => process.stdout.write(s);
+const ln = (s = "") => w(s + "\n");
+const bold = (s) => `${S.bold}${s}${S.reset}`;
+const dim = (s) => `${S.dim}${s}${S.reset}`;
+const green = (s) => `${S.green}${s}${S.reset}`;
+const yellow = (s) => `${S.yellow}${s}${S.reset}`;
+const cyan = (s) => `${S.cyan}${s}${S.reset}`;
+const red = (s) => `${S.red}${s}${S.reset}`;
+const gray = (s) => `${S.gray}${s}${S.reset}`;
+const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+
+// Gradient text using 256-color palette (white → gray, matching website monochrome theme)
+const GRADIENT = [255, 255, 254, 253, 252, 251, 250, 249, 248, 247];
+function gradient(text) {
+  if (!IS_TTY) return text;
+  const chars = [...text];
+  return chars.map((ch, i) => {
+    if (ch === " ") return ch;
+    const idx = Math.floor((i / Math.max(chars.length - 1, 1)) * (GRADIENT.length - 1));
+    return `${S.fg(GRADIENT[idx])}${ch}`;
+  }).join("") + S.reset;
+}
+
+// ─── Terminal cleanup ────────────────────────────────────────────────────────
+function cleanup() {
+  w(S.show);
+  try { if (process.stdin.isTTY && process.stdin.isRaw) process.stdin.setRawMode(false); } catch {}
+}
+process.on("exit", cleanup);
+process.on("SIGINT", () => { cleanup(); ln(); process.exit(0); });
+process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+
+// ─── Branded header ─────────────────────────────────────────────────────────
+const LOGO = [
+  "  ╔╦╗╔═╗╦  ╦╔═╗╦═╗  ╔═╗╔═╗",
+  "  ║║║║ ║╚╗╔╝║╣ ╠╦╝  ║ ║╚═╗",
+  "  ╩ ╩╚═╝ ╚╝ ╚═╝╩╚═  ╚═╝╚═╝",
+];
+
+function printHeader() {
+  ln();
+  for (const line of LOGO) {
+    ln(gradient(line));
+  }
+  ln();
+  ln(`  ${dim(`v${VERSION}`)}  ${gray("the self-improving OS for AI agents")}`);
+  ln();
+  ln(gray("  ─────────────────────────────────────"));
+  ln();
+}
+
+// ─── Clack-style frame ──────────────────────────────────────────────────────
+const BAR_COLOR = S.cyan;
+const bar = () => w(`${BAR_COLOR}│${S.reset}`);
+const barLn = (text = "") => ln(`${BAR_COLOR}│${S.reset}  ${text}`);
+const result = (text) => ln(`${S.green}◇${S.reset}  ${dim(text)}`);
+const question = (text) => ln(`${BAR_COLOR}◆${S.reset}  ${text}`);
+const outro = (text) => { ln(`${BAR_COLOR}└${S.reset}  ${text}`); ln(); };
+
+// ─── Animated spinner ───────────────────────────────────────────────────────
+const SPIN_FRAMES = ["◐", "◓", "◑", "◒"];
+function spinner(label) {
+  if (!IS_TTY) {
+    return { stop: (finalLabel) => { ln(`${BAR_COLOR}│${S.reset}  ${S.green}\u2713${S.reset} ${finalLabel || label}`); } };
+  }
+  let i = 0;
+  w(S.hide);
+  w(`${BAR_COLOR}│${S.reset}  ${S.cyan}${SPIN_FRAMES[0]}${S.reset} ${label}`);
+  const timer = setInterval(() => {
+    i = (i + 1) % SPIN_FRAMES.length;
+    w(`\x1b[2K\r${BAR_COLOR}│${S.reset}  ${S.cyan}${SPIN_FRAMES[i]}${S.reset} ${label}`);
+  }, 80);
+  return {
+    stop: (finalLabel) => {
+      clearInterval(timer);
+      w(`\x1b[2K\r${BAR_COLOR}│${S.reset}  ${S.green}\u2713${S.reset} ${finalLabel || label}\n`);
+      w(S.show);
+    },
+  };
+}
+
+// ─── UI: Text input (raw mode) ──────────────────────────────────────────────
+function textInput({ label = "", initial = "", mask = null, placeholder = "" }) {
+  return new Promise((resolve) => {
+    question(label);
+
+    if (!IS_TTY) {
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(`${BAR_COLOR}│${S.reset}  `, (ans) => { rl.close(); resolve(ans || initial); });
+      return;
+    }
+
+    const { stdin } = process;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    let value = initial;
+    let pos = value.length;
+
+    const render = () => {
+      w("\x1b[2K\r");
+      const prefix = `${BAR_COLOR}│${S.reset}  `;
+      if (value.length === 0 && placeholder) {
+        w(prefix + dim(placeholder));
+      } else if (mask) {
+        w(prefix + mask.repeat(value.length));
+      } else {
+        w(prefix + value);
+      }
+      // Position cursor
+      if (!mask) {
+        const back = value.length - pos;
+        if (back > 0) w(`\x1b[${back}D`);
+      }
+    };
+
+    render();
+
+    const handler = (data) => {
+      if (data === "\r" || data === "\n") {
+        stdin.removeListener("data", handler);
+        stdin.setRawMode(false);
+        stdin.pause();
+        ln();
+        barLn();
+        if (mask) {
+          result("Entered");
+        } else {
+          result(value || initial);
+        }
+        resolve(value || initial);
+        return;
+      }
+      if (data === "\x03") { cleanup(); ln(); process.exit(0); }
+
+      if (data === "\x1b[C") { pos = Math.min(pos + 1, value.length); }
+      else if (data === "\x1b[D") { pos = Math.max(0, pos - 1); }
+      else if (data === "\x1b[H" || data === "\x01") { pos = 0; }
+      else if (data === "\x1b[F" || data === "\x05") { pos = value.length; }
+      else if (data === "\x15") { value = ""; pos = 0; }
+      else if (data === "\x7f" || data === "\x08") {
+        if (pos > 0) {
+          value = value.slice(0, pos - 1) + value.slice(pos);
+          pos--;
+        }
+      }
+      else if (data === "\x1b[3~") {
+        if (pos < value.length) {
+          value = value.slice(0, pos) + value.slice(pos + 1);
+        }
+      }
+      else if (data.startsWith("\x1b")) { /* ignore escape sequences */ }
+      else {
+        for (const ch of data) {
+          if (ch.charCodeAt(0) >= 32) {
+            value = value.slice(0, pos) + ch + value.slice(pos);
+            pos++;
+          }
+        }
+      }
+      render();
+    };
+
+    stdin.on("data", handler);
+  });
+}
+
+// ─── UI: Interactive select (raw mode) ───────────────────────────────────────
+function interactiveSelect(items, { multi = false, preSelected = [], defaultIndex = 0 } = {}) {
+  return new Promise((resolve) => {
+    if (!IS_TTY) {
+      resolve(multi ? preSelected : items[defaultIndex]?.id);
+      return;
+    }
+
+    const { stdin } = process;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    w(S.hide);
+
+    let cursor = defaultIndex;
+    const selected = new Set(preSelected);
+    let prevLines = 0;
+
+    const render = () => {
+      if (prevLines > 0) w(`\x1b[${prevLines}A`);
+
+      let lines = 0;
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const active = i === cursor;
+        const checked = selected.has(item.id);
+
+        const icon = multi
+          ? (checked ? green("◼") : dim("◻"))
+          : (active ? cyan("●") : dim("○"));
+        const label = active ? bold(item.name) : item.name;
+        const padded = strip(label).padEnd(20);
+        const styledPadded = active ? bold(padded) : padded;
+        // Color-coded tier badges
+        let tierLabel = "";
+        if (item.tier === "Full") tierLabel = `${S.green}Full${S.reset}`;
+        else if (item.tier === "Enhanced") tierLabel = `${S.cyan}Enhanced${S.reset}`;
+        else if (item.tier === "Basic+" || item.tier === "Basic") tierLabel = `${S.gray}${item.tier}${S.reset}`;
+        else if (item.tier === "recommended") tierLabel = `${S.green}recommended${S.reset}`;
+        else if (item.tier) tierLabel = dim(item.tier);
+
+        const tierStr = tierLabel ? strip(tierLabel).length : 0;
+        const tierPad = tierLabel ? tierLabel + " ".repeat(Math.max(0, 12 - tierStr)) : " ".repeat(12);
+        const tag = item._detected ? dim("(detected)") : "";
+
+        w(`\x1b[2K${BAR_COLOR}│${S.reset}  ${icon} ${styledPadded}${tierPad}${tag}\n`);
+        lines++;
+      }
+
+      w(`\x1b[2K${BAR_COLOR}│${S.reset}\n`);
+      lines++;
+
+      const hint = multi
+        ? dim("  ↑↓ navigate  space select  a all  enter confirm")
+        : dim("  ↑↓ navigate  enter select");
+      w(`\x1b[2K${BAR_COLOR}│${S.reset}${hint}\n`);
+      lines++;
+
+      prevLines = lines;
+    };
+
+    render();
+
+    const handler = (data) => {
+      if (data === "\x1b[A") { cursor = (cursor - 1 + items.length) % items.length; }
+      else if (data === "\x1b[B") { cursor = (cursor + 1) % items.length; }
+      else if (data === " " && multi) {
+        const id = items[cursor].id;
+        if (selected.has(id)) selected.delete(id);
+        else selected.add(id);
+      }
+      else if ((data === "a" || data === "A") && multi) {
+        if (selected.size === items.length) selected.clear();
+        else items.forEach((i) => selected.add(i.id));
+      }
+      else if (data === "\r" || data === "\n") {
+        stdin.removeListener("data", handler);
+        stdin.setRawMode(false);
+        stdin.pause();
+
+        // Clear rendered lines
+        if (prevLines > 0) {
+          w(`\x1b[${prevLines}A`);
+          for (let i = 0; i < prevLines; i++) w("\x1b[2K\n");
+          w(`\x1b[${prevLines}A`);
+        }
+        w(S.show);
+
+        if (multi) {
+          const names = items.filter((i) => selected.has(i.id)).map((i) => i.name);
+          barLn();
+          result(names.length > 0 ? names.join(", ") : "None");
+          resolve([...selected]);
+        } else {
+          barLn();
+          result(items[cursor].name);
+          resolve(items[cursor].id);
+        }
+        return;
+      }
+      else if (data === "\x03") { cleanup(); ln(); process.exit(0); }
+
+      render();
+    };
+
+    stdin.on("data", handler);
+  });
+}
+
+// ─── License validation ─────────────────────────────────────────────────────
+const VALID_KEYS = new Set(["MOVER-BETA-2026", "MOVER-FOUNDER-001"]);
+function validateKey(key) {
+  if (!key) return false;
+  return VALID_KEYS.has(key.toUpperCase().trim());
+}
+
+// ─── CLI ─────────────────────────────────────────────────────────────────────
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { vault: "", key: "" };
+  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] === "--help" || args[i] === "-h") {
+      ln();
+      ln(`  ${bold("mover os")} ${dim("installer")}`);
+      ln();
+      ln(`  ${dim("Usage")}   npx install-mover-os`);
+      ln();
+      ln(`  ${dim("Options")}`);
+      ln(`    --key KEY       License key (skip interactive prompt)`);
+      ln(`    --vault PATH    Obsidian vault path (skip detection)`);
+      ln();
+      process.exit(0);
+    }
+  }
+  return opts;
+}
+
+// ─── Engine file detection ──────────────────────────────────────────────────
+function detectEngineFiles(vaultPath) {
+  const engineDir = path.join(vaultPath, "02_Areas", "Engine");
+  if (!fs.existsSync(engineDir)) return { exists: false, files: [] };
+  const coreFiles = [
+    "Identity_Prime.md", "Strategy.md", "Active_Context.md",
+    "Mover_Dossier.md", "Auto_Learnings.md", "Goals.md",
+  ];
+  const found = coreFiles.filter((f) => {
+    const p = path.join(engineDir, f);
+    if (!fs.existsSync(p)) return false;
+    // Template files have placeholder content — check if user has actually written to them
+    try {
+      const content = fs.readFileSync(p, "utf8");
+      return content.length > 200; // Templates are ~100-200 chars of scaffolding
+    } catch { return false; }
+  });
+  return { exists: found.length > 0, files: found };
+}
+
+// ─── Uninstall ──────────────────────────────────────────────────────────────
+async function runUninstall(vaultPath) {
+  ln();
+  ln(gradient("  ╔╦╗╔═╗╦  ╦╔═╗╦═╗  ╔═╗╔═╗"));
+  ln(gradient("  ║║║║ ║╚╗╔╝║╣ ╠╦╝  ║ ║╚═╗"));
+  ln(gradient("  ╩ ╩╚═╝ ╚╝ ╚═╝╩╚═  ╚═╝╚═╝"));
+  ln();
+  barLn(dim("uninstalling agent configs..."));
+  barLn();
+
+  const home = os.homedir();
+  let removed = 0;
+
+  // Agent configs
+  const agentPaths = [
+    { label: "Claude Code rules", path: path.join(home, ".claude", "CLAUDE.md") },
+    { label: "Claude Code commands", path: path.join(home, ".claude", "commands"), dir: true },
+    { label: "Claude Code skills", path: path.join(home, ".claude", "skills"), dir: true, keepBuiltins: true },
+    { label: "Cursor rules", path: path.join(home, ".cursor", "rules", "mover-os.mdc") },
+    { label: "Cursor commands", path: path.join(home, ".cursor", "commands"), dir: true },
+    { label: "Cursor skills", path: path.join(home, ".cursor", "skills"), dir: true },
+    { label: "Antigravity rules", path: path.join(home, ".gemini", "GEMINI.md") },
+    { label: "Antigravity workflows", path: path.join(home, ".gemini", "antigravity", "global_workflows"), dir: true },
+    { label: "Codex instructions", path: path.join(home, ".codex", "instructions.md") },
+    { label: "Claude Code hooks", path: path.join(home, ".claude", "hooks"), dir: true },
+  ];
+
+  for (const item of agentPaths) {
+    if (!fs.existsSync(item.path)) continue;
+    try {
+      if (item.dir) {
+        if (item.keepBuiltins) {
+          // Only remove skill directories that match our installed skills
+          for (const entry of fs.readdirSync(item.path, { withFileTypes: true })) {
+            if (entry.isDirectory() && fs.existsSync(path.join(item.path, entry.name, "SKILL.md"))) {
+              fs.rmSync(path.join(item.path, entry.name), { recursive: true, force: true });
+            }
+          }
+        } else {
+          fs.rmSync(item.path, { recursive: true, force: true });
+        }
+      } else {
+        fs.unlinkSync(item.path);
+      }
+      barLn(`${green("\u2713")} ${dim(item.label)}`);
+      removed++;
+    } catch {}
+  }
+
+  // Vault-specific files (only if vault path given)
+  if (vaultPath && fs.existsSync(vaultPath)) {
+    const vaultFiles = [
+      { label: "AGENTS.md", path: path.join(vaultPath, "AGENTS.md") },
+      { label: "SOUL.md", path: path.join(vaultPath, "SOUL.md") },
+      { label: ".mover-version", path: path.join(vaultPath, ".mover-version") },
+      { label: "Claude settings", path: path.join(vaultPath, ".claude", "settings.json") },
+    ];
+
+    const vaultAgentFiles = [
+      { label: ".cursorrules", path: path.join(vaultPath, ".cursorrules") },
+      { label: ".clinerules", path: path.join(vaultPath, ".clinerules"), dir: true },
+      { label: ".windsurfrules", path: path.join(vaultPath, ".windsurfrules") },
+      { label: "AMP.md", path: path.join(vaultPath, "AMP.md") },
+      { label: ".aider.conf.yml", path: path.join(vaultPath, ".aider.conf.yml") },
+    ];
+
+    for (const item of [...vaultFiles, ...vaultAgentFiles]) {
+      if (!fs.existsSync(item.path)) continue;
+      try {
+        if (item.dir) {
+          fs.rmSync(item.path, { recursive: true, force: true });
+        } else {
+          fs.unlinkSync(item.path);
+        }
+        barLn(`${green("\u2713")} ${dim(item.label)}`);
+        removed++;
+      } catch {}
+    }
+  }
+
+  barLn();
+  if (removed > 0) {
+    barLn(dim("Engine files and vault structure left intact."));
+    barLn(dim("Your Identity, Strategy, and Daily Notes are untouched."));
+  } else {
+    barLn(dim("Nothing to remove — Mover OS not detected."));
+  }
+  barLn();
+  outro(`${green("Done.")} ${removed} items removed.`);
+}
+
+// ─── Agent definitions ──────────────────────────────────────────────────────
+const AGENTS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    tier: "Full",
+    detect: () => cmdExists("claude") || fs.existsSync(path.join(os.homedir(), ".claude")),
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    tier: "Full",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".cursor")) || cmdExists("cursor"),
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    tier: "Full",
+    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "saoudrizwan.claude-dev-*"),
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    tier: "Enhanced",
+    detect: () => cmdExists("codex") || fs.existsSync(path.join(os.homedir(), ".codex")),
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    tier: "Enhanced",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".windsurf")) || cmdExists("windsurf"),
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    tier: "Enhanced",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".openclaw")) || cmdExists("openclaw"),
+  },
+  {
+    id: "antigravity",
+    name: "Antigravity",
+    tier: "Basic+",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".gemini")) || cmdExists("gemini"),
+  },
+  {
+    id: "roo-code",
+    name: "Roo Code",
+    tier: "Basic",
+    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "rooveterinaryinc.roo-cline-*"),
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    tier: "Basic",
+    detect: () => cmdExists("gh"),
+  },
+  {
+    id: "amp",
+    name: "Amp",
+    tier: "Basic",
+    detect: () => cmdExists("amp") || fs.existsSync(path.join(os.homedir(), ".amp")),
+  },
+  {
+    id: "aider",
+    name: "Aider",
+    tier: "Basic",
+    detect: () => cmdExists("aider"),
+  },
+];
+
+// ─── Utility functions ──────────────────────────────────────────────────────
+function cmdExists(cmd) {
+  try {
+    execSync(process.platform === "win32" ? `where ${cmd}` : `command -v ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function globDirExists(dir, pattern) {
+  if (!fs.existsSync(dir)) return false;
+  const prefix = pattern.replace("*", "");
+  try {
+    return fs.readdirSync(dir).some((e) => e.startsWith(prefix));
+  } catch {
+    return false;
+  }
+}
+
+function linkOrCopy(src, dest) {
+  try {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    if (fs.existsSync(dest)) fs.unlinkSync(dest);
+    fs.linkSync(src, dest);
+    return "linked";
+  } catch {
+    try {
+      fs.copyFileSync(src, dest);
+      return "copied";
+    } catch {
+      return null;
+    }
+  }
+}
+
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function findSkills(bundleDir) {
+  const skillsDir = path.join(bundleDir, "src", "skills");
+  if (!fs.existsSync(skillsDir)) return [];
+  const skills = [];
+  const walk = (dir) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (fs.existsSync(path.join(full, "SKILL.md"))) {
+          skills.push({ name: entry.name, path: full });
+        } else {
+          walk(full);
+        }
+      }
+    }
+  };
+  walk(skillsDir);
+  return skills;
+}
+
+// ─── AGENTS.md generator ────────────────────────────────────────────────────
+function generateAgentsMd() {
+  return `# AGENTS.md
+
+> Mover OS — The Agentic Operating System for Obsidian
+
+## What This Is
+
+You are operating within **Mover OS**, an AI-powered execution engine built on Obsidian. You audit behavior against stated strategy, extract reusable knowledge, and evolve via user corrections.
+
+## Core Rules
+
+1. **Read before acting.** Load Engine files (02_Areas/Engine/) before any strategic operation.
+2. **Cite sources.** Every claim needs \`[file:line]\` or \`[INFERRED: reason]\`. Confidence < 3 = ask.
+3. **Append-only.** Never delete from plan.md, Auto_Learnings.md, or Daily Notes.
+4. **Grounded output.** No fabricated answers. "I don't know" beats a guess.
+5. **Engine protection.** Never overwrite Identity_Prime.md, Strategy.md, or other Engine files without explicit approval.
+
+## Project Structure
+
+\`\`\`
+00_Inbox/           # Quick capture
+01_Projects/        # Active projects with plan.md + project_state.md
+02_Areas/Engine/    # THE CORE — Identity, Strategy, Context, Dossier
+03_Library/         # Permanent knowledge (MOCs, SOPs, Principles)
+04_Archives/        # Completed projects
+\`\`\`
+
+## Engine Files (Priority Order)
+
+| Priority | File | Purpose |
+|----------|------|---------|
+| P0 | Auto_Learnings.md | AI corrections & behavioral patterns |
+| P1 | Active_Context.md | Current state, blockers, energy |
+| P2 | Strategy.md | Business/life hypothesis being tested |
+| P3 | Identity_Prime.md | User persona, values, anti-identity |
+| P4 | project_state.md | Project-specific knowledge |
+| P5 | Yesterday's Daily Note | Recent session history |
+
+## Behavior
+
+- Be direct. No hedging, no "Great question!", no emdashes.
+- Think like a co-founder, not a consultant.
+- When wrong, name it, fix it, move on.
+- Comment WHY, not WHAT.
+- Have opinions. "It depends" is a cop-out.
+
+## Workflows
+
+Available slash commands: /setup, /walkthrough, /plan-tomorrow, /analyse-day, /log, /review-week, /morning, /overview, /ignite, /harvest, /debug-resistance, /pivot-strategy, /reboot, /refactor-plan
+
+Each workflow hands off to the next. Follow the breadcrumbs.
+
+## Daily Flow
+
+\`\`\`
+/morning → [WORK] → /log → /analyse-day → /plan-tomorrow
+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.
+
+## 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.
+`;
+}
+
+// ─── Claude Code hooks (settings.json) ──────────────────────────────────────
+function generateClaudeSettings() {
+  return JSON.stringify(
+    {
+      hooks: {
+        Stop: [
+          {
+            hooks: [
+              { type: "command", command: 'bash "$HOME/.claude/hooks/session-log-reminder.sh"', timeout: 10 },
+              { type: "command", command: 'bash "$HOME/.claude/hooks/dirty-tree-guard.sh"', timeout: 10 },
+              { type: "command", command: 'bash "$HOME/.claude/hooks/context-staleness.sh"', timeout: 5 },
+            ],
+          },
+        ],
+        PreToolUse: [
+          {
+            matcher: "Write|Edit",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/engine-protection.sh"', timeout: 5 }],
+          },
+          {
+            matcher: "Bash",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/git-safety.sh"', timeout: 5 }],
+          },
+        ],
+        PreCompact: [
+          {
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/pre-compact-backup.sh"', timeout: 15 }],
+          },
+        ],
+      },
+    },
+    null,
+    2
+  );
+}
+
+// ─── .gitignore ─────────────────────────────────────────────────────────────
+function generateGitignore() {
+  return `# Mover OS — protected from git
+02_Areas/Engine/Dailies/
+02_Areas/Engine/Weekly Reviews/
+.obsidian/
+.trash/
+dev/
+`;
+}
+
+// ─── Install functions ──────────────────────────────────────────────────────
+function createVaultStructure(vaultPath) {
+  const dirs = [
+    "00_Inbox",
+    "01_Projects",
+    "01_Projects/_Template Project",
+    "02_Areas/Engine",
+    "02_Areas/Engine/Dailies",
+    "02_Areas/Engine/Weekly Reviews",
+    "03_Library/Cheatsheets",
+    "03_Library/Inputs",
+    "03_Library/MOCs",
+    "03_Library/Principles",
+    "03_Library/Scripts",
+    "03_Library/SOPs",
+    "04_Archives",
+    "Templates",
+  ];
+
+  let created = 0;
+  for (const dir of dirs) {
+    const full = path.join(vaultPath, dir);
+    if (!fs.existsSync(full)) {
+      fs.mkdirSync(full, { recursive: true });
+      created++;
+    }
+  }
+  return created;
+}
+
+function installTemplateFiles(bundleDir, vaultPath) {
+  const structDir = path.join(bundleDir, "src", "structure");
+  if (!fs.existsSync(structDir)) return 0;
+
+  let count = 0;
+  const walk = (dir, rel) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const srcPath = path.join(dir, entry.name);
+      const destPath = path.join(vaultPath, rel, entry.name);
+
+      if (entry.isDirectory()) {
+        walk(srcPath, path.join(rel, entry.name));
+      } else {
+        const relNorm = rel.replace(/\\/g, "/");
+        if (relNorm.includes("02_Areas") && relNorm.includes("Engine") && fs.existsSync(destPath)) {
+          continue;
+        }
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        if (!fs.existsSync(destPath)) {
+          fs.copyFileSync(srcPath, destPath);
+          count++;
+        }
+      }
+    }
+  };
+  walk(structDir, "");
+  return count;
+}
+
+function installWorkflows(bundleDir, destDir) {
+  const srcDir = path.join(bundleDir, "src", "workflows");
+  if (!fs.existsSync(srcDir)) return 0;
+
+  fs.mkdirSync(destDir, { recursive: true });
+  let count = 0;
+  for (const file of fs.readdirSync(srcDir).filter((f) => f.endsWith(".md"))) {
+    if (linkOrCopy(path.join(srcDir, file), path.join(destDir, file))) count++;
+  }
+  return count;
+}
+
+function installRules(bundleDir, destPath) {
+  const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  if (!fs.existsSync(src)) return false;
+  return linkOrCopy(src, destPath) !== null;
+}
+
+function installSkillPacks(bundleDir, destDir) {
+  const skills = findSkills(bundleDir);
+  fs.mkdirSync(destDir, { recursive: true });
+  let count = 0;
+  for (const skill of skills) {
+    const dest = path.join(destDir, skill.name);
+    if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
+    copyDirRecursive(skill.path, dest);
+    count++;
+  }
+  return count;
+}
+
+function installHooksForClaude(bundleDir, vaultPath) {
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  const hooksDst = path.join(os.homedir(), ".claude", "hooks");
+  const settingsDir = path.join(vaultPath, ".claude");
+
+  if (!fs.existsSync(hooksSrc)) return 0;
+
+  fs.mkdirSync(hooksDst, { recursive: true });
+  fs.mkdirSync(settingsDir, { recursive: true });
+
+  let count = 0;
+  for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh"))) {
+    fs.copyFileSync(path.join(hooksSrc, file), path.join(hooksDst, file));
+    count++;
+  }
+
+  const settingsPath = path.join(settingsDir, "settings.json");
+  if (!fs.existsSync(settingsPath)) {
+    fs.writeFileSync(settingsPath, generateClaudeSettings(), "utf8");
+  }
+
+  return count;
+}
+
+// ─── Per-agent install orchestrators ────────────────────────────────────────
+function installClaudeCode(bundleDir, vaultPath) {
+  const home = os.homedir();
+  const steps = [];
+
+  const claudeDir = path.join(home, ".claude");
+  fs.mkdirSync(claudeDir, { recursive: true });
+  if (installRules(bundleDir, path.join(claudeDir, "CLAUDE.md"))) steps.push("rules");
+
+  const cmdsDir = path.join(claudeDir, "commands");
+  const wfCount = installWorkflows(bundleDir, cmdsDir);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
+
+  const skillsDir = path.join(claudeDir, "skills");
+  const skCount = installSkillPacks(bundleDir, skillsDir);
+  if (skCount > 0) steps.push(`${skCount} skills`);
+
+  if (vaultPath) {
+    const hkCount = installHooksForClaude(bundleDir, vaultPath);
+    if (hkCount > 0) steps.push(`${hkCount} hooks`);
+  }
+
+  return steps;
+}
+
+function installCursor(bundleDir, vaultPath) {
+  const home = os.homedir();
+  const steps = [];
+
+  if (vaultPath) {
+    if (installRules(bundleDir, path.join(vaultPath, ".cursorrules"))) steps.push("rules");
+  }
+
+  const cursorRulesDir = path.join(home, ".cursor", "rules");
+  fs.mkdirSync(cursorRulesDir, { recursive: true });
+  const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  if (fs.existsSync(src)) {
+    fs.copyFileSync(src, path.join(cursorRulesDir, "mover-os.mdc"));
+  }
+
+  const cmdsDir = path.join(home, ".cursor", "commands");
+  const wfCount = installWorkflows(bundleDir, cmdsDir);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
+
+  const skillsDir = path.join(home, ".cursor", "skills");
+  const skCount = installSkillPacks(bundleDir, skillsDir);
+  if (skCount > 0) steps.push(`${skCount} skills`);
+
+  return steps;
+}
+
+function installCline(bundleDir, vaultPath) {
+  const steps = [];
+
+  if (vaultPath) {
+    const rulesDir = path.join(vaultPath, ".clinerules");
+    fs.mkdirSync(rulesDir, { recursive: true });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(rulesDir, "mover-os.md"));
+      steps.push("rules");
+    }
+
+    const skillsDir = path.join(vaultPath, ".cline", "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  return steps;
+}
+
+function installCodex(bundleDir, vaultPath) {
+  const home = os.homedir();
+  const steps = [];
+
+  if (vaultPath) {
+    fs.writeFileSync(path.join(vaultPath, "AGENTS.md"), generateAgentsMd(), "utf8");
+    steps.push("AGENTS.md");
+  }
+
+  const codexDir = path.join(home, ".codex");
+  fs.mkdirSync(codexDir, { recursive: true });
+  if (installRules(bundleDir, path.join(codexDir, "instructions.md"))) steps.push("global instructions");
+
+  return steps;
+}
+
+function installWindsurf(bundleDir, vaultPath) {
+  const steps = [];
+  if (vaultPath) {
+    if (installRules(bundleDir, path.join(vaultPath, ".windsurfrules"))) steps.push("rules");
+  }
+  return steps;
+}
+
+function installOpenClaw(bundleDir, vaultPath) {
+  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");
+  }
+
+  const skCount = installSkillPacks(bundleDir, path.join(workspace, "skills"));
+  if (skCount > 0) steps.push(`${skCount} skills`);
+
+  return steps;
+}
+
+function installAntigravity(bundleDir) {
+  const home = os.homedir();
+  const steps = [];
+
+  const geminiDir = path.join(home, ".gemini");
+  fs.mkdirSync(geminiDir, { recursive: true });
+  if (installRules(bundleDir, path.join(geminiDir, "GEMINI.md"))) steps.push("rules");
+
+  const wfDir = path.join(geminiDir, "antigravity", "global_workflows");
+  const wfCount = installWorkflows(bundleDir, wfDir);
+  if (wfCount > 0) steps.push(`${wfCount} workflows`);
+
+  return steps;
+}
+
+function installRooCode(bundleDir, vaultPath) {
+  const steps = [];
+  if (vaultPath) {
+    const rulesDir = path.join(vaultPath, ".roo", "rules");
+    fs.mkdirSync(rulesDir, { recursive: true });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(rulesDir, "mover-os.md"));
+      steps.push("rules");
+    }
+  }
+  return steps;
+}
+
+function installCopilot(bundleDir, vaultPath) {
+  const steps = [];
+  if (vaultPath) {
+    const ghDir = path.join(vaultPath, ".github");
+    fs.mkdirSync(ghDir, { recursive: true });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(ghDir, "copilot-instructions.md"));
+      steps.push("rules");
+    }
+  }
+  return steps;
+}
+
+function installAmp(bundleDir, vaultPath) {
+  const steps = [];
+  if (vaultPath) {
+    fs.writeFileSync(path.join(vaultPath, "AGENTS.md"), generateAgentsMd(), "utf8");
+    steps.push("AGENTS.md");
+    if (installRules(bundleDir, path.join(vaultPath, "AMP.md"))) steps.push("AMP.md");
+  }
+  return steps;
+}
+
+function installAider(bundleDir, vaultPath) {
+  const steps = [];
+  if (vaultPath) {
+    const agentsMdPath = path.join(vaultPath, "AGENTS.md");
+    if (!fs.existsSync(agentsMdPath)) {
+      fs.writeFileSync(agentsMdPath, generateAgentsMd(), "utf8");
+    }
+    steps.push("AGENTS.md");
+
+    const aiderConf = path.join(vaultPath, ".aider.conf.yml");
+    if (!fs.existsSync(aiderConf)) {
+      fs.writeFileSync(aiderConf, "# Mover OS — Aider configuration\nread:\n  - AGENTS.md\n", "utf8");
+      steps.push(".aider.conf.yml");
+    }
+  }
+  return steps;
+}
+
+const AGENT_INSTALLERS = {
+  "claude-code": installClaudeCode,
+  cursor: installCursor,
+  cline: installCline,
+  codex: installCodex,
+  windsurf: installWindsurf,
+  openclaw: installOpenClaw,
+  antigravity: installAntigravity,
+  "roo-code": installRooCode,
+  copilot: installCopilot,
+  amp: installAmp,
+  aider: installAider,
+};
+
+// ─── Pre-flight checks ──────────────────────────────────────────────────────
+function preflight() {
+  const issues = [];
+
+  // Node version
+  const nodeVer = parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeVer < 18) {
+    issues.push({ label: "Node.js", status: "fail", detail: `v${process.versions.node} (need 18+)` });
+  } else {
+    issues.push({ label: "Node.js", status: "ok", detail: `v${process.versions.node}` });
+  }
+
+  // Git
+  const hasGit = cmdExists("git");
+  issues.push({ label: "git", status: hasGit ? "ok" : "warn", detail: hasGit ? "found" : "not found (optional)" });
+
+  // OS
+  const plat = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+  issues.push({ label: "Platform", status: "ok", detail: plat });
+
+  return issues;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+  const opts = parseArgs();
+  const bundleDir = path.resolve(__dirname);
+  const startTime = Date.now();
+
+  // ── Intro ──
+  printHeader();
+
+  // ── Pre-flight ──
+  barLn(gray("Pre-flight"));
+  barLn();
+  const checks = preflight();
+  for (const c of checks) {
+    const icon = c.status === "ok" ? green("\u2713") : c.status === "warn" ? yellow("\u25CB") : red("\u2717");
+    barLn(`${icon} ${dim(`${c.label}  ${c.detail}`)}`);
+  }
+  barLn();
+
+  if (checks.some((c) => c.status === "fail")) {
+    outro(red("Pre-flight failed. Fix the issues above."));
+    process.exit(1);
+  }
+
+  // ── License key ──
+  let key = opts.key;
+
+  if (!key) {
+    let attempts = 0;
+    while (attempts < 3) {
+      key = await textInput({
+        label: "Enter your license key",
+        mask: "\u25AA",
+        placeholder: "MOVER-XXXX-XXXX",
+      });
+
+      if (validateKey(key)) break;
+
+      attempts++;
+      if (attempts < 3) {
+        barLn(red("Invalid key. Try again."));
+        barLn();
+        key = "";
+      }
+    }
+
+    if (!validateKey(key)) {
+      barLn(red("Invalid license key."));
+      barLn();
+      barLn(dim("Get a key at https://moveros.com"));
+      outro("Cancelled.");
+      process.exit(1);
+    }
+  } else {
+    if (!validateKey(key)) {
+      barLn(red("Invalid license key."));
+      barLn();
+      barLn(dim("Get a key at https://moveros.com"));
+      outro("Cancelled.");
+      process.exit(1);
+    }
+    barLn(green("License verified."));
+    barLn();
+  }
+
+  // ── Vault path ──
+  let vaultPath = opts.vault;
+
+  if (!vaultPath) {
+    const candidates = [
+      path.join(os.homedir(), "Documents", "Obsidian"),
+      path.join(os.homedir(), "Obsidian"),
+      path.join(os.homedir(), "Documents", "Mover-OS"),
+    ];
+
+    const detected = candidates.find((p) => {
+      try {
+        return fs.existsSync(p) && (fs.existsSync(path.join(p, ".obsidian")) || fs.existsSync(path.join(p, "02_Areas")));
+      } catch {
+        return false;
+      }
+    });
+
+    const defaultPath = detected || path.join(os.homedir(), "Mover-OS");
+
+    vaultPath = await textInput({
+      label: `Where is your Obsidian vault?${detected ? dim("  (detected)") : ""}`,
+      initial: defaultPath,
+    });
+  } else {
+    barLn(dim(`Vault: ${vaultPath}`));
+    barLn();
+  }
+
+  if (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
+  vaultPath = path.resolve(vaultPath);
+
+  // ── Detect existing install → show mode menu ──
+  const engine = detectEngineFiles(vaultPath);
+  const versionFile = path.join(vaultPath, ".mover-version");
+  const hasExistingInstall = fs.existsSync(versionFile) || engine.exists;
+
+  let installMode = "fresh"; // fresh | update | uninstall
+
+  if (hasExistingInstall) {
+    if (engine.exists) {
+      barLn(yellow("Existing Mover OS vault detected."));
+      barLn(dim(`  Engine files: ${engine.files.join(", ")}`));
+    } else {
+      barLn(yellow("Mover OS installed, but no Engine data yet."));
+    }
+    barLn();
+
+    question("What would you like to do?");
+    barLn();
+
+    installMode = await interactiveSelect(
+      [
+        { id: "update", name: "Update", tier: "recommended" },
+        { id: "fresh", name: "Fresh Install", tier: "overwrites templates" },
+        { id: "uninstall", name: "Uninstall", tier: "removes agent configs" },
+      ],
+      { multi: false, defaultIndex: 0 }
+    );
+  }
+
+  // ── Uninstall flow ──
+  if (installMode === "uninstall") {
+    await runUninstall(vaultPath);
+    return;
+  }
+
+  const updateMode = installMode === "update";
+
+  if (!fs.existsSync(vaultPath)) fs.mkdirSync(vaultPath, { recursive: true });
+
+  // ── Agent selection ──
+  const detectedIds = AGENTS.filter((a) => a.detect()).map((a) => a.id);
+  const agentItems = AGENTS.map((a) => ({
+    ...a,
+    _detected: detectedIds.includes(a.id),
+  }));
+
+  question(`Select your AI agents${detectedIds.length > 0 ? dim("  (detected agents pre-selected)") : ""}`);
+  barLn();
+
+  const selectedIds = await interactiveSelect(agentItems, {
+    multi: true,
+    preSelected: detectedIds,
+  });
+  const selectedAgents = AGENTS.filter((a) => selectedIds.includes(a.id));
+
+  if (selectedAgents.length === 0) {
+    barLn(yellow("No agents selected."));
+    outro("Cancelled.");
+    process.exit(0);
+  }
+
+  // ── Skills ──
+  const allSkills = findSkills(bundleDir);
+  let installSkills = false;
+
+  if (allSkills.length > 0 && selectedAgents.some((a) => ["Full", "Enhanced"].includes(a.tier))) {
+    question(`Install ${bold(String(allSkills.length))} skill packs?  ${dim("code review, marketing, security...")}`);
+    barLn();
+
+    const skillChoice = await interactiveSelect(
+      [
+        { id: "yes", name: "Yes" },
+        { id: "no", name: "No" },
+      ],
+      { multi: false, defaultIndex: 0 }
+    );
+    installSkills = skillChoice === "yes";
+  }
+
+  // ── Install with animated spinners ──
+  barLn();
+  question(updateMode ? bold("Updating...") : bold("Installing..."));
+  barLn();
+
+  let totalSteps = 0;
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+  // 1. Vault structure
+  let sp = spinner("Vault structure");
+  const dirsCreated = createVaultStructure(vaultPath);
+  await sleep(200);
+  sp.stop(`Vault structure${dirsCreated > 0 ? dim(`  ${dirsCreated} folders`) : dim("  verified")}`);
+  totalSteps++;
+
+  // 2. Template files (skip on update)
+  if (!updateMode) {
+    sp = spinner("Engine templates");
+    const templatesInstalled = installTemplateFiles(bundleDir, vaultPath);
+    await sleep(200);
+    sp.stop(`Engine templates${templatesInstalled > 0 ? dim(`  ${templatesInstalled} files`) : dim("  up to date")}`);
+    totalSteps++;
+  }
+
+  // 3. CLAUDE.md (skip on update)
+  if (!updateMode) {
+    const vaultClaudeMd = path.join(vaultPath, "CLAUDE.md");
+    const bundleClaudeMd = path.join(bundleDir, "CLAUDE.md");
+    if (!fs.existsSync(vaultClaudeMd) && fs.existsSync(bundleClaudeMd)) {
+      fs.copyFileSync(bundleClaudeMd, vaultClaudeMd);
+      sp = spinner("CLAUDE.md");
+      await sleep(150);
+      sp.stop("CLAUDE.md");
+      totalSteps++;
+    }
+  }
+
+  // 4. Per-agent installation
+  for (const agent of selectedAgents) {
+    const fn = AGENT_INSTALLERS[agent.id];
+    if (!fn) continue;
+    sp = spinner(agent.name);
+    const steps = agent.id === "antigravity" ? fn(bundleDir) : fn(bundleDir, vaultPath);
+    await sleep(250);
+    if (steps.length > 0) {
+      sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
+      totalSteps++;
+    } else {
+      sp.stop(`${agent.name}  ${dim("configured")}`);
+      totalSteps++;
+    }
+  }
+
+  // 5. AGENTS.md — only for agents that need it
+  const needsAgentsMd = selectedAgents.some((a) => ["codex", "amp", "aider", "openclaw"].includes(a.id));
+  if (needsAgentsMd) {
+    fs.writeFileSync(path.join(vaultPath, "AGENTS.md"), generateAgentsMd(), "utf8");
+    sp = spinner("AGENTS.md");
+    await sleep(150);
+    sp.stop("AGENTS.md");
+    totalSteps++;
+  }
+
+  // 6. .gitignore + git init (fresh install only)
+  if (!updateMode) {
+    const hasGit = cmdExists("git");
+    if (hasGit) {
+      const gitignorePath = path.join(vaultPath, ".gitignore");
+      if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, generateGitignore(), "utf8");
+        sp = spinner(".gitignore");
+        await sleep(100);
+        sp.stop(".gitignore");
+        totalSteps++;
+      }
+      if (!fs.existsSync(path.join(vaultPath, ".git"))) {
+        sp = spinner("Git repository");
+        try {
+          execSync("git init", { cwd: vaultPath, stdio: "ignore" });
+          execSync("git add -A", { cwd: vaultPath, stdio: "ignore" });
+          execSync('git commit -m "Initial commit — Mover OS v' + VERSION + '"', { cwd: vaultPath, stdio: "ignore" });
+          await sleep(300);
+          sp.stop("Git initialized");
+          totalSteps++;
+        } catch {
+          sp.stop(dim("Git skipped"));
+        }
+      }
+    }
+  }
+
+  // 7. Version stamp
+  fs.writeFileSync(path.join(vaultPath, ".mover-version"), `V${VERSION}\n`, "utf8");
+
+  barLn();
+
+  // ── Done ──
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  const verb = updateMode ? "updated" : "installed";
+  outro(`${green("Done.")} Mover OS v${VERSION} ${verb}. ${dim(`${totalSteps} steps in ${elapsed}s`)}`);
+
+  // How to open the vault in each agent
+  const agentOpen = {
+    "claude-code": { cmd: `cd "${vaultPath}" && claude`, name: "Claude Code" },
+    cursor: { cmd: `Open Cursor → File → Open Folder → select vault`, name: "Cursor" },
+    cline: { cmd: `Open VS Code → File → Open Folder → select vault`, name: "Cline (VS Code)" },
+    codex: { cmd: `cd "${vaultPath}" && codex`, name: "Codex" },
+    windsurf: { cmd: `Open Windsurf → File → Open Folder → select vault`, name: "Windsurf" },
+    openclaw: { cmd: `cd "${vaultPath}" && openclaw`, name: "OpenClaw" },
+    antigravity: { cmd: `cd "${vaultPath}" && gemini`, name: "Antigravity" },
+    "roo-code": { cmd: `Open VS Code → File → Open Folder → select vault`, name: "Roo Code" },
+    copilot: { cmd: `Open VS Code → File → Open Folder → select vault`, name: "Copilot" },
+    amp: { cmd: `cd "${vaultPath}" && amp`, name: "Amp" },
+    aider: { cmd: `cd "${vaultPath}" && aider`, name: "Aider" },
+  };
+
+  const primaryAgent = selectedAgents[0];
+  const command = updateMode ? "/update" : "/setup";
+  const agent = agentOpen[primaryAgent.id] || { cmd: "Open your AI agent in the vault", name: "your agent" };
+
+  // Box-drawn summary panel
+  const boxW = 58;
+  const pad = (s, w) => {
+    const visible = strip(s).length;
+    return visible < w ? s + " ".repeat(w - visible) : s;
+  };
+
+  ln(gray(`  ┌${"─".repeat(boxW)}┐`));
+  ln(gray(`  │`) + pad(`  ${bold("Next steps")}`, boxW) + gray(`│`));
+  ln(gray(`  │${"─".repeat(boxW)}│`));
+  ln(gray(`  │`) + pad(`  ${cyan("1")}  Open your vault in ${bold("Obsidian")} ${dim("(for viewing files)")}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`     ${dim(vaultPath.length > 48 ? "..." + vaultPath.slice(-45) : vaultPath)}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`  ${cyan("2")}  Open the vault in ${bold(agent.name)} ${dim("(your AI agent)")}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`     ${dim(agent.cmd.length > 48 ? agent.cmd.slice(0, 48) + "..." : agent.cmd)}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`  ${cyan("3")}  Run ${bold(command)} in ${agent.name}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`     ${dim(updateMode ? "Syncs your Engine with the latest version" : "Builds your Identity, Strategy, and Goals")}`, boxW) + gray(`│`));
+  ln(gray(`  │${" ".repeat(boxW)}│`));
+  ln(gray(`  │`) + pad(`  ${dim("Obsidian = view your files")}`, boxW) + gray(`│`));
+  ln(gray(`  │`) + pad(`  ${dim(agent.name + " = where you work with the AI")}`, boxW) + gray(`│`));
+  ln(gray(`  │${" ".repeat(boxW)}│`));
+  ln(gray(`  │`) + pad(`  ${dim("/morning → [work] → /log → /analyse-day → /plan-tomorrow")}`, boxW) + gray(`│`));
+  ln(gray(`  └${"─".repeat(boxW)}┘`));
+  ln();
+}
+
+main().catch((err) => {
+  cleanup();
+  console.error(red(`\n  Error: ${err.message}`));
+  process.exit(1);
+});