@rely-ai/caliber 1.1.1 → 1.1.3

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;
@@ -51,8 +51,8 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs27 from "fs";
-import path24 from "path";
+import fs25 from "fs";
+import path21 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
@@ -60,11 +60,11 @@ import chalk5 from "chalk";
 import ora2 from "ora";
 import readline4 from "readline";
 import select2 from "@inquirer/select";
-import fs20 from "fs";
+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(path26) {
+function readFileOrNull(path23) {
   try {
-    return readFileSync(path26, "utf-8");
+    return readFileSync(path23, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path26) {
-  const content = readFileOrNull(path26);
+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(path26) {
+function readFileOrNull2(path23) {
   try {
-    return readFileSync3(path26, "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(path26) {
+function readFileOrNull3(path23) {
   try {
-    return readFileSync4(path26, "utf-8");
+    return readFileSync4(path23, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path26) {
-  const content = readFileOrNull3(path26);
+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(path26) {
+function readFileOrNull4(path23) {
   try {
-    return readFileSync5(path26, "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(path26) {
+function readFileOrNull5(path23) {
   try {
-    return readFileSync6(path26, "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));
@@ -3857,283 +3799,8 @@ function displayScoreDelta(before, after) {
 import chalk4 from "chalk";
 import ora from "ora";
 import readline3 from "readline";
-import fs19 from "fs";
-import path18 from "path";
-
-// src/mcp/deps.ts
-import fs18 from "fs";
-import path17 from "path";
-function extractAllDeps(dir) {
-  const deps = /* @__PURE__ */ new Set();
-  parsePackageJson(dir, deps);
-  parseRequirementsTxt(dir, deps);
-  parsePyprojectToml(dir, deps);
-  parseGoMod(dir, deps);
-  parseCargoToml(dir, deps);
-  parseGemfile(dir, deps);
-  parseComposerJson(dir, deps);
-  return Array.from(deps);
-}
-function readFileSafe(filePath) {
-  try {
-    if (fs18.existsSync(filePath)) {
-      return fs18.readFileSync(filePath, "utf-8");
-    }
-  } catch {
-  }
-  return null;
-}
-function parsePackageJson(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "package.json"));
-  if (!content) return;
-  try {
-    const pkg3 = JSON.parse(content);
-    const allDeps = {
-      ...pkg3.dependencies,
-      ...pkg3.devDependencies
-    };
-    for (const name of Object.keys(allDeps)) {
-      deps.add(name);
-    }
-  } catch {
-  }
-}
-function parseRequirementsTxt(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "requirements.txt"));
-  if (!content) return;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("-")) continue;
-    const match = trimmed.match(/^([a-zA-Z0-9_-]+(?:\[[^\]]*\])?)/);
-    if (match) {
-      deps.add(match[1].replace(/\[.*\]/, "").toLowerCase());
-    }
-  }
-}
-function parsePyprojectToml(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "pyproject.toml"));
-  if (!content) return;
-  const depsMatch = content.match(/\bdependencies\s*=\s*\[([\s\S]*?)\]/);
-  if (depsMatch) {
-    const items = depsMatch[1].matchAll(/"([a-zA-Z0-9_-]+)/g);
-    for (const m of items) {
-      deps.add(m[1].toLowerCase());
-    }
-  }
-}
-function parseGoMod(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "go.mod"));
-  if (!content) return;
-  const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/g);
-  if (requireBlock) {
-    for (const block of requireBlock) {
-      const lines = block.split("\n");
-      for (const line of lines) {
-        const match = line.trim().match(/^([a-zA-Z0-9./\-_]+)\s/);
-        if (match && !match[1].startsWith("//") && match[1].includes("/")) {
-          const parts = match[1].split("/");
-          deps.add(parts[parts.length - 1]);
-        }
-      }
-    }
-  }
-}
-function parseCargoToml(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "Cargo.toml"));
-  if (!content) return;
-  const sections = content.split(/\[/);
-  for (const section of sections) {
-    if (section.startsWith("dependencies]") || section.startsWith("dev-dependencies]")) {
-      const lines = section.split("\n").slice(1);
-      for (const line of lines) {
-        if (line.startsWith("[")) break;
-        const match = line.match(/^([a-zA-Z0-9_-]+)\s*=/);
-        if (match) {
-          deps.add(match[1]);
-        }
-      }
-    }
-  }
-}
-function parseGemfile(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "Gemfile"));
-  if (!content) return;
-  const gemPattern = /gem\s+['"]([a-zA-Z0-9_-]+)['"]/g;
-  let match;
-  while ((match = gemPattern.exec(content)) !== null) {
-    deps.add(match[1]);
-  }
-}
-function parseComposerJson(dir, deps) {
-  const content = readFileSafe(path17.join(dir, "composer.json"));
-  if (!content) return;
-  try {
-    const composer = JSON.parse(content);
-    const allDeps = {
-      ...composer.require,
-      ...composer["require-dev"]
-    };
-    for (const name of Object.keys(allDeps)) {
-      if (name !== "php" && !name.startsWith("ext-")) {
-        deps.add(name);
-      }
-    }
-  } catch {
-  }
-}
-
-// src/mcp/prompts.ts
-var CLASSIFY_DEPS_PROMPT = `You classify software dependencies into two categories:
-
-**Tools** (MCP-worthy): Services, platforms, APIs, databases, SaaS products, and cloud services that have their own web dashboards, APIs, or external infrastructure. Examples: supabase, stripe, sentry, datadog, firebase, mongodb, redis, slack, linear, github, vercel, aws-sdk, twilio, sendgrid, algolia, elasticsearch, prisma, planetscale, neon, clerk, auth0.
-
-**Libraries** (skip): Utility packages, frameworks, build tools, test runners, and local-only code that does NOT connect to an external service. Examples: lodash, react, express, vitest, webpack, zod, chalk, commander, typescript, eslint, prettier, axios, dayjs, uuid.
-
-Given a list of dependencies, return ONLY the tool dependencies as a JSON array of strings.
-Return ONLY the JSON array, no explanation.`;
-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/classify.ts
-async function classifyDeps(allDeps) {
-  if (allDeps.length === 0) return [];
-  try {
-    const result = await llmJsonCall({
-      system: CLASSIFY_DEPS_PROMPT,
-      prompt: `Dependencies:
-${JSON.stringify(allDeps)}`,
-      maxTokens: 2e3
-    });
-    if (!Array.isArray(result)) return [];
-    const inputLower = new Set(allDeps.map((d) => d.toLowerCase()));
-    return result.filter((d) => typeof d === "string" && inputLower.has(d.toLowerCase()));
-  } catch {
-    return fallbackClassify(allDeps);
-  }
-}
-function fallbackClassify(deps) {
-  const utilityPatterns = [
-    /^@types\//,
-    /^eslint/,
-    /^prettier/,
-    /^@typescript-eslint\//,
-    /^@commitlint\//,
-    /^@eslint\//,
-    /^webpack/,
-    /^rollup/,
-    /^babel/,
-    /^@babel\//,
-    /^postcss/,
-    /^tailwindcss/,
-    /^autoprefixer/
-  ];
-  const utilities = /* @__PURE__ */ new Set([
-    "typescript",
-    "tslib",
-    "ts-node",
-    "tsx",
-    "prettier",
-    "eslint",
-    "rimraf",
-    "cross-env",
-    "dotenv",
-    "nodemon",
-    "husky",
-    "lint-staged",
-    "commitlint",
-    "chalk",
-    "ora",
-    "commander",
-    "yargs",
-    "meow",
-    "inquirer",
-    "glob",
-    "minimatch",
-    "micromatch",
-    "diff",
-    "semver",
-    "uuid",
-    "nanoid",
-    "debug",
-    "ms",
-    "lodash",
-    "underscore",
-    "ramda",
-    "tsup",
-    "esbuild",
-    "rollup",
-    "webpack",
-    "vite",
-    "parcel",
-    "vitest",
-    "jest",
-    "mocha",
-    "chai",
-    "ava",
-    "tap",
-    "fs-extra",
-    "mkdirp",
-    "del",
-    "path-to-regexp",
-    "strip-ansi",
-    "ansi-colors",
-    "react",
-    "react-dom",
-    "next",
-    "vue",
-    "angular",
-    "svelte",
-    "express",
-    "fastify",
-    "koa",
-    "hapi",
-    "zod",
-    "joi",
-    "yup",
-    "ajv",
-    "axios",
-    "node-fetch",
-    "got",
-    "undici",
-    "moment",
-    "dayjs",
-    "date-fns",
-    "luxon"
-  ]);
-  return deps.filter((d) => {
-    const lower = d.toLowerCase();
-    if (utilities.has(lower)) return false;
-    if (utilityPatterns.some((p) => p.test(lower))) return false;
-    return true;
-  });
-}
+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";
@@ -4285,6 +3952,37 @@ async function searchVendorOrg(dep) {
   }
 }
 
+// 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;
@@ -4377,40 +4075,28 @@ ${truncated}`,
 // src/mcp/index.ts
 async function discoverAndInstallMcps(targetAgent, fingerprint, dir) {
   console.log(chalk4.hex("#6366f1").bold("\n  MCP Server Discovery\n"));
-  const spinner = ora("Analyzing dependencies for tool integrations...").start();
-  const allDeps = extractAllDeps(dir);
-  if (allDeps.length === 0) {
-    spinner.succeed(chalk4.dim("No dependencies found \u2014 skipping MCP discovery"));
-    return { installed: 0, names: [] };
-  }
-  const toolDeps = await classifyDeps(allDeps);
+  const toolDeps = fingerprint.tools;
   if (toolDeps.length === 0) {
-    spinner.succeed(chalk4.dim("No tool dependencies detected \u2014 skipping MCP discovery"));
-    console.log(chalk4.dim(`  All deps (${allDeps.length}): ${allDeps.slice(0, 10).join(", ")}${allDeps.length > 10 ? "..." : ""}`));
+    console.log(chalk4.dim("  No external tools or services detected \u2014 skipping MCP discovery"));
     return { installed: 0, names: [] };
   }
-  spinner.succeed(`Found ${toolDeps.length} tool dependenc${toolDeps.length === 1 ? "y" : "ies"}: ${toolDeps.join(", ")}`);
-  console.log(chalk4.dim(`  All deps (${allDeps.length}): ${allDeps.slice(0, 10).join(", ")}${allDeps.length > 10 ? "..." : ""}`));
-  console.log(chalk4.dim(`  Classified as tools: ${toolDeps.join(", ")}`));
+  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().replace(/^@[^/]+\//, "");
+    const lower = d.toLowerCase();
     return !existingMcps.some((name) => name.includes(lower) || lower.includes(name));
   });
   if (filteredDeps.length === 0) {
-    console.log(chalk4.dim("  All detected tools already have MCP servers configured."));
-    console.log(chalk4.dim(`  Existing MCPs: ${existingMcps.join(", ")}`));
+    spinner.succeed(chalk4.dim("All detected tools already have MCP servers configured"));
     return { installed: 0, names: [] };
   }
-  const searchSpinner = ora("Searching for MCP servers...").start();
   const candidates = await searchAllMcpSources(filteredDeps);
   if (candidates.length === 0) {
-    searchSpinner.succeed(chalk4.dim("No MCP servers found for your dependencies"));
-    console.log(chalk4.dim(`  Searched for: ${filteredDeps.join(", ")}`));
+    spinner.succeed(chalk4.dim("No MCP servers found for detected tools"));
     return { installed: 0, names: [] };
   }
-  searchSpinner.succeed(`Found ${candidates.length} candidate${candidates.length === 1 ? "" : "s"}`);
-  console.log(chalk4.dim(`  Sources: ${candidates.map((c) => c.repoFullName).join(", ")}`));
+  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) {
@@ -4462,26 +4148,26 @@ async function discoverAndInstallMcps(targetAgent, fingerprint, dir) {
     return { installed: 0, names: [] };
   }
   if (targetAgent === "claude" || targetAgent === "both") {
-    writeMcpJson(path18.join(dir, ".mcp.json"), mcpServers);
+    writeMcpJson(path15.join(dir, ".mcp.json"), mcpServers);
   }
   if (targetAgent === "cursor" || targetAgent === "both") {
-    const cursorDir = path18.join(dir, ".cursor");
-    if (!fs19.existsSync(cursorDir)) fs19.mkdirSync(cursorDir, { recursive: true });
-    writeMcpJson(path18.join(cursorDir, "mcp.json"), mcpServers);
+    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 (fs19.existsSync(filePath)) {
-      const parsed = JSON.parse(fs19.readFileSync(filePath, "utf-8"));
+    if (fs17.existsSync(filePath)) {
+      const parsed = JSON.parse(fs17.readFileSync(filePath, "utf-8"));
       if (parsed.mcpServers) existing = parsed.mcpServers;
     }
   } catch {
   }
   const merged = { ...existing, ...mcpServers };
-  fs19.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
+  fs17.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
 }
 function getExistingMcpNames(fingerprint, targetAgent) {
   const names = [];
@@ -4618,11 +4304,12 @@ async function initCommand(options) {
   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(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\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(chalk5.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
@@ -4642,10 +4329,10 @@ async function initCommand(options) {
     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(chalk5.dim(modelLine + "\n"));
-  console.log(title.bold("  Step 2/4 \u2014 Discover your project\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());
@@ -4669,11 +4356,27 @@ async function initCommand(options) {
   const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreSummary(baselineScore);
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
+  const NON_LLM_CHECKS = /* @__PURE__ */ new Set(["hooks_configured", "agents_md_exists", "permissions_configured", "mcp_servers"]);
   if (hasExistingConfig && baselineScore.score === 100) {
     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 allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+  const llmFixableChecks = allFailingChecks.filter((c) => !NON_LLM_CHECKS.has(c.id));
+  if (hasExistingConfig && llmFixableChecks.length === 0 && allFailingChecks.length > 0 && !options.force) {
+    console.log(chalk5.bold.green("\n  Your config is fully optimized for LLM generation.\n"));
+    console.log(chalk5.dim("  Remaining items need CLI actions:\n"));
+    for (const check of allFailingChecks) {
+      console.log(chalk5.dim(`    \u2022 ${check.name}`));
+      if (check.suggestion) {
+        console.log(`      ${chalk5.hex("#83D1EB")(check.suggestion)}`);
+      }
+    }
+    console.log("");
+    console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber onboard --force") + chalk5.dim(" to regenerate anyway.\n"));
+    return;
+  }
   const isEmpty = fingerprint.fileTree.length < 3;
   if (isEmpty) {
     fingerprint.description = await promptInput3("What will you build in this project?");
@@ -4682,11 +4385,11 @@ async function initCommand(options) {
   let passingChecks;
   let currentScore;
   if (hasExistingConfig && baselineScore.score >= 95 && !options.force) {
-    failingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0).map((c) => ({ name: c.name, suggestion: c.suggestion }));
+    failingChecks = llmFixableChecks.map((c) => ({ name: c.name, suggestion: c.suggestion }));
     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(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) {
@@ -4695,11 +4398,11 @@ async function initCommand(options) {
       console.log("");
     }
   } else if (hasExistingConfig) {
-    console.log(title.bold("  Step 3/4 \u2014 Improve your setup\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(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(chalk5.dim("  This can take a couple of minutes depending on your model and provider.\n"));
@@ -4760,17 +4463,25 @@ async function initCommand(options) {
     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(chalk5.dim(`  ${chalk5.green(`${staged.newFiles} new`)} / ${chalk5.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
+  const totalChanges = staged.newFiles + staged.modifiedFiles;
+  console.log(chalk5.dim(`  ${chalk5.green(`${staged.newFiles} new`)} / ${chalk5.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}
 `));
-  const wantsReview = await promptWantsReview();
-  if (wantsReview) {
-    const reviewMethod = await promptReviewMethod();
-    await openReview(reviewMethod, staged.stagedFiles);
+  let action;
+  if (totalChanges === 0) {
+    console.log(chalk5.dim("  No changes needed \u2014 your configs are already up to date.\n"));
+    cleanupStaging();
+    action = "accept";
+  } else {
+    const wantsReview = await promptWantsReview();
+    if (wantsReview) {
+      const reviewMethod = await promptReviewMethod();
+      await openReview(reviewMethod, staged.stagedFiles);
+    }
+    action = await promptReviewAction();
   }
-  let action = await promptReviewAction();
   while (action === "refine") {
     generatedSetup = await refineLoop(generatedSetup, targetAgent, sessionHistory);
     if (!generatedSetup) {
@@ -4819,17 +4530,24 @@ async function initCommand(options) {
     console.error(chalk5.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
-  try {
-    const mcpResult = await discoverAndInstallMcps(targetAgent, fingerprint, process.cwd());
-    if (mcpResult.installed > 0) {
-      console.log(chalk5.bold(`
+  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}`);
+        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")));
     }
-  } 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();
@@ -4938,12 +4656,12 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path26, desc]) => `  ${path26}: ${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).
@@ -4960,7 +4678,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,
@@ -5058,8 +4776,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs20.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs20.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs18.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs18.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -5242,7 +4960,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs20.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk5.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk5.dim(`    ${desc}`));
@@ -5252,7 +4970,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs20.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
         console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
@@ -5262,7 +4980,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs20.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk5.bold(".cursorrules")}`);
       if (desc) console.log(chalk5.dim(`    ${desc}`));
@@ -5272,7 +4990,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs20.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
         console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
@@ -5283,7 +5001,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs20.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk5.bold(rulePath)}`);
         if (desc) {
@@ -5296,7 +5014,7 @@ function printSetupSummary(setup) {
       }
     }
   }
-  if (!fs20.existsSync("AGENTS.md")) {
+  if (!fs18.existsSync("AGENTS.md")) {
     console.log(`  ${chalk5.green("+")} ${chalk5.bold("AGENTS.md")}`);
     console.log(chalk5.dim("    Cross-agent coordination file"));
     console.log("");
@@ -5324,8 +5042,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs20.existsSync(settingsPath)) {
-      settings = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
+    if (fs18.existsSync(settingsPath)) {
+      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -5339,8 +5057,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs20.existsSync(".claude")) fs20.mkdirSync(".claude", { recursive: true });
-  fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs18.existsSync(".claude")) fs18.mkdirSync(".claude", { recursive: true });
+  fs18.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function collectSetupFiles(setup) {
   const files = [];
@@ -5370,7 +5088,7 @@ function collectSetupFiles(setup) {
       }
     }
   }
-  if (!fs20.existsSync("AGENTS.md")) {
+  if (!fs18.existsSync("AGENTS.md")) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -5421,7 +5139,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk7 from "chalk";
-import fs21 from "fs";
+import fs19 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -5447,7 +5165,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk7.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs21.existsSync(entry.path);
+    const exists = fs19.existsSync(entry.path);
     const icon = exists ? chalk7.green("\u2713") : chalk7.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -5534,13 +5252,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs22 from "fs";
-import path19 from "path";
+import fs20 from "fs";
+import path16 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path19.join(dir, "CLAUDE.md");
-  if (fs22.existsSync(claudeMdPath)) {
+  const claudeMdPath = path16.join(dir, "CLAUDE.md");
+  if (fs20.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5549,10 +5267,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path19.join(dir, ".claude", "skills");
-  if (fs22.existsSync(skillsDir)) {
-    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path19.join(skillsDir, file);
+  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 = path16.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -5562,10 +5280,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path19.join(dir, ".mcp.json");
-  if (fs22.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path16.join(dir, ".mcp.json");
+  if (fs20.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5580,8 +5298,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path19.join(dir, ".cursorrules");
-  if (fs22.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path16.join(dir, ".cursorrules");
+  if (fs20.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5590,10 +5308,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path19.join(dir, ".cursor", "rules");
-  if (fs22.existsSync(cursorRulesDir)) {
-    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path19.join(cursorRulesDir, file);
+  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 = path16.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -5603,12 +5321,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
-  if (fs22.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
+  if (fs20.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs22.readdirSync(cursorSkillsDir)) {
-        const skillFile = path19.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs22.existsSync(skillFile)) {
+      for (const name of fs20.readdirSync(cursorSkillsDir)) {
+        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs20.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -5621,10 +5339,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
-  if (fs22.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
+  if (fs20.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5642,7 +5360,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs22.readFileSync(filePath, "utf-8");
+  const text = fs20.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -6218,8 +5936,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs24 from "fs";
-import path21 from "path";
+import fs22 from "fs";
+import path18 from "path";
 import chalk11 from "chalk";
 import ora6 from "ora";
 
@@ -6296,37 +6014,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs21 from "fs";
+import path17 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs23.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs21.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs23.writeFileSync("README.md", docs.readmeMd);
+    fs21.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs23.writeFileSync(".cursorrules", docs.cursorrules);
+    fs21.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path20.join(".cursor", "rules");
-    if (!fs23.existsSync(rulesDir)) fs23.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path17.join(".cursor", "rules");
+    if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path20.join(rulesDir, rule.filename);
-      fs23.writeFileSync(filePath, rule.content);
+      const filePath = path17.join(rulesDir, rule.filename);
+      fs21.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path20.join(".claude", "skills");
-    if (!fs23.existsSync(skillsDir)) fs23.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path17.join(".claude", "skills");
+    if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path20.join(skillsDir, skill.filename);
-      fs23.writeFileSync(filePath, skill.content);
+      const filePath = path17.join(skillsDir, skill.filename);
+      fs21.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -6401,11 +6119,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs24.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path21.join(parentDir, entry.name);
-      if (fs24.existsSync(path21.join(childPath, ".git"))) {
+      const childPath = path18.join(parentDir, entry.name);
+      if (fs22.existsSync(path18.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -6500,7 +6218,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path21.basename(repo);
+      const repoName = path18.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -6747,8 +6465,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs25 from "fs";
-import path22 from "path";
+import fs23 from "fs";
+import path19 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -6756,15 +6474,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs25.existsSync(LEARNING_DIR)) {
-    fs25.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs23.existsSync(LEARNING_DIR)) {
+    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path22.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path22.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -6775,50 +6493,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs25.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs25.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs25.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs25.existsSync(filePath)) return [];
-  const lines = fs25.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs23.existsSync(filePath)) return [];
+  const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs25.existsSync(filePath)) return 0;
-  const content = fs25.readFileSync(filePath, "utf-8");
+  if (!fs23.existsSync(filePath)) return 0;
+  const content = fs23.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs25.existsSync(filePath)) fs25.unlinkSync(filePath);
+  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs25.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs25.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs25.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs26 from "fs";
-import path23 from "path";
+import fs24 from "fs";
+import path20 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6838,8 +6556,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs26.existsSync(claudeMdPath)) {
-    existing = fs26.readFileSync(claudeMdPath, "utf-8");
+  if (fs24.existsSync(claudeMdPath)) {
+    existing = fs24.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6853,15 +6571,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs26.writeFileSync(claudeMdPath, updated);
+  fs24.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path23.join(".claude", "skills", skill.name);
-  if (!fs26.existsSync(skillDir)) fs26.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path23.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs26.existsSync(skillPath)) {
-    const existing = fs26.readFileSync(skillPath, "utf-8");
-    fs26.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path20.join(".claude", "skills", skill.name);
+  if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
+  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);
   } else {
     const frontmatter = [
       "---",
@@ -6870,14 +6588,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs26.writeFileSync(skillPath, frontmatter + skill.content);
+    fs24.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs26.existsSync(claudeMdPath)) return null;
-  const content = fs26.readFileSync(claudeMdPath, "utf-8");
+  if (!fs24.existsSync(claudeMdPath)) return null;
+  const content = fs24.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -7061,9 +6779,9 @@ Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path24.dirname(fileURLToPath(import.meta.url));
+var __dirname = path21.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs27.readFileSync(path24.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;
@@ -7085,22 +6803,22 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs28 from "fs";
-import path25 from "path";
+import fs26 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
 import chalk15 from "chalk";
 import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path25.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs28.readFileSync(path25.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 = path25.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs28.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }