@caliber-ai/cli 0.11.3 → 0.12.0

package/dist/bin.js

@@ -80,10 +80,11 @@ import path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
-import fs15 from "fs";
+import select from "@inquirer/select";
+import fs16 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
@@ -598,6 +599,26 @@ function readExistingConfigs(dir) {
     } catch {
     }
   }
+  const mcpJsonPath = path7.join(dir, ".mcp.json");
+  if (fs6.existsSync(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(fs6.readFileSync(mcpJsonPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        configs.claudeMcpServers = mcpJson.mcpServers;
+      }
+    } catch {
+    }
+  }
+  const cursorMcpPath = path7.join(dir, ".cursor", "mcp.json");
+  if (fs6.existsSync(cursorMcpPath)) {
+    try {
+      const cursorMcpJson = JSON.parse(fs6.readFileSync(cursorMcpPath, "utf-8"));
+      if (cursorMcpJson.mcpServers) {
+        configs.cursorMcpServers = cursorMcpJson.mcpServers;
+      }
+    } catch {
+    }
+  }
   return configs;
 }
 
@@ -899,6 +920,140 @@ function computeFingerprintHash(fingerprint) {
   return crypto2.createHash("sha256").update(key).digest("hex");
 }
 
+// src/scanner/index.ts
+import fs8 from "fs";
+import path9 from "path";
+import crypto3 from "crypto";
+function scanLocalState(dir) {
+  const items = [];
+  const claudeMdPath = path9.join(dir, "CLAUDE.md");
+  if (fs8.existsSync(claudeMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "claude",
+      name: "CLAUDE.md",
+      contentHash: hashFile(claudeMdPath),
+      path: claudeMdPath
+    });
+  }
+  const settingsPath = path9.join(dir, ".claude", "settings.json");
+  if (fs8.existsSync(settingsPath)) {
+    items.push({
+      type: "config",
+      platform: "claude",
+      name: "settings.json",
+      contentHash: hashFile(settingsPath),
+      path: settingsPath
+    });
+  }
+  const skillsDir = path9.join(dir, ".claude", "skills");
+  if (fs8.existsSync(skillsDir)) {
+    for (const file of fs8.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path9.join(skillsDir, file);
+      items.push({
+        type: "skill",
+        platform: "claude",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const mcpJsonPath = path9.join(dir, ".mcp.json");
+  if (fs8.existsSync(mcpJsonPath)) {
+    try {
+      const mcpJson = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "claude",
+            name,
+            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
+            path: mcpJsonPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const cursorrulesPath = path9.join(dir, ".cursorrules");
+  if (fs8.existsSync(cursorrulesPath)) {
+    items.push({
+      type: "rule",
+      platform: "cursor",
+      name: ".cursorrules",
+      contentHash: hashFile(cursorrulesPath),
+      path: cursorrulesPath
+    });
+  }
+  const cursorRulesDir = path9.join(dir, ".cursor", "rules");
+  if (fs8.existsSync(cursorRulesDir)) {
+    for (const file of fs8.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path9.join(cursorRulesDir, file);
+      items.push({
+        type: "rule",
+        platform: "cursor",
+        name: file,
+        contentHash: hashFile(filePath),
+        path: filePath
+      });
+    }
+  }
+  const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
+  if (fs8.existsSync(cursorMcpPath)) {
+    try {
+      const mcpJson = JSON.parse(fs8.readFileSync(cursorMcpPath, "utf-8"));
+      if (mcpJson.mcpServers) {
+        for (const name of Object.keys(mcpJson.mcpServers)) {
+          items.push({
+            type: "mcp",
+            platform: "cursor",
+            name,
+            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
+            path: cursorMcpPath
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  return items;
+}
+function compareState(serverItems, localItems) {
+  const installed = [];
+  const missing = [];
+  const outdated = [];
+  const extra = [];
+  const localMap = /* @__PURE__ */ new Map();
+  for (const item of localItems) {
+    localMap.set(`${item.type}:${item.platform}:${item.name}`, item);
+  }
+  for (const server of serverItems) {
+    const key = `${server.type}:${server.platform}:${server.name}`;
+    const local = localMap.get(key);
+    localMap.delete(key);
+    if (!local) {
+      missing.push(server);
+    } else if (local.contentHash !== server.content_hash) {
+      outdated.push({ server, local });
+    } else {
+      installed.push({ server, local });
+    }
+  }
+  for (const local of localMap.values()) {
+    extra.push(local);
+  }
+  return { installed, missing, outdated, extra };
+}
+function hashFile(filePath) {
+  const content = fs8.readFileSync(filePath);
+  return crypto3.createHash("sha256").update(content).digest("hex");
+}
+function hashContent(content) {
+  return crypto3.createHash("sha256").update(JSON.stringify({ text: content })).digest("hex");
+}
+
 // src/api/client.ts
 init_constants();
 async function forceRefreshToken() {
@@ -1021,132 +1176,150 @@ async function apiStream(path19, body, onChunk, onComplete, onError, onStatus) {
 }
 
 // src/writers/index.ts
-import fs12 from "fs";
+import fs13 from "fs";
 
 // src/writers/claude/index.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs8.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs9.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   const claudeDir = ".claude";
-  if (!fs8.existsSync(claudeDir)) fs8.mkdirSync(claudeDir, { recursive: true });
-  fs8.writeFileSync(
-    path9.join(claudeDir, "settings.json"),
+  if (!fs9.existsSync(claudeDir)) fs9.mkdirSync(claudeDir, { recursive: true });
+  fs9.writeFileSync(
+    path10.join(claudeDir, "settings.json"),
     JSON.stringify(config.settings, null, 2)
   );
-  written.push(path9.join(claudeDir, "settings.json"));
-  fs8.writeFileSync(
-    path9.join(claudeDir, "settings.local.json"),
+  written.push(path10.join(claudeDir, "settings.json"));
+  fs9.writeFileSync(
+    path10.join(claudeDir, "settings.local.json"),
     JSON.stringify(config.settingsLocal, null, 2)
   );
-  written.push(path9.join(claudeDir, "settings.local.json"));
+  written.push(path10.join(claudeDir, "settings.local.json"));
   if (config.skills?.length) {
-    const skillsDir = path9.join(claudeDir, "skills");
-    if (!fs8.existsSync(skillsDir)) fs8.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path10.join(claudeDir, "skills");
+    if (!fs9.existsSync(skillsDir)) fs9.mkdirSync(skillsDir, { recursive: true });
     for (const skill of config.skills) {
       const filename = `${skill.name.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}.md`;
-      const skillPath = path9.join(skillsDir, filename);
-      fs8.writeFileSync(skillPath, skill.content);
+      const skillPath = path10.join(skillsDir, filename);
+      fs9.writeFileSync(skillPath, skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
-    const mcpConfig = { mcpServers: config.mcpServers };
-    fs8.writeFileSync(".mcp.json", JSON.stringify(mcpConfig, null, 2));
+    let existingServers = {};
+    try {
+      if (fs9.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs9.readFileSync(".mcp.json", "utf-8"));
+        if (existing.mcpServers) {
+          existingServers = existing.mcpServers;
+        }
+      }
+    } catch {
+    }
+    const mergedServers = { ...existingServers, ...config.mcpServers };
+    fs9.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs9.writeFileSync(".cursorrules", config.cursorrules);
+    fs10.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path10.join(".cursor", "rules");
-    if (!fs9.existsSync(rulesDir)) fs9.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path11.join(".cursor", "rules");
+    if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path10.join(rulesDir, rule.filename);
-      fs9.writeFileSync(rulePath, rule.content);
+      const rulePath = path11.join(rulesDir, rule.filename);
+      fs10.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs9.existsSync(cursorDir)) fs9.mkdirSync(cursorDir, { recursive: true });
-    const mcpConfig = { mcpServers: config.mcpServers };
-    fs9.writeFileSync(
-      path10.join(cursorDir, "mcp.json"),
-      JSON.stringify(mcpConfig, null, 2)
-    );
-    written.push(path10.join(cursorDir, "mcp.json"));
+    if (!fs10.existsSync(cursorDir)) fs10.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path11.join(cursorDir, "mcp.json");
+    let existingServers = {};
+    try {
+      if (fs10.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs10.readFileSync(mcpPath, "utf-8"));
+        if (existing.mcpServers) {
+          existingServers = existing.mcpServers;
+        }
+      }
+    } catch {
+    }
+    const mergedServers = { ...existingServers, ...config.mcpServers };
+    fs10.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    written.push(mcpPath);
   }
   return written;
 }
 
 // src/writers/backup.ts
 init_constants();
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path11.join(BACKUPS_DIR, timestamp);
+  const backupDir = path12.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs10.existsSync(file)) continue;
-    const dest = path11.join(backupDir, file);
-    const destDir = path11.dirname(dest);
-    if (!fs10.existsSync(destDir)) {
-      fs10.mkdirSync(destDir, { recursive: true });
+    if (!fs11.existsSync(file)) continue;
+    const dest = path12.join(backupDir, file);
+    const destDir = path12.dirname(dest);
+    if (!fs11.existsSync(destDir)) {
+      fs11.mkdirSync(destDir, { recursive: true });
     }
-    fs10.copyFileSync(file, dest);
+    fs11.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path11.join(backupDir, file);
-  if (!fs10.existsSync(backupFile)) return false;
-  const destDir = path11.dirname(file);
-  if (!fs10.existsSync(destDir)) {
-    fs10.mkdirSync(destDir, { recursive: true });
+  const backupFile = path12.join(backupDir, file);
+  if (!fs11.existsSync(backupFile)) return false;
+  const destDir = path12.dirname(file);
+  if (!fs11.existsSync(destDir)) {
+    fs11.mkdirSync(destDir, { recursive: true });
   }
-  fs10.copyFileSync(backupFile, file);
+  fs11.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs11 from "fs";
-import crypto3 from "crypto";
+import fs12 from "fs";
+import crypto4 from "crypto";
 function readManifest() {
   try {
-    if (!fs11.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs11.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs12.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs12.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs11.existsSync(CALIBER_DIR)) {
-    fs11.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs12.existsSync(CALIBER_DIR)) {
+    fs12.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs11.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs12.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs11.readFileSync(filePath);
-  return crypto3.createHash("sha256").update(content).digest("hex");
+  const content = fs12.readFileSync(filePath);
+  return crypto4.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const existingFiles = filesToWrite.filter((f) => fs12.existsSync(f));
+  const existingFiles = filesToWrite.filter((f) => fs13.existsSync(f));
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
   const written = [];
   if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
@@ -1174,8 +1347,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs12.existsSync(entry.path)) {
-        fs12.unlinkSync(entry.path);
+      if (fs13.existsSync(entry.path)) {
+        fs13.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if (entry.action === "modified" && manifest.backupDir) {
@@ -1185,8 +1358,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs12.existsSync(MANIFEST_FILE2)) {
-    fs12.unlinkSync(MANIFEST_FILE2);
+  if (fs13.existsSync(MANIFEST_FILE2)) {
+    fs13.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -1212,34 +1385,34 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs12.existsSync(gitignorePath)) {
-    const content = fs12.readFileSync(gitignorePath, "utf-8");
+  if (fs13.existsSync(gitignorePath)) {
+    const content = fs13.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs12.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs13.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs12.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs13.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/lib/hooks.ts
-import fs13 from "fs";
-import path12 from "path";
-var SETTINGS_PATH = path12.join(".claude", "settings.json");
+import fs14 from "fs";
+import path13 from "path";
+var SETTINGS_PATH = path13.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function readSettings() {
-  if (!fs13.existsSync(SETTINGS_PATH)) return {};
+  if (!fs14.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path12.dirname(SETTINGS_PATH);
-  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
-  fs13.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path13.dirname(SETTINGS_PATH);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -1289,23 +1462,23 @@ function removeHook() {
 
 // src/lib/state.ts
 init_constants();
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 import { execSync as execSync2 } from "child_process";
-var STATE_FILE = path13.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
-    if (!fs14.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs14.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs15.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs15.readFileSync(STATE_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  if (!fs14.existsSync(CALIBER_DIR)) {
-    fs14.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs15.existsSync(CALIBER_DIR)) {
+    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs14.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs15.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -1319,6 +1492,7 @@ function getCurrentHeadSha() {
 }
 
 // src/utils/spinner-messages.ts
+import chalk2 from "chalk";
 var GENERATION_MESSAGES = [
   "Analyzing your project structure and dependencies...",
   "Mapping out build commands and test workflows...",
@@ -1344,25 +1518,46 @@ var SpinnerMessages = class {
   messages;
   index = 0;
   timer = null;
-  constructor(spinner, messages) {
+  startTime = 0;
+  showElapsedTime;
+  currentBaseMessage = "";
+  constructor(spinner, messages, options) {
     this.spinner = spinner;
     this.messages = messages;
+    this.showElapsedTime = options?.showElapsedTime ?? false;
+  }
+  formatElapsed() {
+    const seconds = Math.floor((Date.now() - this.startTime) / 1e3);
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  }
+  updateSpinnerText() {
+    this.spinner.text = this.currentBaseMessage;
   }
   start() {
     this.index = 0;
-    this.spinner.text = this.messages[0];
+    this.startTime = Date.now();
+    this.currentBaseMessage = this.messages[0];
+    this.updateSpinnerText();
+    if (this.showElapsedTime) {
+      this.spinner.suffixText = () => chalk2.dim(`(${this.formatElapsed()})`);
+    }
     this.timer = setInterval(() => {
       this.index = (this.index + 1) % this.messages.length;
-      this.spinner.text = this.messages[this.index];
+      this.currentBaseMessage = this.messages[this.index];
+      this.updateSpinnerText();
     }, 3e3);
   }
   handleServerStatus(status) {
-    this.spinner.text = status;
+    this.currentBaseMessage = status;
+    this.updateSpinnerText();
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = setInterval(() => {
         this.index = (this.index + 1) % this.messages.length;
-        this.spinner.text = this.messages[this.index];
+        this.currentBaseMessage = this.messages[this.index];
+        this.updateSpinnerText();
       }, 3e3);
     }
   }
@@ -1371,12 +1566,13 @@ var SpinnerMessages = class {
       clearInterval(this.timer);
       this.timer = null;
     }
+    this.spinner.suffixText = "";
   }
 };
 
 // src/commands/init.ts
 async function initCommand(options) {
-  console.log(chalk2.bold.hex("#6366f1")(`
+  console.log(chalk3.bold.hex("#6366f1")(`
    \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
   \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
@@ -1384,34 +1580,34 @@ async function initCommand(options) {
   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
   `));
-  console.log(chalk2.dim("  Configure your coding agent environment\n"));
-  console.log(chalk2.bold("  What is Caliber?\n"));
-  console.log(chalk2.dim("  Caliber analyzes your project and generates optimized configurations"));
-  console.log(chalk2.dim("  for AI coding agents (Claude Code, Cursor). It creates CLAUDE.md,"));
-  console.log(chalk2.dim("  .cursorrules, skills, permissions, and MCP servers tailored to your"));
-  console.log(chalk2.dim("  codebase \u2014 so your AI agent understands your project from day one.\n"));
-  console.log(chalk2.bold("  How it works:\n"));
-  console.log(chalk2.dim("  1. Scan      Analyze your code, dependencies, and file structure"));
-  console.log(chalk2.dim("  2. Match     Check if a teammate already configured this project"));
-  console.log(chalk2.dim("  3. Generate  AI creates config files tailored to your project"));
-  console.log(chalk2.dim("  4. Review    You accept, refine, or decline the generated setup"));
-  console.log(chalk2.dim("  5. Apply     Config files are written to your project"));
-  console.log(chalk2.dim("  6. Sync      Setup is saved so teammates get the same config\n"));
-  console.log(chalk2.hex("#6366f1").bold("  Step 1/6 \u2014 Authenticate\n"));
+  console.log(chalk3.dim("  Configure your coding agent environment\n"));
+  console.log(chalk3.bold("  What is Caliber?\n"));
+  console.log(chalk3.dim("  Caliber analyzes your project and generates optimized configurations"));
+  console.log(chalk3.dim("  for AI coding agents (Claude Code, Cursor). It creates CLAUDE.md,"));
+  console.log(chalk3.dim("  .cursorrules, skills, permissions, and MCP servers tailored to your"));
+  console.log(chalk3.dim("  codebase \u2014 so your AI agent understands your project from day one.\n"));
+  console.log(chalk3.bold("  How it works:\n"));
+  console.log(chalk3.dim("  1. Scan      Analyze your code, dependencies, and file structure"));
+  console.log(chalk3.dim("  2. Match     Detect existing configs and check for teammate setups"));
+  console.log(chalk3.dim("  3. Generate  AI creates config files tailored to your project"));
+  console.log(chalk3.dim("  4. Review    You accept, refine, or decline the generated setup"));
+  console.log(chalk3.dim("  5. Apply     Config files are written to your project"));
+  console.log(chalk3.dim("  6. Sync      Setup is saved so teammates get the same config\n"));
+  console.log(chalk3.hex("#6366f1").bold("  Step 1/6 \u2014 Authenticate\n"));
   let auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk2.yellow("Not logged in. Starting authentication...\n"));
+    console.log(chalk3.yellow("Not logged in. Starting authentication...\n"));
     await loginCommand();
     auth2 = getStoredAuth();
     if (!auth2) {
-      console.log(chalk2.red("Authentication required. Exiting."));
+      console.log(chalk3.red("Authentication required. Exiting."));
       throw new Error("__exit__");
     }
   }
-  console.log(chalk2.dim(`Authenticated as ${auth2.email}
+  console.log(chalk3.dim(`Authenticated as ${auth2.email}
 `));
-  console.log(chalk2.hex("#6366f1").bold("  Step 2/6 \u2014 Scan project\n"));
-  console.log(chalk2.dim("  Detecting languages, frameworks, file structure, and existing configs.\n"));
+  console.log(chalk3.hex("#6366f1").bold("  Step 2/6 \u2014 Scan project\n"));
+  console.log(chalk3.dim("  Detecting languages, frameworks, file structure, and existing configs.\n"));
   const spinner = ora2("Analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   const hash = computeFingerprintHash(fingerprint);
@@ -1425,17 +1621,46 @@ async function initCommand(options) {
     has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
     cursor_rules_count: fingerprint.existingConfigs.cursorRules?.length ?? 0,
     skills_count: fingerprint.existingConfigs.claudeSkills?.length ?? 0,
+    has_claude_mcp_servers: !!fingerprint.existingConfigs.claudeMcpServers,
+    has_cursor_mcp_servers: !!fingerprint.existingConfigs.cursorMcpServers,
+    claude_mcp_server_count: fingerprint.existingConfigs.claudeMcpServers ? Object.keys(fingerprint.existingConfigs.claudeMcpServers).length : 0,
+    cursor_mcp_server_count: fingerprint.existingConfigs.cursorMcpServers ? Object.keys(fingerprint.existingConfigs.cursorMcpServers).length : 0,
     file_count: fingerprint.fileTree.length
   });
-  console.log(chalk2.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
-  console.log(chalk2.dim(`  Frameworks: ${fingerprint.frameworks.join(", ") || "none detected"}`));
-  console.log(chalk2.dim(`  Files: ${fingerprint.fileTree.length} found
+  console.log(chalk3.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
+  console.log(chalk3.dim(`  Frameworks: ${fingerprint.frameworks.join(", ") || "none detected"}`));
+  console.log(chalk3.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
-  console.log(chalk2.hex("#6366f1").bold("  Step 3/6 \u2014 Match project\n"));
-  console.log(chalk2.dim("  Checking if a teammate already set up Caliber for this repo.\n"));
-  const matchSpinner = ora2("Checking for existing setup...").start();
+  console.log(chalk3.hex("#6366f1").bold("  Step 3/6 \u2014 Match project\n"));
+  console.log(chalk3.dim("  Scanning for existing rules, skills, MCP servers, and teammate setups.\n"));
+  const matchSpinner = ora2("Scanning for existing setup...").start();
+  const localConfigs = [];
+  const ec = fingerprint.existingConfigs;
+  if (ec.claudeMd) localConfigs.push("CLAUDE.md");
+  if (ec.claudeSettings) localConfigs.push(".claude/settings.json");
+  if (Array.isArray(ec.claudeSkills)) {
+    for (const skill of ec.claudeSkills) {
+      localConfigs.push(`.claude/skills/${skill.filename}`);
+    }
+  }
+  if (ec.cursorrules) localConfigs.push(".cursorrules");
+  if (Array.isArray(ec.cursorRules)) {
+    for (const rule of ec.cursorRules) {
+      localConfigs.push(`.cursor/rules/${rule.filename}`);
+    }
+  }
+  const localState = scanLocalState(process.cwd());
+  const claudeMcpServers = localState.filter((i) => i.type === "mcp" && i.platform === "claude").map((i) => i.name);
+  const cursorMcpServers = localState.filter((i) => i.type === "mcp" && i.platform === "cursor").map((i) => i.name);
+  if (claudeMcpServers.length > 0) {
+    localConfigs.push(`.mcp.json (${claudeMcpServers.join(", ")} \u2014 will merge)`);
+  }
+  if (cursorMcpServers.length > 0) {
+    localConfigs.push(`.cursor/mcp.json (${cursorMcpServers.join(", ")} \u2014 will merge)`);
+  }
   let existingSetup = null;
   let existingProjectId = null;
+  let hasTeammateSetup = false;
   try {
     const match = await apiRequest("/api/projects/match", {
       method: "POST",
@@ -1446,34 +1671,50 @@ async function initCommand(options) {
     }
     if (match.setup) {
       existingSetup = match.setup;
+      hasTeammateSetup = true;
       trackEvent("existing_config_detected", {
         has_claude_md: !!fingerprint.existingConfigs.claudeMd,
         has_cursorrules: !!fingerprint.existingConfigs.cursorrules,
         has_cursor_rules: (fingerprint.existingConfigs.cursorRules?.length ?? 0) > 0,
         has_skills: (fingerprint.existingConfigs.claudeSkills?.length ?? 0) > 0
       });
-      matchSpinner.succeed("Found existing setup");
-    } else {
-      matchSpinner.info("No existing setup found");
     }
   } catch {
-    matchSpinner.info("No existing setup found");
   }
+  matchSpinner.stop();
+  console.log(chalk3.dim("  Local configs:"));
+  if (localConfigs.length > 0) {
+    for (const config of localConfigs) {
+      console.log(`    ${chalk3.green("\u2713")} ${config}`);
+    }
+  } else {
+    console.log(`    ${chalk3.dim("\u2139 None found")}`);
+  }
+  console.log("");
+  console.log(chalk3.dim("  Teammate setup:"));
+  if (hasTeammateSetup) {
+    console.log(`    ${chalk3.green("\u2713")} Found on Caliber`);
+  } else {
+    console.log(`    ${chalk3.dim("\u2139 None found")}`);
+  }
+  console.log("");
   const targetAgent = options.agent || await promptAgent();
   trackEvent("target_agent_selected", { target_agent: targetAgent });
   const isEmpty = fingerprint.fileTree.length < 3;
   if (isEmpty) {
     fingerprint.description = await promptInput("What will you build in this project?");
   }
-  console.log(chalk2.hex("#6366f1").bold("  Step 4/6 \u2014 Generate config\n"));
-  console.log(chalk2.dim("  AI is building CLAUDE.md, permissions, skills, and rules based on"));
-  console.log(chalk2.dim("  your project's stack and conventions.\n"));
+  console.log(chalk3.hex("#6366f1").bold("  Step 4/6 \u2014 Planning a better setup\n"));
+  console.log(chalk3.dim("  AI is building CLAUDE.md, permissions, skills, and rules based on"));
+  console.log(chalk3.dim("  your project's stack and conventions.\n"));
+  console.log(chalk3.dim("  This usually takes 1\u20133 minutes on first run.\n"));
   let generatedSetup = null;
   let setupExplanation;
   let rawOutput;
   trackEvent("generation_started", { target_agent: targetAgent });
+  const hasExistingConfig = !!(ec.claudeMd || ec.claudeSettings || ec.claudeSkills?.length || ec.cursorrules || ec.cursorRules?.length || ec.claudeMcpServers || ec.cursorMcpServers);
   const genSpinner = ora2("Generating setup...").start();
-  const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES);
+  const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
   genMessages.start();
   try {
     await apiStream(
@@ -1481,7 +1722,8 @@ async function initCommand(options) {
       {
         fingerprint,
         targetAgent,
-        prompt: fingerprint.description
+        prompt: fingerprint.description,
+        mode: hasExistingConfig ? "improve" : "create"
       },
       () => {
       },
@@ -1510,45 +1752,45 @@ async function initCommand(options) {
   if (!generatedSetup) {
     genSpinner.fail("Failed to generate setup.");
     if (rawOutput) {
-      console.log(chalk2.dim("\nRaw LLM output (JSON parse failed):"));
-      console.log(chalk2.dim(rawOutput.slice(0, 500)));
+      console.log(chalk3.dim("\nRaw LLM output (JSON parse failed):"));
+      console.log(chalk3.dim(rawOutput.slice(0, 500)));
     }
     throw new Error("__exit__");
   }
   genSpinner.succeed("Setup generated");
   printSetupSummary(generatedSetup);
-  console.log(chalk2.hex("#6366f1").bold("  Step 5/6 \u2014 Review\n"));
-  console.log(chalk2.dim("  Review the proposed files below. You can accept, refine via chat,"));
-  console.log(chalk2.dim("  or see an explanation of why each item was recommended.\n"));
+  console.log(chalk3.hex("#6366f1").bold("  Step 5/6 \u2014 Review\n"));
+  console.log(chalk3.dim("  Review the proposed files below. You can accept, refine via chat,"));
+  console.log(chalk3.dim("  or see an explanation of why each item was recommended.\n"));
   let explained = false;
   let action = await promptAction(explained);
   while (action === "explain") {
     if (setupExplanation) {
       printExplanation(setupExplanation);
     } else {
-      console.log(chalk2.dim("\nNo explanation available for this setup.\n"));
+      console.log(chalk3.dim("\nNo explanation available for this setup.\n"));
     }
     explained = true;
     action = await promptAction(explained);
   }
   if (action === "decline") {
     trackEvent("setup_declined");
-    console.log(chalk2.dim("Setup declined. No files were modified."));
+    console.log(chalk3.dim("Setup declined. No files were modified."));
     return;
   }
   if (action === "refine") {
     generatedSetup = await refineLoop(generatedSetup, targetAgent);
     if (!generatedSetup) {
       trackEvent("refinement_cancelled");
-      console.log(chalk2.dim("Refinement cancelled. No files were modified."));
+      console.log(chalk3.dim("Refinement cancelled. No files were modified."));
       return;
     }
   }
-  console.log(chalk2.hex("#6366f1").bold("  Step 6/6 \u2014 Apply & sync\n"));
-  console.log(chalk2.dim("  Writing config files to your project and syncing to Caliber so"));
-  console.log(chalk2.dim("  teammates get the same setup when they run `caliber init`.\n"));
+  console.log(chalk3.hex("#6366f1").bold("  Step 6/6 \u2014 Apply & sync\n"));
+  console.log(chalk3.dim("  Writing config files to your project and syncing to Caliber so"));
+  console.log(chalk3.dim("  teammates get the same setup when they run `caliber init`.\n"));
   if (options.dryRun) {
-    console.log(chalk2.yellow("\n[Dry run] Would write the following files:"));
+    console.log(chalk3.yellow("\n[Dry run] Would write the following files:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
@@ -1557,30 +1799,30 @@ async function initCommand(options) {
     const result = writeSetup(generatedSetup);
     writeSpinner.succeed("Config files written");
     trackEvent("setup_applied", { files_written: result.written.length, target_agent: targetAgent });
-    console.log(chalk2.bold("\nFiles created/updated:"));
+    console.log(chalk3.bold("\nFiles created/updated:"));
     for (const file of result.written) {
-      console.log(`  ${chalk2.green("\u2713")} ${file}`);
+      console.log(`  ${chalk3.green("\u2713")} ${file}`);
     }
     if (result.backupDir) {
-      console.log(chalk2.dim(`
+      console.log(chalk3.dim(`
   Backups saved to ${result.backupDir}`));
     }
   } catch (err) {
     writeSpinner.fail("Failed to write files");
-    console.error(chalk2.red(err instanceof Error ? err.message : "Unknown error"));
+    console.error(chalk3.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
   if (targetAgent === "claude" || targetAgent === "both") {
     const hookResult = installHook();
     if (hookResult.installed) {
-      console.log(`  ${chalk2.green("\u2713")} Auto-refresh hook installed \u2014 docs update on Claude Code session end`);
-      console.log(chalk2.dim("    Run `caliber hooks remove` to disable"));
+      console.log(`  ${chalk3.green("\u2713")} Auto-refresh hook installed \u2014 docs update on Claude Code session end`);
+      console.log(chalk3.dim("    Run `caliber hooks remove` to disable"));
       const sha = getCurrentHeadSha();
       if (sha) {
         writeState({ lastRefreshSha: sha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
       }
     } else if (hookResult.alreadyInstalled) {
-      console.log(chalk2.dim("  Auto-refresh hook already installed"));
+      console.log(chalk3.dim("  Auto-refresh hook already installed"));
     }
   }
   try {
@@ -1606,14 +1848,14 @@ async function initCommand(options) {
       }
     });
   } catch (err) {
-    console.log(chalk2.yellow(`
+    console.log(chalk3.yellow(`
   Warning: Could not save project to server.`));
-    console.log(chalk2.dim(`  ${err instanceof Error ? err.message : String(err)}`));
-    console.log(chalk2.dim(`  Your local setup is unaffected.
+    console.log(chalk3.dim(`  ${err instanceof Error ? err.message : String(err)}`));
+    console.log(chalk3.dim(`  Your local setup is unaffected.
 `));
   }
-  console.log(chalk2.bold.green("\nSetup complete! Your coding agent is now configured."));
-  console.log(chalk2.dim("Run `caliber undo` to revert changes.\n"));
+  console.log(chalk3.bold.green("\nSetup complete! Your coding agent is now configured."));
+  console.log(chalk3.dim("Run `caliber undo` to revert changes.\n"));
 }
 async function refineLoop(currentSetup, _targetAgent) {
   const history = [];
@@ -1655,71 +1897,41 @@ async function refineLoop(currentSetup, _targetAgent) {
       history.push({ role: "assistant", content: JSON.stringify(refined) });
       refineSpinner.succeed("Setup updated");
       printSetupSummary(refined);
-      console.log(chalk2.dim('Type "done" to accept, or describe more changes.'));
+      console.log(chalk3.dim('Type "done" to accept, or describe more changes.'));
     }
   }
 }
 function promptInput(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
-    rl.question(chalk2.cyan(`${question} `), (answer) => {
+    rl.question(chalk3.cyan(`${question} `), (answer) => {
       rl.close();
       resolve2(answer.trim());
     });
   });
 }
-function promptAgent() {
-  return new Promise((resolve2) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(chalk2.bold("Which coding agent are you using?"));
-    console.log("  1. Claude Code");
-    console.log("  2. Cursor");
-    console.log("  3. Both");
-    rl.question(chalk2.cyan("\nChoose (1-3): "), (answer) => {
-      rl.close();
-      const map = { "1": "claude", "2": "cursor", "3": "both" };
-      resolve2(map[answer.trim()] || "claude");
-    });
+async function promptAgent() {
+  return select({
+    message: "Which coding agent are you using?",
+    choices: [
+      { name: "Claude Code", value: "claude" },
+      { name: "Cursor", value: "cursor" },
+      { name: "Both", value: "both" }
+    ]
   });
 }
-function promptAction(explained) {
-  return new Promise((resolve2) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    console.log(chalk2.bold("What would you like to do?"));
-    if (explained) {
-      console.log("  1. Accept and apply");
-      console.log("  2. Refine via chat");
-      console.log("  3. Decline");
-      rl.question(chalk2.cyan("\nChoose (1-3): "), (answer) => {
-        rl.close();
-        const map = {
-          "1": "accept",
-          "2": "refine",
-          "3": "decline"
-        };
-        resolve2(map[answer.trim()] || "accept");
-      });
-    } else {
-      console.log("  1. Accept and apply");
-      console.log("  2. Refine via chat");
-      console.log("  3. Explain recommendations");
-      console.log("  4. Decline");
-      rl.question(chalk2.cyan("\nChoose (1-4): "), (answer) => {
-        rl.close();
-        const map = {
-          "1": "accept",
-          "2": "refine",
-          "3": "explain",
-          "4": "decline"
-        };
-        resolve2(map[answer.trim()] || "accept");
-      });
-    }
-  });
+async function promptAction(explained) {
+  const choices = [
+    { name: "Accept and apply", value: "accept" },
+    { name: "Refine via chat", value: "refine" },
+    ...!explained ? [{ name: "Explain recommendations", value: "explain" }] : [],
+    { name: "Decline", value: "decline" }
+  ];
+  return select({ message: "What would you like to do?", choices });
 }
 function fileEntry(filePath, desc) {
-  const icon = fs15.existsSync(filePath) ? chalk2.yellow("~") : chalk2.green("+");
-  const description = desc ? chalk2.dim(`\u2014 ${desc}`) : "";
+  const icon = fs16.existsSync(filePath) ? chalk3.yellow("~") : chalk3.green("+");
+  const description = desc ? chalk3.dim(`\u2014 ${desc}`) : "";
   return `  ${icon} ${filePath} ${description}`;
 }
 function printSetupSummary(setup) {
@@ -1766,39 +1978,39 @@ function printSetupSummary(setup) {
     }
   }
   console.log("");
-  console.log(`  ${chalk2.green("+")} ${chalk2.dim("new")}  ${chalk2.yellow("~")} ${chalk2.dim("modified")}`);
+  console.log(`  ${chalk3.green("+")} ${chalk3.dim("new")}  ${chalk3.yellow("~")} ${chalk3.dim("modified")}`);
   console.log("");
 }
 function printExplanation(explanation) {
-  console.log(chalk2.bold("\n  Why this setup?\n"));
+  console.log(chalk3.bold("\n  Why this setup?\n"));
   const lines = explanation.split("\n");
   for (const line of lines) {
     const trimmed = line.trim();
     if (!trimmed) continue;
     const headerMatch = trimmed.match(/^\[(.+)\]$/);
     if (headerMatch) {
-      console.log(`  ${chalk2.bold.hex("#6366f1")(headerMatch[1])}`);
+      console.log(`  ${chalk3.bold.hex("#6366f1")(headerMatch[1])}`);
       continue;
     }
     const itemMatch = trimmed.match(/^-\s+\*\*(.+?)\*\*[:\s]*(.*)$/);
     if (itemMatch) {
       const name = itemMatch[1];
       const desc = itemMatch[2].replace(/^\s*[-—:]\s*/, "");
-      console.log(`    ${chalk2.dim("\u25B8")} ${chalk2.white(name)}  ${chalk2.dim(desc)}`);
+      console.log(`    ${chalk3.dim("\u25B8")} ${chalk3.white(name)}  ${chalk3.dim(desc)}`);
       continue;
     }
     const plainMatch = trimmed.match(/^-\s+(.*)$/);
     if (plainMatch) {
-      console.log(`    ${chalk2.dim("\u25B8")} ${chalk2.dim(plainMatch[1])}`);
+      console.log(`    ${chalk3.dim("\u25B8")} ${chalk3.dim(plainMatch[1])}`);
       continue;
     }
-    console.log(`  ${chalk2.dim(trimmed)}`);
+    console.log(`  ${chalk3.dim(trimmed)}`);
   }
   console.log("");
 }
 
 // src/commands/undo.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import ora3 from "ora";
 function undoCommand() {
   const spinner = ora3("Reverting setup...").start();
@@ -1811,163 +2023,27 @@ function undoCommand() {
     spinner.succeed("Setup reverted successfully.\n");
     trackEvent("setup_undone", { restored: restored.length, removed: removed.length });
     if (restored.length > 0) {
-      console.log(chalk3.cyan("  Restored from backup:"));
+      console.log(chalk4.cyan("  Restored from backup:"));
       for (const file of restored) {
-        console.log(`    ${chalk3.green("\u21A9")} ${file}`);
+        console.log(`    ${chalk4.green("\u21A9")} ${file}`);
       }
     }
     if (removed.length > 0) {
-      console.log(chalk3.cyan("  Removed:"));
+      console.log(chalk4.cyan("  Removed:"));
       for (const file of removed) {
-        console.log(`    ${chalk3.red("\u2717")} ${file}`);
+        console.log(`    ${chalk4.red("\u2717")} ${file}`);
       }
     }
     console.log("");
   } catch (err) {
-    spinner.fail(chalk3.red(err instanceof Error ? err.message : "Undo failed"));
+    spinner.fail(chalk4.red(err instanceof Error ? err.message : "Undo failed"));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/status.ts
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import fs17 from "fs";
-
-// src/scanner/index.ts
-import fs16 from "fs";
-import path14 from "path";
-import crypto4 from "crypto";
-function scanLocalState(dir) {
-  const items = [];
-  const claudeMdPath = path14.join(dir, "CLAUDE.md");
-  if (fs16.existsSync(claudeMdPath)) {
-    items.push({
-      type: "rule",
-      platform: "claude",
-      name: "CLAUDE.md",
-      contentHash: hashFile(claudeMdPath),
-      path: claudeMdPath
-    });
-  }
-  const settingsPath = path14.join(dir, ".claude", "settings.json");
-  if (fs16.existsSync(settingsPath)) {
-    items.push({
-      type: "config",
-      platform: "claude",
-      name: "settings.json",
-      contentHash: hashFile(settingsPath),
-      path: settingsPath
-    });
-  }
-  const skillsDir = path14.join(dir, ".claude", "skills");
-  if (fs16.existsSync(skillsDir)) {
-    for (const file of fs16.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path14.join(skillsDir, file);
-      items.push({
-        type: "skill",
-        platform: "claude",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const mcpJsonPath = path14.join(dir, ".mcp.json");
-  if (fs16.existsSync(mcpJsonPath)) {
-    try {
-      const mcpJson = JSON.parse(fs16.readFileSync(mcpJsonPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "claude",
-            name,
-            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
-            path: mcpJsonPath
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  const cursorrulesPath = path14.join(dir, ".cursorrules");
-  if (fs16.existsSync(cursorrulesPath)) {
-    items.push({
-      type: "rule",
-      platform: "cursor",
-      name: ".cursorrules",
-      contentHash: hashFile(cursorrulesPath),
-      path: cursorrulesPath
-    });
-  }
-  const cursorRulesDir = path14.join(dir, ".cursor", "rules");
-  if (fs16.existsSync(cursorRulesDir)) {
-    for (const file of fs16.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path14.join(cursorRulesDir, file);
-      items.push({
-        type: "rule",
-        platform: "cursor",
-        name: file,
-        contentHash: hashFile(filePath),
-        path: filePath
-      });
-    }
-  }
-  const cursorMcpPath = path14.join(dir, ".cursor", "mcp.json");
-  if (fs16.existsSync(cursorMcpPath)) {
-    try {
-      const mcpJson = JSON.parse(fs16.readFileSync(cursorMcpPath, "utf-8"));
-      if (mcpJson.mcpServers) {
-        for (const name of Object.keys(mcpJson.mcpServers)) {
-          items.push({
-            type: "mcp",
-            platform: "cursor",
-            name,
-            contentHash: hashContent(JSON.stringify(mcpJson.mcpServers[name])),
-            path: cursorMcpPath
-          });
-        }
-      }
-    } catch {
-    }
-  }
-  return items;
-}
-function compareState(serverItems, localItems) {
-  const installed = [];
-  const missing = [];
-  const outdated = [];
-  const extra = [];
-  const localMap = /* @__PURE__ */ new Map();
-  for (const item of localItems) {
-    localMap.set(`${item.type}:${item.platform}:${item.name}`, item);
-  }
-  for (const server of serverItems) {
-    const key = `${server.type}:${server.platform}:${server.name}`;
-    const local = localMap.get(key);
-    localMap.delete(key);
-    if (!local) {
-      missing.push(server);
-    } else if (local.contentHash !== server.content_hash) {
-      outdated.push({ server, local });
-    } else {
-      installed.push({ server, local });
-    }
-  }
-  for (const local of localMap.values()) {
-    extra.push(local);
-  }
-  return { installed, missing, outdated, extra };
-}
-function hashFile(filePath) {
-  const content = fs16.readFileSync(filePath);
-  return crypto4.createHash("sha256").update(content).digest("hex");
-}
-function hashContent(content) {
-  return crypto4.createHash("sha256").update(JSON.stringify({ text: content })).digest("hex");
-}
-
-// src/commands/status.ts
 async function statusCommand(options) {
   const auth2 = getStoredAuth();
   const manifest = readManifest();
@@ -1979,21 +2055,21 @@ async function statusCommand(options) {
     }, null, 2));
     return;
   }
-  console.log(chalk4.bold("\nCaliber Status\n"));
+  console.log(chalk5.bold("\nCaliber Status\n"));
   if (auth2) {
-    console.log(`  Auth: ${chalk4.green("Logged in")} as ${auth2.email}`);
+    console.log(`  Auth: ${chalk5.green("Logged in")} as ${auth2.email}`);
   } else {
-    console.log(`  Auth: ${chalk4.yellow("Not logged in")}`);
+    console.log(`  Auth: ${chalk5.yellow("Not logged in")}`);
   }
   if (!manifest) {
-    console.log(`  Setup: ${chalk4.dim("No setup applied")}`);
-    console.log(chalk4.dim("\n  Run `caliber init` to get started.\n"));
+    console.log(`  Setup: ${chalk5.dim("No setup applied")}`);
+    console.log(chalk5.dim("\n  Run `caliber init` to get started.\n"));
     return;
   }
-  console.log(`  Files managed: ${chalk4.cyan(manifest.entries.length.toString())}`);
+  console.log(`  Files managed: ${chalk5.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
     const exists = fs17.existsSync(entry.path);
-    const icon = exists ? chalk4.green("\u2713") : chalk4.red("\u2717");
+    const icon = exists ? chalk5.green("\u2713") : chalk5.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
   if (auth2) {
@@ -2011,10 +2087,10 @@ async function statusCommand(options) {
         if (serverItems?.length) {
           const localItems = scanLocalState(process.cwd());
           const diff = compareState(serverItems, localItems);
-          console.log(chalk4.bold("\n  Sync"));
-          console.log(`    ${chalk4.green("\u2713")} Installed: ${diff.installed.length}`);
-          if (diff.missing.length) console.log(`    ${chalk4.red("\u2717")} Missing: ${diff.missing.length}`);
-          if (diff.outdated.length) console.log(`    ${chalk4.yellow("~")} Outdated: ${diff.outdated.length}`);
+          console.log(chalk5.bold("\n  Sync"));
+          console.log(`    ${chalk5.green("\u2713")} Installed: ${diff.installed.length}`);
+          if (diff.missing.length) console.log(`    ${chalk5.red("\u2717")} Missing: ${diff.missing.length}`);
+          if (diff.outdated.length) console.log(`    ${chalk5.yellow("~")} Outdated: ${diff.outdated.length}`);
         }
       }
     } catch {
@@ -2024,18 +2100,18 @@ async function statusCommand(options) {
 }
 
 // src/commands/update.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import ora4 from "ora";
-import readline2 from "readline";
+import confirm from "@inquirer/confirm";
 async function updateCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk5.red("Not logged in. Run `caliber login` first."));
+    console.log(chalk6.red("Not logged in. Run `caliber login` first."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk5.yellow("No existing setup found. Run `caliber init` first."));
+    console.log(chalk6.yellow("No existing setup found. Run `caliber init` first."));
     throw new Error("__exit__");
   }
   const spinner = ora4("Re-analyzing project...").start();
@@ -2092,18 +2168,14 @@ async function updateCommand(options) {
   }
   genSpinner.succeed("Setup regenerated");
   if (options.dryRun) {
-    console.log(chalk5.yellow("\n[Dry run] Would write:"));
+    console.log(chalk6.yellow("\n[Dry run] Would write:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
-  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve2) => {
-    rl.question(chalk5.cyan("\n\nApply updated setup? (y/n): "), resolve2);
-  });
-  rl.close();
-  if (answer.trim().toLowerCase() !== "y") {
+  const shouldApply = await confirm({ message: "Apply updated setup?", default: true });
+  if (!shouldApply) {
     trackEvent("update_declined");
-    console.log(chalk5.dim("Update cancelled."));
+    console.log(chalk6.dim("Update cancelled."));
     return;
   }
   const writeSpinner = ora4("Updating config files...").start();
@@ -2111,33 +2183,33 @@ async function updateCommand(options) {
   writeSpinner.succeed("Config files updated");
   trackEvent("setup_updated", { files_written: result.written.length });
   for (const file of result.written) {
-    console.log(`  ${chalk5.green("\u2713")} ${file}`);
+    console.log(`  ${chalk6.green("\u2713")} ${file}`);
   }
   console.log("");
 }
 
 // src/commands/logout.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 function logoutCommand() {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk6.dim("Not currently logged in."));
+    console.log(chalk7.dim("Not currently logged in."));
     return;
   }
   clearAuth();
   trackEvent("logout");
-  console.log(chalk6.green("Logged out successfully."));
+  console.log(chalk7.green("Logged out successfully."));
 }
 
 // src/commands/recommend.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import ora5 from "ora";
 import { mkdirSync, writeFileSync } from "fs";
 import { join } from "path";
 async function recommendCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk7.red("Not authenticated. Run `caliber login` first."));
+    console.log(chalk8.red("Not authenticated. Run `caliber login` first."));
     throw new Error("__exit__");
   }
   const fingerprint = collectFingerprint(process.cwd());
@@ -2147,7 +2219,7 @@ async function recommendCommand(options) {
     { method: "POST", body: { fingerprintHash: hash } }
   );
   if (!match?.project) {
-    console.log(chalk7.yellow("No project found. Run `caliber init` first."));
+    console.log(chalk8.yellow("No project found. Run `caliber init` first."));
     throw new Error("__exit__");
   }
   const projectId = match.project.id;
@@ -2177,7 +2249,7 @@ async function recommendCommand(options) {
     `/api/recommendations/project/${projectId}?status=${statusFilter}`
   );
   if (!recs?.length) {
-    console.log(chalk7.dim(`
+    console.log(chalk8.dim(`
 No ${statusFilter} recommendations. Run \`caliber recommend --generate\` to discover skills.
 `));
     return;
@@ -2202,19 +2274,19 @@ async function interactiveSelect(recs) {
   let lineCount = 0;
   function render() {
     const lines = [];
-    lines.push(chalk7.bold("  Skill Recommendations"));
+    lines.push(chalk8.bold("  Skill Recommendations"));
     lines.push("");
-    lines.push(`  ${chalk7.dim("Name".padEnd(30))} ${chalk7.dim("Score".padEnd(8))} ${chalk7.dim("Technology")}`);
-    lines.push(chalk7.dim("  " + "\u2500".repeat(55)));
+    lines.push(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Score".padEnd(8))} ${chalk8.dim("Technology")}`);
+    lines.push(chalk8.dim("  " + "\u2500".repeat(55)));
     for (let i = 0; i < recs.length; i++) {
       const rec = recs[i];
-      const check = selected.has(i) ? chalk7.green("[x]") : "[ ]";
-      const ptr = i === cursor ? chalk7.cyan("\u276F") : " ";
-      const scoreColor = rec.score >= 90 ? chalk7.green : rec.score >= 70 ? chalk7.blue : chalk7.yellow;
+      const check = selected.has(i) ? chalk8.green("[x]") : "[ ]";
+      const ptr = i === cursor ? chalk8.cyan("\u276F") : " ";
+      const scoreColor = rec.score >= 90 ? chalk8.green : rec.score >= 70 ? chalk8.blue : chalk8.yellow;
       lines.push(`  ${ptr} ${check} ${rec.skill_name.padEnd(26)} ${scoreColor(`${rec.score}%`.padEnd(8))} ${rec.detected_technology}`);
     }
     lines.push("");
-    lines.push(chalk7.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
+    lines.push(chalk8.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -2263,7 +2335,7 @@ async function interactiveSelect(recs) {
         case "\n":
           cleanup();
           if (selected.size === 0) {
-            console.log(chalk7.dim("\n  No skills selected.\n"));
+            console.log(chalk8.dim("\n  No skills selected.\n"));
             resolve2(null);
           } else {
             resolve2(Array.from(selected).sort().map((i) => recs[i]));
@@ -2273,7 +2345,7 @@ async function interactiveSelect(recs) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk7.dim("\n  Cancelled.\n"));
+          console.log(chalk8.dim("\n  Cancelled.\n"));
           resolve2(null);
           break;
       }
@@ -2313,41 +2385,41 @@ async function installSkills(recs) {
   if (installed.length > 0) {
     spinner.succeed(`Installed ${installed.length} skill${installed.length > 1 ? "s" : ""}`);
     for (const p of installed) {
-      console.log(chalk7.green(`  \u2713 ${p}`));
+      console.log(chalk8.green(`  \u2713 ${p}`));
     }
   } else {
     spinner.fail("No skills were installed");
   }
   for (const w of warnings) {
-    console.log(chalk7.yellow(`  \u26A0 ${w}`));
+    console.log(chalk8.yellow(`  \u26A0 ${w}`));
   }
   console.log("");
 }
 function printRecommendations(recs) {
-  console.log(chalk7.bold("\n  Skill Recommendations\n"));
+  console.log(chalk8.bold("\n  Skill Recommendations\n"));
   console.log(
-    `  ${chalk7.dim("Name".padEnd(30))} ${chalk7.dim("Score".padEnd(8))} ${chalk7.dim("Technology".padEnd(15))} ${chalk7.dim("Status")}`
+    `  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Score".padEnd(8))} ${chalk8.dim("Technology".padEnd(15))} ${chalk8.dim("Status")}`
   );
-  console.log(chalk7.dim("  " + "\u2500".repeat(70)));
+  console.log(chalk8.dim("  " + "\u2500".repeat(70)));
   for (const rec of recs) {
-    const scoreColor = rec.score >= 90 ? chalk7.green : rec.score >= 70 ? chalk7.blue : chalk7.yellow;
+    const scoreColor = rec.score >= 90 ? chalk8.green : rec.score >= 70 ? chalk8.blue : chalk8.yellow;
     console.log(
       `  ${rec.skill_name.padEnd(30)} ${scoreColor(`${rec.score}%`.padEnd(8))} ${rec.detected_technology.padEnd(15)} ${rec.status}`
     );
     if (rec.reason) {
-      console.log(`  ${chalk7.dim(rec.reason)}`);
+      console.log(`  ${chalk8.dim(rec.reason)}`);
     }
   }
   console.log("");
 }
 
 // src/commands/health.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 import ora6 from "ora";
 async function healthCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk8.red("Not authenticated. Run `caliber login` first."));
+    console.log(chalk9.red("Not authenticated. Run `caliber login` first."));
     throw new Error("__exit__");
   }
   const fingerprint = collectFingerprint(process.cwd());
@@ -2357,7 +2429,7 @@ async function healthCommand(options) {
     { method: "POST", body: { fingerprintHash: hash } }
   );
   if (!match?.project) {
-    console.log(chalk8.yellow("No project found. Run `caliber init` first."));
+    console.log(chalk9.yellow("No project found. Run `caliber init` first."));
     throw new Error("__exit__");
   }
   const projectId = match.project.id;
@@ -2379,21 +2451,21 @@ async function healthCommand(options) {
   }
   printReport(report);
   if (options.fix) {
-    console.log(chalk8.bold("\nGenerating fix plan..."));
+    console.log(chalk9.bold("\nGenerating fix plan..."));
     const plan = await apiRequest(
       `/api/context/reports/${report.id}/fix-plan`,
       { method: "POST", body: { projectId } }
     );
     if (!plan?.actions.length) {
-      console.log(chalk8.dim("No fixes needed."));
+      console.log(chalk9.dim("No fixes needed."));
       return;
     }
-    console.log(chalk8.bold("\nProposed actions:"));
+    console.log(chalk9.bold("\nProposed actions:"));
     for (const action of plan.actions) {
-      const icon = action.type === "remove" ? chalk8.red("- ") : action.type === "add" ? chalk8.green("+ ") : chalk8.yellow("~ ");
+      const icon = action.type === "remove" ? chalk9.red("- ") : action.type === "add" ? chalk9.green("+ ") : chalk9.yellow("~ ");
       console.log(`  ${icon}${action.type}: ${action.items.join(", ")}`);
     }
-    console.log(chalk8.dim(`
+    console.log(chalk9.dim(`
 Estimated improvement: +${plan.estimatedScoreImprovement} points`));
     const fixSpinner = ora6("Executing fix plan...").start();
     try {
@@ -2403,7 +2475,7 @@ Estimated improvement: +${plan.estimatedScoreImprovement} points`));
       );
       fixSpinner.succeed("Fix applied");
       console.log("");
-      console.log(`  Score: ${result.scoreBefore} \u2192 ${chalk8.green(String(result.scoreAfter))} (${chalk8.green(`+${result.improvement}`)})`);
+      console.log(`  Score: ${result.scoreBefore} \u2192 ${chalk9.green(String(result.scoreAfter))} (${chalk9.green(`+${result.improvement}`)})`);
       if (result.itemsRemoved) console.log(`  Removed: ${result.itemsRemoved} items`);
       if (result.itemsConsolidated) console.log(`  Consolidated: ${result.itemsConsolidated} items`);
       if (result.itemsAdded) console.log(`  Added: ${result.itemsAdded} items`);
@@ -2416,18 +2488,18 @@ Estimated improvement: +${plan.estimatedScoreImprovement} points`));
 }
 function printReport(report) {
   const gradeColors = {
-    A: chalk8.green,
-    B: chalk8.blue,
-    C: chalk8.yellow,
-    D: chalk8.hex("#FFA500"),
-    F: chalk8.red
+    A: chalk9.green,
+    B: chalk9.blue,
+    C: chalk9.yellow,
+    D: chalk9.hex("#FFA500"),
+    F: chalk9.red
   };
-  const gradeColor = gradeColors[report.grade] || chalk8.white;
-  console.log(chalk8.bold("\n  Context Health Report\n"));
+  const gradeColor = gradeColors[report.grade] || chalk9.white;
+  console.log(chalk9.bold("\n  Context Health Report\n"));
   console.log(`  Grade: ${gradeColor(report.grade)}  Score: ${gradeColor(String(report.score))}/100
 `);
   if (Object.keys(report.category_breakdown).length) {
-    console.log(chalk8.dim("  Category Breakdown:"));
+    console.log(chalk9.dim("  Category Breakdown:"));
     const categories = Object.entries(report.category_breakdown);
     const maxCount = Math.max(...categories.map(([, v]) => v.count));
     for (const [name, data] of categories) {
@@ -2438,9 +2510,9 @@ function printReport(report) {
     console.log("");
   }
   if (report.recommendations.length) {
-    console.log(chalk8.dim("  Recommendations:"));
+    console.log(chalk9.dim("  Recommendations:"));
     for (const rec of report.recommendations) {
-      const icon = rec.priority === "high" ? chalk8.red("!") : rec.priority === "medium" ? chalk8.yellow("~") : chalk8.dim("-");
+      const icon = rec.priority === "high" ? chalk9.red("!") : rec.priority === "medium" ? chalk9.yellow("~") : chalk9.dim("-");
       console.log(`    ${icon} ${rec.description}`);
     }
     console.log("");
@@ -2448,12 +2520,12 @@ function printReport(report) {
 }
 
 // src/commands/sync.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import ora7 from "ora";
 async function syncCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk9.red("Not authenticated. Run `caliber login` first."));
+    console.log(chalk10.red("Not authenticated. Run `caliber login` first."));
     throw new Error("__exit__");
   }
   const fingerprint = collectFingerprint(process.cwd());
@@ -2463,7 +2535,7 @@ async function syncCommand(options) {
     { method: "POST", body: { fingerprintHash: hash } }
   );
   if (!match?.project) {
-    console.log(chalk9.yellow("No project found. Run `caliber init` first."));
+    console.log(chalk10.yellow("No project found. Run `caliber init` first."));
     throw new Error("__exit__");
   }
   const projectId = match.project.id;
@@ -2475,7 +2547,7 @@ async function syncCommand(options) {
   );
   spinner.succeed(`Found ${localItems.length} local items, ${serverItems?.length || 0} server items`);
   if (!serverItems?.length) {
-    console.log(chalk9.dim("\nNo items configured on server. Run `caliber init` to set up your project.\n"));
+    console.log(chalk10.dim("\nNo items configured on server. Run `caliber init` to set up your project.\n"));
     return;
   }
   const platformFilter = options.platform;
@@ -2484,12 +2556,12 @@ async function syncCommand(options) {
   const diff = compareState(filteredServer, filteredLocal);
   printDiff(diff);
   if (diff.missing.length === 0 && diff.outdated.length === 0) {
-    console.log(chalk9.green("\nAll items synced.\n"));
+    console.log(chalk10.green("\nAll items synced.\n"));
     await reportToServer(projectId, filteredServer, diff);
     return;
   }
   if (options.dryRun) {
-    console.log(chalk9.dim("\nDry run \u2014 no changes made.\n"));
+    console.log(chalk10.dim("\nDry run \u2014 no changes made.\n"));
     return;
   }
   const installSpinner = ora7("Installing missing and outdated items...").start();
@@ -2545,26 +2617,26 @@ async function reportToServer(projectId, serverItems, diff) {
   }
 }
 function printDiff(diff) {
-  console.log(chalk9.bold("\n  Sync Status\n"));
+  console.log(chalk10.bold("\n  Sync Status\n"));
   if (diff.installed.length) {
-    console.log(`  ${chalk9.green("\u2713")} Installed: ${diff.installed.length}`);
+    console.log(`  ${chalk10.green("\u2713")} Installed: ${diff.installed.length}`);
   }
   if (diff.missing.length) {
-    console.log(`  ${chalk9.red("\u2717")} Missing: ${diff.missing.length}`);
+    console.log(`  ${chalk10.red("\u2717")} Missing: ${diff.missing.length}`);
     for (const item of diff.missing) {
-      console.log(`    ${chalk9.red("-")} ${item.name} (${item.type}/${item.platform})`);
+      console.log(`    ${chalk10.red("-")} ${item.name} (${item.type}/${item.platform})`);
     }
   }
   if (diff.outdated.length) {
-    console.log(`  ${chalk9.yellow("~")} Outdated: ${diff.outdated.length}`);
+    console.log(`  ${chalk10.yellow("~")} Outdated: ${diff.outdated.length}`);
     for (const item of diff.outdated) {
-      console.log(`    ${chalk9.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
+      console.log(`    ${chalk10.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
     }
   }
   if (diff.extra.length) {
-    console.log(`  ${chalk9.dim("+")} Extra (local only): ${diff.extra.length}`);
+    console.log(`  ${chalk10.dim("+")} Extra (local only): ${diff.extra.length}`);
     for (const item of diff.extra) {
-      console.log(`    ${chalk9.dim("+")} ${item.name} (${item.type}/${item.platform})`);
+      console.log(`    ${chalk10.dim("+")} ${item.name} (${item.type}/${item.platform})`);
     }
   }
   console.log("");
@@ -2625,12 +2697,12 @@ function buildSetupFromItems(items) {
 }
 
 // src/commands/diff.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import ora8 from "ora";
 async function diffCommand(options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk10.red("Not authenticated. Run `caliber login` first."));
+    console.log(chalk11.red("Not authenticated. Run `caliber login` first."));
     throw new Error("__exit__");
   }
   const fingerprint = collectFingerprint(process.cwd());
@@ -2640,7 +2712,7 @@ async function diffCommand(options) {
     { method: "POST", body: { fingerprintHash: hash } }
   );
   if (!match?.project) {
-    console.log(chalk10.yellow("No project found. Run `caliber init` first."));
+    console.log(chalk11.yellow("No project found. Run `caliber init` first."));
     throw new Error("__exit__");
   }
   const projectId = match.project.id;
@@ -2651,46 +2723,46 @@ async function diffCommand(options) {
   );
   spinner.stop();
   if (!serverItems?.length) {
-    console.log(chalk10.dim("\nNo items configured on server.\n"));
+    console.log(chalk11.dim("\nNo items configured on server.\n"));
     return;
   }
   const platformFilter = options.platform;
   const filteredServer = platformFilter ? serverItems.filter((i) => i.platform === platformFilter || i.platform === "both") : serverItems;
   const filteredLocal = platformFilter ? localItems.filter((i) => i.platform === platformFilter) : localItems;
   const diff = compareState(filteredServer, filteredLocal);
-  console.log(chalk10.bold("\n  Config Diff\n"));
+  console.log(chalk11.bold("\n  Config Diff\n"));
   if (diff.installed.length) {
-    console.log(`  ${chalk10.green("\u2713")} In sync: ${diff.installed.length}`);
+    console.log(`  ${chalk11.green("\u2713")} In sync: ${diff.installed.length}`);
   }
   if (diff.missing.length) {
-    console.log(`  ${chalk10.red("\u2717")} Missing locally: ${diff.missing.length}`);
+    console.log(`  ${chalk11.red("\u2717")} Missing locally: ${diff.missing.length}`);
     for (const item of diff.missing) {
-      console.log(`    ${chalk10.red("-")} ${item.name} (${item.type}/${item.platform})`);
+      console.log(`    ${chalk11.red("-")} ${item.name} (${item.type}/${item.platform})`);
     }
   }
   if (diff.outdated.length) {
-    console.log(`  ${chalk10.yellow("~")} Outdated: ${diff.outdated.length}`);
+    console.log(`  ${chalk11.yellow("~")} Outdated: ${diff.outdated.length}`);
     for (const item of diff.outdated) {
-      console.log(`    ${chalk10.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
+      console.log(`    ${chalk11.yellow("~")} ${item.server.name} (${item.server.type}/${item.server.platform})`);
     }
   }
   if (diff.extra.length) {
-    console.log(`  ${chalk10.dim("+")} Local only: ${diff.extra.length}`);
+    console.log(`  ${chalk11.dim("+")} Local only: ${diff.extra.length}`);
     for (const item of diff.extra) {
-      console.log(`    ${chalk10.dim("+")} ${item.name} (${item.type}/${item.platform})`);
+      console.log(`    ${chalk11.dim("+")} ${item.name} (${item.type}/${item.platform})`);
     }
   }
   if (diff.missing.length === 0 && diff.outdated.length === 0) {
-    console.log(chalk10.green("\n  Everything is in sync.\n"));
+    console.log(chalk11.green("\n  Everything is in sync.\n"));
   } else {
-    console.log(chalk10.dim("\n  Run `caliber sync` to apply changes.\n"));
+    console.log(chalk11.dim("\n  Run `caliber sync` to apply changes.\n"));
   }
 }
 
 // src/commands/refresh.ts
 import fs19 from "fs";
 import path16 from "path";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import ora9 from "ora";
 
 // src/lib/git-diff.ts
@@ -2824,7 +2896,7 @@ function discoverGitRepos(parentDir) {
 }
 async function refreshSingleRepo(repoDir, options) {
   const quiet = !!options.quiet;
-  const prefix = options.label ? `${chalk11.bold(options.label)} ` : "";
+  const prefix = options.label ? `${chalk12.bold(options.label)} ` : "";
   const state = readState();
   const lastSha = state?.lastRefreshSha ?? null;
   const diff = collectDiff(lastSha);
@@ -2833,7 +2905,7 @@ async function refreshSingleRepo(repoDir, options) {
     if (currentSha) {
       writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
     }
-    log(quiet, chalk11.dim(`${prefix}No changes since last refresh.`));
+    log(quiet, chalk12.dim(`${prefix}No changes since last refresh.`));
     return;
   }
   const spinner = quiet ? null : ora9(`${prefix}Analyzing changes...`).start();
@@ -2868,10 +2940,10 @@ async function refreshSingleRepo(repoDir, options) {
   if (options.dryRun) {
     spinner?.info(`${prefix}Dry run \u2014 would update:`);
     for (const doc of response.docsUpdated) {
-      console.log(`  ${chalk11.yellow("~")} ${doc}`);
+      console.log(`  ${chalk12.yellow("~")} ${doc}`);
     }
     if (response.changesSummary) {
-      console.log(chalk11.dim(`
+      console.log(chalk12.dim(`
   ${response.changesSummary}`));
     }
     return;
@@ -2879,10 +2951,10 @@ async function refreshSingleRepo(repoDir, options) {
   const written = writeRefreshDocs(response.updatedDocs);
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
   for (const file of written) {
-    log(quiet, `  ${chalk11.green("\u2713")} ${file}`);
+    log(quiet, `  ${chalk12.green("\u2713")} ${file}`);
   }
   if (response.changesSummary) {
-    log(quiet, chalk11.dim(`
+    log(quiet, chalk12.dim(`
   ${response.changesSummary}`));
   }
   if (currentSha) {
@@ -2899,7 +2971,7 @@ async function refreshCommand(options) {
     const auth2 = getStoredAuth();
     if (!auth2) {
       if (quiet) return;
-      console.log(chalk11.red("Not authenticated. Run `caliber login` first."));
+      console.log(chalk12.red("Not authenticated. Run `caliber login` first."));
       throw new Error("__exit__");
     }
     if (isGitRepo()) {
@@ -2909,10 +2981,10 @@ async function refreshCommand(options) {
     const repos = discoverGitRepos(process.cwd());
     if (repos.length === 0) {
       if (quiet) return;
-      console.log(chalk11.red("Not inside a git repository and no git repos found in child directories."));
+      console.log(chalk12.red("Not inside a git repository and no git repos found in child directories."));
       throw new Error("__exit__");
     }
-    log(quiet, chalk11.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
+    log(quiet, chalk12.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
@@ -2922,7 +2994,7 @@ async function refreshCommand(options) {
         await refreshSingleRepo(repo, { ...options, label: repoName });
       } catch (err) {
         if (err instanceof Error && err.message === "__exit__") continue;
-        log(quiet, chalk11.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+        log(quiet, chalk12.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
       }
     }
     process.chdir(originalDir);
@@ -2930,46 +3002,48 @@ async function refreshCommand(options) {
     if (err instanceof Error && err.message === "__exit__") throw err;
     if (quiet) return;
     const msg = err instanceof Error ? err.message : "Unknown error";
-    console.log(chalk11.red(`Refresh failed: ${msg}`));
+    console.log(chalk12.red(`Refresh failed: ${msg}`));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/hooks.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function hooksInstallCommand() {
   const result = installHook();
   if (result.alreadyInstalled) {
-    console.log(chalk12.dim("Hook already installed."));
+    console.log(chalk13.dim("Hook already installed."));
     return;
   }
-  console.log(chalk12.green("\u2713") + " SessionEnd hook installed in .claude/settings.json");
-  console.log(chalk12.dim("  Docs will auto-refresh when Claude Code sessions end."));
+  console.log(chalk13.green("\u2713") + " SessionEnd hook installed in .claude/settings.json");
+  console.log(chalk13.dim("  Docs will auto-refresh when Claude Code sessions end."));
 }
 async function hooksRemoveCommand() {
   const result = removeHook();
   if (result.notFound) {
-    console.log(chalk12.dim("Hook not found."));
+    console.log(chalk13.dim("Hook not found."));
     return;
   }
-  console.log(chalk12.green("\u2713") + " SessionEnd hook removed from .claude/settings.json");
+  console.log(chalk13.green("\u2713") + " SessionEnd hook removed from .claude/settings.json");
 }
 async function hooksStatusCommand() {
   const installed = isHookInstalled();
   if (installed) {
-    console.log(chalk12.green("\u2713") + " Auto-refresh hook is " + chalk12.green("installed"));
+    console.log(chalk13.green("\u2713") + " Auto-refresh hook is " + chalk13.green("installed"));
   } else {
-    console.log(chalk12.dim("\u2717") + " Auto-refresh hook is " + chalk12.yellow("not installed"));
-    console.log(chalk12.dim("  Run `caliber hooks install` to enable auto-refresh on session end."));
+    console.log(chalk13.dim("\u2717") + " Auto-refresh hook is " + chalk13.yellow("not installed"));
+    console.log(chalk13.dim("  Run `caliber hooks install` to enable auto-refresh on session end."));
   }
 }
 
 // src/commands/review.ts
-import chalk13 from "chalk";
-import readline3 from "readline";
+import chalk14 from "chalk";
+import readline2 from "readline";
 import ora10 from "ora";
+import select2 from "@inquirer/select";
+import confirm2 from "@inquirer/confirm";
 function prompt(question) {
-  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -2978,30 +3052,26 @@ function prompt(question) {
   });
 }
 async function promptRating() {
-  console.log(chalk13.bold("\n  How helpful was Caliber in setting up your coding agent?\n"));
-  console.log("  1. Not helpful at all");
-  console.log("  2. Slightly helpful");
-  console.log("  3. Moderately helpful");
-  console.log("  4. Very helpful");
-  console.log("  5. Extremely helpful");
-  while (true) {
-    const answer = await prompt(chalk13.cyan("\n  Rating (1-5): "));
-    const num = parseInt(answer, 10);
-    if (num >= 1 && num <= 5) return num;
-    console.log(chalk13.yellow("  Please enter a number between 1 and 5."));
-  }
+  return select2({
+    message: "How helpful was Caliber in setting up your coding agent?",
+    choices: [
+      { name: "Not helpful at all", value: 1 },
+      { name: "Slightly helpful", value: 2 },
+      { name: "Moderately helpful", value: 3 },
+      { name: "Very helpful", value: 4 },
+      { name: "Extremely helpful", value: 5 }
+    ]
+  });
 }
 async function promptRecommend() {
-  console.log(chalk13.bold("\n  Would you recommend Caliber to a colleague?\n"));
-  console.log("  1. Yes");
-  console.log("  2. No");
-  console.log("  3. Maybe");
-  while (true) {
-    const answer = await prompt(chalk13.cyan("\n  Choose (1-3): "));
-    const map = { "1": "yes", "2": "no", "3": "maybe" };
-    if (map[answer]) return map[answer];
-    console.log(chalk13.yellow("  Please enter 1, 2, or 3."));
-  }
+  return select2({
+    message: "Would you recommend Caliber to a colleague?",
+    choices: [
+      { name: "Yes", value: "yes" },
+      { name: "No", value: "no" },
+      { name: "Maybe", value: "maybe" }
+    ]
+  });
 }
 function starRating(rating) {
   return "\u2605".repeat(rating) + "\u2606".repeat(5 - rating);
@@ -3012,7 +3082,7 @@ async function submitReview(body) {
     await apiRequest("/api/reviews", { method: "POST", body });
     spinner.succeed("Review submitted");
     trackEvent("review_submitted", { rating: body.rating, would_recommend: body.wouldRecommend });
-    console.log(chalk13.green.bold("\n  Thank you for your feedback!\n"));
+    console.log(chalk14.green.bold("\n  Thank you for your feedback!\n"));
   } catch (err) {
     const msg = err instanceof Error ? err.message : "Unknown error";
     spinner.fail(`Failed to submit review: ${msg}`);
@@ -3023,37 +3093,37 @@ async function submitReview(body) {
 async function reviewCommand(message, options) {
   const auth2 = getStoredAuth();
   if (!auth2) {
-    console.log(chalk13.red("\n  Not authenticated. Run `caliber login` first.\n"));
+    console.log(chalk14.red("\n  Not authenticated. Run `caliber login` first.\n"));
     throw new Error("__exit__");
   }
   if (message) {
     const rating2 = options.rating ? parseInt(options.rating, 10) : 5;
     if (rating2 < 1 || rating2 > 5 || isNaN(rating2)) {
-      console.log(chalk13.red("Rating must be between 1 and 5."));
+      console.log(chalk14.red("Rating must be between 1 and 5."));
       throw new Error("__exit__");
     }
-    console.log(chalk13.dim(`
+    console.log(chalk14.dim(`
   ${starRating(rating2)} "${message}"
 `));
     await submitReview({ rating: rating2, bestPart: message, biggestGap: "", wouldRecommend: "yes" });
     return;
   }
-  console.log(chalk13.hex("#6366f1").bold("\n  Share your feedback\n"));
-  console.log(chalk13.dim("  We'd love to hear how Caliber is working for you."));
-  console.log(chalk13.dim("  This takes under 2 minutes.\n"));
-  console.log(chalk13.dim('  Tip: use `caliber review "your feedback"` for a quick review.\n'));
+  console.log(chalk14.hex("#6366f1").bold("\n  Share your feedback\n"));
+  console.log(chalk14.dim("  We'd love to hear how Caliber is working for you."));
+  console.log(chalk14.dim("  This takes under 2 minutes.\n"));
+  console.log(chalk14.dim('  Tip: use `caliber review "your feedback"` for a quick review.\n'));
   const rating = await promptRating();
-  const bestPart = await prompt(chalk13.cyan("\n  What did you find most useful? "));
-  const biggestGap = await prompt(chalk13.cyan("\n  What was missing or could be better? "));
+  const bestPart = await prompt(chalk14.cyan("\n  What did you find most useful? "));
+  const biggestGap = await prompt(chalk14.cyan("\n  What was missing or could be better? "));
   const wouldRecommend = await promptRecommend();
-  console.log(chalk13.bold("\n  Your review:\n"));
+  console.log(chalk14.bold("\n  Your review:\n"));
   console.log(`  Rating:          ${starRating(rating)} (${rating}/5)`);
-  console.log(`  Most useful:     ${bestPart || chalk13.dim("(skipped)")}`);
-  console.log(`  Could be better: ${biggestGap || chalk13.dim("(skipped)")}`);
+  console.log(`  Most useful:     ${bestPart || chalk14.dim("(skipped)")}`);
+  console.log(`  Could be better: ${biggestGap || chalk14.dim("(skipped)")}`);
   console.log(`  Would recommend: ${wouldRecommend}`);
-  const confirm = await prompt(chalk13.cyan("\n  Submit this review? (Y/n): "));
-  if (confirm.toLowerCase() === "n") {
-    console.log(chalk13.dim("\n  Review cancelled.\n"));
+  const shouldSubmit = await confirm2({ message: "Submit this review?", default: true });
+  if (!shouldSubmit) {
+    console.log(chalk14.dim("\n  Review cancelled.\n"));
     return;
   }
   await submitReview({ rating, bestPart, biggestGap, wouldRecommend });
@@ -3087,23 +3157,16 @@ hooks.command("status").description("Check if auto-refresh hook is installed").a
 import fs21 from "fs";
 import path18 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import readline4 from "readline";
 import { execSync as execSync4 } from "child_process";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora11 from "ora";
+import confirm3 from "@inquirer/confirm";
 var __dirname_vc = path18.dirname(fileURLToPath4(import.meta.url));
 var pkg4 = JSON.parse(
   fs21.readFileSync(path18.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
-function promptYesNo(question) {
-  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
-    rl.question(chalk14.cyan(`${question} `), (answer) => {
-      rl.close();
-      const normalized = answer.trim().toLowerCase();
-      resolve2(normalized === "" || normalized === "y" || normalized === "yes");
-    });
-  });
+async function promptYesNo(question) {
+  return confirm3({ message: question, default: true });
 }
 async function checkForUpdates() {
   if (process.env.CALIBER_SKIP_UPDATE_CHECK) return;
@@ -3123,17 +3186,17 @@ async function checkForUpdates() {
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk14.yellow(
+        chalk15.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk14.bold("npm install -g @caliber-ai/cli")} to upgrade.
+Run ${chalk15.bold("npm install -g @caliber-ai/cli")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk14.yellow(`
+      chalk15.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await promptYesNo("Would you like to update now? (Y/n)");
@@ -3144,9 +3207,9 @@ Update available: ${current} -> ${latest}`)
     const spinner = ora11("Updating @caliber-ai/cli...").start();
     try {
       execSync4("npm install -g @caliber-ai/cli --force", { stdio: "pipe" });
-      spinner.succeed(chalk14.green(`Updated to ${latest}`));
+      spinner.succeed(chalk15.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk14.dim(`
+      console.log(chalk15.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync4(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -3157,8 +3220,8 @@ Restarting: caliber ${args.join(" ")}
     } catch {
       spinner.fail("Update failed");
       console.log(
-        chalk14.yellow(
-          `Run ${chalk14.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
+        chalk15.yellow(
+          `Run ${chalk15.bold("npm install -g @caliber-ai/cli")} manually to upgrade.
 `
         )
       );