mover-os 4.4.3 → 4.5.1

package/install.js

@@ -89,8 +89,28 @@ function waveGradient(text, frame, totalFrames) {
   }).join("") + S.reset;
 }
 
+// ─── TUI: Alternate screen buffer ────────────────────────────────────────────
+let _inAltScreen = false;
+function enterAltScreen() {
+  if (!IS_TTY || _inAltScreen) return;
+  w("\x1b[?1049h");   // Enter alternate screen
+  w("\x1b[2J\x1b[H"); // Clear + cursor home
+  w(S.hide);
+  _inAltScreen = true;
+}
+function exitAltScreen() {
+  if (!IS_TTY || !_inAltScreen) return;
+  w("\x1b[?1049l");   // Restore original screen
+  w(S.show);
+  _inAltScreen = false;
+}
+function clearContent() {
+  w("\x1b[2J\x1b[H"); // Clear screen + cursor to top
+}
+
 // ─── Terminal cleanup ────────────────────────────────────────────────────────
 function cleanup() {
+  exitAltScreen();
   w(S.show);
   try { if (process.stdin.isTTY && process.stdin.isRaw) process.stdin.setRawMode(false); } catch {}
 }
@@ -252,6 +272,127 @@ function statusLine(icon, label, detail = "") {
   barLn(`${iconMap[icon] || icon} ${label}${detail ? `  ${dim(detail)}` : ""}`);
 }
 
+// ─── TUI: Compact header ────────────────────────────────────────────────────
+function compactHeader() {
+  const pkgVer = require("./package.json").version;
+  let info = "";
+  try {
+    const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+      const parts = [];
+      if (cfg.vaultPath) parts.push(path.basename(cfg.vaultPath));
+      if (cfg.agents?.length) parts.push(`${cfg.agents.length} agents`);
+      info = parts.length ? `${S.gray} · ${parts.join(" · ")}${S.reset}` : "";
+    }
+  } catch {}
+  return `  ${S.bold}moveros${S.reset} ${S.dim}v${pkgVer}${S.reset}${info}`;
+}
+
+// ─── TUI: Screen transitions ────────────────────────────────────────────────
+async function wipeDown(lineCount) {
+  if (!IS_TTY) return;
+  const rows = process.stdout.rows || 24;
+  const count = Math.min(lineCount || rows, rows);
+  w("\x1b[H");
+  for (let i = 0; i < count; i++) {
+    w(`\x1b[${i + 1};1H\x1b[2K`);
+    await sleep(8);
+  }
+}
+
+async function fadeOut() {
+  if (!IS_TTY) return;
+  const rows = process.stdout.rows || 24;
+  for (let i = 1; i <= rows; i++) {
+    w(`\x1b[${i};1H\x1b[2K`);
+    if (i % 3 === 0) await sleep(6);
+  }
+}
+
+async function slideIn(lines) {
+  if (!IS_TTY) { lines.forEach(l => ln(l)); return; }
+  for (const line of lines) {
+    ln(line);
+    await sleep(12);
+  }
+}
+
+async function glowPulse(text, x, y) {
+  if (!IS_TTY) { ln(text); return; }
+  const frames = [255, 252, 255, 250, 248, 246];
+  for (const brightness of frames) {
+    if (y) w(`\x1b[${y};${x}H`);
+    w(`\x1b[2K${S.fg(brightness)}${strip(text)}${S.reset}`);
+    await sleep(40);
+  }
+  if (y) w(`\x1b[${y};${x}H`);
+  w(`\x1b[2K${text}\n`);
+}
+
+async function shimmerText(text, duration = 400) {
+  if (!IS_TTY) { ln(text); return; }
+  const totalFrames = Math.floor(duration / 20);
+  const raw = strip(text);
+  for (let f = 0; f <= totalFrames; f++) {
+    w(`\r\x1b[2K  ${waveGradient(raw, f, totalFrames)}`);
+    await sleep(20);
+  }
+  w(`\r\x1b[2K  ${text}\n`);
+}
+
+// ─── TUI: waitForEsc ────────────────────────────────────────────────────────
+function waitForEsc() {
+  return new Promise((r) => {
+    if (!IS_TTY) { r(); return; }
+    const { stdin } = process;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const h = (data) => {
+      if (data === "\x1b" || data === "\r" || data === "\n" || data === "\x03") {
+        stdin.removeListener("data", h);
+        stdin.setRawMode(false);
+        stdin.pause();
+        if (data === "\x03") { cleanup(); ln(); process.exit(0); }
+        r();
+      }
+    };
+    stdin.on("data", h);
+  });
+}
+
+// ─── TUI: Animated progress for install/update ──────────────────────────────
+async function installProgress(steps) {
+  const total = steps.length;
+  for (let i = 0; i < total; i++) {
+    const step = steps[i];
+    w(`\x1b[2K\r  ${progressBar(i, total, 30)} ${S.dim}${step.label}${S.reset}`);
+    await step.fn();
+    w(`\x1b[2K\r  ${progressBar(i + 1, total, 30)} ${S.green}\u2713${S.reset} ${step.label}\n`);
+    await sleep(60);
+  }
+}
+
+// ─── TUI: Success animation ─────────────────────────────────────────────────
+async function successAnimation(message) {
+  if (!IS_TTY) { ln(message); return; }
+  const check = [
+    "       \u2713",
+    "      \u2713",
+    "     \u2713",
+    "  \u2713 \u2713",
+    "   \u2713",
+  ];
+  ln();
+  for (const line of check) {
+    await shimmerText(green(line), 200);
+  }
+  ln();
+  await shimmerText(bold(message), 400);
+  ln();
+}
+
 // ─── Clack-style frame ──────────────────────────────────────────────────────
 const BAR_COLOR = S.cyan;
 const bar = () => w(`${BAR_COLOR}│${S.reset}`);
