@rely-ai/caliber 1.1.0 → 1.1.2

package/dist/bin.js

@@ -32,17 +32,17 @@ __export(constants_exports, {
   LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
-import path10 from "path";
+import path8 from "path";
 import os2 from "os";
 var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    AUTH_DIR = path10.join(os2.homedir(), ".caliber");
+    AUTH_DIR = path8.join(os2.homedir(), ".caliber");
     CALIBER_DIR = ".caliber";
-    MANIFEST_FILE = path10.join(CALIBER_DIR, "manifest.json");
-    BACKUPS_DIR = path10.join(CALIBER_DIR, "backups");
-    LEARNING_DIR = path10.join(CALIBER_DIR, "learning");
+    MANIFEST_FILE = path8.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path8.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path8.join(CALIBER_DIR, "learning");
     LEARNING_SESSION_FILE = "current-session.jsonl";
     LEARNING_STATE_FILE = "state.json";
     LEARNING_MAX_EVENTS = 500;
@@ -52,19 +52,19 @@ var init_constants = __esm({
 // src/cli.ts
 import { Command } from "commander";
 import fs25 from "fs";
-import path22 from "path";
+import path21 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
-import chalk4 from "chalk";
-import ora from "ora";
-import readline3 from "readline";
+import chalk5 from "chalk";
+import ora2 from "ora";
+import readline4 from "readline";
 import select2 from "@inquirer/select";
 import fs18 from "fs";
 
 // src/fingerprint/index.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path5 from "path";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -91,54 +91,9 @@ function isGitRepo() {
   return isInsideGitRepo();
 }
 
-// src/fingerprint/package-json.ts
+// src/fingerprint/file-tree.ts
 import fs from "fs";
 import path from "path";
-import { globSync } from "glob";
-var WORKSPACE_GLOBS = [
-  "apps/*/package.json",
-  "packages/*/package.json",
-  "services/*/package.json",
-  "libs/*/package.json"
-];
-function analyzePackageJson(dir) {
-  const rootPkgPath = path.join(dir, "package.json");
-  let name;
-  const languages = [];
-  if (fs.existsSync(rootPkgPath)) {
-    try {
-      const pkg3 = JSON.parse(fs.readFileSync(rootPkgPath, "utf-8"));
-      name = pkg3.name;
-      const allDeps = { ...pkg3.dependencies, ...pkg3.devDependencies };
-      if (allDeps.typescript || allDeps["@types/node"]) {
-        languages.push("TypeScript");
-      }
-      languages.push("JavaScript");
-    } catch {
-    }
-  }
-  for (const glob of WORKSPACE_GLOBS) {
-    const matches = globSync(glob, { cwd: dir, absolute: true });
-    for (const pkgPath of matches) {
-      try {
-        const pkg3 = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        const deps = { ...pkg3.dependencies, ...pkg3.devDependencies };
-        if (deps.typescript || deps["@types/node"]) {
-          languages.push("TypeScript");
-        }
-      } catch {
-      }
-    }
-  }
-  return {
-    name,
-    languages: [...new Set(languages)]
-  };
-}
-
-// src/fingerprint/file-tree.ts
-import fs2 from "fs";
-import path2 from "path";
 var IGNORE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -161,10 +116,10 @@ function getFileTree(dir, maxDepth = 3) {
 }
 function scan(base, rel, depth, maxDepth, result) {
   if (depth > maxDepth) return;
-  const fullPath = path2.join(base, rel);
+  const fullPath = path.join(base, rel);
   let entries;
   try {
-    entries = fs2.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -181,122 +136,87 @@ function scan(base, rel, depth, maxDepth, result) {
   }
 }
 
-// src/fingerprint/languages.ts
-import path3 from "path";
-var EXT_TO_LANG = {
-  ".ts": "TypeScript",
-  ".tsx": "TypeScript",
-  ".js": "JavaScript",
-  ".jsx": "JavaScript",
-  ".py": "Python",
-  ".go": "Go",
-  ".rs": "Rust",
-  ".rb": "Ruby",
-  ".java": "Java",
-  ".kt": "Kotlin",
-  ".swift": "Swift",
-  ".cs": "C#",
-  ".cpp": "C++",
-  ".c": "C",
-  ".php": "PHP",
-  ".dart": "Dart",
-  ".ex": "Elixir",
-  ".exs": "Elixir",
-  ".scala": "Scala",
-  ".zig": "Zig"
-};
-function detectLanguages(fileTree) {
-  const langs = /* @__PURE__ */ new Set();
-  for (const file of fileTree) {
-    const ext = path3.extname(file).toLowerCase();
-    if (EXT_TO_LANG[ext]) {
-      langs.add(EXT_TO_LANG[ext]);
-    }
-  }
-  return [...langs];
-}
-
 // src/fingerprint/existing-config.ts
-import fs3 from "fs";
-import path4 from "path";
+import fs2 from "fs";
+import path2 from "path";
 function readExistingConfigs(dir) {
   const configs = {};
-  const readmeMdPath = path4.join(dir, "README.md");
-  if (fs3.existsSync(readmeMdPath)) {
-    configs.readmeMd = fs3.readFileSync(readmeMdPath, "utf-8");
+  const readmeMdPath = path2.join(dir, "README.md");
+  if (fs2.existsSync(readmeMdPath)) {
+    configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
   }
-  const claudeMdPath = path4.join(dir, "CLAUDE.md");
-  if (fs3.existsSync(claudeMdPath)) {
-    configs.claudeMd = fs3.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path2.join(dir, "CLAUDE.md");
+  if (fs2.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path4.join(dir, ".claude", "settings.json");
-  if (fs3.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = path2.join(dir, ".claude", "settings.json");
+  if (fs2.existsSync(claudeSettingsPath)) {
     try {
-      configs.claudeSettings = JSON.parse(fs3.readFileSync(claudeSettingsPath, "utf-8"));
+      configs.claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path4.join(dir, ".claude", "skills");
-  if (fs3.existsSync(skillsDir)) {
+  const skillsDir = path2.join(dir, ".claude", "skills");
+  if (fs2.existsSync(skillsDir)) {
     try {
-      const entries = fs3.readdirSync(skillsDir);
+      const entries = fs2.readdirSync(skillsDir);
       const skills = [];
       for (const entry of entries) {
-        const entryPath = path4.join(skillsDir, entry);
-        const skillMdPath = path4.join(entryPath, "SKILL.md");
-        if (fs3.statSync(entryPath).isDirectory() && fs3.existsSync(skillMdPath)) {
-          skills.push({ filename: `${entry}/SKILL.md`, content: fs3.readFileSync(skillMdPath, "utf-8") });
+        const entryPath = path2.join(skillsDir, entry);
+        const skillMdPath = path2.join(entryPath, "SKILL.md");
+        if (fs2.statSync(entryPath).isDirectory() && fs2.existsSync(skillMdPath)) {
+          skills.push({ filename: `${entry}/SKILL.md`, content: fs2.readFileSync(skillMdPath, "utf-8") });
         } else if (entry.endsWith(".md")) {
-          skills.push({ filename: entry, content: fs3.readFileSync(entryPath, "utf-8") });
+          skills.push({ filename: entry, content: fs2.readFileSync(entryPath, "utf-8") });
         }
       }
       if (skills.length > 0) configs.claudeSkills = skills;
     } catch {
     }
   }
-  const cursorrulesPath = path4.join(dir, ".cursorrules");
-  if (fs3.existsSync(cursorrulesPath)) {
-    configs.cursorrules = fs3.readFileSync(cursorrulesPath, "utf-8");
+  const cursorrulesPath = path2.join(dir, ".cursorrules");
+  if (fs2.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs2.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path4.join(dir, ".cursor", "rules");
-  if (fs3.existsSync(cursorRulesDir)) {
+  const cursorRulesDir = path2.join(dir, ".cursor", "rules");
+  if (fs2.existsSync(cursorRulesDir)) {
     try {
-      const files = fs3.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
+      const files = fs2.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs3.readFileSync(path4.join(cursorRulesDir, f), "utf-8")
+        content: fs2.readFileSync(path2.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorSkillsDir = path4.join(dir, ".cursor", "skills");
-  if (fs3.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path2.join(dir, ".cursor", "skills");
+  if (fs2.existsSync(cursorSkillsDir)) {
     try {
-      const slugs = fs3.readdirSync(cursorSkillsDir).filter((f) => {
-        return fs3.statSync(path4.join(cursorSkillsDir, f)).isDirectory();
+      const slugs = fs2.readdirSync(cursorSkillsDir).filter((f) => {
+        return fs2.statSync(path2.join(cursorSkillsDir, f)).isDirectory();
       });
-      configs.cursorSkills = slugs.filter((slug) => fs3.existsSync(path4.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
+      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path2.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
         name,
         filename: "SKILL.md",
-        content: fs3.readFileSync(path4.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
+        content: fs2.readFileSync(path2.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
       }));
     } catch {
     }
   }
-  const mcpJsonPath = path4.join(dir, ".mcp.json");
-  if (fs3.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path2.join(dir, ".mcp.json");
+  if (fs2.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs3.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         configs.claudeMcpServers = mcpJson.mcpServers;
       }
     } catch {
     }
   }
-  const cursorMcpPath = path4.join(dir, ".cursor", "mcp.json");
-  if (fs3.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path2.join(dir, ".cursor", "mcp.json");
+  if (fs2.existsSync(cursorMcpPath)) {
     try {
-      const cursorMcpJson = JSON.parse(fs3.readFileSync(cursorMcpPath, "utf-8"));
+      const cursorMcpJson = JSON.parse(fs2.readFileSync(cursorMcpPath, "utf-8"));
       if (cursorMcpJson.mcpServers) {
         configs.cursorMcpServers = cursorMcpJson.mcpServers;
       }
@@ -307,8 +227,8 @@ function readExistingConfigs(dir) {
 }
 
 // src/fingerprint/code-analysis.ts
-import fs4 from "fs";
-import path5 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var IGNORE_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -379,16 +299,16 @@ function analyzeCode(dir) {
   let truncated = false;
   const fileSummaries = [];
   for (const relPath of sourceFiles) {
-    const fullPath = path5.join(dir, relPath);
+    const fullPath = path3.join(dir, relPath);
     let content;
     try {
-      content = fs4.readFileSync(fullPath, "utf-8");
+      content = fs3.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
     const lineCount = content.split("\n").length;
     if (lineCount > 500) continue;
-    const ext = path5.extname(relPath);
+    const ext = path3.extname(relPath);
     const language = resolveLanguage(ext);
     if (!language) continue;
     const summary = language === "py" ? extractPython(relPath, content) : extractTypeScriptJavaScript(relPath, content, language);
@@ -404,10 +324,10 @@ function analyzeCode(dir) {
 }
 function walkDir(base, rel, depth, maxDepth, sourceFiles, configFiles, rootDir) {
   if (depth > maxDepth) return;
-  const fullPath = path5.join(base, rel);
+  const fullPath = path3.join(base, rel);
   let entries;
   try {
-    entries = fs4.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs3.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -426,12 +346,12 @@ function walkDir(base, rel, depth, maxDepth, sourceFiles, configFiles, rootDir)
     } else {
       if (CONFIG_FILE_NAMES.has(entry.name)) {
         try {
-          const content = fs4.readFileSync(path5.join(base, relPath), "utf-8");
+          const content = fs3.readFileSync(path3.join(base, relPath), "utf-8");
           configFiles.push({ path: relPath, content });
         } catch {
         }
       }
-      const ext = path5.extname(entry.name);
+      const ext = path3.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext) && !entry.name.endsWith(".d.ts")) {
         sourceFiles.push(relPath);
       }
@@ -439,10 +359,10 @@ function walkDir(base, rel, depth, maxDepth, sourceFiles, configFiles, rootDir)
   }
 }
 function collectConfigsFromDir(base, relDir, pattern, configFiles) {
-  const fullDir = path5.join(base, relDir);
+  const fullDir = path3.join(base, relDir);
   let entries;
   try {
-    entries = fs4.readdirSync(fullDir, { withFileTypes: true });
+    entries = fs3.readdirSync(fullDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -450,7 +370,7 @@ function collectConfigsFromDir(base, relDir, pattern, configFiles) {
     if (entry.isFile() && pattern.test(entry.name)) {
       const relPath = `${relDir}/${entry.name}`;
       try {
-        const content = fs4.readFileSync(path5.join(base, relPath), "utf-8");
+        const content = fs3.readFileSync(path3.join(base, relPath), "utf-8");
         configFiles.push({ path: relPath, content });
       } catch {
       }
@@ -464,7 +384,7 @@ function sortByPriority(files) {
   const servicePattern = /(service|lib|utils)/i;
   const testPattern = /(test|spec|__tests__)/i;
   function priority(filePath) {
-    const base = path5.basename(filePath);
+    const base = path3.basename(filePath);
     if (entryPointNames.has(base)) return 0;
     if (routePattern.test(filePath)) return 1;
     if (schemaPattern.test(filePath)) return 2;
@@ -583,11 +503,11 @@ function estimateSummarySize(summary) {
 }
 
 // src/llm/config.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import os from "os";
-var CONFIG_DIR = path6.join(os.homedir(), ".caliber");
-var CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path4.join(os.homedir(), ".caliber");
+var CONFIG_FILE = path4.join(CONFIG_DIR, "config.json");
 var DEFAULT_MODELS = {
   anthropic: "claude-sonnet-4-6",
   vertex: "claude-sonnet-4-6",
@@ -641,8 +561,8 @@ function resolveFromEnv() {
 }
 function readConfigFile() {
   try {
-    if (!fs5.existsSync(CONFIG_FILE)) return null;
-    const raw = fs5.readFileSync(CONFIG_FILE, "utf-8");
+    if (!fs4.existsSync(CONFIG_FILE)) return null;
+    const raw = fs4.readFileSync(CONFIG_FILE, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
       return null;
@@ -653,18 +573,21 @@ function readConfigFile() {
   }
 }
 function writeConfigFile(config) {
-  if (!fs5.existsSync(CONFIG_DIR)) {
-    fs5.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs4.existsSync(CONFIG_DIR)) {
+    fs4.mkdirSync(CONFIG_DIR, { recursive: true });
   }
   const sanitized = { ...config };
   if (sanitized.apiKey) {
     sanitized.apiKey = sanitized.apiKey.trim();
   }
-  fs5.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
+  fs4.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
 }
 function getConfigFilePath() {
   return CONFIG_FILE;
 }
+function getFastModel() {
+  return process.env.CALIBER_FAST_MODEL || process.env.ANTHROPIC_SMALL_FAST_MODEL || void 0;
+}
 
 // src/llm/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";
@@ -710,7 +633,7 @@ var AnthropicProvider = class {
 };
 
 // src/llm/vertex.ts
-import fs6 from "fs";
+import fs5 from "fs";
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
 import { GoogleAuth } from "google-auth-library";
 var VertexProvider = class {
@@ -733,7 +656,7 @@ var VertexProvider = class {
         }
       } else {
         try {
-          creds = JSON.parse(fs6.readFileSync(raw, "utf-8"));
+          creds = JSON.parse(fs5.readFileSync(raw, "utf-8"));
         } catch {
           throw new Error(`Cannot read credentials file: ${raw}`);
         }
@@ -1470,22 +1393,26 @@ All markdown content inside string values must be properly escaped for JSON (new
 
 If there's nothing worth learning from the events (routine successful operations), return:
 {"claudeMdLearnedSection": null, "skills": null, "explanations": ["No actionable patterns found in these events."]}`;
-var FINGERPRINT_SYSTEM_PROMPT = `You are an expert at detecting programming languages and frameworks from project file trees and dependency files.
+var FINGERPRINT_SYSTEM_PROMPT = `You are an expert at detecting programming languages, frameworks, and external tools/services from project file trees and dependency files.
 
 Analyze the provided file tree and dependency file contents. Return a JSON object with:
-- "languages": array of programming languages used (e.g. "TypeScript", "Python", "Go", "Rust")
-- "frameworks": array of frameworks and key libraries detected (e.g. "FastAPI", "React", "Celery", "Django", "Express", "Next.js")
+- "languages": array of programming languages used (e.g. "TypeScript", "Python", "Go", "Rust", "HCL")
+- "frameworks": array of frameworks and key libraries detected (e.g. "FastAPI", "React", "Celery", "Django", "Express", "Next.js", "Terraform")
+- "tools": array of external tools, services, and platforms the project integrates with \u2014 things that could have an MCP server or API integration (e.g. "PostgreSQL", "Redis", "Stripe", "Sentry", "AWS", "GCP", "GitHub", "Slack", "Docker", "Kubernetes", "Datadog", "PagerDuty", "MongoDB", "Elasticsearch")
 
 Be thorough \u2014 look for signals in:
 - Dependency files (package.json, pyproject.toml, requirements.txt, go.mod, Cargo.toml, etc.)
 - File extensions and directory structure
-- Configuration files (e.g. next.config.js implies Next.js)
+- Configuration files (e.g. next.config.js implies Next.js, .tf files imply Terraform + cloud providers)
+- Infrastructure-as-code files (Terraform, CloudFormation, Pulumi, Dockerfiles, k8s manifests)
+- CI/CD configs (.github/workflows, .gitlab-ci.yml, Jenkinsfile)
+- Environment variable patterns and service references in code
 
-Only include frameworks/languages you're confident about. Return ONLY the JSON object.`;
+Only include items you're confident about. Return ONLY the JSON object.`;
 
 // src/ai/detect.ts
-async function detectFrameworks(fileTree, fileContents) {
-  const parts = ["Analyze this project and detect languages and frameworks.\n"];
+async function detectProjectStack(fileTree, fileContents) {
+  const parts = ["Analyze this project and detect languages, frameworks, and external tools/services.\n"];
   if (fileTree.length > 0) {
     parts.push("File tree:");
     parts.push(fileTree.join("\n"));
@@ -1498,7 +1425,7 @@ async function detectFrameworks(fileTree, fileContents) {
       parts.push(content);
     }
   }
-  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const fastModel = getFastModel();
   const result = await llmJsonCall({
     system: FINGERPRINT_SYSTEM_PROMPT,
     prompt: parts.join("\n"),
@@ -1506,29 +1433,39 @@ async function detectFrameworks(fileTree, fileContents) {
   });
   return {
     languages: Array.isArray(result.languages) ? result.languages : [],
-    frameworks: Array.isArray(result.frameworks) ? result.frameworks : []
+    frameworks: Array.isArray(result.frameworks) ? result.frameworks : [],
+    tools: Array.isArray(result.tools) ? result.tools : []
   };
 }
 
 // src/fingerprint/index.ts
 function collectFingerprint(dir) {
   const gitRemoteUrl = getGitRemoteUrl();
-  const pkgInfo = analyzePackageJson(dir);
   const fileTree = getFileTree(dir);
-  const fileLangs = detectLanguages(fileTree);
   const existingConfigs = readExistingConfigs(dir);
   const codeAnalysis = analyzeCode(dir);
-  const languages = [.../* @__PURE__ */ new Set([...pkgInfo.languages, ...fileLangs])];
+  const packageName = readPackageName(dir);
   return {
     gitRemoteUrl,
-    packageName: pkgInfo.name,
-    languages,
+    packageName,
+    languages: [],
     frameworks: [],
+    tools: [],
     fileTree,
     existingConfigs,
     codeAnalysis
   };
 }
+function readPackageName(dir) {
+  try {
+    const pkgPath = path5.join(dir, "package.json");
+    if (!fs6.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    return pkg3.name;
+  } catch {
+    return void 0;
+  }
+}
 var DEP_FILE_PATTERNS = [
   "package.json",
   "pyproject.toml",
@@ -1550,12 +1487,12 @@ async function enrichFingerprintWithLLM(fingerprint, dir) {
     const fileContents = {};
     let totalSize = 0;
     for (const treePath of fingerprint.fileTree) {
-      const basename = path7.basename(treePath);
+      const basename = path5.basename(treePath);
       if (!DEP_FILE_PATTERNS.includes(basename)) continue;
-      const fullPath = path7.join(dir, treePath);
-      if (!fs7.existsSync(fullPath)) continue;
+      const fullPath = path5.join(dir, treePath);
+      if (!fs6.existsSync(fullPath)) continue;
       try {
-        const content = fs7.readFileSync(fullPath, "utf-8");
+        const content = fs6.readFileSync(fullPath, "utf-8");
         if (totalSize + content.length > MAX_CONTENT_SIZE) break;
         fileContents[treePath] = content;
         totalSize += content.length;
@@ -1564,7 +1501,7 @@ async function enrichFingerprintWithLLM(fingerprint, dir) {
       }
     }
     if (Object.keys(fileContents).length === 0 && fingerprint.fileTree.length === 0) return;
-    const result = await detectFrameworks(fingerprint.fileTree, fileContents);
+    const result = await detectProjectStack(fingerprint.fileTree, fileContents);
     if (result.languages?.length) {
       const langSet = new Set(fingerprint.languages);
       for (const lang of result.languages) langSet.add(lang);
@@ -1575,6 +1512,11 @@ async function enrichFingerprintWithLLM(fingerprint, dir) {
       for (const fw of result.frameworks) fwSet.add(fw);
       fingerprint.frameworks = [...fwSet];
     }
+    if (result.tools?.length) {
+      const toolSet = new Set(fingerprint.tools);
+      for (const tool of result.tools) toolSet.add(tool);
+      fingerprint.tools = [...toolSet];
+    }
   } catch {
   }
 }
@@ -1875,20 +1817,20 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
 }
 
 // src/writers/index.ts
-import fs12 from "fs";
+import fs11 from "fs";
 
 // src/writers/claude/index.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs7 from "fs";
+import path6 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs8.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs7.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path8.join(".claude", "skills", skill.name);
-      if (!fs8.existsSync(skillDir)) fs8.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path8.join(skillDir, "SKILL.md");
+      const skillDir = path6.join(".claude", "skills", skill.name);
+      if (!fs7.existsSync(skillDir)) fs7.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path6.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -1896,49 +1838,49 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs8.writeFileSync(skillPath, frontmatter + skill.content);
+      fs7.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs8.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs8.readFileSync(".mcp.json", "utf-8"));
+      if (fs7.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs7.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs8.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs7.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 path9 from "path";
+import fs8 from "fs";
+import path7 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs9.writeFileSync(".cursorrules", config.cursorrules);
+    fs8.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path9.join(".cursor", "rules");
-    if (!fs9.existsSync(rulesDir)) fs9.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path7.join(".cursor", "rules");
+    if (!fs8.existsSync(rulesDir)) fs8.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path9.join(rulesDir, rule.filename);
-      fs9.writeFileSync(rulePath, rule.content);
+      const rulePath = path7.join(rulesDir, rule.filename);
+      fs8.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path9.join(".cursor", "skills", skill.name);
-      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path9.join(skillDir, "SKILL.md");
+      const skillDir = path7.join(".cursor", "skills", skill.name);
+      if (!fs8.existsSync(skillDir)) fs8.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path7.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -1946,24 +1888,24 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs9.writeFileSync(skillPath, frontmatter + skill.content);
+      fs8.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs9.existsSync(cursorDir)) fs9.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path9.join(cursorDir, "mcp.json");
+    if (!fs8.existsSync(cursorDir)) fs8.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path7.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs9.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs9.readFileSync(mcpPath, "utf-8"));
+      if (fs8.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs9.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs8.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -1971,62 +1913,62 @@ function writeCursorConfig(config) {
 
 // src/writers/backup.ts
 init_constants();
-import fs10 from "fs";
-import path11 from "path";
+import fs9 from "fs";
+import path9 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path11.join(BACKUPS_DIR, timestamp);
+  const backupDir = path9.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 (!fs9.existsSync(file)) continue;
+    const dest = path9.join(backupDir, file);
+    const destDir = path9.dirname(dest);
+    if (!fs9.existsSync(destDir)) {
+      fs9.mkdirSync(destDir, { recursive: true });
     }
-    fs10.copyFileSync(file, dest);
+    fs9.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 = path9.join(backupDir, file);
+  if (!fs9.existsSync(backupFile)) return false;
+  const destDir = path9.dirname(file);
+  if (!fs9.existsSync(destDir)) {
+    fs9.mkdirSync(destDir, { recursive: true });
   }
-  fs10.copyFileSync(backupFile, file);
+  fs9.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs11 from "fs";
+import fs10 from "fs";
 import crypto from "crypto";
 function readManifest() {
   try {
-    if (!fs11.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs11.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs10.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs10.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs11.existsSync(CALIBER_DIR)) {
-    fs11.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs10.existsSync(CALIBER_DIR)) {
+    fs10.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs11.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs10.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs11.readFileSync(filePath);
+  const content = fs10.readFileSync(filePath);
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs12.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs11.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs12.existsSync(f)),
+    ...filesToWrite.filter((f) => fs11.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -2039,7 +1981,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs12.unlinkSync(filePath);
+    fs11.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -2069,8 +2011,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 (fs11.existsSync(entry.path)) {
+        fs11.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -2080,8 +2022,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs12.existsSync(MANIFEST_FILE2)) {
-    fs12.unlinkSync(MANIFEST_FILE2);
+  if (fs11.existsSync(MANIFEST_FILE2)) {
+    fs11.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -2110,23 +2052,23 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs12.existsSync(gitignorePath)) {
-    const content = fs12.readFileSync(gitignorePath, "utf-8");
+  if (fs11.existsSync(gitignorePath)) {
+    const content = fs11.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs12.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs11.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs12.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs11.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
 init_constants();
-import fs13 from "fs";
-import path12 from "path";
-var STAGED_DIR = path12.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path12.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path12.join(STAGED_DIR, "current");
+import fs12 from "fs";
+import path10 from "path";
+var STAGED_DIR = path10.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path10.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path10.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -2136,20 +2078,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path12.join(projectDir, file.path);
-    if (fs13.existsSync(originalPath)) {
-      const existing = fs13.readFileSync(originalPath, "utf-8");
+    const originalPath = path10.join(projectDir, file.path);
+    if (fs12.existsSync(originalPath)) {
+      const existing = fs12.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path12.join(PROPOSED_DIR, file.path);
-    fs13.mkdirSync(path12.dirname(proposedPath), { recursive: true });
-    fs13.writeFileSync(proposedPath, file.content);
-    if (fs13.existsSync(originalPath)) {
-      const currentPath = path12.join(CURRENT_DIR, file.path);
-      fs13.mkdirSync(path12.dirname(currentPath), { recursive: true });
-      fs13.copyFileSync(originalPath, currentPath);
+    const proposedPath = path10.join(PROPOSED_DIR, file.path);
+    fs12.mkdirSync(path10.dirname(proposedPath), { recursive: true });
+    fs12.writeFileSync(proposedPath, file.content);
+    if (fs12.existsSync(originalPath)) {
+      const currentPath = path10.join(CURRENT_DIR, file.path);
+      fs12.mkdirSync(path10.dirname(currentPath), { recursive: true });
+      fs12.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -2160,8 +2102,8 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs13.existsSync(STAGED_DIR)) {
-    fs13.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs12.existsSync(STAGED_DIR)) {
+    fs12.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
@@ -2207,24 +2149,24 @@ function openDiffsInEditor(editor, files) {
 import { createTwoFilesPatch } from "diff";
 
 // src/lib/hooks.ts
-import fs14 from "fs";
-import path13 from "path";
+import fs13 from "fs";
+import path11 from "path";
 import { execSync as execSync5 } from "child_process";
-var SETTINGS_PATH = path13.join(".claude", "settings.json");
+var SETTINGS_PATH = path11.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function readSettings() {
-  if (!fs14.existsSync(SETTINGS_PATH)) return {};
+  if (!fs13.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path13.dirname(SETTINGS_PATH);
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-  fs14.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path11.dirname(SETTINGS_PATH);
+  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
+  fs13.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -2282,19 +2224,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync5("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path13.join(gitDir, "hooks");
+    return path11.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path11.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs14.existsSync(hookPath)) return false;
-  const content = fs14.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs13.existsSync(hookPath)) return false;
+  const content = fs13.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -2303,43 +2245,43 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path13.dirname(hookPath);
-  if (!fs14.existsSync(hooksDir)) fs14.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path11.dirname(hookPath);
+  if (!fs13.existsSync(hooksDir)) fs13.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs14.existsSync(hookPath)) {
-    content = fs14.readFileSync(hookPath, "utf-8");
+  if (fs13.existsSync(hookPath)) {
+    content = fs13.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + PRECOMMIT_BLOCK + "\n";
   } else {
     content = "#!/bin/sh\n\n" + PRECOMMIT_BLOCK + "\n";
   }
-  fs14.writeFileSync(hookPath, content);
-  fs14.chmodSync(hookPath, 493);
+  fs13.writeFileSync(hookPath, content);
+  fs13.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs14.existsSync(hookPath)) {
+  if (!hookPath || !fs13.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs14.readFileSync(hookPath, "utf-8");
+  let content = fs13.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs14.unlinkSync(hookPath);
+    fs13.unlinkSync(hookPath);
   } else {
-    fs14.writeFileSync(hookPath, content);
+    fs13.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs15 from "fs";
-import path14 from "path";
-var SETTINGS_PATH2 = path14.join(".claude", "settings.json");
+import fs14 from "fs";
+import path12 from "path";
+var SETTINGS_PATH2 = path12.join(".claude", "settings.json");
 var HOOK_CONFIGS = [
   {
     event: "PostToolUse",
@@ -2358,17 +2300,17 @@ var HOOK_CONFIGS = [
   }
 ];
 function readSettings2() {
-  if (!fs15.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs14.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs15.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs14.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path14.dirname(SETTINGS_PATH2);
-  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
-  fs15.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path12.dirname(SETTINGS_PATH2);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, command) {
   return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
@@ -2425,23 +2367,23 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs16 from "fs";
-import path15 from "path";
+import fs15 from "fs";
+import path13 from "path";
 import { execSync as execSync6 } from "child_process";
-var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path13.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
-    if (!fs16.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs16.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 (!fs16.existsSync(CALIBER_DIR)) {
-    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs15.existsSync(CALIBER_DIR)) {
+    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs16.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs15.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -2724,15 +2666,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path24) {
+function readFileOrNull(path23) {
   try {
-    return readFileSync(path24, "utf-8");
+    return readFileSync(path23, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path24) {
-  const content = readFileOrNull(path24);
+function readJsonOrNull(path23) {
+  const content = readFileOrNull(path23);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3088,9 +3030,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path24) {
+function readFileOrNull2(path23) {
   try {
-    return readFileSync3(path24, "utf-8");
+    return readFileSync3(path23, "utf-8");
   } catch {
     return null;
   }
@@ -3241,15 +3183,15 @@ function checkQuality(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import { join as join4 } from "path";
-function readFileOrNull3(path24) {
+function readFileOrNull3(path23) {
   try {
-    return readFileSync4(path24, "utf-8");
+    return readFileSync4(path23, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path24) {
-  const content = readFileOrNull3(path24);
+function readJsonOrNull2(path23) {
+  const content = readFileOrNull3(path23);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3432,9 +3374,9 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-function readFileOrNull4(path24) {
+function readFileOrNull4(path23) {
   try {
-    return readFileSync5(path24, "utf-8");
+    return readFileSync5(path23, "utf-8");
   } catch {
     return null;
   }
@@ -3544,9 +3486,9 @@ function checkFreshness(dir) {
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
 import { execSync as execSync7 } from "child_process";
 import { join as join6 } from "path";
-function readFileOrNull5(path24) {
+function readFileOrNull5(path23) {
   try {
-    return readFileSync6(path24, "utf-8");
+    return readFileSync6(path23, "utf-8");
   } catch {
     return null;
   }
@@ -3641,22 +3583,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs17 from "fs";
-import path16 from "path";
-var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+import fs16 from "fs";
+import path14 from "path";
+var DISMISSED_FILE = path14.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs17.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs17.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs16.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs16.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs17.existsSync(CALIBER_DIR)) {
-    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs16.existsSync(CALIBER_DIR)) {
+    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs17.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs16.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -3853,10 +3795,502 @@ function displayScoreDelta(before, after) {
   }
 }
 
+// src/mcp/index.ts
+import chalk4 from "chalk";
+import ora from "ora";
+import readline3 from "readline";
+import fs17 from "fs";
+import path15 from "path";
+
+// src/mcp/search.ts
+var AWESOME_MCP_URL = "https://raw.githubusercontent.com/punkpeye/awesome-mcp-servers/main/README.md";
+var GITHUB_SEARCH_URL = "https://github.com/search";
+var SEARCH_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Accept": "text/html"
+};
+function parseGitHubSearchHtml(html) {
+  try {
+    const scriptMatch = html.match(/<script type="application\/json" data-target="react-app\.embeddedData">([\s\S]*?)<\/script>/);
+    if (!scriptMatch) {
+      return [];
+    }
+    const data = JSON.parse(scriptMatch[1]);
+    const results = data?.payload?.results;
+    if (!Array.isArray(results)) {
+      return [];
+    }
+    return results.map((r) => {
+      const repo = r.repo?.repository;
+      const ownerLogin = repo?.owner_login || "";
+      const name = repo?.name || "";
+      const description = typeof r.hl_trunc_description === "string" ? r.hl_trunc_description.replace(/<\/?em>/g, "") : null;
+      return {
+        full_name: `${ownerLogin}/${name}`,
+        description,
+        stargazers_count: typeof r.followers === "number" ? r.followers : 0,
+        pushed_at: repo?.updated_at || "",
+        owner_login: ownerLogin
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function searchAllMcpSources(toolDeps) {
+  if (toolDeps.length === 0) return [];
+  const searches = [
+    searchAwesomeMcpLists(toolDeps),
+    ...toolDeps.map((dep) => searchGitHub(dep)),
+    ...toolDeps.map((dep) => searchVendorOrg(dep))
+  ];
+  const results = await Promise.all(searches);
+  const seen = /* @__PURE__ */ new Map();
+  for (const batch of results) {
+    for (const candidate of batch) {
+      const key = candidate.repoFullName.toLowerCase();
+      const existing = seen.get(key);
+      if (!existing || candidate.vendor || candidate.stars > existing.stars) {
+        seen.set(key, candidate);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+async function searchAwesomeMcpLists(toolDeps) {
+  try {
+    const resp = await fetch(AWESOME_MCP_URL, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok) return [];
+    const markdown = await resp.text();
+    const candidates = [];
+    const depLower = toolDeps.map((d) => d.toLowerCase().replace(/^@[^/]+\//, ""));
+    const itemPattern = /^[-*]\s+\[([^\]]+)\]\(([^)]+)\)\s*[-–—:]\s*(.*)/gm;
+    let match;
+    while ((match = itemPattern.exec(markdown)) !== null) {
+      const [, name, url, description] = match;
+      if (!url.includes("github.com")) continue;
+      const text = `${name} ${description}`.toLowerCase();
+      const matchedDep = depLower.find((d) => text.includes(d));
+      if (!matchedDep) continue;
+      const repoMatch = url.match(/github\.com\/([^/]+\/[^/]+)/);
+      if (!repoMatch) continue;
+      candidates.push({
+        name: name.trim(),
+        repoFullName: repoMatch[1],
+        url: url.trim(),
+        description: description.trim().slice(0, 200),
+        stars: 0,
+        lastPush: "",
+        vendor: false,
+        score: 0,
+        reason: "",
+        matchedDep: toolDeps.find((d) => d.toLowerCase().replace(/^@[^/]+\//, "") === matchedDep) || matchedDep
+      });
+    }
+    return candidates;
+  } catch {
+    return [];
+  }
+}
+async function searchGitHub(dep) {
+  const depName = dep.replace(/^@[^/]+\//, "");
+  try {
+    const query = encodeURIComponent(`${depName} mcp server`);
+    const url = `${GITHUB_SEARCH_URL}?q=${query}&type=repositories&s=stars&o=desc`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: SEARCH_HEADERS
+    });
+    if (!resp.ok) return [];
+    const html = await resp.text();
+    const repos = parseGitHubSearchHtml(html).slice(0, 5);
+    return repos.map((repo) => ({
+      name: repo.full_name.split("/")[1],
+      repoFullName: repo.full_name,
+      url: `https://github.com/${repo.full_name}`,
+      description: repo.description || "",
+      stars: repo.stargazers_count,
+      lastPush: repo.pushed_at,
+      vendor: false,
+      score: 0,
+      reason: "",
+      matchedDep: dep
+    }));
+  } catch {
+    return [];
+  }
+}
+async function searchVendorOrg(dep) {
+  const depName = dep.replace(/^@([^/]+)\/.*/, "$1").replace(/^@/, "");
+  const orgName = depName.toLowerCase();
+  try {
+    const query = encodeURIComponent(`mcp org:${orgName}`);
+    const url = `${GITHUB_SEARCH_URL}?q=${query}&type=repositories&s=stars&o=desc`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: SEARCH_HEADERS
+    });
+    if (!resp.ok) return [];
+    const html = await resp.text();
+    const repos = parseGitHubSearchHtml(html).slice(0, 5);
+    return repos.map((repo) => ({
+      name: repo.full_name.split("/")[1],
+      repoFullName: repo.full_name,
+      url: `https://github.com/${repo.full_name}`,
+      description: repo.description || "",
+      stars: repo.stargazers_count,
+      lastPush: repo.pushed_at,
+      vendor: repo.owner_login.toLowerCase() === orgName,
+      score: 0,
+      reason: "",
+      matchedDep: dep
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/mcp/prompts.ts
+var SCORE_MCP_PROMPT = `You evaluate MCP (Model Context Protocol) server candidates for relevance to a software project.
+
+Score each candidate from 0-100 based on:
+- **Relevance** (40%): How directly does it match the project's detected tool dependencies?
+- **Capabilities** (30%): Does it provide meaningful read+write operations (not just read-only)?
+- **Quality signals** (30%): Stars, recent activity, vendor/official status
+
+Return a JSON array where each element has:
+- "index": the candidate's index number
+- "score": relevance score 0-100
+- "reason": one-liner explaining the score (max 80 chars)
+
+Be selective. Only score candidates that would genuinely help developers working on this project.
+Return ONLY the JSON array.`;
+var EXTRACT_CONFIG_PROMPT = `You extract MCP server configuration from a README file.
+
+Look for the MCP server's configuration block \u2014 typically a JSON snippet showing how to add it to claude_desktop_config.json, .mcp.json, or similar.
+
+Return a JSON object with:
+- "command": the executable command (e.g., "npx", "uvx", "node", "docker")
+- "args": array of arguments (e.g., ["-y", "@supabase/mcp-server"])
+- "env": array of objects, each with:
+  - "key": environment variable name (e.g., "SUPABASE_ACCESS_TOKEN")
+  - "description": brief description of what this value is (e.g., "Personal access token from dashboard")
+  - "required": boolean
+
+If the README shows multiple configuration methods, prefer npx > uvx > node > docker.
+If you cannot determine the configuration, return {"command": "", "args": [], "env": []}.
+Return ONLY the JSON object.`;
+
+// src/mcp/validate.ts
+var MIN_STARS = 100;
+var MAX_AGE_DAYS = 180;
+async function validateAndScore(candidates, toolDeps) {
+  const qualityFiltered = candidates.filter((c) => {
+    if (c.vendor) return true;
+    if (c.stars > 0 && c.stars < MIN_STARS) return false;
+    if (c.lastPush) {
+      const pushDate = new Date(c.lastPush);
+      const daysAgo = (Date.now() - pushDate.getTime()) / (1e3 * 60 * 60 * 24);
+      if (daysAgo > MAX_AGE_DAYS) return false;
+    }
+    return true;
+  });
+  if (qualityFiltered.length === 0) return [];
+  try {
+    return await scoreWithLLM(qualityFiltered, toolDeps);
+  } catch {
+    return qualityFiltered.slice(0, 5).map((c) => ({
+      ...c,
+      score: 50,
+      reason: c.description.slice(0, 80)
+    }));
+  }
+}
+async function scoreWithLLM(candidates, toolDeps) {
+  const candidateList = candidates.map((c, i) => {
+    const vendorTag = c.vendor ? " [VENDOR/OFFICIAL]" : "";
+    return `${i}. "${c.name}"${vendorTag} (${c.stars} stars) \u2014 ${c.description.slice(0, 100)}`;
+  }).join("\n");
+  const scored = await llmJsonCall({
+    system: SCORE_MCP_PROMPT,
+    prompt: `TOOL DEPENDENCIES IN PROJECT:
+${toolDeps.join(", ")}
+
+MCP SERVER CANDIDATES:
+${candidateList}`,
+    maxTokens: 4e3
+  });
+  if (!Array.isArray(scored)) return [];
+  return scored.filter((s) => s.score >= 60 && s.index >= 0 && s.index < candidates.length).sort((a, b) => b.score - a.score).slice(0, 5).map((s) => ({
+    ...candidates[s.index],
+    score: s.score,
+    reason: s.reason || candidates[s.index].description.slice(0, 80)
+  }));
+}
+
+// src/mcp/config-extract.ts
+async function fetchReadme(repoFullName) {
+  try {
+    const resp = await fetch(
+      `https://raw.githubusercontent.com/${repoFullName}/HEAD/README.md`,
+      { signal: AbortSignal.timeout(1e4) }
+    );
+    if (resp.ok) return await resp.text();
+  } catch {
+  }
+  try {
+    const resp = await fetch(
+      `https://raw.githubusercontent.com/${repoFullName}/main/README.md`,
+      { signal: AbortSignal.timeout(1e4) }
+    );
+    if (resp.ok) return await resp.text();
+  } catch {
+  }
+  return null;
+}
+async function extractMcpConfig(readme, serverName) {
+  try {
+    const truncated = readme.length > 15e3 ? readme.slice(0, 15e3) : readme;
+    const result = await llmJsonCall({
+      system: EXTRACT_CONFIG_PROMPT,
+      prompt: `MCP Server: ${serverName}
+
+README:
+${truncated}`,
+      maxTokens: 2e3
+    });
+    if (!result || !result.command) return null;
+    return {
+      command: result.command,
+      args: Array.isArray(result.args) ? result.args : [],
+      env: Array.isArray(result.env) ? result.env : []
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/mcp/index.ts
+async function discoverAndInstallMcps(targetAgent, fingerprint, dir) {
+  console.log(chalk4.hex("#6366f1").bold("\n  MCP Server Discovery\n"));
+  const toolDeps = fingerprint.tools;
+  if (toolDeps.length === 0) {
+    console.log(chalk4.dim("  No external tools or services detected \u2014 skipping MCP discovery"));
+    return { installed: 0, names: [] };
+  }
+  const spinner = ora(`Searching MCP servers for ${toolDeps.length} detected tool${toolDeps.length === 1 ? "" : "s"}...`).start();
+  console.log(chalk4.dim(`  Detected: ${toolDeps.join(", ")}`));
+  const existingMcps = getExistingMcpNames(fingerprint, targetAgent);
+  const filteredDeps = toolDeps.filter((d) => {
+    const lower = d.toLowerCase();
+    return !existingMcps.some((name) => name.includes(lower) || lower.includes(name));
+  });
+  if (filteredDeps.length === 0) {
+    spinner.succeed(chalk4.dim("All detected tools already have MCP servers configured"));
+    return { installed: 0, names: [] };
+  }
+  const candidates = await searchAllMcpSources(filteredDeps);
+  if (candidates.length === 0) {
+    spinner.succeed(chalk4.dim("No MCP servers found for detected tools"));
+    return { installed: 0, names: [] };
+  }
+  spinner.succeed(`Found ${candidates.length} candidate${candidates.length === 1 ? "" : "s"} for ${filteredDeps.join(", ")}`);
+  const scoreSpinner = ora("Scoring MCP candidates...").start();
+  const scored = await validateAndScore(candidates, filteredDeps);
+  if (scored.length === 0) {
+    scoreSpinner.succeed(chalk4.dim("No quality MCP servers passed validation"));
+    console.log(chalk4.dim(`  Candidates checked: ${candidates.map((c) => c.name).join(", ")}`));
+    return { installed: 0, names: [] };
+  }
+  scoreSpinner.succeed(`${scored.length} quality MCP server${scored.length === 1 ? "" : "s"} found`);
+  console.log(chalk4.dim(`  Scored: ${scored.map((c) => `${c.name} (${c.score})`).join(", ")}`));
+  const selected = await interactiveSelect(scored);
+  if (!selected || selected.length === 0) {
+    return { installed: 0, names: [] };
+  }
+  const mcpServers = {};
+  const installedNames = [];
+  for (const mcp of selected) {
+    console.log(chalk4.bold(`
+  Configuring ${mcp.name}...`));
+    const readme = await fetchReadme(mcp.repoFullName);
+    if (!readme) {
+      console.log(chalk4.yellow(`  Could not fetch README for ${mcp.repoFullName} \u2014 skipping`));
+      console.log(chalk4.dim(`  Manual setup: ${mcp.url}`));
+      continue;
+    }
+    const config = await extractMcpConfig(readme, mcp.name);
+    if (!config || !config.command) {
+      console.log(chalk4.yellow(`  Could not extract config for ${mcp.name} \u2014 skipping`));
+      console.log(chalk4.dim(`  Manual setup: ${mcp.url}`));
+      continue;
+    }
+    const env = {};
+    for (const envVar of config.env) {
+      if (!envVar.required) continue;
+      const value = await promptInput2(`  ? ${envVar.key} (${envVar.description})`);
+      if (value) {
+        env[envVar.key] = value;
+      }
+    }
+    const serverConfig = {
+      command: config.command
+    };
+    if (config.args.length > 0) serverConfig.args = config.args;
+    if (Object.keys(env).length > 0) serverConfig.env = env;
+    mcpServers[mcp.name] = serverConfig;
+    installedNames.push(mcp.name);
+    console.log(`  ${chalk4.green("\u2713")} ${mcp.name} configured`);
+  }
+  if (installedNames.length === 0) {
+    return { installed: 0, names: [] };
+  }
+  if (targetAgent === "claude" || targetAgent === "both") {
+    writeMcpJson(path15.join(dir, ".mcp.json"), mcpServers);
+  }
+  if (targetAgent === "cursor" || targetAgent === "both") {
+    const cursorDir = path15.join(dir, ".cursor");
+    if (!fs17.existsSync(cursorDir)) fs17.mkdirSync(cursorDir, { recursive: true });
+    writeMcpJson(path15.join(cursorDir, "mcp.json"), mcpServers);
+  }
+  return { installed: installedNames.length, names: installedNames };
+}
+function writeMcpJson(filePath, mcpServers) {
+  let existing = {};
+  try {
+    if (fs17.existsSync(filePath)) {
+      const parsed = JSON.parse(fs17.readFileSync(filePath, "utf-8"));
+      if (parsed.mcpServers) existing = parsed.mcpServers;
+    }
+  } catch {
+  }
+  const merged = { ...existing, ...mcpServers };
+  fs17.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
+}
+function getExistingMcpNames(fingerprint, targetAgent) {
+  const names = [];
+  if (targetAgent === "claude" || targetAgent === "both") {
+    if (fingerprint.existingConfigs.claudeMcpServers) {
+      names.push(...Object.keys(fingerprint.existingConfigs.claudeMcpServers).map((k) => k.toLowerCase()));
+    }
+  }
+  if (targetAgent === "cursor" || targetAgent === "both") {
+    if (fingerprint.existingConfigs.cursorMcpServers) {
+      names.push(...Object.keys(fingerprint.existingConfigs.cursorMcpServers).map((k) => k.toLowerCase()));
+    }
+  }
+  return names;
+}
+function promptInput2(question) {
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(chalk4.cyan(`${question}: `), (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function interactiveSelect(candidates) {
+  if (!process.stdin.isTTY) {
+    console.log(chalk4.bold("\n  Available MCP servers:\n"));
+    for (const c of candidates) {
+      const vendorTag = c.vendor ? chalk4.blue(" (vendor)") : "";
+      console.log(`  ${String(c.score).padStart(3)}  ${c.name}${vendorTag}  ${chalk4.dim(c.reason)}`);
+    }
+    console.log("");
+    return null;
+  }
+  const selected = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  const { stdin, stdout } = process;
+  let lineCount = 0;
+  function render() {
+    const lines = [];
+    lines.push(chalk4.bold("  Select MCP servers to install:"));
+    lines.push("");
+    for (let i = 0; i < candidates.length; i++) {
+      const c = candidates[i];
+      const check = selected.has(i) ? chalk4.green("[x]") : "[ ]";
+      const ptr = i === cursor ? chalk4.cyan(">") : " ";
+      const scoreColor = c.score >= 90 ? chalk4.green : c.score >= 70 ? chalk4.yellow : chalk4.dim;
+      const vendorTag = c.vendor ? chalk4.blue(" (vendor)") : "";
+      lines.push(`  ${ptr} ${check} ${scoreColor(String(c.score).padStart(3))}  ${c.name}${vendorTag}  ${chalk4.dim(c.reason.slice(0, 40))}`);
+    }
+    lines.push("");
+    lines.push(chalk4.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q skip"));
+    return lines.join("\n");
+  }
+  function draw(initial) {
+    if (!initial && lineCount > 0) {
+      stdout.write(`\x1B[${lineCount}A`);
+    }
+    stdout.write("\x1B[0J");
+    const output = render();
+    stdout.write(output + "\n");
+    lineCount = output.split("\n").length;
+  }
+  return new Promise((resolve2) => {
+    console.log("");
+    draw(true);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+    function onData(key) {
+      switch (key) {
+        case "\x1B[A":
+          cursor = (cursor - 1 + candidates.length) % candidates.length;
+          draw(false);
+          break;
+        case "\x1B[B":
+          cursor = (cursor + 1) % candidates.length;
+          draw(false);
+          break;
+        case " ":
+          selected.has(cursor) ? selected.delete(cursor) : selected.add(cursor);
+          draw(false);
+          break;
+        case "a":
+          candidates.forEach((_, i) => selected.add(i));
+          draw(false);
+          break;
+        case "n":
+          selected.clear();
+          draw(false);
+          break;
+        case "\r":
+        case "\n":
+          cleanup();
+          if (selected.size === 0) {
+            console.log(chalk4.dim("\n  No MCP servers selected.\n"));
+            resolve2(null);
+          } else {
+            resolve2(Array.from(selected).sort().map((i) => candidates[i]));
+          }
+          break;
+        case "q":
+        case "\x1B":
+        case "":
+          cleanup();
+          console.log(chalk4.dim("\n  Skipped MCP server installation.\n"));
+          resolve2(null);
+          break;
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+
 // src/commands/onboard.ts
 async function initCommand(options) {
-  const brand = chalk4.hex("#EB9D83");
-  const title = chalk4.hex("#83D1EB");
+  const brand = chalk5.hex("#EB9D83");
+  const title = chalk5.hex("#83D1EB");
   console.log(brand.bold(`
    \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
@@ -3865,19 +4299,20 @@ 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(chalk4.dim("  Onboard your project for AI-assisted development\n"));
+  console.log(chalk5.dim("  Onboard your project for AI-assisted development\n"));
   console.log(title.bold("  Welcome to Caliber\n"));
-  console.log(chalk4.dim("  Caliber analyzes your codebase and creates tailored config files"));
-  console.log(chalk4.dim("  so your AI coding agents understand your project from day one.\n"));
+  console.log(chalk5.dim("  Caliber analyzes your codebase and creates tailored config files"));
+  console.log(chalk5.dim("  so your AI coding agents understand your project from day one.\n"));
   console.log(title.bold("  How onboarding works:\n"));
-  console.log(chalk4.dim("  1. Connect   Set up your LLM provider"));
-  console.log(chalk4.dim("  2. Discover  Analyze your code, dependencies, and structure"));
-  console.log(chalk4.dim("  3. Generate  Create config files tailored to your project"));
-  console.log(chalk4.dim("  4. Review    Preview, refine, and apply the changes\n"));
-  console.log(title.bold("  Step 1/4 \u2014 Connect your LLM\n"));
+  console.log(chalk5.dim("  1. Connect    Set up your LLM provider"));
+  console.log(chalk5.dim("  2. Discover   Analyze your code, dependencies, and structure"));
+  console.log(chalk5.dim("  3. Generate   Create config files tailored to your project"));
+  console.log(chalk5.dim("  4. Review     Preview, refine, and apply the changes"));
+  console.log(chalk5.dim("  5. Enhance    Discover MCP servers for your tools\n"));
+  console.log(title.bold("  Step 1/5 \u2014 Connect your LLM\n"));
   let config = loadConfig();
   if (!config) {
-    console.log(chalk4.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
+    console.log(chalk5.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
     try {
       await runInteractiveProviderSetup({
         selectMessage: "How do you want to use Caliber? (choose LLM provider)"
@@ -3888,23 +4323,23 @@ async function initCommand(options) {
     }
     config = loadConfig();
     if (!config) {
-      console.log(chalk4.red("  Setup was cancelled or failed.\n"));
+      console.log(chalk5.red("  Setup was cancelled or failed.\n"));
       throw new Error("__exit__");
     }
-    console.log(chalk4.green("  \u2713 Provider saved. Let's continue.\n"));
+    console.log(chalk5.green("  \u2713 Provider saved. Let's continue.\n"));
   }
   const displayModel = config.model === "default" && config.provider === "claude-cli" ? process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)" : config.model;
-  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const fastModel = getFastModel();
   const modelLine = fastModel ? `  Provider: ${config.provider} | Model: ${displayModel} | Scan: ${fastModel}` : `  Provider: ${config.provider} | Model: ${displayModel}`;
-  console.log(chalk4.dim(modelLine + "\n"));
-  console.log(title.bold("  Step 2/4 \u2014 Discover your project\n"));
-  console.log(chalk4.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
-  const spinner = ora("Analyzing project...").start();
+  console.log(chalk5.dim(modelLine + "\n"));
+  console.log(title.bold("  Step 2/5 \u2014 Discover your project\n"));
+  console.log(chalk5.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
+  const spinner = ora2("Analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   await enrichFingerprintWithLLM(fingerprint, process.cwd());
   spinner.succeed("Project analyzed");
-  console.log(chalk4.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
-  console.log(chalk4.dim(`  Files: ${fingerprint.fileTree.length} found
+  console.log(chalk5.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
+  console.log(chalk5.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   const targetAgent = options.agent || await promptAgent();
   const preScore = computeLocalScore(process.cwd(), targetAgent);
@@ -3922,13 +4357,13 @@ async function initCommand(options) {
   displayScoreSummary(baselineScore);
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
   if (hasExistingConfig && baselineScore.score === 100) {
-    console.log(chalk4.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to regenerate anyway.\n"));
+    console.log(chalk5.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
+    console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber onboard --force") + chalk5.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const isEmpty = fingerprint.fileTree.length < 3;
   if (isEmpty) {
-    fingerprint.description = await promptInput2("What will you build in this project?");
+    fingerprint.description = await promptInput3("What will you build in this project?");
   }
   let failingChecks;
   let passingChecks;
@@ -3938,25 +4373,25 @@ async function initCommand(options) {
     passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
     currentScore = baselineScore.score;
     if (failingChecks.length > 0) {
-      console.log(title.bold("  Step 3/4 \u2014 Fine-tuning\n"));
-      console.log(chalk4.dim(`  Your setup scores ${baselineScore.score}/100 \u2014 fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
+      console.log(title.bold("  Step 3/5 \u2014 Fine-tuning\n"));
+      console.log(chalk5.dim(`  Your setup scores ${baselineScore.score}/100 \u2014 fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
 `));
       for (const check of failingChecks) {
-        console.log(chalk4.dim(`    \u2022 ${check.name}`));
+        console.log(chalk5.dim(`    \u2022 ${check.name}`));
       }
       console.log("");
     }
   } else if (hasExistingConfig) {
-    console.log(title.bold("  Step 3/4 \u2014 Improve your setup\n"));
-    console.log(chalk4.dim("  Reviewing your existing configs against your codebase"));
-    console.log(chalk4.dim("  and preparing improvements.\n"));
+    console.log(title.bold("  Step 3/5 \u2014 Improve your setup\n"));
+    console.log(chalk5.dim("  Reviewing your existing configs against your codebase"));
+    console.log(chalk5.dim("  and preparing improvements.\n"));
   } else {
-    console.log(title.bold("  Step 3/4 \u2014 Build your agent setup\n"));
-    console.log(chalk4.dim("  Creating config files tailored to your project.\n"));
+    console.log(title.bold("  Step 3/5 \u2014 Build your agent setup\n"));
+    console.log(chalk5.dim("  Creating config files tailored to your project.\n"));
   }
-  console.log(chalk4.dim("  This can take a couple of minutes depending on your model and provider.\n"));
+  console.log(chalk5.dim("  This can take a couple of minutes depending on your model and provider.\n"));
   const genStartTime = Date.now();
-  const genSpinner = ora("Generating setup...").start();
+  const genSpinner = ora2("Generating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
   genMessages.start();
   let generatedSetup = null;
@@ -3996,8 +4431,8 @@ async function initCommand(options) {
   if (!generatedSetup) {
     genSpinner.fail("Failed to generate setup.");
     if (rawOutput) {
-      console.log(chalk4.dim("\nRaw LLM output (JSON parse failed):"));
-      console.log(chalk4.dim(rawOutput.slice(0, 500)));
+      console.log(chalk5.dim("\nRaw LLM output (JSON parse failed):"));
+      console.log(chalk5.dim(rawOutput.slice(0, 500)));
     }
     throw new Error("__exit__");
   }
@@ -4005,17 +4440,17 @@ async function initCommand(options) {
   const mins = Math.floor(elapsedMs / 6e4);
   const secs = Math.floor(elapsedMs % 6e4 / 1e3);
   const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-  genSpinner.succeed(`Setup generated ${chalk4.dim(`in ${timeStr}`)}`);
+  genSpinner.succeed(`Setup generated ${chalk5.dim(`in ${timeStr}`)}`);
   printSetupSummary(generatedSetup);
   const sessionHistory = [];
   sessionHistory.push({
     role: "assistant",
     content: summarizeSetup("Initial generation", generatedSetup)
   });
-  console.log(title.bold("  Step 4/4 \u2014 Review and apply\n"));
+  console.log(title.bold("  Step 4/5 \u2014 Review and apply\n"));
   const setupFiles = collectSetupFiles(generatedSetup);
   const staged = stageFiles(setupFiles, process.cwd());
-  console.log(chalk4.dim(`  ${chalk4.green(`${staged.newFiles} new`)} / ${chalk4.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
+  console.log(chalk5.dim(`  ${chalk5.green(`${staged.newFiles} new`)} / ${chalk5.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
 `));
   const wantsReview = await promptWantsReview();
   if (wantsReview) {
@@ -4027,12 +4462,12 @@ async function initCommand(options) {
     generatedSetup = await refineLoop(generatedSetup, targetAgent, sessionHistory);
     if (!generatedSetup) {
       cleanupStaging();
-      console.log(chalk4.dim("Refinement cancelled. No files were modified."));
+      console.log(chalk5.dim("Refinement cancelled. No files were modified."));
       return;
     }
     const updatedFiles = collectSetupFiles(generatedSetup);
     const restaged = stageFiles(updatedFiles, process.cwd());
-    console.log(chalk4.dim(`  ${chalk4.green(`${restaged.newFiles} new`)} / ${chalk4.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
+    console.log(chalk5.dim(`  ${chalk5.green(`${restaged.newFiles} new`)} / ${chalk5.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
 `));
     printSetupSummary(generatedSetup);
     await openReview("terminal", restaged.stagedFiles);
@@ -4040,37 +4475,56 @@ async function initCommand(options) {
   }
   cleanupStaging();
   if (action === "decline") {
-    console.log(chalk4.dim("Setup declined. No files were modified."));
+    console.log(chalk5.dim("Setup declined. No files were modified."));
     return;
   }
   if (options.dryRun) {
-    console.log(chalk4.yellow("\n[Dry run] Would write the following files:"));
+    console.log(chalk5.yellow("\n[Dry run] Would write the following files:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
-  const writeSpinner = ora("Writing config files...").start();
+  const writeSpinner = ora2("Writing config files...").start();
   try {
     const result = writeSetup(generatedSetup);
     writeSpinner.succeed("Config files written");
-    console.log(chalk4.bold("\nFiles created/updated:"));
+    console.log(chalk5.bold("\nFiles created/updated:"));
     for (const file of result.written) {
-      console.log(`  ${chalk4.green("\u2713")} ${file}`);
+      console.log(`  ${chalk5.green("\u2713")} ${file}`);
     }
     if (result.deleted.length > 0) {
-      console.log(chalk4.bold("\nFiles removed:"));
+      console.log(chalk5.bold("\nFiles removed:"));
       for (const file of result.deleted) {
-        console.log(`  ${chalk4.red("\u2717")} ${file}`);
+        console.log(`  ${chalk5.red("\u2717")} ${file}`);
       }
     }
     if (result.backupDir) {
-      console.log(chalk4.dim(`
+      console.log(chalk5.dim(`
   Backups saved to ${result.backupDir}`));
     }
   } catch (err) {
     writeSpinner.fail("Failed to write files");
-    console.error(chalk4.red(err instanceof Error ? err.message : "Unknown error"));
+    console.error(chalk5.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
+  console.log(title.bold("\n  Step 5/5 \u2014 Enhance with MCP servers\n"));
+  console.log(chalk5.dim("  MCP servers connect your AI agents to external tools and services"));
+  console.log(chalk5.dim("  like databases, APIs, and platforms your project depends on.\n"));
+  if (fingerprint.tools.length > 0) {
+    try {
+      const mcpResult = await discoverAndInstallMcps(targetAgent, fingerprint, process.cwd());
+      if (mcpResult.installed > 0) {
+        console.log(chalk5.bold(`
+  ${mcpResult.installed} MCP server${mcpResult.installed > 1 ? "s" : ""} configured`));
+        for (const name of mcpResult.names) {
+          console.log(`  ${chalk5.green("\u2713")} ${name}`);
+        }
+      }
+    } catch (err) {
+      console.log(chalk5.dim("  MCP discovery skipped: " + (err instanceof Error ? err.message : "unknown error")));
+    }
+  } else {
+    console.log(chalk5.dim("  No external tools or services detected \u2014 skipping MCP discovery.\n"));
+  }
   ensurePermissions();
   const sha = getCurrentHeadSha();
   writeState({
@@ -4080,56 +4534,56 @@ async function initCommand(options) {
   });
   console.log("");
   console.log(title.bold("  Keep your configs fresh\n"));
-  console.log(chalk4.dim("  Caliber can automatically update your agent configs when your code changes.\n"));
+  console.log(chalk5.dim("  Caliber can automatically update your agent configs when your code changes.\n"));
   const hookChoice = await promptHookType(targetAgent);
   if (hookChoice === "claude" || hookChoice === "both") {
     const hookResult = installHook();
     if (hookResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove") + chalk4.dim(" to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber hooks remove") + chalk5.dim(" to disable"));
     } else if (hookResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Claude Code hook already installed"));
+      console.log(chalk5.dim("  Claude Code hook already installed"));
     }
     const learnResult = installLearningHooks();
     if (learnResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
-      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber learn remove") + chalk4.dim(" to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber learn remove") + chalk5.dim(" to disable"));
     } else if (learnResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Learning hooks already installed"));
+      console.log(chalk5.dim("  Learning hooks already installed"));
     }
   }
   if (hookChoice === "precommit" || hookChoice === "both") {
     const precommitResult = installPreCommitHook();
     if (precommitResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk4.dim("    Run ") + chalk4.hex("#83D1EB")("caliber hooks remove-precommit") + chalk4.dim(" to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber hooks remove-precommit") + chalk5.dim(" to disable"));
     } else if (precommitResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Pre-commit hook already installed"));
+      console.log(chalk5.dim("  Pre-commit hook already installed"));
     } else {
-      console.log(chalk4.yellow("  Could not install pre-commit hook (not a git repository?)"));
+      console.log(chalk5.yellow("  Could not install pre-commit hook (not a git repository?)"));
     }
   }
   if (hookChoice === "skip") {
-    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run ") + chalk4.hex("#83D1EB")("caliber hooks install") + chalk4.dim(" later to enable."));
+    console.log(chalk5.dim("  Skipped auto-refresh hooks. Run ") + chalk5.hex("#83D1EB")("caliber hooks install") + chalk5.dim(" later to enable."));
   }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
     console.log("");
-    console.log(chalk4.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
+    console.log(chalk5.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
     try {
       const { restored, removed } = undoSetup();
       if (restored.length > 0 || removed.length > 0) {
-        console.log(chalk4.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
+        console.log(chalk5.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
       }
     } catch {
     }
-    console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber onboard --force") + chalk4.dim(" to override.\n"));
+    console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber onboard --force") + chalk5.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
-  console.log(chalk4.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
-  console.log(chalk4.dim("  Run ") + chalk4.hex("#83D1EB")("caliber undo") + chalk4.dim(" to revert changes.\n"));
-  console.log(chalk4.bold("  Next steps:\n"));
+  console.log(chalk5.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
+  console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber undo") + chalk5.dim(" to revert changes.\n"));
+  console.log(chalk5.bold("  Next steps:\n"));
   console.log(`    ${title("caliber score")}        See your full config breakdown`);
   console.log(`    ${title("caliber recommend")}    Discover community skills for your stack`);
   console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
@@ -4137,7 +4591,7 @@ async function initCommand(options) {
 }
 async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
   while (true) {
-    const message = await promptInput2("\nWhat would you like to change?");
+    const message = await promptInput3("\nWhat would you like to change?");
     if (!message || message.toLowerCase() === "done" || message.toLowerCase() === "accept") {
       return currentSetup;
     }
@@ -4146,12 +4600,12 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
     }
     const isValid = await classifyRefineIntent(message);
     if (!isValid) {
-      console.log(chalk4.dim("  This doesn't look like a config change request."));
-      console.log(chalk4.dim("  Describe what to add, remove, or modify in your configs."));
-      console.log(chalk4.dim('  Type "done" to accept the current setup.\n'));
+      console.log(chalk5.dim("  This doesn't look like a config change request."));
+      console.log(chalk5.dim("  Describe what to add, remove, or modify in your configs."));
+      console.log(chalk5.dim('  Type "done" to accept the current setup.\n'));
       continue;
     }
-    const refineSpinner = ora("Refining setup...").start();
+    const refineSpinner = ora2("Refining setup...").start();
     const refineMessages = new SpinnerMessages(refineSpinner, REFINE_MESSAGES);
     refineMessages.start();
     const refined = await refineSetup(
@@ -4169,21 +4623,21 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
       });
       refineSpinner.succeed("Setup updated");
       printSetupSummary(refined);
-      console.log(chalk4.dim('Type "done" to accept, or describe more changes.'));
+      console.log(chalk5.dim('Type "done" to accept, or describe more changes.'));
     } else {
       refineSpinner.fail("Refinement failed \u2014 could not parse AI response.");
-      console.log(chalk4.dim('Try rephrasing your request, or type "done" to keep the current setup.'));
+      console.log(chalk5.dim('Try rephrasing your request, or type "done" to keep the current setup.'));
     }
   }
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path24, desc]) => `  ${path24}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path23, desc]) => `  ${path23}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
 async function classifyRefineIntent(message) {
-  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const fastModel = getFastModel();
   try {
     const result = await llmJsonCall({
       system: `You classify whether a user message is a valid request to modify AI agent config files (CLAUDE.md, .cursorrules, skills).
@@ -4200,7 +4654,7 @@ Return {"valid": true} or {"valid": false}. Nothing else.`,
   }
 }
 async function evaluateDismissals(failingChecks, fingerprint) {
-  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const fastModel = getFastModel();
   const checkList = failingChecks.map((c) => ({
     id: c.id,
     name: c.name,
@@ -4229,10 +4683,10 @@ ${JSON.stringify(checkList, null, 2)}`,
     return [];
   }
 }
-function promptInput2(question) {
-  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+function promptInput3(question) {
+  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
-    rl.question(chalk4.cyan(`${question} `), (answer) => {
+    rl.question(chalk5.cyan(`${question} `), (answer) => {
       rl.close();
       resolve2(answer.trim());
     });
@@ -4294,7 +4748,7 @@ async function openReview(method, stagedFiles) {
       originalPath: f.originalPath,
       proposedPath: f.proposedPath
     })));
-    console.log(chalk4.dim("  Diffs opened in your editor.\n"));
+    console.log(chalk5.dim("  Diffs opened in your editor.\n"));
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
@@ -4325,8 +4779,8 @@ async function openReview(method, stagedFiles) {
 async function interactiveDiffExplorer(files) {
   if (!process.stdin.isTTY) {
     for (const f of files) {
-      const icon = f.isNew ? chalk4.green("+") : chalk4.yellow("~");
-      const stats = f.isNew ? chalk4.dim(`${f.lines} lines`) : `${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+      const icon = f.isNew ? chalk5.green("+") : chalk5.yellow("~");
+      const stats = f.isNew ? chalk5.dim(`${f.lines} lines`) : `${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
       console.log(`    ${icon} ${f.relativePath}  ${stats}`);
     }
     console.log("");
@@ -4342,47 +4796,47 @@ async function interactiveDiffExplorer(files) {
   }
   function renderFileList() {
     const lines = [];
-    lines.push(chalk4.bold("  Review changes"));
+    lines.push(chalk5.bold("  Review changes"));
     lines.push("");
     for (let i = 0; i < files.length; i++) {
       const f = files[i];
-      const ptr = i === cursor ? chalk4.cyan(">") : " ";
-      const icon = f.isNew ? chalk4.green("+") : chalk4.yellow("~");
-      const stats = f.isNew ? chalk4.dim(`${f.lines} lines`) : `${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+      const ptr = i === cursor ? chalk5.cyan(">") : " ";
+      const icon = f.isNew ? chalk5.green("+") : chalk5.yellow("~");
+      const stats = f.isNew ? chalk5.dim(`${f.lines} lines`) : `${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
       lines.push(`  ${ptr} ${icon} ${f.relativePath}  ${stats}`);
     }
     lines.push("");
-    lines.push(chalk4.dim("  \u2191\u2193 navigate  \u23CE view diff  q done"));
+    lines.push(chalk5.dim("  \u2191\u2193 navigate  \u23CE view diff  q done"));
     return lines.join("\n");
   }
   function renderDiff(index) {
     const f = files[index];
     const lines = [];
-    const header = f.isNew ? `  ${chalk4.green("+")} ${f.relativePath} ${chalk4.dim("(new file)")}` : `  ${chalk4.yellow("~")} ${f.relativePath} ${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+    const header = f.isNew ? `  ${chalk5.green("+")} ${f.relativePath} ${chalk5.dim("(new file)")}` : `  ${chalk5.yellow("~")} ${f.relativePath} ${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
     lines.push(header);
-    lines.push(chalk4.dim("  " + "\u2500".repeat(60)));
+    lines.push(chalk5.dim("  " + "\u2500".repeat(60)));
     const patchLines = f.patch.split("\n");
     const bodyLines = patchLines.slice(4);
     const maxVisible = getTermHeight() - 4;
     const visibleLines = bodyLines.slice(scrollOffset, scrollOffset + maxVisible);
     for (const line of visibleLines) {
       if (line.startsWith("+")) {
-        lines.push(chalk4.green("  " + line));
+        lines.push(chalk5.green("  " + line));
       } else if (line.startsWith("-")) {
-        lines.push(chalk4.red("  " + line));
+        lines.push(chalk5.red("  " + line));
       } else if (line.startsWith("@@")) {
-        lines.push(chalk4.cyan("  " + line));
+        lines.push(chalk5.cyan("  " + line));
       } else {
-        lines.push(chalk4.dim("  " + line));
+        lines.push(chalk5.dim("  " + line));
       }
     }
     const totalBody = bodyLines.length;
     if (totalBody > maxVisible) {
       const pct = Math.round((scrollOffset + maxVisible) / totalBody * 100);
-      lines.push(chalk4.dim(`  \u2500\u2500 ${Math.min(pct, 100)}% \u2500\u2500`));
+      lines.push(chalk5.dim(`  \u2500\u2500 ${Math.min(pct, 100)}% \u2500\u2500`));
     }
     lines.push("");
-    lines.push(chalk4.dim("  \u2191\u2193 scroll  \u23B5/esc back to file list"));
+    lines.push(chalk5.dim("  \u2191\u2193 scroll  \u23B5/esc back to file list"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -4476,46 +4930,46 @@ function printSetupSummary(setup) {
   const fileDescriptions = setup.fileDescriptions;
   const deletions = setup.deletions;
   console.log("");
-  console.log(chalk4.bold("  Proposed changes:\n"));
+  console.log(chalk5.bold("  Proposed changes:\n"));
   const getDescription = (filePath) => {
     return fileDescriptions?.[filePath];
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs18.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription("CLAUDE.md");
-      console.log(`  ${icon} ${chalk4.bold("CLAUDE.md")}`);
-      if (desc) console.log(chalk4.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk5.bold("CLAUDE.md")}`);
+      if (desc) console.log(chalk5.dim(`    ${desc}`));
       console.log("");
     }
     const skills = claude.skills;
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
-        console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
+        console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs18.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription(".cursorrules");
-      console.log(`  ${icon} ${chalk4.bold(".cursorrules")}`);
-      if (desc) console.log(chalk4.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk5.bold(".cursorrules")}`);
+      if (desc) console.log(chalk5.dim(`    ${desc}`));
       console.log("");
     }
     const cursorSkills = cursor.skills;
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
-        console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
+        console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
@@ -4523,32 +4977,32 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs18.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(rulePath);
-        console.log(`  ${icon} ${chalk4.bold(rulePath)}`);
+        console.log(`  ${icon} ${chalk5.bold(rulePath)}`);
         if (desc) {
-          console.log(chalk4.dim(`    ${desc}`));
+          console.log(chalk5.dim(`    ${desc}`));
         } else {
           const firstLine = rule.content.split("\n").filter((l) => l.trim() && !l.trim().startsWith("#"))[0];
-          if (firstLine) console.log(chalk4.dim(`    ${firstLine.trim().slice(0, 80)}`));
+          if (firstLine) console.log(chalk5.dim(`    ${firstLine.trim().slice(0, 80)}`));
         }
         console.log("");
       }
     }
   }
   if (!fs18.existsSync("AGENTS.md")) {
-    console.log(`  ${chalk4.green("+")} ${chalk4.bold("AGENTS.md")}`);
-    console.log(chalk4.dim("    Cross-agent coordination file"));
+    console.log(`  ${chalk5.green("+")} ${chalk5.bold("AGENTS.md")}`);
+    console.log(chalk5.dim("    Cross-agent coordination file"));
     console.log("");
   }
   if (Array.isArray(deletions) && deletions.length > 0) {
     for (const del of deletions) {
-      console.log(`  ${chalk4.red("-")} ${chalk4.bold(del.filePath)}`);
-      console.log(chalk4.dim(`    ${del.reason}`));
+      console.log(`  ${chalk5.red("-")} ${chalk5.bold(del.filePath)}`);
+      console.log(chalk5.dim(`    ${del.reason}`));
       console.log("");
     }
   }
-  console.log(`  ${chalk4.green("+")} ${chalk4.dim("new")}  ${chalk4.yellow("~")} ${chalk4.dim("modified")}  ${chalk4.red("-")} ${chalk4.dim("removed")}`);
+  console.log(`  ${chalk5.green("+")} ${chalk5.dim("new")}  ${chalk5.yellow("~")} ${chalk5.dim("modified")}  ${chalk5.red("-")} ${chalk5.dim("removed")}`);
   console.log("");
 }
 function buildSkillContent(skill) {
@@ -4629,10 +5083,10 @@ ${agentRefs.join(" ")}
 }
 
 // src/commands/undo.ts
-import chalk5 from "chalk";
-import ora2 from "ora";
+import chalk6 from "chalk";
+import ora3 from "ora";
 function undoCommand() {
-  const spinner = ora2("Reverting setup...").start();
+  const spinner = ora3("Reverting setup...").start();
   try {
     const { restored, removed } = undoSetup();
     if (restored.length === 0 && removed.length === 0) {
@@ -4641,26 +5095,26 @@ function undoCommand() {
     }
     spinner.succeed("Setup reverted successfully.\n");
     if (restored.length > 0) {
-      console.log(chalk5.cyan("  Restored from backup:"));
+      console.log(chalk6.cyan("  Restored from backup:"));
       for (const file of restored) {
-        console.log(`    ${chalk5.green("\u21A9")} ${file}`);
+        console.log(`    ${chalk6.green("\u21A9")} ${file}`);
       }
     }
     if (removed.length > 0) {
-      console.log(chalk5.cyan("  Removed:"));
+      console.log(chalk6.cyan("  Removed:"));
       for (const file of removed) {
-        console.log(`    ${chalk5.red("\u2717")} ${file}`);
+        console.log(`    ${chalk6.red("\u2717")} ${file}`);
       }
     }
     console.log("");
   } catch (err) {
-    spinner.fail(chalk5.red(err instanceof Error ? err.message : "Undo failed"));
+    spinner.fail(chalk6.red(err instanceof Error ? err.message : "Undo failed"));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/status.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 import fs19 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
@@ -4674,45 +5128,45 @@ async function statusCommand(options) {
     }, null, 2));
     return;
   }
-  console.log(chalk6.bold("\nCaliber Status\n"));
+  console.log(chalk7.bold("\nCaliber Status\n"));
   if (config) {
-    console.log(`  LLM: ${chalk6.green(config.provider)} (${config.model})`);
+    console.log(`  LLM: ${chalk7.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run ${chalk6.hex("#83D1EB")("caliber config")}`);
+    console.log(`  LLM: ${chalk7.yellow("Not configured")} \u2014 run ${chalk7.hex("#83D1EB")("caliber config")}`);
   }
   if (!manifest) {
-    console.log(`  Setup: ${chalk6.dim("No setup applied")}`);
-    console.log(chalk6.dim("\n  Run ") + chalk6.hex("#83D1EB")("caliber onboard") + chalk6.dim(" to get started.\n"));
+    console.log(`  Setup: ${chalk7.dim("No setup applied")}`);
+    console.log(chalk7.dim("\n  Run ") + chalk7.hex("#83D1EB")("caliber onboard") + chalk7.dim(" to get started.\n"));
     return;
   }
-  console.log(`  Files managed: ${chalk6.cyan(manifest.entries.length.toString())}`);
+  console.log(`  Files managed: ${chalk7.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
     const exists = fs19.existsSync(entry.path);
-    const icon = exists ? chalk6.green("\u2713") : chalk6.red("\u2717");
+    const icon = exists ? chalk7.green("\u2713") : chalk7.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
   console.log("");
 }
 
 // src/commands/regenerate.ts
-import chalk7 from "chalk";
-import ora3 from "ora";
+import chalk8 from "chalk";
+import ora4 from "ora";
 import confirm from "@inquirer/confirm";
 async function regenerateCommand(options) {
   const config = loadConfig();
   if (!config) {
-    console.log(chalk7.red("No LLM provider configured. Run ") + chalk7.hex("#83D1EB")("caliber config") + chalk7.red(" (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
+    console.log(chalk8.red("No LLM provider configured. Run ") + chalk8.hex("#83D1EB")("caliber config") + chalk8.red(" (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk7.yellow("No existing setup found. Run ") + chalk7.hex("#83D1EB")("caliber onboard") + chalk7.yellow(" first."));
+    console.log(chalk8.yellow("No existing setup found. Run ") + chalk8.hex("#83D1EB")("caliber onboard") + chalk8.yellow(" first."));
     throw new Error("__exit__");
   }
-  const spinner = ora3("Re-analyzing project...").start();
+  const spinner = ora4("Re-analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   spinner.succeed("Project re-analyzed");
-  const genSpinner = ora3("Regenerating setup...").start();
+  const genSpinner = ora4("Regenerating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES);
   genMessages.start();
   let generatedSetup = null;
@@ -4749,37 +5203,37 @@ async function regenerateCommand(options) {
   }
   genSpinner.succeed("Setup regenerated");
   if (options.dryRun) {
-    console.log(chalk7.yellow("\n[Dry run] Would write:"));
+    console.log(chalk8.yellow("\n[Dry run] Would write:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
   const shouldApply = await confirm({ message: "Apply regenerated setup?", default: true });
   if (!shouldApply) {
-    console.log(chalk7.dim("Regeneration cancelled."));
+    console.log(chalk8.dim("Regeneration cancelled."));
     return;
   }
-  const writeSpinner = ora3("Updating config files...").start();
+  const writeSpinner = ora4("Updating config files...").start();
   const result = writeSetup(generatedSetup);
   writeSpinner.succeed("Config files updated");
   for (const file of result.written) {
-    console.log(`  ${chalk7.green("\u2713")} ${file}`);
+    console.log(`  ${chalk8.green("\u2713")} ${file}`);
   }
   console.log("");
 }
 
 // src/commands/recommend.ts
-import chalk8 from "chalk";
-import ora4 from "ora";
+import chalk9 from "chalk";
+import ora5 from "ora";
 import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5, existsSync as existsSync9, writeFileSync } from "fs";
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
 import fs20 from "fs";
-import path17 from "path";
+import path16 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  const claudeMdPath = path16.join(dir, "CLAUDE.md");
   if (fs20.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
@@ -4789,10 +5243,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path17.join(dir, ".claude", "skills");
+  const skillsDir = path16.join(dir, ".claude", "skills");
   if (fs20.existsSync(skillsDir)) {
     for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path17.join(skillsDir, file);
+      const filePath = path16.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -4802,7 +5256,7 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  const mcpJsonPath = path16.join(dir, ".mcp.json");
   if (fs20.existsSync(mcpJsonPath)) {
     try {
       const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
@@ -4820,7 +5274,7 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  const cursorrulesPath = path16.join(dir, ".cursorrules");
   if (fs20.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
@@ -4830,10 +5284,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
   if (fs20.existsSync(cursorRulesDir)) {
     for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path17.join(cursorRulesDir, file);
+      const filePath = path16.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -4843,11 +5297,11 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
   if (fs20.existsSync(cursorSkillsDir)) {
     try {
       for (const name of fs20.readdirSync(cursorSkillsDir)) {
-        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
         if (fs20.existsSync(skillFile)) {
           items.push({
             type: "skill",
@@ -4861,7 +5315,7 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
   if (fs20.existsSync(cursorMcpPath)) {
     try {
       const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
@@ -5040,7 +5494,7 @@ async function searchAllProviders(technologies, platform) {
   }
   return combined;
 }
-async function scoreWithLLM(candidates, projectContext, technologies) {
+async function scoreWithLLM2(candidates, projectContext, technologies) {
   const candidateList = candidates.map((c, i) => `${i}. "${c.name}" \u2014 ${c.reason || "no description"}`).join("\n");
   const scored = await llmJsonCall({
     system: `You evaluate whether AI agent skills and tools are relevant to a specific software project.
@@ -5193,11 +5647,11 @@ async function recommendCommand(options) {
     ...extractTopDeps()
   ].filter(Boolean))];
   if (technologies.length === 0) {
-    console.log(chalk8.yellow("Could not detect any languages or dependencies. Try running from a project root."));
+    console.log(chalk9.yellow("Could not detect any languages or dependencies. Try running from a project root."));
     throw new Error("__exit__");
   }
   const primaryPlatform = platforms.includes("claude") ? "claude" : platforms[0];
-  const searchSpinner = ora4("Searching skill registries...").start();
+  const searchSpinner = ora5("Searching skill registries...").start();
   const allCandidates = await searchAllProviders(technologies, primaryPlatform);
   if (!allCandidates.length) {
     searchSpinner.succeed("No skills found matching your tech stack.");
@@ -5210,15 +5664,15 @@ async function recommendCommand(options) {
     return;
   }
   searchSpinner.succeed(
-    `Found ${allCandidates.length} skills` + (filteredCount > 0 ? chalk8.dim(` (${filteredCount} already installed)`) : "")
+    `Found ${allCandidates.length} skills` + (filteredCount > 0 ? chalk9.dim(` (${filteredCount} already installed)`) : "")
   );
   let results;
   const config = loadConfig();
   if (config) {
-    const scoreSpinner = ora4("Scoring relevance for your project...").start();
+    const scoreSpinner = ora5("Scoring relevance for your project...").start();
     try {
       const projectContext = buildProjectContext(process.cwd());
-      results = await scoreWithLLM(newCandidates, projectContext, technologies);
+      results = await scoreWithLLM2(newCandidates, projectContext, technologies);
       if (results.length === 0) {
         scoreSpinner.succeed("No highly relevant skills found for your specific project.");
         return;
@@ -5231,7 +5685,7 @@ async function recommendCommand(options) {
   } else {
     results = newCandidates.slice(0, 20);
   }
-  const fetchSpinner = ora4("Verifying skill availability...").start();
+  const fetchSpinner = ora5("Verifying skill availability...").start();
   const contentMap = /* @__PURE__ */ new Map();
   await Promise.all(results.map(async (rec) => {
     const content = await fetchSkillContent(rec);
@@ -5244,14 +5698,14 @@ async function recommendCommand(options) {
   }
   const unavailableCount = results.length - available.length;
   fetchSpinner.succeed(
-    `${available.length} installable skill${available.length > 1 ? "s" : ""}` + (unavailableCount > 0 ? chalk8.dim(` (${unavailableCount} unavailable)`) : "")
+    `${available.length} installable skill${available.length > 1 ? "s" : ""}` + (unavailableCount > 0 ? chalk9.dim(` (${unavailableCount} unavailable)`) : "")
   );
-  const selected = await interactiveSelect(available);
+  const selected = await interactiveSelect2(available);
   if (selected?.length) {
     await installSkills(selected, platforms, contentMap);
   }
 }
-async function interactiveSelect(recs) {
+async function interactiveSelect2(recs) {
   if (!process.stdin.isTTY) {
     printRecommendations(recs);
     return null;
@@ -5263,27 +5717,27 @@ async function interactiveSelect(recs) {
   const hasScores = recs.some((r) => r.score > 0);
   function render() {
     const lines = [];
-    lines.push(chalk8.bold("  Recommendations"));
+    lines.push(chalk9.bold("  Recommendations"));
     lines.push("");
     if (hasScores) {
-      lines.push(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+      lines.push(`  ${chalk9.dim("Score".padEnd(7))} ${chalk9.dim("Name".padEnd(28))} ${chalk9.dim("Why")}`);
     } else {
-      lines.push(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+      lines.push(`  ${chalk9.dim("Name".padEnd(30))} ${chalk9.dim("Technology".padEnd(18))} ${chalk9.dim("Source")}`);
     }
-    lines.push(chalk8.dim("  " + "\u2500".repeat(70)));
+    lines.push(chalk9.dim("  " + "\u2500".repeat(70)));
     for (let i = 0; i < recs.length; i++) {
       const rec = recs[i];
-      const check = selected.has(i) ? chalk8.green("[x]") : "[ ]";
-      const ptr = i === cursor ? chalk8.cyan(">") : " ";
+      const check = selected.has(i) ? chalk9.green("[x]") : "[ ]";
+      const ptr = i === cursor ? chalk9.cyan(">") : " ";
       if (hasScores) {
-        const scoreColor = rec.score >= 90 ? chalk8.green : rec.score >= 70 ? chalk8.yellow : chalk8.dim;
-        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 40))}`);
+        const scoreColor = rec.score >= 90 ? chalk9.green : rec.score >= 70 ? chalk9.yellow : chalk9.dim;
+        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(26)} ${chalk9.dim(rec.reason.slice(0, 40))}`);
       } else {
-        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk9.dim(rec.source_url || "")}`);
       }
     }
     lines.push("");
-    lines.push(chalk8.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
+    lines.push(chalk9.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -5332,7 +5786,7 @@ async function interactiveSelect(recs) {
         case "\n":
           cleanup();
           if (selected.size === 0) {
-            console.log(chalk8.dim("\n  No skills selected.\n"));
+            console.log(chalk9.dim("\n  No skills selected.\n"));
             resolve2(null);
           } else {
             resolve2(Array.from(selected).sort().map((i) => recs[i]));
@@ -5342,7 +5796,7 @@ async function interactiveSelect(recs) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk8.dim("\n  Cancelled.\n"));
+          console.log(chalk9.dim("\n  Cancelled.\n"));
           resolve2(null);
           break;
       }
@@ -5388,7 +5842,7 @@ async function fetchSkillContent(rec) {
   return null;
 }
 async function installSkills(recs, platforms, contentMap) {
-  const spinner = ora4(`Installing ${recs.length} skill${recs.length > 1 ? "s" : ""}...`).start();
+  const spinner = ora5(`Installing ${recs.length} skill${recs.length > 1 ? "s" : ""}...`).start();
   const installed = [];
   for (const rec of recs) {
     const content = contentMap.get(rec.slug);
@@ -5404,7 +5858,7 @@ async function installSkills(recs, platforms, contentMap) {
   if (installed.length > 0) {
     spinner.succeed(`Installed ${installed.length} file${installed.length > 1 ? "s" : ""}`);
     for (const p of installed) {
-      console.log(chalk8.green(`  \u2713 ${p}`));
+      console.log(chalk9.green(`  \u2713 ${p}`));
     }
   } else {
     spinner.fail("No skills were installed");
@@ -5413,25 +5867,25 @@ async function installSkills(recs, platforms, contentMap) {
 }
 function printRecommendations(recs) {
   const hasScores = recs.some((r) => r.score > 0);
-  console.log(chalk8.bold("\n  Recommendations\n"));
+  console.log(chalk9.bold("\n  Recommendations\n"));
   if (hasScores) {
-    console.log(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+    console.log(`  ${chalk9.dim("Score".padEnd(7))} ${chalk9.dim("Name".padEnd(28))} ${chalk9.dim("Why")}`);
   } else {
-    console.log(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+    console.log(`  ${chalk9.dim("Name".padEnd(30))} ${chalk9.dim("Technology".padEnd(18))} ${chalk9.dim("Source")}`);
   }
-  console.log(chalk8.dim("  " + "\u2500".repeat(70)));
+  console.log(chalk9.dim("  " + "\u2500".repeat(70)));
   for (const rec of recs) {
     if (hasScores) {
-      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 50))}`);
+      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(26)} ${chalk9.dim(rec.reason.slice(0, 50))}`);
     } else {
-      console.log(`  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+      console.log(`  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk9.dim(rec.source_url || "")}`);
     }
   }
   console.log("");
 }
 
 // src/commands/score.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 async function scoreCommand(options) {
   const dir = process.cwd();
   const target = options.agent ?? readState()?.targetAgent;
@@ -5445,23 +5899,23 @@ async function scoreCommand(options) {
     return;
   }
   displayScore(result);
-  const separator = chalk9.gray("  " + "\u2500".repeat(53));
+  const separator = chalk10.gray("  " + "\u2500".repeat(53));
   console.log(separator);
   if (result.score < 40) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to generate a complete, optimized setup."));
+    console.log(chalk10.gray("  Run ") + chalk10.hex("#83D1EB")("caliber onboard") + chalk10.gray(" to generate a complete, optimized setup."));
   } else if (result.score < 70) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#83D1EB")("caliber onboard") + chalk9.gray(" to improve your setup."));
+    console.log(chalk10.gray("  Run ") + chalk10.hex("#83D1EB")("caliber onboard") + chalk10.gray(" to improve your setup."));
   } else {
-    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#83D1EB")("caliber update") + chalk9.gray(" to keep it fresh."));
+    console.log(chalk10.green("  Looking good!") + chalk10.gray(" Run ") + chalk10.hex("#83D1EB")("caliber update") + chalk10.gray(" to keep it fresh."));
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
 import fs22 from "fs";
-import path19 from "path";
-import chalk10 from "chalk";
-import ora5 from "ora";
+import path18 from "path";
+import chalk11 from "chalk";
+import ora6 from "ora";
 
 // src/lib/git-diff.ts
 import { execSync as execSync8 } from "child_process";
@@ -5537,7 +5991,7 @@ function collectDiff(lastSha) {
 
 // src/writers/refresh.ts
 import fs21 from "fs";
-import path18 from "path";
+import path17 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
@@ -5553,19 +6007,19 @@ function writeRefreshDocs(docs) {
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path18.join(".cursor", "rules");
+    const rulesDir = path17.join(".cursor", "rules");
     if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path18.join(rulesDir, rule.filename);
+      const filePath = path17.join(rulesDir, rule.filename);
       fs21.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path18.join(".claude", "skills");
+    const skillsDir = path17.join(".claude", "skills");
     if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path18.join(skillsDir, skill.filename);
+      const filePath = path17.join(skillsDir, skill.filename);
       fs21.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
@@ -5644,8 +6098,8 @@ function discoverGitRepos(parentDir) {
     const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path19.join(parentDir, entry.name);
-      if (fs22.existsSync(path19.join(childPath, ".git"))) {
+      const childPath = path18.join(parentDir, entry.name);
+      if (fs22.existsSync(path18.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -5655,7 +6109,7 @@ function discoverGitRepos(parentDir) {
 }
 async function refreshSingleRepo(repoDir, options) {
   const quiet = !!options.quiet;
-  const prefix = options.label ? `${chalk10.bold(options.label)} ` : "";
+  const prefix = options.label ? `${chalk11.bold(options.label)} ` : "";
   const state = readState();
   const lastSha = state?.lastRefreshSha ?? null;
   const diff = collectDiff(lastSha);
@@ -5664,10 +6118,10 @@ async function refreshSingleRepo(repoDir, options) {
     if (currentSha) {
       writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
     }
-    log(quiet, chalk10.dim(`${prefix}No changes since last refresh.`));
+    log(quiet, chalk11.dim(`${prefix}No changes since last refresh.`));
     return;
   }
-  const spinner = quiet ? null : ora5(`${prefix}Analyzing changes...`).start();
+  const spinner = quiet ? null : ora6(`${prefix}Analyzing changes...`).start();
   const existingDocs = readExistingConfigs(repoDir);
   const fingerprint = collectFingerprint(repoDir);
   const projectContext = {
@@ -5696,10 +6150,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(`  ${chalk10.yellow("~")} ${doc}`);
+      console.log(`  ${chalk11.yellow("~")} ${doc}`);
     }
     if (response.changesSummary) {
-      console.log(chalk10.dim(`
+      console.log(chalk11.dim(`
   ${response.changesSummary}`));
     }
     return;
@@ -5707,10 +6161,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, `  ${chalk10.green("\u2713")} ${file}`);
+    log(quiet, `  ${chalk11.green("\u2713")} ${file}`);
   }
   if (response.changesSummary) {
-    log(quiet, chalk10.dim(`
+    log(quiet, chalk11.dim(`
   ${response.changesSummary}`));
   }
   if (currentSha) {
@@ -5723,7 +6177,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk10.red("No LLM provider configured. Run ") + chalk10.hex("#83D1EB")("caliber config") + chalk10.red(" (e.g. choose Cursor) or set an API key."));
+      console.log(chalk11.red("No LLM provider configured. Run ") + chalk11.hex("#83D1EB")("caliber config") + chalk11.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     if (isGitRepo()) {
@@ -5733,20 +6187,20 @@ async function refreshCommand(options) {
     const repos = discoverGitRepos(process.cwd());
     if (repos.length === 0) {
       if (quiet) return;
-      console.log(chalk10.red("Not inside a git repository and no git repos found in child directories."));
+      console.log(chalk11.red("Not inside a git repository and no git repos found in child directories."));
       throw new Error("__exit__");
     }
-    log(quiet, chalk10.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
+    log(quiet, chalk11.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path19.basename(repo);
+      const repoName = path18.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
       } catch (err) {
         if (err instanceof Error && err.message === "__exit__") continue;
-        log(quiet, chalk10.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+        log(quiet, chalk11.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
       }
     }
     process.chdir(originalDir);
@@ -5754,13 +6208,13 @@ 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(chalk10.red(`Refresh failed: ${msg}`));
+    console.log(chalk11.red(`Refresh failed: ${msg}`));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/hooks.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var HOOKS = [
   {
     id: "session-end",
@@ -5780,13 +6234,13 @@ var HOOKS = [
   }
 ];
 function printStatus() {
-  console.log(chalk11.bold("\n  Hooks\n"));
+  console.log(chalk12.bold("\n  Hooks\n"));
   for (const hook of HOOKS) {
     const installed = hook.isInstalled();
-    const icon = installed ? chalk11.green("\u2713") : chalk11.dim("\u2717");
-    const state = installed ? chalk11.green("enabled") : chalk11.dim("disabled");
+    const icon = installed ? chalk12.green("\u2713") : chalk12.dim("\u2717");
+    const state = installed ? chalk12.green("enabled") : chalk12.dim("disabled");
     console.log(`  ${icon} ${hook.label.padEnd(26)} ${state}`);
-    console.log(chalk11.dim(`    ${hook.description}`));
+    console.log(chalk12.dim(`    ${hook.description}`));
   }
   console.log("");
 }
@@ -5795,9 +6249,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.install();
       if (result.alreadyInstalled) {
-        console.log(chalk11.dim(`  ${hook.label} already enabled.`));
+        console.log(chalk12.dim(`  ${hook.label} already enabled.`));
       } else {
-        console.log(chalk11.green("  \u2713") + ` ${hook.label} enabled`);
+        console.log(chalk12.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
     return;
@@ -5806,9 +6260,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.remove();
       if (result.notFound) {
-        console.log(chalk11.dim(`  ${hook.label} already disabled.`));
+        console.log(chalk12.dim(`  ${hook.label} already disabled.`));
       } else {
-        console.log(chalk11.green("  \u2713") + ` ${hook.label} removed`);
+        console.log(chalk12.green("  \u2713") + ` ${hook.label} removed`);
       }
     }
     return;
@@ -5823,18 +6277,18 @@ async function hooksCommand(options) {
   const states = HOOKS.map((h) => h.isInstalled());
   function render() {
     const lines = [];
-    lines.push(chalk11.bold("  Hooks"));
+    lines.push(chalk12.bold("  Hooks"));
     lines.push("");
     for (let i = 0; i < HOOKS.length; i++) {
       const hook = HOOKS[i];
       const enabled = states[i];
-      const toggle = enabled ? chalk11.green("[on] ") : chalk11.dim("[off]");
-      const ptr = i === cursor ? chalk11.cyan(">") : " ";
+      const toggle = enabled ? chalk12.green("[on] ") : chalk12.dim("[off]");
+      const ptr = i === cursor ? chalk12.cyan(">") : " ";
       lines.push(`  ${ptr} ${toggle} ${hook.label}`);
-      lines.push(chalk11.dim(`        ${hook.description}`));
+      lines.push(chalk12.dim(`        ${hook.description}`));
     }
     lines.push("");
-    lines.push(chalk11.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
+    lines.push(chalk12.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -5865,16 +6319,16 @@ async function hooksCommand(options) {
         const wantEnabled = states[i];
         if (wantEnabled && !wasInstalled) {
           hook.install();
-          console.log(chalk11.green("  \u2713") + ` ${hook.label} enabled`);
+          console.log(chalk12.green("  \u2713") + ` ${hook.label} enabled`);
           changed++;
         } else if (!wantEnabled && wasInstalled) {
           hook.remove();
-          console.log(chalk11.green("  \u2713") + ` ${hook.label} disabled`);
+          console.log(chalk12.green("  \u2713") + ` ${hook.label} disabled`);
           changed++;
         }
       }
       if (changed === 0) {
-        console.log(chalk11.dim("  No changes."));
+        console.log(chalk12.dim("  No changes."));
       }
       console.log("");
     }
@@ -5910,7 +6364,7 @@ async function hooksCommand(options) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk11.dim("\n  Cancelled.\n"));
+          console.log(chalk12.dim("\n  Cancelled.\n"));
           resolve2();
           break;
       }
@@ -5920,43 +6374,43 @@ async function hooksCommand(options) {
 }
 
 // src/commands/config.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function configCommand() {
   const existing = loadConfig();
   if (existing) {
-    console.log(chalk12.bold("\nCurrent Configuration\n"));
-    console.log(`  Provider: ${chalk12.cyan(existing.provider)}`);
-    console.log(`  Model:    ${chalk12.cyan(existing.model)}`);
+    console.log(chalk13.bold("\nCurrent Configuration\n"));
+    console.log(`  Provider: ${chalk13.cyan(existing.provider)}`);
+    console.log(`  Model:    ${chalk13.cyan(existing.model)}`);
     if (existing.apiKey) {
       const masked = existing.apiKey.slice(0, 8) + "..." + existing.apiKey.slice(-4);
-      console.log(`  API Key:  ${chalk12.dim(masked)}`);
+      console.log(`  API Key:  ${chalk13.dim(masked)}`);
     }
     if (existing.provider === "cursor") {
-      console.log(`  Seat:     ${chalk12.dim("Cursor (agent acp)")}`);
+      console.log(`  Seat:     ${chalk13.dim("Cursor (agent acp)")}`);
     }
     if (existing.provider === "claude-cli") {
-      console.log(`  Seat:     ${chalk12.dim("Claude Code (claude -p)")}`);
+      console.log(`  Seat:     ${chalk13.dim("Claude Code (claude -p)")}`);
     }
     if (existing.baseUrl) {
-      console.log(`  Base URL: ${chalk12.dim(existing.baseUrl)}`);
+      console.log(`  Base URL: ${chalk13.dim(existing.baseUrl)}`);
     }
     if (existing.vertexProjectId) {
-      console.log(`  Vertex Project: ${chalk12.dim(existing.vertexProjectId)}`);
-      console.log(`  Vertex Region:  ${chalk12.dim(existing.vertexRegion || "us-east5")}`);
+      console.log(`  Vertex Project: ${chalk13.dim(existing.vertexProjectId)}`);
+      console.log(`  Vertex Region:  ${chalk13.dim(existing.vertexRegion || "us-east5")}`);
     }
-    console.log(`  Source:   ${chalk12.dim(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.VERTEX_PROJECT_ID || process.env.CALIBER_USE_CURSOR_SEAT || process.env.CALIBER_USE_CLAUDE_CLI ? "environment variables" : getConfigFilePath())}`);
+    console.log(`  Source:   ${chalk13.dim(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.VERTEX_PROJECT_ID || process.env.CALIBER_USE_CURSOR_SEAT || process.env.CALIBER_USE_CLAUDE_CLI ? "environment variables" : getConfigFilePath())}`);
     console.log("");
   }
   await runInteractiveProviderSetup();
-  console.log(chalk12.green("\n\u2713 Configuration saved"));
-  console.log(chalk12.dim(`  ${getConfigFilePath()}
+  console.log(chalk13.green("\n\u2713 Configuration saved"));
+  console.log(chalk13.dim(`  ${getConfigFilePath()}
 `));
-  console.log(chalk12.dim("  You can also set environment variables instead:"));
-  console.log(chalk12.dim("  ANTHROPIC_API_KEY, OPENAI_API_KEY, VERTEX_PROJECT_ID, CALIBER_USE_CURSOR_SEAT=1, or CALIBER_USE_CLAUDE_CLI=1\n"));
+  console.log(chalk13.dim("  You can also set environment variables instead:"));
+  console.log(chalk13.dim("  ANTHROPIC_API_KEY, OPENAI_API_KEY, VERTEX_PROJECT_ID, CALIBER_USE_CURSOR_SEAT=1, or CALIBER_USE_CLAUDE_CLI=1\n"));
 }
 
 // src/commands/learn.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // src/learner/stdin.ts
 var STDIN_TIMEOUT_MS = 5e3;
@@ -5988,7 +6442,7 @@ function readStdin() {
 // src/learner/storage.ts
 init_constants();
 import fs23 from "fs";
-import path20 from "path";
+import path19 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -6001,10 +6455,10 @@ function ensureLearningDir() {
   }
 }
 function sessionFilePath() {
-  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -6058,7 +6512,7 @@ function resetState() {
 
 // src/learner/writer.ts
 import fs24 from "fs";
-import path21 from "path";
+import path20 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6096,9 +6550,9 @@ ${LEARNED_END}`;
   fs24.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path21.join(".claude", "skills", skill.name);
+  const skillDir = path20.join(".claude", "skills", skill.name);
   if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path21.join(skillDir, "SKILL.md");
+  const skillPath = path20.join(skillDir, "SKILL.md");
   if (!skill.isNew && fs24.existsSync(skillPath)) {
     const existing = fs24.readFileSync(skillPath, "utf-8");
     fs24.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
@@ -6257,53 +6711,53 @@ async function learnFinalizeCommand() {
 async function learnInstallCommand() {
   const result = installLearningHooks();
   if (result.alreadyInstalled) {
-    console.log(chalk13.dim("Learning hooks already installed."));
+    console.log(chalk14.dim("Learning hooks already installed."));
     return;
   }
-  console.log(chalk13.green("\u2713") + " Learning hooks installed in .claude/settings.json");
-  console.log(chalk13.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
-  console.log(chalk13.dim("  Session learnings will be written to CLAUDE.md and skills."));
+  console.log(chalk14.green("\u2713") + " Learning hooks installed in .claude/settings.json");
+  console.log(chalk14.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
+  console.log(chalk14.dim("  Session learnings will be written to CLAUDE.md and skills."));
 }
 async function learnRemoveCommand() {
   const result = removeLearningHooks();
   if (result.notFound) {
-    console.log(chalk13.dim("Learning hooks not found."));
+    console.log(chalk14.dim("Learning hooks not found."));
     return;
   }
-  console.log(chalk13.green("\u2713") + " Learning hooks removed from .claude/settings.json");
+  console.log(chalk14.green("\u2713") + " Learning hooks removed from .claude/settings.json");
 }
 async function learnStatusCommand() {
   const installed = areLearningHooksInstalled();
   const state = readState2();
   const eventCount = getEventCount();
-  console.log(chalk13.bold("Session Learning Status"));
+  console.log(chalk14.bold("Session Learning Status"));
   console.log();
   if (installed) {
-    console.log(chalk13.green("\u2713") + " Learning hooks are " + chalk13.green("installed"));
+    console.log(chalk14.green("\u2713") + " Learning hooks are " + chalk14.green("installed"));
   } else {
-    console.log(chalk13.dim("\u2717") + " Learning hooks are " + chalk13.yellow("not installed"));
-    console.log(chalk13.dim("  Run `caliber learn install` to enable session learning."));
+    console.log(chalk14.dim("\u2717") + " Learning hooks are " + chalk14.yellow("not installed"));
+    console.log(chalk14.dim("  Run `caliber learn install` to enable session learning."));
   }
   console.log();
-  console.log(`Events recorded: ${chalk13.cyan(String(eventCount))}`);
-  console.log(`Total this session: ${chalk13.cyan(String(state.eventCount))}`);
+  console.log(`Events recorded: ${chalk14.cyan(String(eventCount))}`);
+  console.log(`Total this session: ${chalk14.cyan(String(state.eventCount))}`);
   if (state.lastAnalysisTimestamp) {
-    console.log(`Last analysis: ${chalk13.cyan(state.lastAnalysisTimestamp)}`);
+    console.log(`Last analysis: ${chalk14.cyan(state.lastAnalysisTimestamp)}`);
   } else {
-    console.log(`Last analysis: ${chalk13.dim("none")}`);
+    console.log(`Last analysis: ${chalk14.dim("none")}`);
   }
   const learnedSection = readLearnedSection();
   if (learnedSection) {
     const lineCount = learnedSection.split("\n").filter(Boolean).length;
     console.log(`
-Learned items in CLAUDE.md: ${chalk13.cyan(String(lineCount))}`);
+Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
   }
 }
 
 // src/cli.ts
-var __dirname = path22.dirname(fileURLToPath(import.meta.url));
+var __dirname = path21.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs25.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs25.readFileSync(path21.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -6326,20 +6780,20 @@ learn.command("status").description("Show learning system status").action(learnS
 
 // src/utils/version-check.ts
 import fs26 from "fs";
-import path23 from "path";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
-import chalk14 from "chalk";
-import ora6 from "ora";
+import chalk15 from "chalk";
+import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs26.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path22.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync9("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
     return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
@@ -6363,17 +6817,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 @rely-ai/caliber")} to upgrade.
+Run ${chalk15.bold("npm install -g @rely-ai/caliber")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk14.yellow(`
+      chalk15.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
@@ -6381,7 +6835,7 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
-    const spinner = ora6("Updating caliber...").start();
+    const spinner = ora7("Updating caliber...").start();
     try {
       execSync9(`npm install -g @rely-ai/caliber@${latest}`, {
         stdio: "pipe",
@@ -6391,13 +6845,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk14.yellow(`Run ${chalk14.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
+        console.log(chalk15.yellow(`Run ${chalk15.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
 `));
         return;
       }
-      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(" ")}
 `));
       execSync9(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -6410,11 +6864,11 @@ Restarting: caliber ${args.join(" ")}
       if (err instanceof Error) {
         const stderr = err.stderr;
         const errMsg = stderr ? String(stderr).trim().split("\n").pop() : err.message.split("\n")[0];
-        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk14.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk15.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk14.yellow(
-          `Run ${chalk14.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
+        chalk15.yellow(
+          `Run ${chalk15.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
 `
         )
       );