mover-os 4.3.0

package/install.js

@@ -0,0 +1,2775 @@
+#!/usr/bin/env node
+// ══════════════════════════════════════════════════════════════════════════════
+// Mover OS — Interactive TUI Installer
+// Zero dependencies. Node.js 18+.
+//
+// Usage:
+//   npx moveros
+//   npx moveros --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 agentic operating system for obsidian")}`);
+  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;
+        const tag = item._detected ? dim("(detected)") : "";
+
+        w(`\x1b[2K${BAR_COLOR}│${S.reset}  ${icon} ${styledPadded}${tag}\n`);
+        lines++;
+      }
+
+      // Tooltip: description of highlighted item
+      const tip = items[cursor]?.tier || "";
+      w(`\x1b[2K${BAR_COLOR}│${S.reset}\n`);
+      lines++;
+      w(`\x1b[2K${BAR_COLOR}│${S.reset}  ${tip ? `${dim("→")} ${tip}` : ""}\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 (Polar) ─────────────────────────────────────────────
+// All license keys are validated server-side via Polar API.
+// No hardcoded keys — every key must be a real Polar license.
+
+async function validateKey(key) {
+  if (!key) return false;
+  const k = key.trim();
+
+  // Polar license key validation
+  try {
+    const https = require("https");
+    const result = await new Promise((resolve, reject) => {
+      const body = JSON.stringify({ key: k, organization_id: POLAR_ORG_ID });
+      const req = https.request({
+        hostname: "api.polar.sh",
+        path: "/v1/customer-portal/license-keys/validate",
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        timeout: 10000,
+      }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => {
+          try { resolve(JSON.parse(data)); } catch { reject(new Error("Invalid response")); }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
+      req.write(body);
+      req.end();
+    });
+    return result.status === "granted";
+  } catch {
+    // Network error — cannot validate without Polar
+    return false;
+  }
+}
+
+async function activateKey(key) {
+  if (!key) return;
+  try {
+    const https = require("https");
+    const body = JSON.stringify({ key: key.trim(), organization_id: POLAR_ORG_ID, label: os.hostname() });
+    await new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: "api.polar.sh",
+        path: "/v1/customer-portal/license-keys/activate",
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+        timeout: 10000,
+      }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => data += chunk);
+        res.on("end", () => resolve(data));
+      });
+      req.on("error", reject);
+      req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
+      req.write(body);
+      req.end();
+    });
+  } catch { /* Activation failure is non-blocking */ }
+}
+
+// Polar organization ID
+const POLAR_ORG_ID = process.env.POLAR_ORG_ID || "ba863394-6bca-4965-952a-06b7c017adb7";
+
+// ─── Payload Download ────────────────────────────────────────────────────────
+const DOWNLOAD_URL = "https://moveros.dev/api/download";
+
+async function downloadPayload(key) {
+  const https = require("https");
+  const tmpDir = path.join(os.tmpdir(), `moveros-${Date.now()}`);
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const tarPath = path.join(tmpDir, "payload.tar.gz");
+
+  // Download tarball
+  await new Promise((resolve, reject) => {
+    const url = new URL(DOWNLOAD_URL);
+    const req = https.request({
+      hostname: url.hostname,
+      path: url.pathname,
+      method: "GET",
+      headers: { "X-License-Key": key.trim() },
+      timeout: 60000,
+    }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        // Follow redirect — only to trusted domains
+        const redirectUrl = new URL(res.headers.location);
+        const trusted = ["github.com", "objects.githubusercontent.com", "moveros.dev"];
+        if (!trusted.some((d) => redirectUrl.hostname === d || redirectUrl.hostname.endsWith("." + d))) {
+          reject(new Error("Untrusted redirect domain"));
+          return;
+        }
+        const req2 = https.request({
+          hostname: redirectUrl.hostname,
+          path: redirectUrl.pathname + (redirectUrl.search || ""),
+          method: "GET",
+          timeout: 60000,
+        }, (res2) => {
+          const chunks = [];
+          res2.on("data", (c) => chunks.push(c));
+          res2.on("end", () => {
+            fs.writeFileSync(tarPath, Buffer.concat(chunks));
+            resolve();
+          });
+        });
+        req2.on("error", reject);
+        req2.on("timeout", () => { req2.destroy(); reject(new Error("Timeout")); });
+        req2.end();
+        return;
+      }
+      if (res.statusCode === 401) {
+        let body = "";
+        res.on("data", (c) => body += c);
+        res.on("end", () => reject(new Error("License key rejected by server")));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`Download failed (HTTP ${res.statusCode})`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        fs.writeFileSync(tarPath, Buffer.concat(chunks));
+        resolve();
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => { req.destroy(); reject(new Error("Download timeout")); });
+    req.end();
+  });
+
+  // Extract tarball
+  try {
+    execSync(`tar -xzf "${tarPath}" -C "${tmpDir}"`, { stdio: "ignore" });
+  } catch {
+    throw new Error("Failed to extract payload. Ensure 'tar' is available.");
+  }
+
+  // Clean up tarball
+  try { fs.unlinkSync(tarPath); } catch {}
+
+  return tmpDir;
+}
+
+// ─── CLI ─────────────────────────────────────────────────────────────────────
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { vault: "", key: "", update: false };
+  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") {
+      ln();
+      ln(`  ${bold("mover os")} ${dim("installer")}`);
+      ln();
+      ln(`  ${dim("Usage")}   npx moveros`);
+      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();
+      process.exit(0);
+    }
+  }
+  return opts;
+}
+
+// ─── Obsidian vault detection ───────────────────────────────────────────────
+function detectObsidianVaults() {
+  const configPaths = {
+    win32: path.join(os.homedir(), "AppData", "Roaming", "Obsidian", "obsidian.json"),
+    darwin: path.join(os.homedir(), "Library", "Application Support", "obsidian", "obsidian.json"),
+    linux: path.join(os.homedir(), ".config", "obsidian", "obsidian.json"),
+  };
+  const configPath = configPaths[process.platform];
+  if (!configPath || !fs.existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (!config.vaults) return [];
+    return Object.values(config.vaults)
+      .map((v) => v.path)
+      .filter((p) => p && fs.existsSync(p))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+// ─── Change detection (update mode) ─────────────────────────────────────────
+function detectChanges(bundleDir, vaultPath, selectedAgentIds) {
+  const home = os.homedir();
+  const result = { workflows: [], hooks: [], rules: null, templates: [] };
+
+  // --- Workflows: compare source vs first installed destination ---
+  const wfSrc = path.join(bundleDir, "src", "workflows");
+  const wfDests = [
+    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "commands"),
+    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "commands"),
+    selectedAgentIds.includes("antigravity") && path.join(home, ".gemini", "antigravity", "global_workflows"),
+  ].filter(Boolean);
+  const wfDest = wfDests.find((d) => fs.existsSync(d));
+
+  if (fs.existsSync(wfSrc)) {
+    for (const file of fs.readdirSync(wfSrc).filter((f) => f.endsWith(".md"))) {
+      const srcContent = fs.readFileSync(path.join(wfSrc, file), "utf8");
+      const destFile = wfDest && path.join(wfDest, file);
+      if (!destFile || !fs.existsSync(destFile)) {
+        result.workflows.push({ file, status: "new" });
+      } else {
+        const destContent = fs.readFileSync(destFile, "utf8");
+        result.workflows.push({
+          file,
+          status: srcContent === destContent ? "unchanged" : "changed",
+        });
+      }
+    }
+  }
+
+  // --- Hooks: compare with CRLF normalization ---
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  const hooksDest = path.join(home, ".claude", "hooks");
+  if (fs.existsSync(hooksSrc) && selectedAgentIds.includes("claude-code")) {
+    for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".sh") || f.endsWith(".md"))) {
+      const srcContent = fs.readFileSync(path.join(hooksSrc, file), "utf8")
+        .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const destFile = path.join(hooksDest, file);
+      if (!fs.existsSync(destFile)) {
+        result.hooks.push({ file, status: "new" });
+      } else {
+        const destContent = fs.readFileSync(destFile, "utf8")
+          .replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        result.hooks.push({
+          file,
+          status: srcContent === destContent ? "unchanged" : "changed",
+        });
+      }
+    }
+  }
+
+  // --- Rules: compare source vs first installed destination ---
+  const rulesSrc = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  const rulesDests = [
+    selectedAgentIds.includes("claude-code") && path.join(home, ".claude", "CLAUDE.md"),
+    selectedAgentIds.includes("cursor") && path.join(home, ".cursor", "rules", "mover-os.mdc"),
+    selectedAgentIds.includes("gemini-cli") && path.join(home, ".gemini", "GEMINI.md"),
+  ].filter(Boolean);
+  const rulesDest = rulesDests.find((d) => fs.existsSync(d));
+  if (fs.existsSync(rulesSrc) && rulesDest) {
+    const srcContent = fs.readFileSync(rulesSrc, "utf8");
+    const destContent = fs.readFileSync(rulesDest, "utf8");
+    result.rules = srcContent === destContent ? "unchanged" : "changed";
+  } else {
+    result.rules = "unchanged";
+  }
+
+  // --- Templates: non-Engine vault files ---
+  const structDir = path.join(bundleDir, "src", "structure");
+  if (fs.existsSync(structDir)) {
+    const walkTemplates = (dir, rel) => {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const entryRel = path.join(rel, entry.name);
+        if (entry.isDirectory()) {
+          walkTemplates(path.join(dir, entry.name), entryRel);
+        } else {
+          const relNorm = entryRel.replace(/\\/g, "/");
+          if (relNorm.includes("02_Areas") && relNorm.includes("Engine")) continue;
+          const srcContent = fs.readFileSync(path.join(dir, entry.name), "utf8");
+          const destFile = path.join(vaultPath, entryRel);
+          if (!fs.existsSync(destFile)) {
+            result.templates.push({ file: entryRel, status: "new" });
+          } else {
+            const destContent = fs.readFileSync(destFile, "utf8");
+            result.templates.push({
+              file: entryRel,
+              status: srcContent === destContent ? "unchanged" : "changed",
+            });
+          }
+        }
+      }
+    };
+    walkTemplates(structDir, "");
+  }
+
+  return result;
+}
+
+function countChanges(changes) {
+  let n = 0;
+  n += changes.workflows.filter((f) => f.status !== "unchanged").length;
+  n += changes.hooks.filter((f) => f.status !== "unchanged").length;
+  if (changes.rules === "changed") n++;
+  n += changes.templates.filter((f) => f.status !== "unchanged").length;
+  return n;
+}
+
+function displayChangeSummary(changes, installedVersion, newVersion) {
+  // Version line
+  if (installedVersion && newVersion && installedVersion !== newVersion) {
+    barLn(`  Installed: ${dim(installedVersion)} → ${bold(newVersion)}`);
+  } else if (installedVersion === newVersion) {
+    barLn(`  Version: ${dim(installedVersion)} (files may differ)`);
+  }
+  barLn();
+
+  // Workflows
+  const wfChanged = changes.workflows.filter((f) => f.status === "changed");
+  const wfNew = changes.workflows.filter((f) => f.status === "new");
+  const wfUnchanged = changes.workflows.filter((f) => f.status === "unchanged");
+  barLn(`  Workflows ${dim(`(${wfChanged.length + wfNew.length} changed, ${wfUnchanged.length} unchanged)`)}:`);
+  for (const f of wfChanged) barLn(`    ${yellow("✦")} /${f.file.replace(".md", "")}`);
+  for (const f of wfNew) barLn(`    ${green("+")} /${f.file.replace(".md", "")} ${dim("(new)")}`);
+  if (wfChanged.length === 0 && wfNew.length === 0) barLn(`    ${dim("all up to date")}`);
+  barLn();
+
+  // Hooks
+  if (changes.hooks.length > 0) {
+    const hkChanged = changes.hooks.filter((f) => f.status === "changed");
+    const hkNew = changes.hooks.filter((f) => f.status === "new");
+    const hkUnchanged = changes.hooks.filter((f) => f.status === "unchanged");
+    barLn(`  Hooks ${dim(`(${hkChanged.length + hkNew.length} changed, ${hkUnchanged.length} unchanged)`)}:`);
+    for (const f of hkChanged) barLn(`    ${yellow("✦")} ${f.file}`);
+    for (const f of hkNew) barLn(`    ${green("+")} ${f.file} ${dim("(new)")}`);
+    if (hkChanged.length === 0 && hkNew.length === 0) barLn(`    ${dim("all up to date")}`);
+    barLn();
+  }
+
+  // Rules
+  barLn(`  Rules: ${changes.rules === "changed" ? yellow("changed") : dim("unchanged")}`);
+
+  // Templates
+  const tmplChanged = changes.templates.filter((f) => f.status === "changed");
+  const tmplNew = changes.templates.filter((f) => f.status === "new");
+  if (tmplChanged.length > 0 || tmplNew.length > 0) {
+    barLn(`  Templates ${dim(`(${tmplChanged.length + tmplNew.length} changed)`)}:`);
+    for (const f of tmplChanged) barLn(`    ${yellow("✦")} ${f.file.replace(/\\/g, "/")}`);
+    for (const f of tmplNew) barLn(`    ${green("+")} ${f.file.replace(/\\/g, "/")} ${dim("(new)")}`);
+  } else {
+    barLn(`  Templates: ${dim("unchanged")}`);
+  }
+  barLn();
+}
+
+// ─── 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();
+  for (const line of LOGO) {
+    ln(gradient(line));
+  }
+  ln();
+
+  const home = os.homedir();
+
+  // ── Build category map (only include categories that actually exist on disk) ──
+  const categories = [];
+
+  // Rules
+  const rulesPaths = [
+    { label: "Claude Code rules", path: path.join(home, ".claude", "CLAUDE.md") },
+    { label: "Cursor rules", path: path.join(home, ".cursor", "rules", "mover-os.mdc") },
+    { label: "Antigravity rules", path: path.join(home, ".gemini", "GEMINI.md") },
+    { label: "Codex instructions", path: path.join(home, ".codex", "instructions.md") },
+    { label: "Windsurf rules", path: path.join(home, ".windsurfrules") },
+  ];
+  if (vaultPath) {
+    rulesPaths.push(
+      { label: "AGENTS.md", path: path.join(vaultPath, "AGENTS.md") },
+      { label: "SOUL.md", path: path.join(vaultPath, "SOUL.md") },
+      { label: ".cursorrules", path: path.join(vaultPath, ".cursorrules") },
+      { label: ".clinerules", path: path.join(vaultPath, ".clinerules"), dir: true },
+      { label: ".windsurfrules", path: path.join(vaultPath, ".windsurfrules") },
+    );
+  }
+  const rulesExist = rulesPaths.some(p => fs.existsSync(p.path));
+  if (rulesExist) categories.push({ id: "rules", name: "Rules", description: "Global rules files for all agents", items: rulesPaths });
+
+  // Skills
+  const skillsPaths = [
+    { label: "Claude Code skills", path: path.join(home, ".claude", "skills"), dir: true, keepBuiltins: true },
+    { label: "Cursor skills", path: path.join(home, ".cursor", "skills"), dir: true },
+    { label: "Codex skills", path: path.join(home, ".codex", "skills"), dir: true },
+    { label: "Windsurf skills", path: path.join(home, ".windsurf", "skills"), dir: true },
+    { label: "Antigravity skills", path: path.join(home, ".gemini", "antigravity", "skills"), dir: true },
+  ];
+  const skillsExist = skillsPaths.some(p => fs.existsSync(p.path));
+  if (skillsExist) categories.push({ id: "skills", name: "Skills", description: "61 curated skill packs", items: skillsPaths });
+
+  // Commands / Workflows
+  const commandsPaths = [
+    { label: "Claude Code commands", path: path.join(home, ".claude", "commands"), dir: true },
+    { label: "Cursor commands", path: path.join(home, ".cursor", "commands"), dir: true },
+    { label: "Antigravity workflows", path: path.join(home, ".gemini", "antigravity", "global_workflows"), dir: true },
+  ];
+  const commandsExist = commandsPaths.some(p => fs.existsSync(p.path));
+  if (commandsExist) categories.push({ id: "commands", name: "Commands & Workflows", description: "22 slash commands / workflows", items: commandsPaths });
+
+  // Hooks
+  const hooksPaths = [
+    { label: "Claude Code hooks", path: path.join(home, ".claude", "hooks"), dir: true },
+  ];
+  const hooksExist = hooksPaths.some(p => fs.existsSync(p.path));
+  if (hooksExist) categories.push({ id: "hooks", name: "Hooks", description: "6 Claude Code lifecycle hooks", items: hooksPaths });
+
+  // Vault structure (only if vault has Mover OS structure)
+  if (vaultPath) {
+    const vaultStructurePaths = [
+      { label: "00_Inbox/", path: path.join(vaultPath, "00_Inbox"), dir: true },
+      { label: "01_Projects/", path: path.join(vaultPath, "01_Projects"), dir: true },
+      { label: "02_Areas/", path: path.join(vaultPath, "02_Areas"), dir: true },
+      { label: "03_Library/", path: path.join(vaultPath, "03_Library"), dir: true },
+      { label: "04_Archives/", path: path.join(vaultPath, "04_Archives"), dir: true },
+      { label: "Templates/", path: path.join(vaultPath, "Templates"), dir: true },
+    ];
+    const structureExists = vaultStructurePaths.some(p => fs.existsSync(p.path));
+    if (structureExists) categories.push({ id: "vault", name: "Vault Structure", description: "PARA folders + Engine (DESTRUCTIVE — deletes your data)", items: vaultStructurePaths, destructive: true });
+  }
+
+  // Mover OS source folder (if cloned into vault)
+  if (vaultPath) {
+    const moverBundlePath = path.join(vaultPath, "01_Projects", "Mover OS Bundle");
+    if (fs.existsSync(moverBundlePath)) {
+      categories.push({ id: "bundle", name: "Mover OS Bundle", description: "01_Projects/Mover OS Bundle/ source folder", items: [
+        { label: "Mover OS Bundle/", path: moverBundlePath, dir: true },
+      ], destructive: true });
+    }
+  }
+
+  // Config files
+  const configPaths = [];
+  if (vaultPath) {
+    configPaths.push(
+      { label: ".mover-version", path: path.join(vaultPath, ".mover-version") },
+      { label: "Claude settings", path: path.join(vaultPath, ".claude", "settings.json") },
+    );
+  }
+  const configExists = configPaths.some(p => fs.existsSync(p.path));
+  if (configExists) categories.push({ id: "config", name: "Config Files", description: ".mover-version, settings.json", items: configPaths });
+
+  if (categories.length === 0) {
+    barLn(dim("Nothing to remove — Mover OS not detected."));
+    barLn();
+    outro(`${green("Done.")}`);
+    return;
+  }
+
+  // ── Multi-select: what to uninstall ──
+  barLn(bold("What do you want to uninstall?"));
+  barLn();
+
+  const selected = await interactiveSelect(
+    categories.map(c => ({
+      id: c.id,
+      name: c.destructive ? `${c.name} (DESTRUCTIVE)` : c.name,
+      tier: c.description,
+      _detected: !c.destructive,
+    })),
+    { multi: true, preSelected: categories.filter(c => !c.destructive).map(c => c.id) }
+  );
+
+  if (!selected || selected.length === 0) {
+    barLn(dim("Nothing selected. Uninstall cancelled."));
+    barLn();
+    outro(`${green("Done.")}`);
+    return;
+  }
+
+  // ── Destructive warnings ──
+  for (const destructiveId of ["vault", "bundle"]) {
+    if (!selected.includes(destructiveId)) continue;
+    const warnings = {
+      vault: { title: "This will delete your entire vault structure.", detail: "Your Identity, Strategy, Daily Notes, and all Engine files will be permanently deleted.", skip: "Vault structure removal skipped." },
+      bundle: { title: "This will delete the Mover OS source folder.", detail: "01_Projects/Mover OS Bundle/ and all its contents will be permanently removed.", skip: "Bundle removal skipped." },
+    };
+    const w = warnings[destructiveId];
+    barLn();
+    barLn(`${S.red}${bold("WARNING: " + w.title)}${S.reset}`);
+    barLn(`${S.red}${w.detail}${S.reset}`);
+    barLn();
+    const confirm = await textInput({ label: "Type DELETE to confirm (or press Enter to skip):" });
+    if (confirm !== "DELETE") {
+      barLn(dim(w.skip));
+      selected.splice(selected.indexOf(destructiveId), 1);
+    }
+  }
+
+  // ── Execute removal ──
+  barLn();
+  barLn(dim("removing selected components..."));
+  barLn();
+  let removed = 0;
+
+  for (const catId of selected) {
+    const cat = categories.find(c => c.id === catId);
+    if (!cat) continue;
+    for (const item of cat.items) {
+      if (!fs.existsSync(item.path)) continue;
+      try {
+        if (item.dir) {
+          if (item.keepBuiltins) {
+            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 {}
+    }
+  }
+
+  // Deactivate license key (frees activation slot on Polar)
+  const configPath = path.join(home, ".mover", "config.json");
+  if (fs.existsSync(configPath)) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (cfg.licenseKey) {
+        barLn(dim("Deactivating license..."));
+        try {
+          const https = require("https");
+          const body = JSON.stringify({ key: cfg.licenseKey, organization_id: POLAR_ORG_ID, label: os.hostname() });
+          await new Promise((resolve, reject) => {
+            const req = https.request({
+              hostname: "api.polar.sh",
+              path: "/v1/customer-portal/license-keys/deactivate",
+              method: "POST",
+              headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+              timeout: 10000,
+            }, (res) => {
+              let data = "";
+              res.on("data", (chunk) => data += chunk);
+              res.on("end", () => resolve(data));
+            });
+            req.on("error", reject);
+            req.on("timeout", () => { req.destroy(); reject(new Error("Timeout")); });
+            req.write(body);
+            req.end();
+          });
+          barLn(`${green("\u2713")} ${dim("License deactivated — activation slot freed")}`);
+        } catch {
+          barLn(`${dim("Could not reach Polar — license not deactivated")}`);
+        }
+      }
+      // Remove config file
+      fs.unlinkSync(configPath);
+      barLn(`${green("\u2713")} ${dim("~/.mover/config.json")}`);
+      removed++;
+    } catch {}
+  }
+
+  barLn();
+  if (!selected.includes("vault")) {
+    barLn(dim("Engine files and vault structure left intact."));
+    barLn(dim("Your Identity, Strategy, and Daily Notes are untouched."));
+  }
+  barLn();
+  outro(`${green("Done.")} ${removed} items removed.`);
+}
+
+// ─── Agent definitions ──────────────────────────────────────────────────────
+const AGENTS = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    tier: "Full integration — rules, 22 commands, skills, 6 hooks",
+    detect: () => cmdExists("claude") || fs.existsSync(path.join(os.homedir(), ".claude")),
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    tier: "Rules, commands, skills, hooks",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".cursor")) || cmdExists("cursor"),
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    tier: "Rules, skills, hooks",
+    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "saoudrizwan.claude-dev-*"),
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    tier: "Rules, skills, workflows",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".windsurf")) || cmdExists("windsurf"),
+  },
+  {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    tier: "Rules, skills, commands",
+    detect: () => cmdExists("gemini") || fs.existsSync(path.join(os.homedir(), ".gemini", "settings.json")),
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    tier: "Rules, skills",
+    detect: () => cmdExists("gh"),
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    tier: "Rules, skills",
+    detect: () => cmdExists("codex") || fs.existsSync(path.join(os.homedir(), ".codex")),
+  },
+  // Hidden agents: install functions preserved but not shown in selection UI.
+  // Vault-root AGENTS.md provides basic rules for these agents.
+  {
+    id: "antigravity",
+    name: "Antigravity",
+    tier: "Rules, skills, workflows",
+    detect: () => fs.existsSync(path.join(os.homedir(), ".gemini", "antigravity")),
+  },
+  // 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"),
+  },
+  {
+    id: "roo-code",
+    name: "Roo Code",
+    tier: "Rules, skills",
+    hidden: true,
+    detect: () => globDirExists(path.join(os.homedir(), ".vscode", "extensions"), "rooveterinaryinc.roo-cline-*"),
+  },
+];
+
+// ─── 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;
+  }
+}
+
+let linkFallbackWarned = 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);
+      if (!linkFallbackWarned) {
+        console.log(`\n  ${dim("Note: Hard links unavailable — using copies. Edits won't auto-propagate.")}`);
+        console.log(`  ${dim("Run link.sh after editing source files to re-sync.")}\n`);
+        linkFallbackWarned = true;
+      }
+      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);
+    }
+  }
+}
+
+// ─── Skill categories (maps skill folder name → category) ───────────────────
+const SKILL_CATEGORIES = {
+  // Development
+  "agent-code-reviewer": "development",
+  "agent-security-auditor": "development",
+  "systematic-debugging": "development",
+  "find-bugs": "development",
+  "refactoring": "development",
+  "react-best-practices": "development",
+  "webhook-handler-patterns": "development",
+  // Marketing
+  "copywriting": "marketing",
+  "copy-editing": "marketing",
+  "seo-audit": "marketing",
+  "seo-content-writer": "marketing",
+  "social-content": "marketing",
+  "email-sequence": "marketing",
+  "paid-ads": "marketing",
+  "analytics-tracking": "marketing",
+  "human-writer": "marketing",
+  "marketing-ideas": "marketing",
+  "marketing-psychology": "marketing",
+  "ab-test-setup": "marketing",
+  // CRO
+  "page-cro": "cro",
+  "form-cro": "cro",
+  "signup-flow-cro": "cro",
+  "onboarding-cro": "cro",
+  "popup-cro": "cro",
+  "paywall-upgrade-cro": "cro",
+  // Strategy
+  "pricing-strategy": "strategy",
+  "launch-strategy": "strategy",
+  "competitor-alternatives": "strategy",
+  "free-tool-strategy": "strategy",
+  "referral-program": "strategy",
+  "agent-strategy-analyst": "strategy",
+  "agent-research-analyst": "strategy",
+  "agent-content-researcher": "strategy",
+  // SEO
+  "programmatic-seo": "seo",
+  "schema-markup": "seo",
+  // Design
+  "frontend-design": "design",
+  "ui-ux-pro-max": "design",
+  // Obsidian
+  "obsidian-markdown": "obsidian",
+  "obsidian-bases": "obsidian",
+  "obsidian-cli": "obsidian",
+  "json-canvas": "obsidian",
+  // Tools (always installed — core utilities)
+  "defuddle": "tools",
+  "skill-creator": "tools",
+  "find-skills": "tools",
+};
+
+const CATEGORY_META = [
+  { id: "development", name: "Development", desc: "code review, debugging, security" },
+  { id: "marketing", name: "Marketing", desc: "copy, SEO, social, email, ads" },
+  { id: "cro", name: "CRO", desc: "page optimization, forms, popups" },
+  { id: "strategy", name: "Strategy", desc: "pricing, launch, competitors" },
+  { id: "seo", name: "SEO", desc: "programmatic SEO, schema markup" },
+  { id: "design", name: "Design", desc: "frontend, UI/UX" },
+  { id: "obsidian", name: "Obsidian", desc: "markdown, bases, canvas, CLI" },
+];
+
+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, category: SKILL_CATEGORIES[entry.name] || "tools" });
+        } 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 }],
+          },
+        ],
+        PostToolUse: [
+          {
+            matcher: "Write|Edit",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/plan-sync-reminder.sh"', timeout: 5 }],
+          },
+        ],
+        PreCompact: [
+          {
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/pre-compact-backup.sh"', timeout: 15 }],
+          },
+        ],
+        SessionEnd: [
+          {
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/session-end.sh"', timeout: 10 }],
+          },
+        ],
+        PermissionRequest: [
+          {
+            matcher: "Write|Edit",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/engine-permission-request.sh"', timeout: 5 }],
+          },
+        ],
+        SessionStart: [
+          {
+            matcher: "startup|clear",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/session-start.sh" full', timeout: 5 }],
+          },
+          {
+            matcher: "compact",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/session-start.sh" volatile', timeout: 5 }],
+          },
+        ],
+        ConfigChange: [
+          {
+            matcher: "user_settings",
+            hooks: [{ type: "command", command: 'bash "$HOME/.claude/hooks/config-guard.sh"', timeout: 5 }],
+          },
+        ],
+      },
+    },
+    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 writeMoverConfig(vaultPath, agentIds, licenseKey) {
+  const configDir = path.join(os.homedir(), ".mover");
+  if (!fs.existsSync(configDir)) fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  const configPath = path.join(configDir, "config.json");
+  const config = {
+    vaultPath: vaultPath,
+    agents: agentIds,
+    feedbackWebhook: "https://moveros.dev/api/feedback",
+    installedAt: new Date().toISOString(),
+  };
+  if (licenseKey) config.licenseKey = licenseKey;
+  // If config exists, preserve installedAt and licenseKey from original install
+  if (fs.existsSync(configPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      if (existing.installedAt) config.installedAt = existing.installedAt;
+      if (existing.licenseKey && !licenseKey) config.licenseKey = existing.licenseKey;
+      config.updatedAt = new Date().toISOString();
+    } catch {}
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+  return configPath;
+}
+
+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, selectedWorkflows) {
+  const srcDir = path.join(bundleDir, "src", "workflows");
+  if (!fs.existsSync(srcDir)) return 0;
+
+  fs.mkdirSync(destDir, { recursive: true });
+  const srcFiles = new Set(fs.readdirSync(srcDir).filter((f) => f.endsWith(".md")));
+  let count = 0;
+  for (const file of srcFiles) {
+    if (selectedWorkflows && !selectedWorkflows.has(file)) continue;
+    if (linkOrCopy(path.join(srcDir, file), path.join(destDir, file))) count++;
+  }
+
+  // Clean orphaned workflows (renamed/removed in updates)
+  // Only removes files that contain Mover OS markers — preserves user-created commands
+  for (const file of fs.readdirSync(destDir).filter((f) => f.endsWith(".md"))) {
+    if (!srcFiles.has(file)) {
+      try {
+        const content = fs.readFileSync(path.join(destDir, file), "utf8");
+        if (content.includes("Risk Tier:") || content.includes("**Trigger:** User runs")) {
+          fs.unlinkSync(path.join(destDir, file));
+          ln(`  ${dim("Removed orphan:")} ${file}`);
+        }
+      } catch (e) { /* skip unreadable files */ }
+    }
+  }
+  return count;
+}
+
+// ─── Rules Diff-Merge ────────────────────────────────────────────────────────
+// During updates, preserve user customizations appended below the sentinel.
+// Sentinel: <!-- MOVER_OS_RULES_END
+// Fallback: ## My Customizations
+
+const RULES_SENTINEL = "<!-- MOVER_OS_RULES_END";
+const CUSTOM_HEADER = "## My Customizations";
+
+function extractCustomizations(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const content = fs.readFileSync(filePath, "utf8");
+
+  // Check for sentinel first
+  const sentinelIdx = content.indexOf(RULES_SENTINEL);
+  if (sentinelIdx !== -1) {
+    const lineEnd = content.indexOf("\n", sentinelIdx);
+    if (lineEnd !== -1) {
+      const customs = content.substring(lineEnd + 1).trim();
+      return customs.length > 0 ? customs : null;
+    }
+  }
+
+  // Fallback: look for ## My Customizations header
+  const customIdx = content.indexOf(CUSTOM_HEADER);
+  if (customIdx !== -1) {
+    const customs = content.substring(customIdx).trim();
+    return customs.length > 0 ? customs : null;
+  }
+
+  return null;
+}
+
+function installRules(bundleDir, destPath, agentId) {
+  const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  if (!fs.existsSync(src)) return false;
+
+  // Extract any user customizations from existing file before overwriting
+  const customizations = extractCustomizations(destPath);
+
+  if (customizations) {
+    const chars = customizations.length;
+    ln(`  ${yellow("!")} Preserving ${chars.toLocaleString()} chars of user customizations`);
+  }
+
+  // Claude Code gets a hard link (live updates). Other agents get an adapted copy.
+  if (!agentId || agentId === "claude-code") {
+    if (customizations) {
+      // Can't hard-link when user has customizations (shared inode = shared content).
+      // Copy source, then append customizations.
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      if (fs.existsSync(destPath)) fs.unlinkSync(destPath);
+      let content = fs.readFileSync(src, "utf8");
+      if (!content.includes(RULES_SENTINEL)) {
+        content += `\n${RULES_SENTINEL} — Everything below this line is preserved during updates -->\n`;
+      }
+      content += "\n" + customizations + "\n";
+      fs.writeFileSync(destPath, content, "utf8");
+
+      // Size warning
+      if (content.length > 8000) {
+        ln(`  ${yellow("!")} Rules file is ${content.length.toLocaleString()} chars (>${dim("8k")}). Large files may degrade AI attention to later sections.`);
+      }
+      return true;
+    }
+    return linkOrCopy(src, destPath) !== null;
+  }
+
+  // Adapted rules: strip Claude-specific sections for other agents
+  let content = fs.readFileSync(src, "utf8");
+
+  // Strip S10.5 Subagents (Task tool is Claude-specific)
+  content = content.replace(/## 10\.5 Subagents[\s\S]*?(?=\n---\n)/m, "");
+
+  // Strip Pre-Flight Active_Context hook reference (hooks are Claude-specific)
+  // Keep the vault path and Active_Context loading instructions — those are universal
+
+  // Add agent-specific header
+  const agentHeaders = {
+    "cursor": "# Cursor Project Rules",
+    "windsurf": "# Windsurf Rules",
+    "gemini-cli": "# Gemini CLI Rules",
+    "antigravity": "# Antigravity Rules",
+    "copilot": "# Copilot Instructions",
+  };
+
+  if (agentHeaders[agentId]) {
+    content = content.replace(/^# Mover OS Global Rules/m, agentHeaders[agentId]);
+  }
+
+  // Append preserved customizations for non-Claude agents too
+  if (customizations) {
+    if (!content.includes(RULES_SENTINEL)) {
+      content += `\n${RULES_SENTINEL} — Everything below this line is preserved during updates -->\n`;
+    }
+    content += "\n" + customizations + "\n";
+  }
+
+  // Size warning
+  if (content.length > 8000) {
+    ln(`  ${yellow("!")} Rules file is ${content.length.toLocaleString()} chars (>${dim("8k")}). Large files may degrade AI attention to later sections.`);
+  }
+
+  fs.writeFileSync(destPath, content, "utf8");
+  return true;
+}
+
+function installSkillPacks(bundleDir, destDir, selectedCategories) {
+  const skills = findSkills(bundleDir);
+  fs.mkdirSync(destDir, { recursive: true });
+  const installedNames = new Set();
+  let count = 0;
+  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);
+    if (fs.existsSync(dest)) fs.rmSync(dest, { recursive: true, force: true });
+    copyDirRecursive(skill.path, dest);
+    installedNames.add(skill.name);
+    count++;
+  }
+
+  // Clean orphaned skills (renamed/removed in updates)
+  // Only removes dirs that contain SKILL.md — preserves user-created skills
+  for (const dir of fs.readdirSync(destDir)) {
+    if (installedNames.has(dir)) continue;
+    const dirPath = path.join(destDir, dir);
+    try {
+      if (fs.statSync(dirPath).isDirectory() && fs.existsSync(path.join(dirPath, "SKILL.md"))) {
+        const content = fs.readFileSync(path.join(dirPath, "SKILL.md"), "utf8");
+        if (content.includes("## Activation") || content.includes("## When to Use")) {
+          fs.rmSync(dirPath, { recursive: true, force: true });
+          ln(`  ${dim("Removed orphan skill:")} ${dir}`);
+        }
+      }
+    } catch (e) { /* skip */ }
+  }
+  return count;
+}
+
+function installHooksForClaude(bundleDir, vaultPath) {
+  const hooksSrc = path.join(bundleDir, "src", "hooks");
+  const hooksDst = path.join(os.homedir(), ".claude", "hooks");
+  // Write hooks to GLOBAL settings (~/.claude/) not project settings ({vault}/.claude/).
+  // Project settings should stay empty to prevent double-fire.
+  const settingsDir = path.join(os.homedir(), ".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"))) {
+    const dst = path.join(hooksDst, file);
+    // Read, strip \r (CRLF→LF), write — prevents "command not found" on macOS/Linux
+    const content = fs.readFileSync(path.join(hooksSrc, file), "utf8").replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    fs.writeFileSync(dst, content, { mode: 0o755 });
+    count++;
+  }
+  // Copy hook template files (.md) and scripts (.js)
+  for (const file of fs.readdirSync(hooksSrc).filter((f) => f.endsWith(".md") || f.endsWith(".js"))) {
+    const dst = path.join(hooksDst, file);
+    fs.copyFileSync(path.join(hooksSrc, file), dst);
+    count++;
+  }
+
+  // Deep-merge hooks into existing settings.json (preserve user config)
+  const settingsPath = path.join(settingsDir, "settings.json");
+  const newHooks = JSON.parse(generateClaudeSettings()).hooks;
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      if (!existing.hooks) existing.hooks = {};
+      // Merge each hook event (Stop, PreToolUse, PreCompact)
+      for (const [event, entries] of Object.entries(newHooks)) {
+        if (!existing.hooks[event]) {
+          existing.hooks[event] = entries;
+        } else {
+          // Check if our hooks are already registered (by command substring)
+          const existingCmds = JSON.stringify(existing.hooks[event]);
+          const alreadyHas = entries[0].hooks.every(
+            (h) => existingCmds.includes(h.command.split("/").pop().replace('"', ""))
+          );
+          if (!alreadyHas) {
+            existing.hooks[event].push(...entries);
+          }
+        }
+      }
+      fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf8");
+    } catch {
+      // Corrupt settings — backup before overwrite
+      const backupPath = settingsPath + ".bak";
+      try { fs.copyFileSync(settingsPath, backupPath); } catch {}
+      ln(`  ${yellow("!")} Settings file corrupt — backed up to settings.json.bak, writing fresh`);
+      fs.writeFileSync(settingsPath, generateClaudeSettings(), "utf8");
+    }
+  } else {
+    fs.writeFileSync(settingsPath, generateClaudeSettings(), "utf8");
+  }
+
+  return count;
+}
+
+// ─── Per-agent install orchestrators ────────────────────────────────────────
+function installClaudeCode(bundleDir, vaultPath, skillOpts) {
+  const home = os.homedir();
+  const steps = [];
+
+  const claudeDir = path.join(home, ".claude");
+  fs.mkdirSync(claudeDir, { recursive: true });
+  if (!skillOpts?.skipRules) {
+    if (installRules(bundleDir, path.join(claudeDir, "CLAUDE.md"), "claude-code")) steps.push("rules");
+  }
+
+  const cmdsDir = path.join(claudeDir, "commands");
+  const wfCount = installWorkflows(bundleDir, cmdsDir, skillOpts?.workflows);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
+
+  if (skillOpts && skillOpts.install) {
+    const skillsDir = path.join(claudeDir, "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  if (vaultPath && !skillOpts?.skipHooks) {
+    const hkCount = installHooksForClaude(bundleDir, vaultPath);
+    if (hkCount > 0) steps.push(`${hkCount} hooks`);
+  }
+
+  // Status line
+  if (skillOpts && skillOpts.statusLine) {
+    const statusSrc = path.join(bundleDir, "src", "hooks", "statusline.js");
+    const statusDst = path.join(home, ".claude", "statusline.js");
+    if (fs.existsSync(statusSrc)) {
+      fs.copyFileSync(statusSrc, statusDst);
+      const globalSettings = path.join(home, ".claude", "settings.json");
+      try {
+        const settings = fs.existsSync(globalSettings)
+          ? JSON.parse(fs.readFileSync(globalSettings, "utf8"))
+          : {};
+        settings.statusLine = { type: "command", command: "node ~/.claude/statusline.js" };
+        fs.writeFileSync(globalSettings, JSON.stringify(settings, null, 2), "utf8");
+      } catch {
+        fs.writeFileSync(
+          globalSettings,
+          JSON.stringify({ statusLine: { type: "command", command: "node ~/.claude/statusline.js" } }, null, 2),
+          "utf8"
+        );
+      }
+      steps.push("status line");
+    }
+  }
+
+  return steps;
+}
+
+function installCursor(bundleDir, vaultPath, skillOpts) {
+  const home = os.homedir();
+  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 });
+    const src = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+    if (fs.existsSync(src)) {
+      linkOrCopy(src, path.join(cursorRulesDir, "mover-os.mdc"));
+    }
+  }
+
+  const cmdsDir = path.join(home, ".cursor", "commands");
+  const wfCount = installWorkflows(bundleDir, cmdsDir, skillOpts?.workflows);
+  if (wfCount > 0) steps.push(`${wfCount} commands`);
+
+  if (skillOpts && skillOpts.install) {
+    const skillsDir = path.join(home, ".cursor", "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  return steps;
+}
+
+function installCline(bundleDir, vaultPath, skillOpts) {
+  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)) {
+      linkOrCopy(src, path.join(rulesDir, "mover-os.md"));
+      steps.push("rules");
+    }
+
+    if (skillOpts && skillOpts.install) {
+      const skillsDir = path.join(vaultPath, ".cline", "skills");
+      const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+      if (skCount > 0) steps.push(`${skCount} skills`);
+    }
+  }
+
+  return steps;
+}
+
+function installCodex(bundleDir, vaultPath, skillOpts) {
+  const home = os.homedir();
+  const steps = [];
+
+  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");
+
+  if (skillOpts && skillOpts.install) {
+    const skillsDir = path.join(codexDir, "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  return steps;
+}
+
+function installWindsurf(bundleDir, vaultPath, skillOpts) {
+  const home = os.homedir();
+  const steps = [];
+  if (vaultPath) {
+    if (installRules(bundleDir, path.join(vaultPath, ".windsurfrules"), "windsurf")) steps.push("rules");
+  }
+
+  if (skillOpts && skillOpts.install) {
+    const skillsDir = path.join(home, ".windsurf", "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  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;
+}
+
+function installGeminiCli(bundleDir, vaultPath, skillOpts, writtenFiles) {
+  const home = os.homedir();
+  const steps = [];
+
+  const geminiDir = path.join(home, ".gemini");
+  fs.mkdirSync(geminiDir, { recursive: true });
+  const geminiMdPath = path.join(geminiDir, "GEMINI.md");
+  if (!writtenFiles.has(geminiMdPath)) {
+    if (installRules(bundleDir, geminiMdPath, "gemini-cli")) steps.push("rules");
+    writtenFiles.add(geminiMdPath);
+  } else {
+    steps.push("rules (shared)");
+  }
+
+  if (skillOpts && skillOpts.install) {
+    const skCount = installSkillPacks(bundleDir, path.join(geminiDir, "skills"), skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  return steps;
+}
+
+function installAntigravity(bundleDir, vaultPath, skillOpts, writtenFiles) {
+  const home = os.homedir();
+  const steps = [];
+
+  const geminiDir = path.join(home, ".gemini");
+  fs.mkdirSync(geminiDir, { recursive: true });
+  const geminiMdPath = path.join(geminiDir, "GEMINI.md");
+  if (!writtenFiles.has(geminiMdPath)) {
+    if (installRules(bundleDir, geminiMdPath, "antigravity")) steps.push("rules");
+    writtenFiles.add(geminiMdPath);
+  } else {
+    steps.push("rules (shared)");
+  }
+
+  const wfDir = path.join(geminiDir, "antigravity", "global_workflows");
+  const wfCount = installWorkflows(bundleDir, wfDir, skillOpts?.workflows);
+  if (wfCount > 0) steps.push(`${wfCount} workflows`);
+
+  if (skillOpts && skillOpts.install) {
+    const skillsDir = path.join(geminiDir, "antigravity", "skills");
+    const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+    if (skCount > 0) steps.push(`${skCount} skills`);
+  }
+
+  return steps;
+}
+
+function installRooCode(bundleDir, vaultPath, skillOpts) {
+  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");
+    }
+
+    if (skillOpts && skillOpts.install) {
+      const skillsDir = path.join(vaultPath, ".roo", "skills");
+      const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+      if (skCount > 0) steps.push(`${skCount} skills`);
+    }
+  }
+  return steps;
+}
+
+function installCopilot(bundleDir, vaultPath, skillOpts) {
+  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");
+    }
+
+    if (skillOpts && skillOpts.install) {
+      const skillsDir = path.join(ghDir, "skills");
+      const skCount = installSkillPacks(bundleDir, skillsDir, skillOpts.categories);
+      if (skCount > 0) steps.push(`${skCount} skills`);
+    }
+  }
+  return steps;
+}
+
+const AGENT_INSTALLERS = {
+  "claude-code": installClaudeCode,
+  cursor: installCursor,
+  cline: installCline,
+  codex: installCodex,
+  windsurf: installWindsurf,
+  openclaw: installOpenClaw,
+  "gemini-cli": installGeminiCli,
+  antigravity: installAntigravity,
+  "roo-code": installRooCode,
+  copilot: installCopilot,
+};
+
+// ─── 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 });
+
+  // Obsidian — check common install locations
+  let hasObsidian = false;
+  if (process.platform === "darwin") {
+    hasObsidian = fs.existsSync("/Applications/Obsidian.app");
+  } else if (process.platform === "win32") {
+    hasObsidian = fs.existsSync(path.join(os.homedir(), "AppData", "Local", "Obsidian"));
+  } else {
+    hasObsidian = cmdExists("obsidian") || fs.existsSync(path.join(os.homedir(), ".config", "obsidian"));
+  }
+  issues.push({
+    label: "Obsidian",
+    status: hasObsidian ? "ok" : "warn",
+    detail: hasObsidian ? "found" : "not found — get it at obsidian.md",
+  });
+
+  return issues;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+  const opts = parseArgs();
+  let 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);
+  }
+
+  // ── Headless quick update (--update flag) ──
+  if (opts.update) {
+    // Validate stored key
+    let updateKey = opts.key;
+    if (!updateKey) {
+      const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+      if (fs.existsSync(cfgPath)) {
+        try { updateKey = JSON.parse(fs.readFileSync(cfgPath, "utf8")).licenseKey; } catch {}
+      }
+    }
+    if (!updateKey || !await validateKey(updateKey)) {
+      outro(red("Valid license key required. Use: npx moveros --update --key YOUR_KEY"));
+      process.exit(1);
+    }
+
+    // Download payload if not bundled
+    const hasSrcUpdate = fs.existsSync(path.join(bundleDir, "src", "workflows"));
+    if (!hasSrcUpdate) {
+      barLn(dim("Downloading payload..."));
+      try {
+        bundleDir = await downloadPayload(updateKey);
+      } catch (err) {
+        outro(red(`Download failed: ${err.message}`));
+        process.exit(1);
+      }
+    }
+
+    // Auto-detect vault
+    let vaultPath = opts.vault;
+    if (!vaultPath) {
+      const obsVaults = detectObsidianVaults();
+      vaultPath = obsVaults.find((p) =>
+        fs.existsSync(path.join(p, ".mover-version"))
+      );
+      if (!vaultPath) {
+        outro(red("No Mover OS vault found. Use: npx moveros --update --vault /path"));
+        process.exit(1);
+      }
+    }
+    if (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
+    vaultPath = path.resolve(vaultPath);
+    barLn(dim(`Vault: ${vaultPath}`));
+
+    // Auto-detect agents
+    const detectedAgents = AGENTS.filter((a) => a.detect());
+    if (detectedAgents.length === 0) {
+      outro(red("No AI agents detected."));
+      process.exit(1);
+    }
+    const selectedIds = detectedAgents.map((a) => a.id);
+    barLn(dim(`Agents: ${detectedAgents.map((a) => a.name).join(", ")}`));
+    barLn();
+
+    // Detect changes
+    const changes = detectChanges(bundleDir, vaultPath, selectedIds);
+    const totalChanged = countChanges(changes);
+
+    // Read versions
+    const vfPath = path.join(vaultPath, ".mover-version");
+    const installedVer = fs.existsSync(vfPath) ? fs.readFileSync(vfPath, "utf8").trim() : null;
+    let newVer = `V${VERSION}`;
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(bundleDir, "package.json"), "utf8"));
+      newVer = pkg.version || newVer;
+    } catch {}
+
+    displayChangeSummary(changes, installedVer, newVer);
+
+    if (totalChanged === 0) {
+      outro(green("Already up to date."));
+      return;
+    }
+
+    // Apply all changes
+    barLn(bold("Updating..."));
+    barLn();
+    const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+    // Vault structure
+    createVaultStructure(vaultPath);
+
+    // Templates
+    installTemplateFiles(bundleDir, vaultPath);
+
+    // Per-agent installation
+    const writtenFiles = new Set();
+    const skillOpts = { install: true, categories: null, workflows: null };
+    for (const agent of detectedAgents) {
+      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);
+      await sleep(200);
+      if (steps.length > 0) {
+        sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
+      } else {
+        sp.stop(`${agent.name}  ${dim("configured")}`);
+      }
+    }
+
+    // Update version marker + config
+    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `V${VERSION}\n`, "utf8");
+    writeMoverConfig(vaultPath, selectedIds);
+
+    barLn();
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+    outro(`${green("Done.")} ${totalChanged} files updated in ${elapsed}s. Run ${bold("/update")} if version bumped.`);
+    return;
+  }
+
+  // ── License key ──
+  let key = opts.key;
+
+  // Check stored key from previous install
+  if (!key) {
+    const configPath = path.join(os.homedir(), ".mover", "config.json");
+    if (fs.existsSync(configPath)) {
+      try {
+        const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (cfg.licenseKey) key = cfg.licenseKey;
+      } catch {}
+    }
+  }
+
+  if (!key) {
+    let attempts = 0;
+    while (attempts < 3) {
+      key = await textInput({
+        label: "Enter your license key",
+        mask: "\u25AA",
+        placeholder: "MOVER-XXXX-XXXX",
+      });
+
+      const sp = spinner("Validating...");
+      const valid = await validateKey(key);
+      if (valid) {
+        sp.stop(green("License verified"));
+        await activateKey(key);
+        break;
+      }
+
+      sp.stop(red("Invalid key"));
+      attempts++;
+      if (attempts < 3) {
+        barLn(red("Try again."));
+        barLn();
+        key = "";
+      }
+    }
+
+    if (!await validateKey(key)) {
+      barLn(red("Invalid license key."));
+      barLn();
+      barLn(dim("Get a key at https://moveros.dev"));
+      outro("Cancelled.");
+      process.exit(1);
+    }
+  } else {
+    const sp = spinner("Validating license...");
+    if (!await validateKey(key)) {
+      sp.stop(red("Invalid key"));
+      barLn();
+      barLn(dim("Get a key at https://moveros.dev"));
+      outro("Cancelled.");
+      process.exit(1);
+    }
+    sp.stop(green("License verified"));
+    await activateKey(key);
+    barLn();
+  }
+
+  // ── Download payload ──
+  const hasSrc = fs.existsSync(path.join(bundleDir, "src", "workflows"));
+  if (!hasSrc) {
+    const dlSp = spinner("Downloading Mover OS...");
+    try {
+      bundleDir = await downloadPayload(key);
+      dlSp.stop(green("Downloaded"));
+    } catch (err) {
+      dlSp.stop(red("Download failed"));
+      barLn(red(err.message));
+      barLn();
+      barLn(dim("Check your connection and try again."));
+      outro("Cancelled.");
+      process.exit(1);
+    }
+    barLn();
+  }
+
+  // ── Vault path ──
+  let vaultPath = opts.vault;
+
+  if (!vaultPath) {
+    const obsVaults = detectObsidianVaults();
+
+    if (obsVaults.length > 0) {
+      question("Select your Obsidian vault");
+      barLn();
+
+      const vaultItems = obsVaults.map((p) => {
+        const name = path.basename(p);
+        const hasMover =
+          fs.existsSync(path.join(p, ".mover-version")) ||
+          fs.existsSync(path.join(p, "02_Areas", "Engine"));
+        return {
+          id: p,
+          name: `${name}${hasMover ? dim("  (Mover OS)") : ""}`,
+          tier: dim(p),
+        };
+      });
+      vaultItems.push({
+        id: "__manual__",
+        name: "Enter path manually",
+        tier: "Type or paste a custom vault path",
+      });
+
+      const selected = await interactiveSelect(vaultItems, { multi: false });
+
+      if (selected === "__manual__") {
+        vaultPath = await textInput({
+          label: "Where is your Obsidian vault?",
+          initial: path.join(os.homedir(), "Mover-OS"),
+        });
+      } else {
+        vaultPath = selected;
+      }
+    } else {
+      vaultPath = await textInput({
+        label: "Where is your Obsidian vault?",
+        initial: path.join(os.homedir(), "Mover-OS"),
+      });
+    }
+  } 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: "Refreshes rules, commands, and skills. Your data stays safe." },
+        { id: "fresh", name: "Fresh Install", tier: "Full setup from scratch. Template files will be overwritten." },
+        { id: "uninstall", name: "Uninstall", tier: "Remove Mover OS files from your agents and vault." },
+      ],
+      { multi: false, defaultIndex: 0 }
+    );
+  }
+
+  // ── Uninstall flow ──
+  if (installMode === "uninstall") {
+    await runUninstall(vaultPath);
+    return;
+  }
+
+  const updateMode = installMode === "update";
+
+  // ── Backup (update mode only, if Engine files exist) ──
+  if (updateMode && engine.exists) {
+    barLn();
+    question("Back up before updating?");
+    barLn(dim("  Select what to save. Your data won't be overwritten, but backups are always safer."));
+    barLn();
+
+    const backupItems = [
+      { id: "engine", name: "Engine files", tier: "Identity, Strategy, Goals, and all Engine data" },
+    ];
+
+    const areasDir = path.join(vaultPath, "02_Areas");
+    if (fs.existsSync(areasDir)) {
+      backupItems.push({ id: "areas", name: "Full Areas folder", tier: "Everything in 02_Areas/ including Dailies and Reviews" });
+    }
+
+    // Only offer agent config backup if any agents are detected
+    const detectedForBackup = AGENTS.filter((a) => a.detect()).map((a) => a.id);
+    if (detectedForBackup.length > 0) {
+      backupItems.push({ id: "agents", name: "Agent configs", tier: `Current rules, skills, and commands from ${detectedForBackup.length} detected agent(s)` });
+    }
+
+    backupItems.push({ id: "skip", name: "Skip backup", tier: "Continue without backing up" });
+
+    const backupChoices = await interactiveSelect(backupItems, {
+      multi: true,
+      preSelected: ["engine"],
+    });
+
+    if (backupChoices.length > 0 && !(backupChoices.length === 1 && backupChoices.includes("skip"))) {
+      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 archivesDir = path.join(vaultPath, "04_Archives");
+
+      // Engine files backup
+      if (backupChoices.includes("engine")) {
+        const backupDir = path.join(archivesDir, `Engine_Backup_${ts}`);
+        const engineDir = path.join(vaultPath, "02_Areas", "Engine");
+        try {
+          fs.mkdirSync(backupDir, { recursive: true });
+          let backed = 0;
+          for (const file of fs.readdirSync(engineDir)) {
+            const src = path.join(engineDir, file);
+            if (fs.statSync(src).isFile()) {
+              fs.copyFileSync(src, path.join(backupDir, file));
+              backed++;
+            }
+          }
+          barLn(green(`  Backed up ${backed} Engine files to 04_Archives/Engine_Backup_${ts}/`));
+        } catch (err) {
+          barLn(yellow(`  Engine backup failed: ${err.message}. Continuing anyway.`));
+        }
+      }
+
+      // Full Areas folder backup
+      if (backupChoices.includes("areas")) {
+        const backupDir = path.join(archivesDir, `Areas_Backup_${ts}`);
+        try {
+          copyDirRecursive(path.join(vaultPath, "02_Areas"), backupDir);
+          barLn(green(`  Backed up full Areas folder to 04_Archives/Areas_Backup_${ts}/`));
+        } catch (err) {
+          barLn(yellow(`  Areas backup failed: ${err.message}. Continuing anyway.`));
+        }
+      }
+
+      // Agent configs backup
+      if (backupChoices.includes("agents")) {
+        const home = os.homedir();
+        const agentBackupDir = path.join(archivesDir, `Agent_Backup_${ts}`);
+        const AGENT_CONFIG_PATHS = {
+          "claude-code": [
+            { src: path.join(home, ".claude", "CLAUDE.md"), label: "CLAUDE.md" },
+            { src: path.join(home, ".claude", "commands"), label: "commands" },
+            { src: path.join(home, ".claude", "skills"), label: "skills" },
+            { src: path.join(home, ".claude", "hooks"), label: "hooks" },
+          ],
+          cursor: [
+            { src: path.join(home, ".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" },
+            { src: path.join(vaultPath, ".cline", "skills"), label: "skills" },
+          ],
+          windsurf: [
+            { src: path.join(vaultPath, ".windsurfrules"), label: ".windsurfrules" },
+            { 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", "skills"), label: "skills" },
+          ],
+          antigravity: [
+            { src: path.join(home, ".gemini", "GEMINI.md"), label: "GEMINI.md" },
+            { src: path.join(home, ".gemini", "antigravity", "global_workflows"), label: "workflows" },
+            { src: path.join(home, ".gemini", "antigravity", "skills"), label: "skills" },
+          ],
+          copilot: [
+            { src: path.join(vaultPath, ".github", "copilot-instructions.md"), label: "copilot-instructions.md" },
+            { src: path.join(vaultPath, ".github", "skills"), label: "skills" },
+          ],
+          codex: [
+            { src: path.join(home, ".codex", "instructions.md"), label: "instructions.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", "skills"), label: "skills" },
+          ],
+        };
+
+        let agentsBacked = 0;
+        for (const agentId of detectedForBackup) {
+          const paths = AGENT_CONFIG_PATHS[agentId];
+          if (!paths) continue;
+          const agentDir = path.join(agentBackupDir, agentId);
+          let hasContent = false;
+          for (const { src, label } of paths) {
+            try {
+              if (!fs.existsSync(src)) continue;
+              const stat = fs.statSync(src);
+              if (stat.isDirectory()) {
+                copyDirRecursive(src, path.join(agentDir, label));
+                hasContent = true;
+              } else {
+                fs.mkdirSync(agentDir, { recursive: true });
+                fs.copyFileSync(src, path.join(agentDir, label));
+                hasContent = true;
+              }
+            } catch { /* skip inaccessible paths */ }
+          }
+          if (hasContent) agentsBacked++;
+        }
+        if (agentsBacked > 0) {
+          barLn(green(`  Backed up configs from ${agentsBacked} agent(s) to 04_Archives/Agent_Backup_${ts}/`));
+        }
+      }
+    }
+  }
+
+  if (!fs.existsSync(vaultPath)) fs.mkdirSync(vaultPath, { recursive: true });
+
+  // ── Agent selection ──
+  const visibleAgents = AGENTS.filter((a) => !a.hidden);
+  const detectedIds = visibleAgents.filter((a) => a.detect()).map((a) => a.id);
+  const agentItems = visibleAgents.map((a) => ({
+    ...a,
+    _detected: detectedIds.includes(a.id),
+  }));
+
+  if (detectedIds.length === 0) {
+    barLn(yellow("No AI agents detected."));
+    barLn(dim("You need at least one to use Mover OS. Recommended: Claude Code (claude.ai/code)"));
+    barLn();
+  }
+  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);
+  }
+
+  // ── Change detection + selection (update mode only) ──
+  let selectedWorkflows = null; // null = install all
+  let skipHooks = false;
+  let skipRules = false;
+  let skipTemplates = false;
+
+  if (updateMode) {
+    const changes = detectChanges(bundleDir, vaultPath, selectedIds);
+    const totalChanged = countChanges(changes);
+
+    // Read versions for display
+    const versionFilePath = path.join(vaultPath, ".mover-version");
+    const installedVersion = fs.existsSync(versionFilePath)
+      ? fs.readFileSync(versionFilePath, "utf8").trim()
+      : null;
+    let newVersion = `V${VERSION}`;
+    try {
+      const pkgPath = path.join(bundleDir, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        newVersion = pkg.version || newVersion;
+      }
+    } catch {}
+
+    barLn();
+    question("Change Summary");
+    barLn();
+    displayChangeSummary(changes, installedVersion, newVersion);
+
+    if (totalChanged === 0) {
+      barLn(green("  Already up to date."));
+      barLn();
+    } else {
+      const applyChoice = await interactiveSelect(
+        [
+          { id: "all", name: "Yes, update all changed files", tier: "" },
+          { id: "select", name: "Select individually", tier: "" },
+          { id: "cancel", name: "Cancel", tier: "" },
+        ],
+        { multi: false, defaultIndex: 0 }
+      );
+
+      if (applyChoice === "cancel") {
+        outro("Cancelled.");
+        process.exit(0);
+      }
+
+      if (applyChoice === "select") {
+        // Build list of only changed/new files for individual selection
+        const changedItems = [];
+        const changedPreSelected = [];
+        for (const f of changes.workflows.filter((x) => x.status !== "unchanged")) {
+          const id = `wf:${f.file}`;
+          changedItems.push({ id, name: `/${f.file.replace(".md", "")}`, tier: dim(f.status === "new" ? "new workflow" : "workflow") });
+          changedPreSelected.push(id);
+        }
+        for (const f of changes.hooks.filter((x) => x.status !== "unchanged")) {
+          const id = `hook:${f.file}`;
+          changedItems.push({ id, name: f.file, tier: dim(f.status === "new" ? "new hook" : "hook") });
+          changedPreSelected.push(id);
+        }
+        if (changes.rules === "changed") {
+          changedItems.push({ id: "rules", name: "Global Rules", tier: dim("rules") });
+          changedPreSelected.push("rules");
+        }
+        for (const f of changes.templates.filter((x) => x.status !== "unchanged")) {
+          const id = `tmpl:${f.file}`;
+          changedItems.push({ id, name: f.file.replace(/\\/g, "/"), tier: dim(f.status === "new" ? "new template" : "template") });
+          changedPreSelected.push(id);
+        }
+
+        if (changedItems.length > 0) {
+          question("Select files to update");
+          barLn();
+          const selectedFileIds = await interactiveSelect(changedItems, {
+            multi: true,
+            preSelected: changedPreSelected,
+          });
+
+          // Build workflow filter Set
+          const selectedWfFiles = selectedFileIds
+            .filter((id) => id.startsWith("wf:"))
+            .map((id) => id.slice(3));
+          if (selectedWfFiles.length < changes.workflows.filter((x) => x.status !== "unchanged").length) {
+            selectedWorkflows = new Set(selectedWfFiles);
+          }
+          // Check if hooks/rules/templates were deselected
+          skipHooks = !selectedFileIds.some((id) => id.startsWith("hook:"));
+          skipRules = !selectedFileIds.includes("rules");
+          skipTemplates = !selectedFileIds.some((id) => id.startsWith("tmpl:"));
+        }
+      }
+      // "all" = selectedWorkflows stays null, skip flags stay false
+    }
+  }
+
+  // ── Skills ──
+  const allSkills = findSkills(bundleDir);
+  let installSkills = false;
+  let selectedCategories = null; // null = all, Set = filtered
+
+  if (allSkills.length > 0 && selectedAgents.some((a) => a.id !== "aider")) {
+    // Count skills per category
+    const catCounts = {};
+    for (const sk of allSkills) {
+      catCounts[sk.category] = (catCounts[sk.category] || 0) + 1;
+    }
+
+    question(`${bold(String(allSkills.length))} skill packs available. Select categories:`);
+    barLn();
+
+    const categoryItems = CATEGORY_META.map((c) => ({
+      id: c.id,
+      name: `${c.name}  ${dim(`(${catCounts[c.id] || 0})`)}`,
+      tier: dim(c.desc),
+    }));
+
+    // Pre-select Development + Obsidian (core categories everyone needs)
+    const preSelected = ["development", "obsidian"];
+
+    const selectedCatIds = await interactiveSelect(categoryItems, {
+      multi: true,
+      preSelected,
+    });
+
+    installSkills = selectedCatIds.length > 0;
+    if (installSkills) {
+      selectedCategories = new Set(selectedCatIds);
+      // Count how many skills will be installed (selected categories + tools)
+      const skillCount = allSkills.filter((s) => s.category === "tools" || selectedCategories.has(s.category)).length;
+      barLn(dim(`${skillCount} skills selected`));
+    }
+  }
+
+  // ── Status line (Claude Code only) ──
+  let installStatusLine = false;
+  if (selectedIds.includes("claude-code")) {
+    barLn();
+    question("Install Claude Code status line?");
+    barLn(dim("  Shows model, project, context usage, and session cost in your terminal."));
+    barLn(dim("  Example: [Opus 4.6] my-project | Context: 42% | $3.50"));
+    barLn();
+
+    const slChoice = await interactiveSelect(
+      [
+        { id: "yes", name: "Yes, install it", tier: "Adds a live status bar to every Claude Code session" },
+        { id: "no", name: "No, skip", tier: "You can add it later in ~/.claude/settings.json" },
+      ],
+      { multi: false, defaultIndex: 0 }
+    );
+    installStatusLine = slChoice === "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));
+
+  // 0. Legacy cleanup (remove files from older installer versions)
+  const legacyPaths = [
+    path.join(vaultPath, "src"),           // hooks used to install here
+    path.join(vaultPath, "SOUL.md"),       // old soul file
+  ];
+  for (const lp of legacyPaths) {
+    if (fs.existsSync(lp)) {
+      try {
+        const stat = fs.statSync(lp);
+        if (stat.isDirectory()) {
+          fs.rmSync(lp, { recursive: true, force: true });
+        } else {
+          fs.unlinkSync(lp);
+        }
+      } catch {}
+    }
+  }
+
+  // 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 (runs in both modes — only creates missing files, never overwrites)
+  if (!skipTemplates) {
+    sp = spinner(updateMode ? "New template files" : "Engine templates");
+    const templatesInstalled = installTemplateFiles(bundleDir, vaultPath);
+    await sleep(200);
+    sp.stop(updateMode
+      ? `New template files${templatesInstalled > 0 ? dim(`  ${templatesInstalled} added`) : dim("  all present")}`
+      : `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
+  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++;
+    }
+  }
+
+  // 5. AGENTS.md — only for agents that need it (consolidated write)
+  const needsAgentsMd = selectedAgents.some((a) => ["codex"].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. Obsidian theme (install CSS snippet)
+  {
+    const snippetsDir = path.join(vaultPath, ".obsidian", "snippets");
+    const themeSrc = path.join(bundleDir, "src", "theme", "minimal-theme.css");
+    const themeDst = path.join(snippetsDir, "minimal-theme.css");
+    if (fs.existsSync(themeSrc)) {
+      fs.mkdirSync(snippetsDir, { recursive: true });
+      fs.copyFileSync(themeSrc, themeDst);
+      sp = spinner("Obsidian theme");
+      await sleep(150);
+      sp.stop(`Obsidian theme  ${dim("enable in Settings → Appearance → CSS snippets")}`);
+      totalSteps++;
+    }
+  }
+
+  // 7. .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 01_Projects 02_Areas/Engine 03_Library 04_Archives .gitignore .mover-version CLAUDE.md", { 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"));
+        }
+      }
+    }
+  }
+
+  // 8. Version stamp (fresh install only — update mode lets /update workflow stamp after migrations)
+  if (!updateMode) {
+    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `V${VERSION}\n`, "utf8");
+  }
+
+  // 9. Write ~/.mover/config.json (both fresh + update)
+  writeMoverConfig(vaultPath, selectedIds, key);
+
+  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`)}`);
+
+  // Size check on installed rules files
+  const rulesFile = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
+  if (fs.existsSync(rulesFile)) {
+    const rulesSize = fs.statSync(rulesFile).size;
+    const estimatedTokens = Math.round(rulesSize / 4);
+    if (estimatedTokens > 12000) {
+      ln(`  ${yellow("Warning:")} Global rules file is ~${(estimatedTokens / 1000).toFixed(1)}k tokens.`);
+      ln(`  ${dim("Large rule files consume context window. Consider trimming unused sections.")}`);
+      ln();
+    }
+  }
+
+  const agentNames = selectedAgents.map((a) => a.name);
+
+  // ── What you got ──
+  ln(gray("  ─────────────────────────────────────────────"));
+  ln();
+  ln(`  ${bold("What was installed")}`);
+  ln();
+  ln(`  ${green("▸")} ${bold("22")} workflows    ${dim("slash commands for daily rhythm, projects, strategy")}`);
+  ln(`  ${green("▸")} ${bold("61")} skills        ${dim("curated packs for dev, marketing, CRO, design")}`);
+  if (selectedIds.includes("claude-code")) {
+    ln(`  ${green("▸")} ${bold("6")}  hooks         ${dim("lifecycle guards (engine protection, git safety)")}`);
+  }
+  ln(`  ${green("▸")} ${bold(String(selectedAgents.length))}  agent${selectedAgents.length > 1 ? "s" : ""}        ${dim(agentNames.join(", "))}`);
+  ln(`  ${green("▸")} PARA vault     ${dim("folders, templates, Engine scaffold")}`);
+  ln();
+
+  // ── Next steps ──
+  ln(gray("  ─────────────────────────────────────────────"));
+  ln();
+  ln(`  ${bold("Next steps")}`);
+  ln();
+  if (updateMode) {
+    ln(`  ${cyan("1")}  Open the vault folder in your AI agent`);
+    ln(`     ${dim("Updated: " + agentNames.join(", "))}`);
+    ln();
+    ln(`  ${cyan("2")}  Run ${bold("/update")}`);
+    ln(`     ${dim("Syncs your Engine with the latest version")}`);
+  } else {
+    ln(`  ${cyan("1")}  Open your vault in ${bold("Obsidian")}`);
+    ln(`     ${dim("This is where you view and browse your files")}`);
+    ln();
+    ln(`  ${cyan("2")}  Open the vault folder in your AI agent`);
+    ln(`     ${dim("Installed: " + agentNames.join(", "))}`);
+    ln();
+    ln(`  ${cyan("3")}  Enable the Obsidian theme`);
+    ln(`     ${dim("Settings → Appearance → CSS snippets → minimal-theme")}`);
+    ln();
+    ln(`  ${cyan("4")}  Run ${bold("/setup")}`);
+    ln(`     ${dim("Builds your Identity, Strategy, and Goals")}`);
+    ln();
+    ln(gray("  ─────────────────────────────────────────────"));
+    ln();
+    ln(`  ${dim("Obsidian = view your files")}`);
+    ln(`  ${dim("Your AI agent = where you work")}`);
+  }
+  ln();
+  ln(`  ${dim("/morning → [work] → /log → /analyse-day → /plan-tomorrow")}`);
+  ln();
+}
+
+main().catch((err) => {
+  cleanup();
+  console.error(red(`\n  Error: ${err.message}`));
+  process.exit(1);
+});