@@ -421,10 +562,12 @@ function interactiveSelect(items, { multi = false, preSelected = [], defaultInde
 
         const icon = multi
           ? (checked ? green("◼") : dim("◻"))
-          : (active ? cyan("●") : dim("○"));
-        const label = active ? bold(item.name) : item.name;
+          : (active ? `${S.bold}${S.fg(255)}›${S.reset}` : dim(" "));
+        const label = active
+          ? `${S.bold}${S.fg(255)}${item.name}${S.reset}`
+          : `${S.fg(245)}${item.name}${S.reset}`;
         const padded = strip(label).padEnd(20);
-        const styledPadded = active ? bold(padded) : padded;
+        const styledPadded = active ? `${S.bold}${S.fg(255)}${padded}${S.reset}` : `${S.fg(245)}${padded}${S.reset}`;
         const tag = item._detected ? dim("(detected)") : "";
 
         w(`\x1b[2K${BAR_COLOR}│${S.reset}  ${icon} ${styledPadded}${tag}\n`);
@@ -655,14 +798,69 @@ async function downloadPayload(key) {
   return tmpDir;
 }
 
+// ─── Path helpers ────────────────────────────────────────────────────────────
+function getSessionDate() {
+  const now = new Date();
+  if (now.getHours() < 5) return new Date(now.getTime() - 86400000);
+  return now;
+}
+
+function resolveDailyNotePath(engineDir, date) {
+  if (!date) date = getSessionDate();
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  const ymd = `${yyyy}-${mm}-${dd}`;
+  // Primary: month subfolder (Mover OS convention)
+  const monthPath = path.join(engineDir, "Dailies", `${yyyy}-${mm}`, `Daily - ${ymd}.md`);
+  if (fs.existsSync(monthPath)) return monthPath;
+  // Fallback: flat Dailies folder (older vaults)
+  const flatPath = path.join(engineDir, "Dailies", `Daily - ${ymd}.md`);
+  if (fs.existsSync(flatPath)) return flatPath;
+  return monthPath; // default for creation
+}
+
 // ─── CLI ─────────────────────────────────────────────────────────────────────
+// ─── Frecency Tracking ──────────────────────────────────────────────────────
+function loadCliUsage() {
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  if (!fs.existsSync(cfgPath)) return {};
+  try {
+    const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+    return cfg.cli_usage || {};
+  } catch { return {}; }
+}
+
+function recordCliUsage(cmd) {
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  try {
+    const cfg = fs.existsSync(cfgPath) ? JSON.parse(fs.readFileSync(cfgPath, "utf8")) : {};
+    if (!cfg.cli_usage) cfg.cli_usage = {};
+    const entry = cfg.cli_usage[cmd] || { count: 0, last: 0 };
+    entry.count++;
+    entry.last = Date.now();
+    cfg.cli_usage[cmd] = entry;
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+  } catch {}
+}
+
+function frecencyScore(usage, cmd) {
+  const e = usage[cmd];
+  if (!e || !e.count) return 0;
+  const ageHours = (Date.now() - (e.last || 0)) / 3600000;
+  const recency = ageHours < 1 ? 4 : ageHours < 24 ? 3 : ageHours < 168 ? 2 : 1;
+  return e.count * recency;
+}
+
 // ─── CLI Commands ────────────────────────────────────────────────────────────
 const CLI_COMMANDS = {
-  install:  { desc: "Full interactive install",                  alias: [] },
-  update:   { desc: "Update all agents",                         alias: ["-u"] },
+  install:   { desc: "Fresh install wizard",                       alias: [] },
+  update:    { desc: "Comprehensive update — agents, rules, skills", alias: ["-u"] },
+  uninstall: { desc: "Remove Mover OS from vault and agents",     alias: [] },
   doctor:   { desc: "Health check across all installed agents",  alias: [] },
   pulse:    { desc: "Terminal dashboard — energy, tasks, streaks",alias: [] },
-  warm:     { desc: "Pre-warm an AI session with context",       alias: [] },
+  // warm removed — hooks + rules + /morning already handle session priming
   capture:  { desc: "Quick capture — tasks, links, ideas",       alias: [] },
   who:      { desc: "Entity memory lookup",                      alias: [] },
   diff:     { desc: "Engine file evolution viewer",              alias: [] },
@@ -743,8 +941,8 @@ function detectObsidianVaults() {
 }
 
 function compareVersions(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
+  const pa = String(a).replace(/^[vV]/, "").split(".").map(Number);
+  const pb = String(b).replace(/^[vV]/, "").split(".").map(Number);
   for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
     const va = pa[i] || 0, vb = pb[i] || 0;
     if (va > vb) return 1;
@@ -1573,7 +1771,7 @@ Stuck: /debug-resistance
 
 ## CLI Utility
 
-\`moveros\` provides system-level terminal operations: pulse (dashboard), warm (pre-warm sessions), sync (update agents), doctor (health check), who (entity lookup), capture (quick inbox). Use native agent capabilities first — the CLI supplements, never replaces.
+\`moveros\` provides system-level terminal operations: pulse (dashboard), sync (update agents), doctor (health check), who (entity lookup), capture (quick inbox). Use native agent capabilities first — the CLI supplements, never replaces.
 `;
 }
 
@@ -2715,7 +2913,7 @@ function preflight() {
 // ─── CLI Command Handlers (stubs — implemented progressively) ────────────────
 const CLI_HANDLERS = {
   pulse:    async (opts) => { await cmdPulse(opts); },
-  warm:     async (opts) => { await cmdWarm(opts); },
+  // warm removed
   capture:  async (opts) => { await cmdCapture(opts); },
   who:      async (opts) => { await cmdWho(opts); },
   diff:     async (opts) => { await cmdDiff(opts); },
@@ -2725,10 +2923,11 @@ const CLI_HANDLERS = {
   settings: async (opts) => { await cmdSettings(opts); },
   backup:   async (opts) => { await cmdBackup(opts); },
   restore:  async (opts) => { await cmdRestore(opts); },
-  doctor:   async (opts) => { await cmdDoctor(opts); },
-  prayer:   async (opts) => { await cmdPrayer(opts); },
-  help:     async (opts) => { await cmdHelp(opts); },
-  test:     async (opts) => { await cmdTest(opts); },
+  doctor:    async (opts) => { await cmdDoctor(opts); },
+  prayer:    async (opts) => { await cmdPrayer(opts); },
+  help:      async (opts) => { await cmdHelp(opts); },
+  uninstall: async (opts) => { await runUninstall(resolveVaultPath(opts.vault)); },
+  test:      async (opts) => { await cmdTest(opts); },
 };
 
 // ─── moveros doctor ─────────────────────────────────────────────────────────
@@ -2859,10 +3058,7 @@ async function cmdPulse(opts) {
 
   // Today's tasks from Daily Note
   barLn();
-  const now = new Date();
-  const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-  const month = ymd.substring(0, 7);
-  const dailyPath = path.join(engineDir, "Dailies", month, `Daily - ${ymd}.md`);
+  const dailyPath = resolveDailyNotePath(engineDir);
   if (fs.existsSync(dailyPath)) {
     const daily = fs.readFileSync(dailyPath, "utf8");
     const taskSection = daily.match(/##\s*Tasks[\s\S]*?(?=\n##|\n---)/i);
@@ -2917,91 +3113,25 @@ async function cmdPulse(opts) {
     statusLine(streak >= 3 ? "ok" : "info", "Daily streak", `${streak} day${streak !== 1 ? "s" : ""}`);
   }
 
-  // Last session log time
-  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
-  if (fs.existsSync(cfgPath)) {
+  // Last session log time — read from Active_Context.md Workflow State
+  const acLogPath = path.join(engineDir, "Active_Context.md");
+  if (fs.existsSync(acLogPath)) {
     try {
-      const cfgData = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
-      if (cfgData.lastLog) {
-        const ago = Math.round((Date.now() - new Date(cfgData.lastLog).getTime()) / 3600000);
-        statusLine(ago < 8 ? "ok" : ago < 24 ? "info" : "warn", "Last /log", `${ago}h ago`);
+      const acContent = fs.readFileSync(acLogPath, "utf8");
+      const logMatch = acContent.match(/log_last_run:\s*(\S+)/);
+      if (logMatch) {
+        const agoMs = Date.now() - new Date(logMatch[1]).getTime();
+        const agoMin = Math.round(agoMs / 60000);
+        const agoH = Math.round(agoMs / 3600000);
+        const agoStr = agoMin < 60 ? `${agoMin}m ago` : `${agoH}h ago`;
+        statusLine(agoH < 8 ? "ok" : agoH < 24 ? "info" : "warn", "Last /log", agoStr);
       }
     } catch {}
   }
   barLn();
 }
 
-// ─── moveros warm ───────────────────────────────────────────────────────────
-async function cmdWarm(opts) {
-  const vault = resolveVaultPath(opts.vault);
-  if (!vault) { barLn(red("No vault found.")); return; }
-  const agent = opts.rest[0] || "claude";
-  const engineDir = path.join(vault, "02_Areas", "Engine");
-  const home = os.homedir();
-
-  // Build context primer
-  const sections = [];
-  sections.push("# Session Context Primer");
-  sections.push(`Generated: ${new Date().toISOString()}\n`);
-
-  // Active Context snapshot
-  const acPath = path.join(engineDir, "Active_Context.md");
-  if (fs.existsSync(acPath)) {
-    const ac = fs.readFileSync(acPath, "utf8");
-    // Extract key sections (first 2000 chars)
-    sections.push("## Active Context\n" + ac.substring(0, 2000));
-  }
-
-  // Current project state
-  const cwd = process.cwd();
-  const planPath = path.join(cwd, "dev", "plan.md");
-  if (fs.existsSync(planPath)) {
-    const plan = fs.readFileSync(planPath, "utf8");
-    // Find last active phase
-    const phases = plan.match(/### Phase \d+[\s\S]*?(?=### Phase|\Z)/g);
-    if (phases) {
-      const active = phases[phases.length - 1].substring(0, 1500);
-      sections.push("## Current Plan (last phase)\n" + active);
-    }
-  }
-
-  // Today's daily note tasks
-  const now = new Date();
-  const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-  const dailyPath = path.join(engineDir, "Dailies", ymd.substring(0, 7), `Daily - ${ymd}.md`);
-  if (fs.existsSync(dailyPath)) {
-    const daily = fs.readFileSync(dailyPath, "utf8");
-    const taskSection = daily.match(/##\s*Tasks[\s\S]*?(?=\n##)/i);
-    if (taskSection) sections.push("## Today's Tasks\n" + taskSection[0]);
-  }
-
-  const primer = sections.join("\n\n---\n\n") + "\n";
-
-  // Write to agent-specific location
-  const targets = {
-    claude: path.join(home, ".claude", "tmp", "session-primer.md"),
-    cursor: path.join(vault, ".cursor", "rules", "session-primer.mdc"),
-    gemini: path.join(home, ".gemini", "session-primer.md"),
-    codex: path.join(home, ".codex", "skills", "session-primer", "SKILL.md"),
-    windsurf: path.join(vault, ".windsurf", "rules", "session-primer.md"),
-    cline: path.join(vault, ".clinerules", "session-primer.md"),
-  };
-
-  const dest = targets[agent] || targets.claude;
-  fs.mkdirSync(path.dirname(dest), { recursive: true });
-
-  let content = primer;
-  if (agent === "cursor") {
-    content = `---\ndescription: "Session context primer — auto-generated by moveros warm"\nglobs:\nalwaysApply: true\n---\n\n${primer}`;
-  } else if (agent === "codex") {
-    content = `---\nname: session-primer\ndescription: "Auto-generated session context from moveros warm"\n---\n\n${primer}`;
-  }
-
-  fs.writeFileSync(dest, content, "utf8");
-  statusLine("ok", "Warm", `${agent} primer written`);
-  barLn(dim(`  ${dest}`));
-  barLn();
-}
+// cmdWarm removed — hooks + rules + /morning handle session priming
 
 // ─── moveros capture ────────────────────────────────────────────────────────
 async function cmdCapture(opts) {
@@ -3011,7 +3141,19 @@ async function cmdCapture(opts) {
   const now = new Date();
   const ymd = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
   const ts = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
-  const capturePath = path.join(vault, "00_Inbox", `Capture - ${ymd}.md`);
+
+  // Find existing capture file — prefer today's, fallback to most recent, create new if none
+  const inboxDir = path.join(vault, "00_Inbox");
+  fs.mkdirSync(inboxDir, { recursive: true });
+  const existingCaptures = fs.readdirSync(inboxDir)
+    .filter(f => f.toLowerCase().startsWith("capture") && f.endsWith(".md"))
+    .sort();
+  const todayCapture = existingCaptures.find(f => f.includes(ymd));
+  const capturePath = todayCapture
+    ? path.join(inboxDir, todayCapture)
+    : existingCaptures.length > 0
+      ? path.join(inboxDir, existingCaptures[existingCaptures.length - 1])
+      : path.join(inboxDir, `Capture - ${ymd}.md`);
 
   // Determine type from flags
   let type = null, content = "";
@@ -3057,7 +3199,6 @@ async function cmdCapture(opts) {
   else entry = `- ${content}  *(${ts})*`;
 
   // Append to capture file
-  fs.mkdirSync(path.dirname(capturePath), { recursive: true });
   if (!fs.existsSync(capturePath)) {
     fs.writeFileSync(capturePath, `# Capture — ${ymd}\n\n${entry}\n`, "utf8");
   } else {
@@ -3263,13 +3404,20 @@ async function cmdReplay(opts) {
   const vault = resolveVaultPath(opts.vault);
   if (!vault) { barLn(red("No vault found.")); return; }
 
+  const engineDir = path.join(vault, "02_Areas", "Engine");
   let dateStr = opts.rest.find((a) => a.startsWith("--date="))?.split("=")[1];
-  if (!dateStr) {
-    const now = new Date();
-    dateStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+  let targetDate;
+  if (dateStr) {
+    const [y, m, d] = dateStr.split("-").map(Number);
+    targetDate = new Date(y, m - 1, d);
+  } else {
+    targetDate = getSessionDate();
+    const y = targetDate.getFullYear();
+    const m = String(targetDate.getMonth() + 1).padStart(2, "0");
+    const d = String(targetDate.getDate()).padStart(2, "0");
+    dateStr = `${y}-${m}-${d}`;
   }
-  const month = dateStr.substring(0, 7);
-  const dailyPath = path.join(vault, "02_Areas", "Engine", "Dailies", month, `Daily - ${dateStr}.md`);
+  const dailyPath = resolveDailyNotePath(engineDir, targetDate);
 
   barLn(bold(`  Session Replay — ${dateStr}`));
   barLn();
@@ -3646,6 +3794,19 @@ async function cmdPrayer(opts) {
 }
 
 // ─── moveros settings ───────────────────────────────────────────────────────
+const KNOWN_SETTINGS = {
+  review_day:          { type: "string", desc: "Weekly review day", defaults: "Sunday" },
+  evening_zone_start:  { type: "number", desc: "Evening starts at (hour)", defaults: 18 },
+  midnight_cutoff:     { type: "number", desc: "Before this hour = yesterday", defaults: 5 },
+  deep_work_hours:     { type: "number", desc: "Daily deep work target (hours)", defaults: 8 },
+  sleep_target:        { type: "number", desc: "Sleep target (hours)", defaults: 8 },
+  track_food:          { type: "boolean", desc: "Track food in daily notes", defaults: true },
+  track_sleep:         { type: "boolean", desc: "Track sleep in daily notes", defaults: true },
+  show_prayer_times:   { type: "boolean", desc: "Show prayer times in statusline", defaults: false },
+  backup_retention:    { type: "number", desc: "Max backups to keep", defaults: 5 },
+  friction_level:      { type: "number", desc: "Max friction level (1-4)", defaults: 3 },
+};
+
 async function cmdSettings(opts) {
   const cfgPath = path.join(os.homedir(), ".mover", "config.json");
 
@@ -3654,17 +3815,15 @@ async function cmdSettings(opts) {
     return;
   }
 
-  const cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
+  let cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8"));
 
-  // moveros settings set <key> <value>
+  // moveros settings set <key> <value> — CLI mode
   if (opts.rest[0] === "set" && opts.rest[1]) {
     const key = opts.rest[1];
     let val = opts.rest.slice(2).join(" ");
-    // Auto-type conversion
     if (val === "true") val = true;
     else if (val === "false") val = false;
     else if (/^\d+$/.test(val)) val = parseInt(val, 10);
-
     if (!cfg.settings) cfg.settings = {};
     cfg.settings[key] = val;
     fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
@@ -3672,23 +3831,51 @@ async function cmdSettings(opts) {
     return;
   }
 
-  // Show all settings
+  // Interactive mode — show settings as a selectable list
   barLn(bold("  Settings"));
   barLn();
   barLn(`  ${dim("Vault:")}   ${cfg.vaultPath || dim("not set")}`);
   barLn(`  ${dim("Key:")}     ${cfg.licenseKey ? cyan(cfg.licenseKey.substring(0, 12) + "...") : dim("not set")}`);
   barLn(`  ${dim("Agents:")}  ${(cfg.agents || []).join(", ") || dim("none")}`);
-  barLn(`  ${dim("Version:")} ${cfg.version || dim("unknown")}`);
   barLn();
-  if (cfg.settings) {
-    barLn(dim("  Custom:"));
-    for (const [k, v] of Object.entries(cfg.settings)) {
-      barLn(`    ${k}: ${JSON.stringify(v)}`);
-    }
-    barLn();
+
+  const settings = cfg.settings || {};
+  const items = Object.entries(KNOWN_SETTINGS).map(([key, meta]) => {
+    const current = settings[key] !== undefined ? settings[key] : meta.defaults;
+    const display = typeof current === "boolean" ? (current ? green("on") : red("off")) : String(current);
+    return {
+      id: key,
+      name: `${key.padEnd(22)} ${display.padEnd(8)} ${dim(meta.desc)}`,
+      tier: `Current: ${JSON.stringify(current)}  Default: ${JSON.stringify(meta.defaults)}`,
+    };
+  });
+
+  question(dim("  Select a setting to edit (esc to go back)"));
+  barLn();
+  const picked = await interactiveSelect(items);
+  if (!picked) return;
+
+  const meta = KNOWN_SETTINGS[picked];
+  const current = settings[picked] !== undefined ? settings[picked] : meta.defaults;
+
+  if (meta.type === "boolean") {
+    // Toggle immediately
+    const newVal = !current;
+    if (!cfg.settings) cfg.settings = {};
+    cfg.settings[picked] = newVal;
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    statusLine("ok", picked, newVal ? "on" : "off");
+  } else {
+    // Prompt for new value
+    const answer = await textInput({ label: `${picked}`, initial: String(current) });
+    if (answer === null || answer.trim() === "" || answer === String(current)) return;
+    let val = answer.trim();
+    if (meta.type === "number") val = parseInt(val, 10);
+    if (!cfg.settings) cfg.settings = {};
+    cfg.settings[picked] = val;
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+    statusLine("ok", picked, JSON.stringify(val));
   }
-  barLn(dim("  Edit: moveros settings set <key> <value>"));
-  barLn(dim(`  File: ${cfgPath}`));
   barLn();
 }
 
@@ -4046,9 +4233,6 @@ async function cmdHelp(opts) {
         `  ${cyan("who")}         Entity lookup — search People, Orgs, Places`,
         `                ${dim("moveros who \"Ishaaq\" → everything you know about them")}`,
         "",
-        `  ${cyan("warm")}        Pre-warm an AI session with fresh context`,
-        `                ${dim("Run before opening Claude/Cursor. Eliminates cold start.")}`,
-        "",
         `  ${cyan("prayer")}      Mosque timetable — next prayer in your status line`,
         `                ${dim("Paste or fetch. Shows countdown. Optional.")}`,
       ],
@@ -4216,113 +4400,135 @@ async function cmdHelp(opts) {
 // ─── moveros test (dev only) ────────────────────────────────────────────────
 async function cmdTest(opts) { barLn(yellow("moveros test — not yet implemented.")); }
 
-// ─── Interactive Main Menu ────────────────────────────────────────────────────
-async function cmdMainMenu() {
-  const menuOrder = [
-    "install", "update",
-    "pulse", "replay", "diff",
-    "doctor", "sync", "context", "warm",
-    "capture", "who",
-    "settings", "prayer", "backup", "restore", "help",
-  ];
-
-  const menuItems = menuOrder
-    .filter(cmd => { const m = CLI_COMMANDS[cmd]; return m && !m.hidden; })
-    .map(cmd => ({
-      id: cmd,
-      name: `${cmd.padEnd(12)} ${dim(CLI_COMMANDS[cmd].desc)}`,
-    }));
+// ─── What's New ──────────────────────────────────────────────────────────────
+const WHATS_NEW = {
+  "4.2.0": {
+    headline: "Engine Intelligence + Pattern Detection",
+    features: [
+      "Tiered workflow reads — Active_Context as cache, deep reads only when needed",
+      "Active Patterns section in Active_Context — AI-detected behavioral patterns",
+      "Identity Snapshot cached in Active_Context — no full file reads for light workflows",
+      "Monthly review overdue detection in /review-week",
+      "Critical Path Check in /analyse-day (DIRECT/PREREQUISITE/DRIFT)",
+    ],
+  },
+  "4.3.0": {
+    headline: "Soul + Friction + Skills",
+    features: [
+      "Soul personality — sharp observations, humor, callbacks, earned respect",
+      "Level 3 friction (Earn It) — AI holds the line on avoidance",
+      "Pre-Escalation Gate — compound work detection, no false positives",
+      "Curated skill packs — marketing, CRO, SEO, design, obsidian",
+      "Skill evaluation system — A/B testing skills with benchmarks",
+    ],
+  },
+  "4.5.0": {
+    headline: "Smart Menu + TUI + Comprehensive Update",
+    features: [
+      "Frecency-based menu — surfaces your most-used commands",
+      "Interactive settings — toggle from the menu, no CLI flags",
+      "Full-screen TUI — alternate screen buffer, clean transitions",
+      "Comprehensive update — backup, agent management, What's New",
+      "Install/Update separation — install is fresh only, update is interactive",
+      "Uninstall as standalone command",
+    ],
+  },
+};
 
-  question(`${bold("moveros")} ${dim("— choose a command")}`);
-  barLn();
-  const choice = await interactiveSelect(menuItems);
-  if (!choice) {
-    outro(dim("Cancelled."));
-    process.exit(0);
+function showWhatsNew(fromVer, toVer) {
+  if (!fromVer || !toVer) return;
+  const versions = Object.keys(WHATS_NEW)
+    .filter(v => compareVersions(v, fromVer) > 0 && compareVersions(v, toVer) <= 0)
+    .sort(compareVersions);
+  if (versions.length === 0) return;
+
+  for (const v of versions) {
+    const wn = WHATS_NEW[v];
+    question(bold(`What's New in v${v}`));
+    barLn(dim(wn.headline));
+    barLn();
+    for (const f of wn.features) {
+      barLn(`  ${green("+")} ${f}`);
+    }
+    barLn();
   }
-  return choice;
 }
 
-// ─── Vault Resolution Helper ─────────────────────────────────────────────────
-function resolveVaultPath(explicitVault) {
-  if (explicitVault) {
-    let v = explicitVault;
-    if (v.startsWith("~")) v = path.join(os.homedir(), v.slice(1));
-    return path.resolve(v);
-  }
-  // Try config.json
+// ─── Interactive Main Menu (Frecency + Context-Aware) ─────────────────────────
+async function cmdMainMenu() {
+  const usage = loadCliUsage();
+  const hasVault = !!resolveVaultPath();
   const cfgPath = path.join(os.homedir(), ".mover", "config.json");
-  if (fs.existsSync(cfgPath)) {
-    try {
-      const v = JSON.parse(fs.readFileSync(cfgPath, "utf8")).vaultPath;
-      if (v && fs.existsSync(v)) return v;
-    } catch {}
-  }
-  // Try Obsidian detection
-  const obsVaults = detectObsidianVaults();
-  return obsVaults.find((p) => fs.existsSync(path.join(p, ".mover-version"))) || null;
-}
-
-// ─── Main ───────────────────────────────────────────────────────────────────
-async function main() {
-  const opts = parseArgs();
-  let bundleDir = path.resolve(__dirname);
-  const startTime = Date.now();
-
-  // ── Intro ──
-  await printHeader();
-
-  // ── Route: no command → interactive menu (persistent loop) ──
-  const lightCommands = ["pulse", "warm", "capture", "who", "diff", "sync", "replay", "context", "settings", "backup", "restore", "doctor", "prayer", "help", "test"];
+  const hasConfig = fs.existsSync(cfgPath);
+  const hasPrayer = hasConfig && (() => { try { return !!JSON.parse(fs.readFileSync(cfgPath, "utf8")).settings?.show_prayer_times; } catch { return false; } })();
 
-  if (!opts.command) {
-    // Interactive loop — stay open like a real app
-    while (true) {
-      opts.command = await cmdMainMenu();
-      if (!opts.command) break; // user cancelled
+  // All non-hidden commands
+  const allCmds = Object.keys(CLI_COMMANDS).filter(c => !CLI_COMMANDS[c].hidden);
 
-      if (lightCommands.includes(opts.command)) {
-        const handler = CLI_HANDLERS[opts.command];
-        if (handler) await handler(opts);
-        else barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
-        opts.command = ""; // reset for next loop
-        barLn(dim("  Press enter to return to menu..."));
-        await new Promise((r) => { process.stdin.resume(); process.stdin.once("data", () => { process.stdin.pause(); r(); }); });
-        continue;
-      }
-      break; // install/update break out of loop into pre-flight
-    }
-    if (!opts.command) return;
-  }
+  // Context filter: hide irrelevant commands
+  const contextFilter = (cmd) => {
+    if (!hasVault && ["pulse", "replay", "diff", "sync", "capture", "who", "context", "backup", "restore", "doctor"].includes(cmd)) return false;
+    if (!hasPrayer && cmd === "prayer") return false;
+    return true;
+  };
 
-  // ── Route: direct CLI command (non-interactive) ──
-  if (lightCommands.includes(opts.command)) {
-    const handler = CLI_HANDLERS[opts.command];
-    if (handler) {
-      await handler(opts);
-    } else {
-      barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
-    }
-    return;
+  const eligible = allCmds.filter(contextFilter);
+
+  // Pinned: always visible
+  const pinned = ["settings", "help"];
+  // Also pin install if no vault, update if vault exists
+  if (!hasVault) pinned.unshift("install");
+  else pinned.unshift("update");
+
+  // Score remaining by frecency
+  const scored = eligible
+    .filter(c => !pinned.includes(c))
+    .map(c => ({ cmd: c, score: frecencyScore(usage, c) }))
+    .sort((a, b) => b.score - a.score);
+
+  // Show top N frecency commands + pinned + "more..."
+  const MAX_SURFACE = 5;
+  const surfaced = scored.slice(0, MAX_SURFACE).map(s => s.cmd);
+  const hidden = scored.slice(MAX_SURFACE).map(s => s.cmd);
+
+  // Build menu: pinned first, then frecency-surfaced, then "more..." if needed
+  const topItems = [...new Set([...pinned, ...surfaced])];
+  const menuItems = topItems.map(cmd => ({
+    id: cmd,
+    name: `${cmd.padEnd(12)} ${dim(CLI_COMMANDS[cmd].desc)}`,
+  }));
+  if (hidden.length > 0) {
+    menuItems.push({ id: "__more__", name: `${"more...".padEnd(12)} ${dim(`${hidden.length} more commands`)}` });
   }
 
-  // ── Pre-flight (install + update only) ──
-  barLn(gray("Pre-flight"));
+  question(`${bold("moveros")} ${dim("— choose a command")}`);
   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}`)}`);
+  let choice = await interactiveSelect(menuItems);
+
+  if (choice === "__more__") {
+    // Show full list
+    const fullItems = eligible
+      .filter(c => !c.startsWith("__"))
+      .map(cmd => ({
+        id: cmd,
+        name: `${cmd.padEnd(12)} ${dim(CLI_COMMANDS[cmd].desc)}`,
+      }));
+    barLn();
+    question(`${bold("moveros")} ${dim("— all commands")}`);
+    barLn();
+    choice = await interactiveSelect(fullItems);
   }
-  barLn();
 
-  if (checks.some((c) => c.status === "fail")) {
-    outro(red("Pre-flight failed. Fix the issues above."));
-    process.exit(1);
-  }
+  if (!choice) return null;
+  return choice;
+}
 
-  // ── CLI self-update check ──
-  if (opts.command === "update" && !opts._selfUpdated) {
+// ─── Comprehensive Update (10-step interactive) ─────────────────────────────
+async function cmdUpdateComprehensive(opts, bundleDir, startTime) {
+  const isQuick = opts.rest.includes("--quick");
+
+  // Step 1: CLI Self-Update
+  if (!opts._selfUpdated) {
     try {
       const localVer = require("./package.json").version;
       const npmVer = execSync("npm view mover-os version", { encoding: "utf8", timeout: 10000 }).trim();
@@ -4334,7 +4540,6 @@ async function main() {
           sp.stop(`CLI updated to ${npmVer}`);
           barLn(dim("  Re-running with updated CLI..."));
           barLn();
-          // Re-exec with new code — pass args through, add flag to prevent loop
           const args = process.argv.slice(2).concat("--_self-updated");
           const { spawnSync } = require("child_process");
           const result = spawnSync(process.argv[0], [process.argv[1], ...args], {
@@ -4346,7 +4551,7 @@ async function main() {
           barLn(dim("  Continuing with current version..."));
         }
       } else {
-        barLn(`${green("\u2713")} ${dim("CLI is up to date")} ${dim(`(${localVer})`)}`);
+        statusLine("ok", "CLI", `up to date (${localVer})`);
       }
     } catch {
       barLn(dim("  Could not check for CLI updates (offline?)"));
@@ -4354,90 +4559,77 @@ async function main() {
     barLn();
   }
 
-  // ── Headless quick update ──
-  if (opts.command === "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);
-      }
-    }
+  // Step 2: Vault Detection
+  let vaultPath = resolveVaultPath(opts.vault);
+  if (!vaultPath) {
+    outro(red("No Mover OS vault found. Use: moveros update --vault /path"));
+    process.exit(1);
+  }
+  statusLine("ok", "Vault", path.basename(vaultPath));
 
-    // 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);
-      }
+  // Step 3: Key Validation
+  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 (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
-    vaultPath = path.resolve(vaultPath);
-    barLn(dim(`Vault: ${vaultPath}`));
+  }
+  const keyFromConfig = !!updateKey;
+  if (!updateKey) {
+    updateKey = await textInput({ label: "License key", mask: "\u25AA", placeholder: "MOVER-XXXX-XXXX" });
+    if (!updateKey) return;
+  }
+  const sp1 = spinner("Validating license");
+  const keyValid = await validateKey(updateKey);
+  if (!keyValid && keyFromConfig) {
+    sp1.stop(dim("License check skipped (offline — using stored key)"));
+  } else if (!keyValid) {
+    sp1.stop(red("Invalid key"));
+    outro(red("Valid license key required."));
+    process.exit(1);
+  } else {
+    sp1.stop(green("License verified"));
+  }
+  barLn();
 
-    // Auto-detect agents
-    const detectedAgents = AGENTS.filter((a) => a.detect());
-    if (detectedAgents.length === 0) {
-      outro(red("No AI agents detected."));
+  // Download payload if not bundled
+  const hasSrc = fs.existsSync(path.join(bundleDir, "src", "workflows"));
+  if (!hasSrc) {
+    const dlSp = spinner("Downloading Mover OS");
+    try {
+      bundleDir = await downloadPayload(updateKey);
+      dlSp.stop(green("Downloaded"));
+    } catch (err) {
+      dlSp.stop(red("Download failed"));
+      outro(red(err.message));
       process.exit(1);
     }
-    const selectedIds = detectedAgents.map((a) => a.id);
-    barLn(dim(`Agents: ${detectedAgents.map((a) => a.name).join(", ")}`));
     barLn();
+  }
+
+  // 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 {}
 
-    // Detect changes
+  // Quick mode: skip interactive steps
+  if (isQuick) {
+    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);
     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
+    if (totalChanged === 0) { outro(green("Already up to date.")); return; }
     barLn(bold("Updating..."));
     barLn();
-
-    // 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) {
@@ -4446,20 +4638,325 @@ async function main() {
       const sp = spinner(agent.name);
       const steps = fn(bundleDir, vaultPath, skillOpts, writtenFiles, agent.id);
       await sleep(200);
-      if (steps.length > 0) {
-        sp.stop(`${agent.name}  ${dim(steps.join(", "))}`);
-      } else {
-        sp.stop(`${agent.name}  ${dim("configured")}`);
+      sp.stop(steps.length > 0 ? `${agent.name}  ${dim(steps.join(", "))}` : `${agent.name}  ${dim("configured")}`);
+    }
+    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").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;
+  }
+
+  // Step 4: What's New
+  showWhatsNew(installedVer, newVer);
+
+  // Step 5: Backup Offer
+  const engine = detectEngineFiles(vaultPath);
+  if (engine.exists) {
+    question("Back up before updating?");
+    barLn(dim("  Select what to save. Esc to skip."));
+    barLn();
+    const backupItems = [
+      { id: "engine", name: "Engine files", tier: "Identity, Strategy, Goals, Context" },
+    ];
+    if (fs.existsSync(path.join(vaultPath, "02_Areas"))) {
+      backupItems.push({ id: "areas", name: "Full Areas folder", tier: "Everything in 02_Areas/" });
+    }
+    const detectedForBackup = AGENTS.filter((a) => a.detect()).map((a) => a.id);
+    if (detectedForBackup.length > 0) {
+      backupItems.push({ id: "agents", name: "Agent configs", tier: `Rules, skills from ${detectedForBackup.length} agent(s)` });
+    }
+    const backupChoices = await interactiveSelect(backupItems, { multi: true, preSelected: ["engine"] });
+    if (backupChoices && backupChoices.length > 0) {
+      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");
+      if (backupChoices.includes("engine")) {
+        const engineDir = path.join(vaultPath, "02_Areas", "Engine");
+        const backupDir = path.join(archivesDir, `Engine_Backup_${ts}`);
+        try {
+          fs.mkdirSync(backupDir, { recursive: true });
+          let backed = 0;
+          for (const f of fs.readdirSync(engineDir).filter(f => fs.statSync(path.join(engineDir, f)).isFile())) {
+            fs.copyFileSync(path.join(engineDir, f), path.join(backupDir, f));
+            backed++;
+          }
+          statusLine("ok", "Backed up", `${backed} Engine files`);
+        } catch (err) { barLn(yellow(`  Backup failed: ${err.message}`)); }
+      }
+      if (backupChoices.includes("areas")) {
+        try {
+          copyDirRecursive(path.join(vaultPath, "02_Areas"), path.join(archivesDir, `Areas_Backup_${ts}`));
+          statusLine("ok", "Backed up", "Full Areas folder");
+        } catch (err) { barLn(yellow(`  Areas backup failed: ${err.message}`)); }
+      }
+      if (backupChoices.includes("agents")) {
+        try {
+          const agentBackupDir = path.join(archivesDir, `Agent_Backup_${ts}`);
+          fs.mkdirSync(agentBackupDir, { recursive: true });
+          let agentsBacked = 0;
+          for (const ag of AGENTS.filter((a) => a.detect())) {
+            const agDir = path.join(agentBackupDir, ag.id);
+            fs.mkdirSync(agDir, { recursive: true });
+            for (const cp of (ag.configPaths || [])) {
+              if (fs.existsSync(cp.src)) {
+                try { fs.copyFileSync(cp.src, path.join(agDir, path.basename(cp.src))); agentsBacked++; } catch {}
+              }
+            }
+          }
+          statusLine("ok", "Backed up", `${agentsBacked} agent config files`);
+        } catch (err) { barLn(yellow(`  Agent backup failed: ${err.message}`)); }
       }
     }
+    barLn();
+  }
 
-    // Update version marker + config
-    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `V${VERSION}\n`, "utf8");
-    writeMoverConfig(vaultPath, selectedIds);
+  // Step 6: Agent Management
+  const visibleAgents = AGENTS.filter((a) => !a.hidden);
+  const detectedIds = visibleAgents.filter((a) => a.detect()).map((a) => a.id);
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  let currentAgents = [];
+  if (fs.existsSync(cfgPath)) {
+    try { currentAgents = JSON.parse(fs.readFileSync(cfgPath, "utf8")).agents || []; } catch {}
+  }
+  const preSelectedAgents = [...new Set([...detectedIds, ...currentAgents])];
+
+  question(`Agents ${dim("(add or remove)")}`);
+  barLn();
+  const agentItems = visibleAgents.map((a) => ({
+    ...a,
+    _detected: detectedIds.includes(a.id),
+  }));
+  const selectedIds = await interactiveSelect(agentItems, { multi: true, preSelected: preSelectedAgents });
+  if (!selectedIds || selectedIds.length === 0) return;
+  const selectedAgents = AGENTS.filter((a) => selectedIds.includes(a.id));
+  barLn();
+
+  // Step 7: Change Detection
+  const changes = detectChanges(bundleDir, vaultPath, selectedIds);
+  const totalChanged = countChanges(changes);
+  question("Change Summary");
+  barLn();
+  displayChangeSummary(changes, installedVer, newVer);
 
+  if (totalChanged === 0) {
+    barLn(green("  Already up to date."));
     barLn();
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-    outro(`${green("Done.")} ${totalChanged} files updated in ${elapsed}s. Run ${bold("/update")} if version bumped.`);
+    outro(`${green("Done.")} No changes needed. ${dim(`(${elapsed}s)`)}`);
+    return;
+  }
+
+  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 || applyChoice === "cancel") { outro("Cancelled."); return; }
+
+  let selectedWorkflows = null;
+  let skipHooks = false, skipRules = false, skipTemplates = false;
+  if (applyChoice === "select") {
+    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" : "changed") });
+      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" : "changed") });
+      changedPreSelected.push(id);
+    }
+    if (changedItems.length > 0) {
+      question("Select files to update");
+      barLn();
+      const selectedFileIds = await interactiveSelect(changedItems, { multi: true, preSelected: changedPreSelected });
+      if (!selectedFileIds) return;
+      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);
+      }
+      skipHooks = !selectedFileIds.some((id) => id.startsWith("hook:"));
+      skipRules = !selectedFileIds.includes("rules");
+      skipTemplates = !selectedFileIds.some((id) => id.startsWith("tmpl:"));
+    }
+  }
+
+  // Step 8: Apply Changes (with progress animation)
+  barLn();
+  question(bold("Applying updates"));
+  barLn();
+
+  const installSteps = [];
+  installSteps.push({ label: "Vault structure", fn: async () => { createVaultStructure(vaultPath); await sleep(100); } });
+  if (!skipTemplates) {
+    installSteps.push({ label: "Template files", fn: async () => { installTemplateFiles(bundleDir, vaultPath); await sleep(100); } });
+  }
+
+  const writtenFiles = new Set();
+  const skillOpts = { install: true, categories: null, workflows: selectedWorkflows, skipHooks, skipRules, skipTemplates };
+  for (const agent of selectedAgents) {
+    const sel = AGENT_SELECTIONS.find((s) => s.id === agent.id);
+    const targets = sel ? sel.targets : [agent.id];
+    for (const targetId of targets) {
+      const fn = AGENT_INSTALLERS[targetId];
+      if (!fn) continue;
+      const targetReg = AGENT_REGISTRY[targetId];
+      const displayName = targetReg ? targetReg.name : agent.name;
+      installSteps.push({ label: displayName, fn: async () => { fn(bundleDir, vaultPath, skillOpts, writtenFiles, targetId); await sleep(150); } });
+    }
+  }
+
+  await installProgress(installSteps);
+
+  // Step 9: Skills Refresh
+  barLn();
+  const allSkills = findSkills(bundleDir);
+  if (allSkills.length > 0 && selectedAgents.some((a) => a.id !== "aider")) {
+    question("Refresh skill categories?");
+    barLn();
+    const catCounts = {};
+    for (const sk of allSkills) { catCounts[sk.category] = (catCounts[sk.category] || 0) + 1; }
+    const categoryItems = CATEGORY_META.map((c) => ({
+      id: c.id,
+      name: `${c.name}  ${dim(`(${catCounts[c.id] || 0})`)}`,
+      tier: dim(c.desc),
+    }));
+    const selectedCatIds = await interactiveSelect(categoryItems, { multi: true, preSelected: ["development", "obsidian"] });
+    if (selectedCatIds && selectedCatIds.length > 0) {
+      const catSet = new Set(selectedCatIds);
+      const refreshOpts = { install: true, categories: catSet, workflows: null };
+      for (const agent of selectedAgents) {
+        const fn = AGENT_INSTALLERS[agent.id];
+        if (fn) fn(bundleDir, vaultPath, refreshOpts, writtenFiles, agent.id);
+      }
+      const skillCount = allSkills.filter((s) => s.category === "tools" || catSet.has(s.category)).length;
+      statusLine("ok", "Skills refreshed", `${skillCount} across ${selectedAgents.length} agent(s)`);
+    }
+    barLn();
+  }
+
+  // Update version marker + config
+  fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
+  writeMoverConfig(vaultPath, selectedIds, updateKey);
+
+  // Step 10: Summary + Success
+  barLn();
+  await successAnimation(`Mover OS updated — ${totalChanged} files`);
+
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  outro(`${green("Done.")} ${dim(`${elapsed}s`)}  Run ${bold("/update")} in your agent to sync Engine.`);
+}
+
+// ─── Vault Resolution Helper ─────────────────────────────────────────────────
+function resolveVaultPath(explicitVault) {
+  if (explicitVault) {
+    let v = explicitVault;
+    if (v.startsWith("~")) v = path.join(os.homedir(), v.slice(1));
+    return path.resolve(v);
+  }
+  // Try config.json
+  const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+  if (fs.existsSync(cfgPath)) {
+    try {
+      const v = JSON.parse(fs.readFileSync(cfgPath, "utf8")).vaultPath;
+      if (v && fs.existsSync(v)) return v;
+    } catch {}
+  }
+  // Try Obsidian detection
+  const obsVaults = detectObsidianVaults();
+  return obsVaults.find((p) => fs.existsSync(path.join(p, ".mover-version"))) || null;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+async function main() {
+  const opts = parseArgs();
+  let bundleDir = path.resolve(__dirname);
+  const startTime = Date.now();
+
+  // ── TUI: Enter alternate screen ──
+  enterAltScreen();
+
+  // ── Intro: Logo plays once ──
+  await printHeader();
+
+  // ── Route: no command → interactive menu (persistent loop) ──
+  const lightCommands = ["pulse", "capture", "who", "diff", "sync", "replay", "context", "settings", "backup", "restore", "doctor", "prayer", "help", "uninstall", "test"];
+
+  if (!opts.command) {
+    // Interactive loop — stay open like a real app
+    while (true) {
+      clearContent();
+      ln(compactHeader());
+      ln();
+
+      opts.command = await cmdMainMenu();
+      if (!opts.command) break; // user hit Esc — clean exit
+
+      if (lightCommands.includes(opts.command)) {
+        await wipeDown(12);
+        ln(compactHeader());
+        ln();
+
+        recordCliUsage(opts.command);
+        const handler = CLI_HANDLERS[opts.command];
+        if (handler) await handler(opts);
+        else barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
+        opts.command = ""; // reset for next loop
+
+        barLn(dim("  esc to go back"));
+        await waitForEsc();
+        continue;
+      }
+      // install/update — record usage and break out into pre-flight
+      recordCliUsage(opts.command);
+      break;
+    }
+    if (!opts.command) return;
+  }
+
+  // ── Route: direct CLI command (non-interactive) ──
+  if (lightCommands.includes(opts.command)) {
+    recordCliUsage(opts.command);
+    const handler = CLI_HANDLERS[opts.command];
+    if (handler) {
+      await handler(opts);
+    } else {
+      barLn(yellow(`Command '${opts.command}' is not yet implemented.`));
+    }
+    return;
+  }
+
+  // ── Pre-flight (install + update only) ──
+  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);
+  }
+
+  // ── Comprehensive Update ──
+  if (opts.command === "update") {
+    await cmdUpdateComprehensive(opts, bundleDir, startTime);
     return;
   }
 
@@ -4599,213 +5096,22 @@ async function main() {
   if (vaultPath.startsWith("~")) vaultPath = path.join(os.homedir(), vaultPath.slice(1));
   vaultPath = path.resolve(vaultPath);
 
-  // ── Detect existing install → show mode menu ──
+  // ── Fresh install only — redirect if existing ──
   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?");
+    question(yellow("Mover OS is already installed in this vault."));
+    barLn(dim("  Use " + bold("moveros update") + " to refresh agents, rules, and skills."));
+    barLn(dim("  Use " + bold("moveros uninstall") + " to remove Mover OS."));
     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 }
-    );
-    if (!installMode) return;
-  }
-
-  // ── Uninstall flow ──
-  if (installMode === "uninstall") {
-    await runUninstall(vaultPath);
+    barLn(dim("  esc to exit"));
+    await waitForEsc();
     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 && 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(vaultPath, ".cursor", "rules"), label: "rules" },
-            { src: path.join(home, ".cursor", "commands"), label: "commands" },
-            { src: path.join(home, ".cursor", "skills"), label: "skills" },
-          ],
-          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(vaultPath, ".windsurf", "rules"), label: "rules" },
-            { src: path.join(vaultPath, ".windsurf", "workflows"), label: "workflows" },
-            { src: path.join(home, ".windsurf", "skills"), label: "skills" },
-          ],
-          "gemini-cli": [
-            { src: path.join(home, ".gemini", "GEMINI.md"), label: "GEMINI.md" },
-            { src: path.join(home, ".gemini", "commands"), label: "commands" },
-            { src: path.join(home, ".gemini", "skills"), label: "skills" },
-          ],
-          antigravity: [
-            { 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", "prompts"), label: "prompts" },
-            { src: path.join(vaultPath, ".github", "skills"), label: "skills" },
-          ],
-          codex: [
-            { src: path.join(home, ".codex", "AGENTS.md"), label: "AGENTS.md" },
-            { src: path.join(home, ".codex", "skills"), label: "skills" },
-          ],
-          "roo-code": [
-            { src: path.join(vaultPath, ".roo", "rules"), label: "rules" },
-            { src: path.join(vaultPath, ".roo", "commands"), label: "commands" },
-            { src: path.join(vaultPath, ".roo", "skills"), label: "skills" },
-          ],
-          "amazon-q": [
-            { src: path.join(vaultPath, ".amazonq", "rules"), label: "rules" },
-            { src: path.join(home, ".aws", "amazonq", "cli-agents"), label: "cli-agents" },
-          ],
-          "kilo-code": [
-            { src: path.join(vaultPath, ".kilocode", "rules"), label: "rules" },
-            { src: path.join(vaultPath, ".kilocode", "skills"), label: "skills" },
-            { src: path.join(vaultPath, ".kilocode", "commands"), label: "commands" },
-          ],
-          amp: [
-            { src: path.join(vaultPath, "AGENTS.md"), label: "AGENTS.md" },
-            { src: path.join(vaultPath, ".agents", "skills"), label: "skills" },
-          ],
-          "continue": [
-            { src: path.join(vaultPath, ".continue", "rules"), label: "rules" },
-            { src: path.join(vaultPath, ".continue", "prompts"), label: "prompts" },
-          ],
-          opencode: [
-            { src: path.join(vaultPath, "AGENTS.md"), label: "AGENTS.md" },
-            { src: path.join(vaultPath, ".opencode", "agents"), label: "agents" },
-          ],
-          aider: [
-            { src: path.join(vaultPath, "CONVENTIONS.md"), label: "CONVENTIONS.md" },
-          ],
-        };
-
-        let agentsBacked = 0;
-        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}/`));
-        }
-      }
-    }
-  }
+  const updateMode = false;
 
   if (!fs.existsSync(vaultPath)) fs.mkdirSync(vaultPath, { recursive: true });
 
@@ -4838,102 +5144,9 @@ async function main() {
     return;
   }
 
-  // ── 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 || applyChoice === "cancel") {
-        outro("Cancelled.");
-        return;
-      }
-
-      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,
-          });
-          if (!selectedFileIds) return;
-
-          // 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
-    }
-  }
+  // Fresh install — no change detection needed
+  const selectedWorkflows = null;
+  const skipHooks = false, skipRules = false, skipTemplates = false;
 
   // ── Skills ──
   const allSkills = findSkills(bundleDir);
@@ -5100,9 +5313,44 @@ async function main() {
     }
   }
 
+  // ── Settings step — let user configure before install ──
+  {
+    barLn();
+    question("Configure settings " + dim("(esc to use defaults)"));
+    barLn();
+    const settingsItems = [
+      { id: "review_day", name: "review_day          Sunday      Weekly review day" },
+      { id: "track_food", name: "track_food          on          Track food in daily notes" },
+      { id: "track_sleep", name: "track_sleep         on          Track sleep in daily notes" },
+      { id: "friction_level", name: "friction_level      3           Max friction level (1-4)" },
+    ];
+    const settingsPick = await interactiveSelect(settingsItems);
+    if (settingsPick) {
+      const meta = KNOWN_SETTINGS[settingsPick];
+      if (meta) {
+        const cfgPath = path.join(os.homedir(), ".mover", "config.json");
+        let cfg = {};
+        if (fs.existsSync(cfgPath)) { try { cfg = JSON.parse(fs.readFileSync(cfgPath, "utf8")); } catch {} }
+        if (!cfg.settings) cfg.settings = {};
+        if (meta.type === "boolean") {
+          cfg.settings[settingsPick] = !(cfg.settings[settingsPick] !== undefined ? cfg.settings[settingsPick] : meta.defaults);
+          statusLine("ok", settingsPick, cfg.settings[settingsPick] ? "on" : "off");
+        } else {
+          const answer = await textInput({ label: settingsPick, initial: String(meta.defaults) });
+          if (answer !== null && answer.trim() !== "") {
+            cfg.settings[settingsPick] = meta.type === "number" ? parseInt(answer.trim(), 10) : answer.trim();
+            statusLine("ok", settingsPick, JSON.stringify(cfg.settings[settingsPick]));
+          }
+        }
+        fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2), "utf8");
+      }
+    }
+  }
+
   // ── Install with animated spinners ──
   barLn();
-  question(updateMode ? bold("Updating...") : bold("Installing..."));
+  question(bold("Installing..."));
   barLn();
 
   let totalSteps = 0;
@@ -5134,17 +5382,15 @@ async function main() {
 
   // 2. Template files (runs in both modes — only creates missing files, never overwrites)
   if (!skipTemplates) {
-    sp = spinner(updateMode ? "New template files" : "Engine templates");
+    sp = spinner("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")}`);
+    sp.stop(`Engine templates${templatesInstalled > 0 ? dim(`  ${templatesInstalled} files`) : dim("  up to date")}`);
     totalSteps++;
   }
 
-  // 3. CLAUDE.md (skip on update)
-  if (!updateMode) {
+  // 3. CLAUDE.md
+  {
     const vaultClaudeMd = path.join(vaultPath, "CLAUDE.md");
     const bundleClaudeMd = path.join(bundleDir, "CLAUDE.md");
     if (!fs.existsSync(vaultClaudeMd) && fs.existsSync(bundleClaudeMd)) {
@@ -5207,8 +5453,8 @@ async function main() {
     }
   }
 
-  // 7. Git init Engine folder only (fresh install only)
-  if (!updateMode) {
+  // 7. Git init Engine folder
+  {
     const hasGit = cmdExists("git");
     if (hasGit) {
       const engineDir = path.join(vaultPath, "02_Areas", "Engine");
@@ -5234,9 +5480,9 @@ async function main() {
     }
   }
 
-  // 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");
+  // 8. Version stamp
+  {
+    fs.writeFileSync(path.join(vaultPath, ".mover-version"), `${require("./package.json").version}\n`, "utf8");
   }
 
   // 9. Write ~/.mover/config.json (both fresh + update)
@@ -5246,8 +5492,7 @@ async function main() {
 
   // ── 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`)}`);
+  outro(`${green("Done.")} Mover OS v${VERSION} installed. ${dim(`${totalSteps} steps in ${elapsed}s`)}`);
 
   // Size check on installed rules files
   const rulesFile = path.join(bundleDir, "src", "system", "Mover_Global_Rules.md");
@@ -5282,30 +5527,22 @@ async function main() {
   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(`  ${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();
@@ -5316,8 +5553,7 @@ async function main() {
   ln(`  ${green("▸")} ${bold("moveros pulse")}     ${dim("Dashboard — energy, tasks, streaks")}`);
   ln(`  ${green("▸")} ${bold("moveros doctor")}    ${dim("Health check across all agents")}`);
   ln(`  ${green("▸")} ${bold("moveros capture")}   ${dim("Quick inbox — tasks, links, ideas")}`);
-  ln(`  ${green("▸")} ${bold("moveros warm")}      ${dim("Pre-warm your next AI session")}`);
-  ln(`  ${green("▸")} ${bold("moveros sync")}      ${dim("Update all agents to latest")}`);
+  ln(`  ${green("▸")} ${bold("moveros update")}    ${dim("Update agents, rules, and skills")}`);
   ln(`  ${green("▸")} ${bold("moveros")}           ${dim("Full menu with all commands")}`);
   ln();
 }