@rely-ai/caliber 1.0.0 → 1.1.1

package/dist/bin.js

@@ -51,16 +51,16 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs24 from "fs";
-import path21 from "path";
+import fs27 from "fs";
+import path24 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
-import chalk4 from "chalk";
-import ora from "ora";
-import readline3 from "readline";
+import chalk5 from "chalk";
+import ora2 from "ora";
+import readline4 from "readline";
 import select2 from "@inquirer/select";
-import fs17 from "fs";
+import fs20 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
@@ -2127,16 +2127,25 @@ 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");
+function normalizeContent(content) {
+  return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
 function stageFiles(files, projectDir) {
   cleanupStaging();
   let newFiles = 0;
   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");
+      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);
-    const originalPath = path12.join(projectDir, file.path);
     if (fs13.existsSync(originalPath)) {
       const currentPath = path12.join(CURRENT_DIR, file.path);
       fs13.mkdirSync(path12.dirname(currentPath), { recursive: true });
@@ -2715,15 +2724,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path23) {
+function readFileOrNull(path26) {
   try {
-    return readFileSync(path23, "utf-8");
+    return readFileSync(path26, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path23) {
-  const content = readFileOrNull(path23);
+function readJsonOrNull(path26) {
+  const content = readFileOrNull(path26);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3079,9 +3088,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path23) {
+function readFileOrNull2(path26) {
   try {
-    return readFileSync3(path23, "utf-8");
+    return readFileSync3(path26, "utf-8");
   } catch {
     return null;
   }
@@ -3232,15 +3241,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(path23) {
+function readFileOrNull3(path26) {
   try {
-    return readFileSync4(path23, "utf-8");
+    return readFileSync4(path26, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path23) {
-  const content = readFileOrNull3(path23);
+function readJsonOrNull2(path26) {
+  const content = readFileOrNull3(path26);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3423,9 +3432,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(path23) {
+function readFileOrNull4(path26) {
   try {
-    return readFileSync5(path23, "utf-8");
+    return readFileSync5(path26, "utf-8");
   } catch {
     return null;
   }
@@ -3535,9 +3544,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(path23) {
+function readFileOrNull5(path26) {
   try {
-    return readFileSync6(path23, "utf-8");
+    return readFileSync6(path26, "utf-8");
   } catch {
     return null;
   }
@@ -3630,6 +3639,29 @@ function checkBonus(dir) {
   return checks;
 }
 
+// src/scoring/dismissed.ts
+init_constants();
+import fs17 from "fs";
+import path16 from "path";
+var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+function readDismissedChecks() {
+  try {
+    if (!fs17.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs17.readFileSync(DISMISSED_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function writeDismissedChecks(checks) {
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  }
+  fs17.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+}
+function getDismissedIds() {
+  return new Set(readDismissedChecks().map((c) => c.id));
+}
+
 // src/scoring/index.ts
 function sumCategory(checks, category) {
   const categoryChecks = checks.filter((c) => c.category === category);
@@ -3666,7 +3698,8 @@ function computeLocalScore(dir, targetAgent) {
     ...checkFreshness(dir),
     ...checkBonus(dir)
   ];
-  const checks = filterChecksForTarget(allChecks, target);
+  const dismissed = getDismissedIds();
+  const checks = filterChecksForTarget(allChecks, target).filter((c) => !dismissed.has(c.id));
   const maxPossible = checks.reduce((s, c) => s + c.maxPoints, 0);
   const earned = checks.reduce((s, c) => s + c.earnedPoints, 0);
   const score = maxPossible > 0 ? Math.min(100, Math.max(0, Math.round(earned / maxPossible * 100))) : 0;
@@ -3772,7 +3805,7 @@ function displayScoreSummary(result) {
     const remaining = failing.length - shown.length;
     const moreText = remaining > 0 ? ` (+${remaining} more)` : "";
     console.log(chalk3.dim(`
-  Run ${chalk3.reset("caliber score")} for details.${moreText}`));
+  Run ${chalk3.hex("#83D1EB")("caliber score")} for details.${moreText}`));
   }
   console.log("");
 }
@@ -3820,10 +3853,758 @@ function displayScoreDelta(before, after) {
   }
 }
 
+// src/mcp/index.ts
+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;
+  });
+}
+
+// src/mcp/search.ts
+var AWESOME_MCP_URL = "https://raw.githubusercontent.com/punkpeye/awesome-mcp-servers/main/README.md";
+var GITHUB_SEARCH_URL = "https://github.com/search";
+var SEARCH_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  "Accept": "text/html"
+};
+function parseGitHubSearchHtml(html) {
+  try {
+    const scriptMatch = html.match(/<script type="application\/json" data-target="react-app\.embeddedData">([\s\S]*?)<\/script>/);
+    if (!scriptMatch) {
+      return [];
+    }
+    const data = JSON.parse(scriptMatch[1]);
+    const results = data?.payload?.results;
+    if (!Array.isArray(results)) {
+      return [];
+    }
+    return results.map((r) => {
+      const repo = r.repo?.repository;
+      const ownerLogin = repo?.owner_login || "";
+      const name = repo?.name || "";
+      const description = typeof r.hl_trunc_description === "string" ? r.hl_trunc_description.replace(/<\/?em>/g, "") : null;
+      return {
+        full_name: `${ownerLogin}/${name}`,
+        description,
+        stargazers_count: typeof r.followers === "number" ? r.followers : 0,
+        pushed_at: repo?.updated_at || "",
+        owner_login: ownerLogin
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function searchAllMcpSources(toolDeps) {
+  if (toolDeps.length === 0) return [];
+  const searches = [
+    searchAwesomeMcpLists(toolDeps),
+    ...toolDeps.map((dep) => searchGitHub(dep)),
+    ...toolDeps.map((dep) => searchVendorOrg(dep))
+  ];
+  const results = await Promise.all(searches);
+  const seen = /* @__PURE__ */ new Map();
+  for (const batch of results) {
+    for (const candidate of batch) {
+      const key = candidate.repoFullName.toLowerCase();
+      const existing = seen.get(key);
+      if (!existing || candidate.vendor || candidate.stars > existing.stars) {
+        seen.set(key, candidate);
+      }
+    }
+  }
+  return Array.from(seen.values());
+}
+async function searchAwesomeMcpLists(toolDeps) {
+  try {
+    const resp = await fetch(AWESOME_MCP_URL, {
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok) return [];
+    const markdown = await resp.text();
+    const candidates = [];
+    const depLower = toolDeps.map((d) => d.toLowerCase().replace(/^@[^/]+\//, ""));
+    const itemPattern = /^[-*]\s+\[([^\]]+)\]\(([^)]+)\)\s*[-–—:]\s*(.*)/gm;
+    let match;
+    while ((match = itemPattern.exec(markdown)) !== null) {
+      const [, name, url, description] = match;
+      if (!url.includes("github.com")) continue;
+      const text = `${name} ${description}`.toLowerCase();
+      const matchedDep = depLower.find((d) => text.includes(d));
+      if (!matchedDep) continue;
+      const repoMatch = url.match(/github\.com\/([^/]+\/[^/]+)/);
+      if (!repoMatch) continue;
+      candidates.push({
+        name: name.trim(),
+        repoFullName: repoMatch[1],
+        url: url.trim(),
+        description: description.trim().slice(0, 200),
+        stars: 0,
+        lastPush: "",
+        vendor: false,
+        score: 0,
+        reason: "",
+        matchedDep: toolDeps.find((d) => d.toLowerCase().replace(/^@[^/]+\//, "") === matchedDep) || matchedDep
+      });
+    }
+    return candidates;
+  } catch {
+    return [];
+  }
+}
+async function searchGitHub(dep) {
+  const depName = dep.replace(/^@[^/]+\//, "");
+  try {
+    const query = encodeURIComponent(`${depName} mcp server`);
+    const url = `${GITHUB_SEARCH_URL}?q=${query}&type=repositories&s=stars&o=desc`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: SEARCH_HEADERS
+    });
+    if (!resp.ok) return [];
+    const html = await resp.text();
+    const repos = parseGitHubSearchHtml(html).slice(0, 5);
+    return repos.map((repo) => ({
+      name: repo.full_name.split("/")[1],
+      repoFullName: repo.full_name,
+      url: `https://github.com/${repo.full_name}`,
+      description: repo.description || "",
+      stars: repo.stargazers_count,
+      lastPush: repo.pushed_at,
+      vendor: false,
+      score: 0,
+      reason: "",
+      matchedDep: dep
+    }));
+  } catch {
+    return [];
+  }
+}
+async function searchVendorOrg(dep) {
+  const depName = dep.replace(/^@([^/]+)\/.*/, "$1").replace(/^@/, "");
+  const orgName = depName.toLowerCase();
+  try {
+    const query = encodeURIComponent(`mcp org:${orgName}`);
+    const url = `${GITHUB_SEARCH_URL}?q=${query}&type=repositories&s=stars&o=desc`;
+    const resp = await fetch(url, {
+      signal: AbortSignal.timeout(1e4),
+      headers: SEARCH_HEADERS
+    });
+    if (!resp.ok) return [];
+    const html = await resp.text();
+    const repos = parseGitHubSearchHtml(html).slice(0, 5);
+    return repos.map((repo) => ({
+      name: repo.full_name.split("/")[1],
+      repoFullName: repo.full_name,
+      url: `https://github.com/${repo.full_name}`,
+      description: repo.description || "",
+      stars: repo.stargazers_count,
+      lastPush: repo.pushed_at,
+      vendor: repo.owner_login.toLowerCase() === orgName,
+      score: 0,
+      reason: "",
+      matchedDep: dep
+    }));
+  } catch {
+    return [];
+  }
+}
+
+// src/mcp/validate.ts
+var MIN_STARS = 100;
+var MAX_AGE_DAYS = 180;
+async function validateAndScore(candidates, toolDeps) {
+  const qualityFiltered = candidates.filter((c) => {
+    if (c.vendor) return true;
+    if (c.stars > 0 && c.stars < MIN_STARS) return false;
+    if (c.lastPush) {
+      const pushDate = new Date(c.lastPush);
+      const daysAgo = (Date.now() - pushDate.getTime()) / (1e3 * 60 * 60 * 24);
+      if (daysAgo > MAX_AGE_DAYS) return false;
+    }
+    return true;
+  });
+  if (qualityFiltered.length === 0) return [];
+  try {
+    return await scoreWithLLM(qualityFiltered, toolDeps);
+  } catch {
+    return qualityFiltered.slice(0, 5).map((c) => ({
+      ...c,
+      score: 50,
+      reason: c.description.slice(0, 80)
+    }));
+  }
+}
+async function scoreWithLLM(candidates, toolDeps) {
+  const candidateList = candidates.map((c, i) => {
+    const vendorTag = c.vendor ? " [VENDOR/OFFICIAL]" : "";
+    return `${i}. "${c.name}"${vendorTag} (${c.stars} stars) \u2014 ${c.description.slice(0, 100)}`;
+  }).join("\n");
+  const scored = await llmJsonCall({
+    system: SCORE_MCP_PROMPT,
+    prompt: `TOOL DEPENDENCIES IN PROJECT:
+${toolDeps.join(", ")}
+
+MCP SERVER CANDIDATES:
+${candidateList}`,
+    maxTokens: 4e3
+  });
+  if (!Array.isArray(scored)) return [];
+  return scored.filter((s) => s.score >= 60 && s.index >= 0 && s.index < candidates.length).sort((a, b) => b.score - a.score).slice(0, 5).map((s) => ({
+    ...candidates[s.index],
+    score: s.score,
+    reason: s.reason || candidates[s.index].description.slice(0, 80)
+  }));
+}
+
+// src/mcp/config-extract.ts
+async function fetchReadme(repoFullName) {
+  try {
+    const resp = await fetch(
+      `https://raw.githubusercontent.com/${repoFullName}/HEAD/README.md`,
+      { signal: AbortSignal.timeout(1e4) }
+    );
+    if (resp.ok) return await resp.text();
+  } catch {
+  }
+  try {
+    const resp = await fetch(
+      `https://raw.githubusercontent.com/${repoFullName}/main/README.md`,
+      { signal: AbortSignal.timeout(1e4) }
+    );
+    if (resp.ok) return await resp.text();
+  } catch {
+  }
+  return null;
+}
+async function extractMcpConfig(readme, serverName) {
+  try {
+    const truncated = readme.length > 15e3 ? readme.slice(0, 15e3) : readme;
+    const result = await llmJsonCall({
+      system: EXTRACT_CONFIG_PROMPT,
+      prompt: `MCP Server: ${serverName}
+
+README:
+${truncated}`,
+      maxTokens: 2e3
+    });
+    if (!result || !result.command) return null;
+    return {
+      command: result.command,
+      args: Array.isArray(result.args) ? result.args : [],
+      env: Array.isArray(result.env) ? result.env : []
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/mcp/index.ts
+async function discoverAndInstallMcps(targetAgent, fingerprint, dir) {
+  console.log(chalk4.hex("#6366f1").bold("\n  MCP Server Discovery\n"));
+  const 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);
+  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 ? "..." : ""}`));
+    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 existingMcps = getExistingMcpNames(fingerprint, targetAgent);
+  const filteredDeps = toolDeps.filter((d) => {
+    const lower = d.toLowerCase().replace(/^@[^/]+\//, "");
+    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(", ")}`));
+    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(", ")}`));
+    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(", ")}`));
+  const scoreSpinner = ora("Scoring MCP candidates...").start();
+  const scored = await validateAndScore(candidates, filteredDeps);
+  if (scored.length === 0) {
+    scoreSpinner.succeed(chalk4.dim("No quality MCP servers passed validation"));
+    console.log(chalk4.dim(`  Candidates checked: ${candidates.map((c) => c.name).join(", ")}`));
+    return { installed: 0, names: [] };
+  }
+  scoreSpinner.succeed(`${scored.length} quality MCP server${scored.length === 1 ? "" : "s"} found`);
+  console.log(chalk4.dim(`  Scored: ${scored.map((c) => `${c.name} (${c.score})`).join(", ")}`));
+  const selected = await interactiveSelect(scored);
+  if (!selected || selected.length === 0) {
+    return { installed: 0, names: [] };
+  }
+  const mcpServers = {};
+  const installedNames = [];
+  for (const mcp of selected) {
+    console.log(chalk4.bold(`
+  Configuring ${mcp.name}...`));
+    const readme = await fetchReadme(mcp.repoFullName);
+    if (!readme) {
+      console.log(chalk4.yellow(`  Could not fetch README for ${mcp.repoFullName} \u2014 skipping`));
+      console.log(chalk4.dim(`  Manual setup: ${mcp.url}`));
+      continue;
+    }
+    const config = await extractMcpConfig(readme, mcp.name);
+    if (!config || !config.command) {
+      console.log(chalk4.yellow(`  Could not extract config for ${mcp.name} \u2014 skipping`));
+      console.log(chalk4.dim(`  Manual setup: ${mcp.url}`));
+      continue;
+    }
+    const env = {};
+    for (const envVar of config.env) {
+      if (!envVar.required) continue;
+      const value = await promptInput2(`  ? ${envVar.key} (${envVar.description})`);
+      if (value) {
+        env[envVar.key] = value;
+      }
+    }
+    const serverConfig = {
+      command: config.command
+    };
+    if (config.args.length > 0) serverConfig.args = config.args;
+    if (Object.keys(env).length > 0) serverConfig.env = env;
+    mcpServers[mcp.name] = serverConfig;
+    installedNames.push(mcp.name);
+    console.log(`  ${chalk4.green("\u2713")} ${mcp.name} configured`);
+  }
+  if (installedNames.length === 0) {
+    return { installed: 0, names: [] };
+  }
+  if (targetAgent === "claude" || targetAgent === "both") {
+    writeMcpJson(path18.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);
+  }
+  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 (parsed.mcpServers) existing = parsed.mcpServers;
+    }
+  } catch {
+  }
+  const merged = { ...existing, ...mcpServers };
+  fs19.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
+}
+function getExistingMcpNames(fingerprint, targetAgent) {
+  const names = [];
+  if (targetAgent === "claude" || targetAgent === "both") {
+    if (fingerprint.existingConfigs.claudeMcpServers) {
+      names.push(...Object.keys(fingerprint.existingConfigs.claudeMcpServers).map((k) => k.toLowerCase()));
+    }
+  }
+  if (targetAgent === "cursor" || targetAgent === "both") {
+    if (fingerprint.existingConfigs.cursorMcpServers) {
+      names.push(...Object.keys(fingerprint.existingConfigs.cursorMcpServers).map((k) => k.toLowerCase()));
+    }
+  }
+  return names;
+}
+function promptInput2(question) {
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(chalk4.cyan(`${question}: `), (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function interactiveSelect(candidates) {
+  if (!process.stdin.isTTY) {
+    console.log(chalk4.bold("\n  Available MCP servers:\n"));
+    for (const c of candidates) {
+      const vendorTag = c.vendor ? chalk4.blue(" (vendor)") : "";
+      console.log(`  ${String(c.score).padStart(3)}  ${c.name}${vendorTag}  ${chalk4.dim(c.reason)}`);
+    }
+    console.log("");
+    return null;
+  }
+  const selected = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  const { stdin, stdout } = process;
+  let lineCount = 0;
+  function render() {
+    const lines = [];
+    lines.push(chalk4.bold("  Select MCP servers to install:"));
+    lines.push("");
+    for (let i = 0; i < candidates.length; i++) {
+      const c = candidates[i];
+      const check = selected.has(i) ? chalk4.green("[x]") : "[ ]";
+      const ptr = i === cursor ? chalk4.cyan(">") : " ";
+      const scoreColor = c.score >= 90 ? chalk4.green : c.score >= 70 ? chalk4.yellow : chalk4.dim;
+      const vendorTag = c.vendor ? chalk4.blue(" (vendor)") : "";
+      lines.push(`  ${ptr} ${check} ${scoreColor(String(c.score).padStart(3))}  ${c.name}${vendorTag}  ${chalk4.dim(c.reason.slice(0, 40))}`);
+    }
+    lines.push("");
+    lines.push(chalk4.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q skip"));
+    return lines.join("\n");
+  }
+  function draw(initial) {
+    if (!initial && lineCount > 0) {
+      stdout.write(`\x1B[${lineCount}A`);
+    }
+    stdout.write("\x1B[0J");
+    const output = render();
+    stdout.write(output + "\n");
+    lineCount = output.split("\n").length;
+  }
+  return new Promise((resolve2) => {
+    console.log("");
+    draw(true);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+    function onData(key) {
+      switch (key) {
+        case "\x1B[A":
+          cursor = (cursor - 1 + candidates.length) % candidates.length;
+          draw(false);
+          break;
+        case "\x1B[B":
+          cursor = (cursor + 1) % candidates.length;
+          draw(false);
+          break;
+        case " ":
+          selected.has(cursor) ? selected.delete(cursor) : selected.add(cursor);
+          draw(false);
+          break;
+        case "a":
+          candidates.forEach((_, i) => selected.add(i));
+          draw(false);
+          break;
+        case "n":
+          selected.clear();
+          draw(false);
+          break;
+        case "\r":
+        case "\n":
+          cleanup();
+          if (selected.size === 0) {
+            console.log(chalk4.dim("\n  No MCP servers selected.\n"));
+            resolve2(null);
+          } else {
+            resolve2(Array.from(selected).sort().map((i) => candidates[i]));
+          }
+          break;
+        case "q":
+        case "\x1B":
+        case "":
+          cleanup();
+          console.log(chalk4.dim("\n  Skipped MCP server installation.\n"));
+          resolve2(null);
+          break;
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+
 // src/commands/onboard.ts
 async function initCommand(options) {
-  const brand = chalk4.hex("#EB9D83");
-  const title = chalk4.hex("#83D1EB");
+  const brand = chalk5.hex("#EB9D83");
+  const title = chalk5.hex("#83D1EB");
   console.log(brand.bold(`
    \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
@@ -3832,19 +4613,19 @@ async function initCommand(options) {
   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
   `));
-  console.log(chalk4.dim("  Onboard your project for AI-assisted development\n"));
+  console.log(chalk5.dim("  Onboard your project for AI-assisted development\n"));
   console.log(title.bold("  Welcome to Caliber\n"));
-  console.log(chalk4.dim("  Caliber analyzes your codebase and creates tailored config files"));
-  console.log(chalk4.dim("  so your AI coding agents understand your project from day one.\n"));
+  console.log(chalk5.dim("  Caliber analyzes your codebase and creates tailored config files"));
+  console.log(chalk5.dim("  so your AI coding agents understand your project from day one.\n"));
   console.log(title.bold("  How onboarding works:\n"));
-  console.log(chalk4.dim("  1. Connect   Set up your LLM provider"));
-  console.log(chalk4.dim("  2. Discover  Analyze your code, dependencies, and structure"));
-  console.log(chalk4.dim("  3. Generate  Create config files tailored to your project"));
-  console.log(chalk4.dim("  4. Review    Preview, refine, and apply the changes\n"));
+  console.log(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"));
   let config = loadConfig();
   if (!config) {
-    console.log(chalk4.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
+    console.log(chalk5.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
     try {
       await runInteractiveProviderSetup({
         selectMessage: "How do you want to use Caliber? (choose LLM provider)"
@@ -3855,36 +4636,47 @@ async function initCommand(options) {
     }
     config = loadConfig();
     if (!config) {
-      console.log(chalk4.red("  Setup was cancelled or failed.\n"));
+      console.log(chalk5.red("  Setup was cancelled or failed.\n"));
       throw new Error("__exit__");
     }
-    console.log(chalk4.green("  \u2713 Provider saved. Let's continue.\n"));
+    console.log(chalk5.green("  \u2713 Provider saved. Let's continue.\n"));
   }
   const displayModel = config.model === "default" && config.provider === "claude-cli" ? process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)" : config.model;
   const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
   const modelLine = fastModel ? `  Provider: ${config.provider} | Model: ${displayModel} | Scan: ${fastModel}` : `  Provider: ${config.provider} | Model: ${displayModel}`;
-  console.log(chalk4.dim(modelLine + "\n"));
+  console.log(chalk5.dim(modelLine + "\n"));
   console.log(title.bold("  Step 2/4 \u2014 Discover your project\n"));
-  console.log(chalk4.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
-  const spinner = ora("Analyzing project...").start();
+  console.log(chalk5.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
+  const spinner = ora2("Analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   await enrichFingerprintWithLLM(fingerprint, process.cwd());
   spinner.succeed("Project analyzed");
-  console.log(chalk4.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
-  console.log(chalk4.dim(`  Files: ${fingerprint.fileTree.length} found
+  console.log(chalk5.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
+  console.log(chalk5.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
   const targetAgent = options.agent || await promptAgent();
+  const preScore = computeLocalScore(process.cwd(), targetAgent);
+  const failingForDismissal = preScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+  if (failingForDismissal.length > 0) {
+    const newDismissals = await evaluateDismissals(failingForDismissal, fingerprint);
+    if (newDismissals.length > 0) {
+      const existing = readDismissedChecks();
+      const existingIds = new Set(existing.map((d) => d.id));
+      const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
+      writeDismissedChecks(merged);
+    }
+  }
   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);
   if (hasExistingConfig && baselineScore.score === 100) {
-    console.log(chalk4.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk4.dim("  Run `caliber onboard --force` to regenerate anyway.\n"));
+    console.log(chalk5.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
+    console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber onboard --force") + chalk5.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const isEmpty = fingerprint.fileTree.length < 3;
   if (isEmpty) {
-    fingerprint.description = await promptInput2("What will you build in this project?");
+    fingerprint.description = await promptInput3("What will you build in this project?");
   }
   let failingChecks;
   let passingChecks;
@@ -3895,24 +4687,24 @@ async function initCommand(options) {
     currentScore = baselineScore.score;
     if (failingChecks.length > 0) {
       console.log(title.bold("  Step 3/4 \u2014 Fine-tuning\n"));
-      console.log(chalk4.dim(`  Your setup scores ${baselineScore.score}/100 \u2014 fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
+      console.log(chalk5.dim(`  Your setup scores ${baselineScore.score}/100 \u2014 fixing ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
 `));
       for (const check of failingChecks) {
-        console.log(chalk4.dim(`    \u2022 ${check.name}`));
+        console.log(chalk5.dim(`    \u2022 ${check.name}`));
       }
       console.log("");
     }
   } else if (hasExistingConfig) {
     console.log(title.bold("  Step 3/4 \u2014 Improve your setup\n"));
-    console.log(chalk4.dim("  Reviewing your existing configs against your codebase"));
-    console.log(chalk4.dim("  and preparing improvements.\n"));
+    console.log(chalk5.dim("  Reviewing your existing configs against your codebase"));
+    console.log(chalk5.dim("  and preparing improvements.\n"));
   } else {
     console.log(title.bold("  Step 3/4 \u2014 Build your agent setup\n"));
-    console.log(chalk4.dim("  Creating config files tailored to your project.\n"));
+    console.log(chalk5.dim("  Creating config files tailored to your project.\n"));
   }
-  console.log(chalk4.dim("  This can take a couple of minutes depending on your model and provider.\n"));
+  console.log(chalk5.dim("  This can take a couple of minutes depending on your model and provider.\n"));
   const genStartTime = Date.now();
-  const genSpinner = ora("Generating setup...").start();
+  const genSpinner = ora2("Generating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
   genMessages.start();
   let generatedSetup = null;
@@ -3952,8 +4744,8 @@ async function initCommand(options) {
   if (!generatedSetup) {
     genSpinner.fail("Failed to generate setup.");
     if (rawOutput) {
-      console.log(chalk4.dim("\nRaw LLM output (JSON parse failed):"));
-      console.log(chalk4.dim(rawOutput.slice(0, 500)));
+      console.log(chalk5.dim("\nRaw LLM output (JSON parse failed):"));
+      console.log(chalk5.dim(rawOutput.slice(0, 500)));
     }
     throw new Error("__exit__");
   }
@@ -3961,7 +4753,7 @@ async function initCommand(options) {
   const mins = Math.floor(elapsedMs / 6e4);
   const secs = Math.floor(elapsedMs % 6e4 / 1e3);
   const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-  genSpinner.succeed(`Setup generated ${chalk4.dim(`in ${timeStr}`)}`);
+  genSpinner.succeed(`Setup generated ${chalk5.dim(`in ${timeStr}`)}`);
   printSetupSummary(generatedSetup);
   const sessionHistory = [];
   sessionHistory.push({
@@ -3971,7 +4763,7 @@ async function initCommand(options) {
   console.log(title.bold("  Step 4/4 \u2014 Review and apply\n"));
   const setupFiles = collectSetupFiles(generatedSetup);
   const staged = stageFiles(setupFiles, process.cwd());
-  console.log(chalk4.dim(`  ${chalk4.green(`${staged.newFiles} new`)} / ${chalk4.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
+  console.log(chalk5.dim(`  ${chalk5.green(`${staged.newFiles} new`)} / ${chalk5.yellow(`${staged.modifiedFiles} modified`)} file${staged.newFiles + staged.modifiedFiles !== 1 ? "s" : ""}
 `));
   const wantsReview = await promptWantsReview();
   if (wantsReview) {
@@ -3983,12 +4775,12 @@ async function initCommand(options) {
     generatedSetup = await refineLoop(generatedSetup, targetAgent, sessionHistory);
     if (!generatedSetup) {
       cleanupStaging();
-      console.log(chalk4.dim("Refinement cancelled. No files were modified."));
+      console.log(chalk5.dim("Refinement cancelled. No files were modified."));
       return;
     }
     const updatedFiles = collectSetupFiles(generatedSetup);
     const restaged = stageFiles(updatedFiles, process.cwd());
-    console.log(chalk4.dim(`  ${chalk4.green(`${restaged.newFiles} new`)} / ${chalk4.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
+    console.log(chalk5.dim(`  ${chalk5.green(`${restaged.newFiles} new`)} / ${chalk5.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
 `));
     printSetupSummary(generatedSetup);
     await openReview("terminal", restaged.stagedFiles);
@@ -3996,37 +4788,49 @@ async function initCommand(options) {
   }
   cleanupStaging();
   if (action === "decline") {
-    console.log(chalk4.dim("Setup declined. No files were modified."));
+    console.log(chalk5.dim("Setup declined. No files were modified."));
     return;
   }
   if (options.dryRun) {
-    console.log(chalk4.yellow("\n[Dry run] Would write the following files:"));
+    console.log(chalk5.yellow("\n[Dry run] Would write the following files:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
-  const writeSpinner = ora("Writing config files...").start();
+  const writeSpinner = ora2("Writing config files...").start();
   try {
     const result = writeSetup(generatedSetup);
     writeSpinner.succeed("Config files written");
-    console.log(chalk4.bold("\nFiles created/updated:"));
+    console.log(chalk5.bold("\nFiles created/updated:"));
     for (const file of result.written) {
-      console.log(`  ${chalk4.green("\u2713")} ${file}`);
+      console.log(`  ${chalk5.green("\u2713")} ${file}`);
     }
     if (result.deleted.length > 0) {
-      console.log(chalk4.bold("\nFiles removed:"));
+      console.log(chalk5.bold("\nFiles removed:"));
       for (const file of result.deleted) {
-        console.log(`  ${chalk4.red("\u2717")} ${file}`);
+        console.log(`  ${chalk5.red("\u2717")} ${file}`);
       }
     }
     if (result.backupDir) {
-      console.log(chalk4.dim(`
+      console.log(chalk5.dim(`
   Backups saved to ${result.backupDir}`));
     }
   } catch (err) {
     writeSpinner.fail("Failed to write files");
-    console.error(chalk4.red(err instanceof Error ? err.message : "Unknown error"));
+    console.error(chalk5.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
+  try {
+    const mcpResult = await discoverAndInstallMcps(targetAgent, fingerprint, process.cwd());
+    if (mcpResult.installed > 0) {
+      console.log(chalk5.bold(`
+  ${mcpResult.installed} MCP server${mcpResult.installed > 1 ? "s" : ""} configured`));
+      for (const name of mcpResult.names) {
+        console.log(`  ${chalk5.green("\u2713")} ${name}`);
+      }
+    }
+  } catch (err) {
+    console.log(chalk5.dim("  MCP discovery skipped: " + (err instanceof Error ? err.message : "unknown error")));
+  }
   ensurePermissions();
   const sha = getCurrentHeadSha();
   writeState({
@@ -4036,56 +4840,56 @@ async function initCommand(options) {
   });
   console.log("");
   console.log(title.bold("  Keep your configs fresh\n"));
-  console.log(chalk4.dim("  Caliber can automatically update your agent configs when your code changes.\n"));
+  console.log(chalk5.dim("  Caliber can automatically update your agent configs when your code changes.\n"));
   const hookChoice = await promptHookType(targetAgent);
   if (hookChoice === "claude" || hookChoice === "both") {
     const hookResult = installHook();
     if (hookResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-      console.log(chalk4.dim("    Run `caliber hooks remove` to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber hooks remove") + chalk5.dim(" to disable"));
     } else if (hookResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Claude Code hook already installed"));
+      console.log(chalk5.dim("  Claude Code hook already installed"));
     }
     const learnResult = installLearningHooks();
     if (learnResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
-      console.log(chalk4.dim("    Run `caliber learn remove` to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber learn remove") + chalk5.dim(" to disable"));
     } else if (learnResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Learning hooks already installed"));
+      console.log(chalk5.dim("  Learning hooks already installed"));
     }
   }
   if (hookChoice === "precommit" || hookChoice === "both") {
     const precommitResult = installPreCommitHook();
     if (precommitResult.installed) {
-      console.log(`  ${chalk4.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk4.dim("    Run `caliber hooks remove-precommit` to disable"));
+      console.log(`  ${chalk5.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
+      console.log(chalk5.dim("    Run ") + chalk5.hex("#83D1EB")("caliber hooks remove-precommit") + chalk5.dim(" to disable"));
     } else if (precommitResult.alreadyInstalled) {
-      console.log(chalk4.dim("  Pre-commit hook already installed"));
+      console.log(chalk5.dim("  Pre-commit hook already installed"));
     } else {
-      console.log(chalk4.yellow("  Could not install pre-commit hook (not a git repository?)"));
+      console.log(chalk5.yellow("  Could not install pre-commit hook (not a git repository?)"));
     }
   }
   if (hookChoice === "skip") {
-    console.log(chalk4.dim("  Skipped auto-refresh hooks. Run `caliber hooks install` later to enable."));
+    console.log(chalk5.dim("  Skipped auto-refresh hooks. Run ") + chalk5.hex("#83D1EB")("caliber hooks install") + chalk5.dim(" later to enable."));
   }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
     console.log("");
-    console.log(chalk4.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
+    console.log(chalk5.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
     try {
       const { restored, removed } = undoSetup();
       if (restored.length > 0 || removed.length > 0) {
-        console.log(chalk4.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
+        console.log(chalk5.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
       }
     } catch {
     }
-    console.log(chalk4.dim("  Run `caliber onboard --force` to override.\n"));
+    console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber onboard --force") + chalk5.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
-  console.log(chalk4.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
-  console.log(chalk4.dim("  Run `caliber undo` to revert changes.\n"));
-  console.log(chalk4.bold("  Next steps:\n"));
+  console.log(chalk5.bold.green("  Onboarding complete! Your project is ready for AI-assisted development."));
+  console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("caliber undo") + chalk5.dim(" to revert changes.\n"));
+  console.log(chalk5.bold("  Next steps:\n"));
   console.log(`    ${title("caliber score")}        See your full config breakdown`);
   console.log(`    ${title("caliber recommend")}    Discover community skills for your stack`);
   console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
@@ -4093,7 +4897,7 @@ async function initCommand(options) {
 }
 async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
   while (true) {
-    const message = await promptInput2("\nWhat would you like to change?");
+    const message = await promptInput3("\nWhat would you like to change?");
     if (!message || message.toLowerCase() === "done" || message.toLowerCase() === "accept") {
       return currentSetup;
     }
@@ -4102,12 +4906,12 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
     }
     const isValid = await classifyRefineIntent(message);
     if (!isValid) {
-      console.log(chalk4.dim("  This doesn't look like a config change request."));
-      console.log(chalk4.dim("  Describe what to add, remove, or modify in your configs."));
-      console.log(chalk4.dim('  Type "done" to accept the current setup.\n'));
+      console.log(chalk5.dim("  This doesn't look like a config change request."));
+      console.log(chalk5.dim("  Describe what to add, remove, or modify in your configs."));
+      console.log(chalk5.dim('  Type "done" to accept the current setup.\n'));
       continue;
     }
-    const refineSpinner = ora("Refining setup...").start();
+    const refineSpinner = ora2("Refining setup...").start();
     const refineMessages = new SpinnerMessages(refineSpinner, REFINE_MESSAGES);
     refineMessages.start();
     const refined = await refineSetup(
@@ -4125,16 +4929,16 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
       });
       refineSpinner.succeed("Setup updated");
       printSetupSummary(refined);
-      console.log(chalk4.dim('Type "done" to accept, or describe more changes.'));
+      console.log(chalk5.dim('Type "done" to accept, or describe more changes.'));
     } else {
       refineSpinner.fail("Refinement failed \u2014 could not parse AI response.");
-      console.log(chalk4.dim('Try rephrasing your request, or type "done" to keep the current setup.'));
+      console.log(chalk5.dim('Try rephrasing your request, or type "done" to keep the current setup.'));
     }
   }
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path23, desc]) => `  ${path23}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path26, desc]) => `  ${path26}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -4155,10 +4959,40 @@ Return {"valid": true} or {"valid": false}. Nothing else.`,
     return true;
   }
 }
-function promptInput2(question) {
-  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+async function evaluateDismissals(failingChecks, fingerprint) {
+  const fastModel = process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  const checkList = failingChecks.map((c) => ({
+    id: c.id,
+    name: c.name,
+    suggestion: c.suggestion
+  }));
+  try {
+    const result = await llmJsonCall({
+      system: `You evaluate whether scoring checks are applicable to a project.
+Given the project's languages/frameworks and a list of failing checks, return which checks are NOT applicable.
+
+Only dismiss checks that truly don't apply \u2014 e.g. "Build/test/lint commands" for a pure Terraform/HCL repo with no build system.
+Do NOT dismiss checks that could reasonably apply even if the project doesn't use them yet.
+
+Return {"dismissed": [{"id": "check_id", "reason": "brief reason"}]} or {"dismissed": []} if all apply.`,
+      prompt: `Languages: ${fingerprint.languages.join(", ") || "none"}
+Frameworks: ${fingerprint.frameworks.join(", ") || "none"}
+
+Failing checks:
+${JSON.stringify(checkList, null, 2)}`,
+      maxTokens: 200,
+      ...fastModel ? { model: fastModel } : {}
+    });
+    if (!Array.isArray(result.dismissed)) return [];
+    return result.dismissed.filter((d) => d.id && d.reason && failingChecks.some((c) => c.id === d.id)).map((d) => ({ id: d.id, reason: d.reason, dismissedAt: (/* @__PURE__ */ new Date()).toISOString() }));
+  } catch {
+    return [];
+  }
+}
+function promptInput3(question) {
+  const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
-    rl.question(chalk4.cyan(`${question} `), (answer) => {
+    rl.question(chalk5.cyan(`${question} `), (answer) => {
       rl.close();
       resolve2(answer.trim());
     });
@@ -4220,12 +5054,12 @@ async function openReview(method, stagedFiles) {
       originalPath: f.originalPath,
       proposedPath: f.proposedPath
     })));
-    console.log(chalk4.dim("  Diffs opened in your editor.\n"));
+    console.log(chalk5.dim("  Diffs opened in your editor.\n"));
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs17.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs17.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs20.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs20.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -4251,8 +5085,8 @@ async function openReview(method, stagedFiles) {
 async function interactiveDiffExplorer(files) {
   if (!process.stdin.isTTY) {
     for (const f of files) {
-      const icon = f.isNew ? chalk4.green("+") : chalk4.yellow("~");
-      const stats = f.isNew ? chalk4.dim(`${f.lines} lines`) : `${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+      const icon = f.isNew ? chalk5.green("+") : chalk5.yellow("~");
+      const stats = f.isNew ? chalk5.dim(`${f.lines} lines`) : `${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
       console.log(`    ${icon} ${f.relativePath}  ${stats}`);
     }
     console.log("");
@@ -4268,47 +5102,47 @@ async function interactiveDiffExplorer(files) {
   }
   function renderFileList() {
     const lines = [];
-    lines.push(chalk4.bold("  Review changes"));
+    lines.push(chalk5.bold("  Review changes"));
     lines.push("");
     for (let i = 0; i < files.length; i++) {
       const f = files[i];
-      const ptr = i === cursor ? chalk4.cyan(">") : " ";
-      const icon = f.isNew ? chalk4.green("+") : chalk4.yellow("~");
-      const stats = f.isNew ? chalk4.dim(`${f.lines} lines`) : `${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+      const ptr = i === cursor ? chalk5.cyan(">") : " ";
+      const icon = f.isNew ? chalk5.green("+") : chalk5.yellow("~");
+      const stats = f.isNew ? chalk5.dim(`${f.lines} lines`) : `${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
       lines.push(`  ${ptr} ${icon} ${f.relativePath}  ${stats}`);
     }
     lines.push("");
-    lines.push(chalk4.dim("  \u2191\u2193 navigate  \u23CE view diff  q done"));
+    lines.push(chalk5.dim("  \u2191\u2193 navigate  \u23CE view diff  q done"));
     return lines.join("\n");
   }
   function renderDiff(index) {
     const f = files[index];
     const lines = [];
-    const header = f.isNew ? `  ${chalk4.green("+")} ${f.relativePath} ${chalk4.dim("(new file)")}` : `  ${chalk4.yellow("~")} ${f.relativePath} ${chalk4.green(`+${f.added}`)} ${chalk4.red(`-${f.removed}`)}`;
+    const header = f.isNew ? `  ${chalk5.green("+")} ${f.relativePath} ${chalk5.dim("(new file)")}` : `  ${chalk5.yellow("~")} ${f.relativePath} ${chalk5.green(`+${f.added}`)} ${chalk5.red(`-${f.removed}`)}`;
     lines.push(header);
-    lines.push(chalk4.dim("  " + "\u2500".repeat(60)));
+    lines.push(chalk5.dim("  " + "\u2500".repeat(60)));
     const patchLines = f.patch.split("\n");
     const bodyLines = patchLines.slice(4);
     const maxVisible = getTermHeight() - 4;
     const visibleLines = bodyLines.slice(scrollOffset, scrollOffset + maxVisible);
     for (const line of visibleLines) {
       if (line.startsWith("+")) {
-        lines.push(chalk4.green("  " + line));
+        lines.push(chalk5.green("  " + line));
       } else if (line.startsWith("-")) {
-        lines.push(chalk4.red("  " + line));
+        lines.push(chalk5.red("  " + line));
       } else if (line.startsWith("@@")) {
-        lines.push(chalk4.cyan("  " + line));
+        lines.push(chalk5.cyan("  " + line));
       } else {
-        lines.push(chalk4.dim("  " + line));
+        lines.push(chalk5.dim("  " + line));
       }
     }
     const totalBody = bodyLines.length;
     if (totalBody > maxVisible) {
       const pct = Math.round((scrollOffset + maxVisible) / totalBody * 100);
-      lines.push(chalk4.dim(`  \u2500\u2500 ${Math.min(pct, 100)}% \u2500\u2500`));
+      lines.push(chalk5.dim(`  \u2500\u2500 ${Math.min(pct, 100)}% \u2500\u2500`));
     }
     lines.push("");
-    lines.push(chalk4.dim("  \u2191\u2193 scroll  \u23B5/esc back to file list"));
+    lines.push(chalk5.dim("  \u2191\u2193 scroll  \u23B5/esc back to file list"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -4402,46 +5236,46 @@ function printSetupSummary(setup) {
   const fileDescriptions = setup.fileDescriptions;
   const deletions = setup.deletions;
   console.log("");
-  console.log(chalk4.bold("  Proposed changes:\n"));
+  console.log(chalk5.bold("  Proposed changes:\n"));
   const getDescription = (filePath) => {
     return fileDescriptions?.[filePath];
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs17.existsSync("CLAUDE.md") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs20.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription("CLAUDE.md");
-      console.log(`  ${icon} ${chalk4.bold("CLAUDE.md")}`);
-      if (desc) console.log(chalk4.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk5.bold("CLAUDE.md")}`);
+      if (desc) console.log(chalk5.dim(`    ${desc}`));
       console.log("");
     }
     const skills = claude.skills;
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs20.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
-        console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
+        console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs17.existsSync(".cursorrules") ? chalk4.yellow("~") : chalk4.green("+");
+      const icon = fs20.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription(".cursorrules");
-      console.log(`  ${icon} ${chalk4.bold(".cursorrules")}`);
-      if (desc) console.log(chalk4.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk5.bold(".cursorrules")}`);
+      if (desc) console.log(chalk5.dim(`    ${desc}`));
       console.log("");
     }
     const cursorSkills = cursor.skills;
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs17.existsSync(skillPath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs20.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk4.bold(skillPath)}`);
-        console.log(chalk4.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
+        console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
@@ -4449,32 +5283,32 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs17.existsSync(rulePath) ? chalk4.yellow("~") : chalk4.green("+");
+        const icon = fs20.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(rulePath);
-        console.log(`  ${icon} ${chalk4.bold(rulePath)}`);
+        console.log(`  ${icon} ${chalk5.bold(rulePath)}`);
         if (desc) {
-          console.log(chalk4.dim(`    ${desc}`));
+          console.log(chalk5.dim(`    ${desc}`));
         } else {
           const firstLine = rule.content.split("\n").filter((l) => l.trim() && !l.trim().startsWith("#"))[0];
-          if (firstLine) console.log(chalk4.dim(`    ${firstLine.trim().slice(0, 80)}`));
+          if (firstLine) console.log(chalk5.dim(`    ${firstLine.trim().slice(0, 80)}`));
         }
         console.log("");
       }
     }
   }
-  if (!fs17.existsSync("AGENTS.md")) {
-    console.log(`  ${chalk4.green("+")} ${chalk4.bold("AGENTS.md")}`);
-    console.log(chalk4.dim("    Cross-agent coordination file"));
+  if (!fs20.existsSync("AGENTS.md")) {
+    console.log(`  ${chalk5.green("+")} ${chalk5.bold("AGENTS.md")}`);
+    console.log(chalk5.dim("    Cross-agent coordination file"));
     console.log("");
   }
   if (Array.isArray(deletions) && deletions.length > 0) {
     for (const del of deletions) {
-      console.log(`  ${chalk4.red("-")} ${chalk4.bold(del.filePath)}`);
-      console.log(chalk4.dim(`    ${del.reason}`));
+      console.log(`  ${chalk5.red("-")} ${chalk5.bold(del.filePath)}`);
+      console.log(chalk5.dim(`    ${del.reason}`));
       console.log("");
     }
   }
-  console.log(`  ${chalk4.green("+")} ${chalk4.dim("new")}  ${chalk4.yellow("~")} ${chalk4.dim("modified")}  ${chalk4.red("-")} ${chalk4.dim("removed")}`);
+  console.log(`  ${chalk5.green("+")} ${chalk5.dim("new")}  ${chalk5.yellow("~")} ${chalk5.dim("modified")}  ${chalk5.red("-")} ${chalk5.dim("removed")}`);
   console.log("");
 }
 function buildSkillContent(skill) {
@@ -4490,8 +5324,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs17.existsSync(settingsPath)) {
-      settings = JSON.parse(fs17.readFileSync(settingsPath, "utf-8"));
+    if (fs20.existsSync(settingsPath)) {
+      settings = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -4505,8 +5339,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs17.existsSync(".claude")) fs17.mkdirSync(".claude", { recursive: true });
-  fs17.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs20.existsSync(".claude")) fs20.mkdirSync(".claude", { recursive: true });
+  fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function collectSetupFiles(setup) {
   const files = [];
@@ -4536,7 +5370,7 @@ function collectSetupFiles(setup) {
       }
     }
   }
-  if (!fs17.existsSync("AGENTS.md")) {
+  if (!fs20.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.");
@@ -4555,10 +5389,10 @@ ${agentRefs.join(" ")}
 }
 
 // src/commands/undo.ts
-import chalk5 from "chalk";
-import ora2 from "ora";
+import chalk6 from "chalk";
+import ora3 from "ora";
 function undoCommand() {
-  const spinner = ora2("Reverting setup...").start();
+  const spinner = ora3("Reverting setup...").start();
   try {
     const { restored, removed } = undoSetup();
     if (restored.length === 0 && removed.length === 0) {
@@ -4567,27 +5401,27 @@ function undoCommand() {
     }
     spinner.succeed("Setup reverted successfully.\n");
     if (restored.length > 0) {
-      console.log(chalk5.cyan("  Restored from backup:"));
+      console.log(chalk6.cyan("  Restored from backup:"));
       for (const file of restored) {
-        console.log(`    ${chalk5.green("\u21A9")} ${file}`);
+        console.log(`    ${chalk6.green("\u21A9")} ${file}`);
       }
     }
     if (removed.length > 0) {
-      console.log(chalk5.cyan("  Removed:"));
+      console.log(chalk6.cyan("  Removed:"));
       for (const file of removed) {
-        console.log(`    ${chalk5.red("\u2717")} ${file}`);
+        console.log(`    ${chalk6.red("\u2717")} ${file}`);
       }
     }
     console.log("");
   } catch (err) {
-    spinner.fail(chalk5.red(err instanceof Error ? err.message : "Undo failed"));
+    spinner.fail(chalk6.red(err instanceof Error ? err.message : "Undo failed"));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/status.ts
-import chalk6 from "chalk";
-import fs18 from "fs";
+import chalk7 from "chalk";
+import fs21 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -4600,45 +5434,45 @@ async function statusCommand(options) {
     }, null, 2));
     return;
   }
-  console.log(chalk6.bold("\nCaliber Status\n"));
+  console.log(chalk7.bold("\nCaliber Status\n"));
   if (config) {
-    console.log(`  LLM: ${chalk6.green(config.provider)} (${config.model})`);
+    console.log(`  LLM: ${chalk7.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk6.yellow("Not configured")} \u2014 run \`caliber config\``);
+    console.log(`  LLM: ${chalk7.yellow("Not configured")} \u2014 run ${chalk7.hex("#83D1EB")("caliber config")}`);
   }
   if (!manifest) {
-    console.log(`  Setup: ${chalk6.dim("No setup applied")}`);
-    console.log(chalk6.dim("\n  Run `caliber onboard` to get started.\n"));
+    console.log(`  Setup: ${chalk7.dim("No setup applied")}`);
+    console.log(chalk7.dim("\n  Run ") + chalk7.hex("#83D1EB")("caliber onboard") + chalk7.dim(" to get started.\n"));
     return;
   }
-  console.log(`  Files managed: ${chalk6.cyan(manifest.entries.length.toString())}`);
+  console.log(`  Files managed: ${chalk7.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs18.existsSync(entry.path);
-    const icon = exists ? chalk6.green("\u2713") : chalk6.red("\u2717");
+    const exists = fs21.existsSync(entry.path);
+    const icon = exists ? chalk7.green("\u2713") : chalk7.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
   console.log("");
 }
 
 // src/commands/regenerate.ts
-import chalk7 from "chalk";
-import ora3 from "ora";
+import chalk8 from "chalk";
+import ora4 from "ora";
 import confirm from "@inquirer/confirm";
 async function regenerateCommand(options) {
   const config = loadConfig();
   if (!config) {
-    console.log(chalk7.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
+    console.log(chalk8.red("No LLM provider configured. Run ") + chalk8.hex("#83D1EB")("caliber config") + chalk8.red(" (e.g. choose Cursor) or set ANTHROPIC_API_KEY."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk7.yellow("No existing setup found. Run `caliber onboard` first."));
+    console.log(chalk8.yellow("No existing setup found. Run ") + chalk8.hex("#83D1EB")("caliber onboard") + chalk8.yellow(" first."));
     throw new Error("__exit__");
   }
-  const spinner = ora3("Re-analyzing project...").start();
+  const spinner = ora4("Re-analyzing project...").start();
   const fingerprint = collectFingerprint(process.cwd());
   spinner.succeed("Project re-analyzed");
-  const genSpinner = ora3("Regenerating setup...").start();
+  const genSpinner = ora4("Regenerating setup...").start();
   const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES);
   genMessages.start();
   let generatedSetup = null;
@@ -4675,38 +5509,38 @@ async function regenerateCommand(options) {
   }
   genSpinner.succeed("Setup regenerated");
   if (options.dryRun) {
-    console.log(chalk7.yellow("\n[Dry run] Would write:"));
+    console.log(chalk8.yellow("\n[Dry run] Would write:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
   const shouldApply = await confirm({ message: "Apply regenerated setup?", default: true });
   if (!shouldApply) {
-    console.log(chalk7.dim("Regeneration cancelled."));
+    console.log(chalk8.dim("Regeneration cancelled."));
     return;
   }
-  const writeSpinner = ora3("Updating config files...").start();
+  const writeSpinner = ora4("Updating config files...").start();
   const result = writeSetup(generatedSetup);
   writeSpinner.succeed("Config files updated");
   for (const file of result.written) {
-    console.log(`  ${chalk7.green("\u2713")} ${file}`);
+    console.log(`  ${chalk8.green("\u2713")} ${file}`);
   }
   console.log("");
 }
 
 // src/commands/recommend.ts
-import chalk8 from "chalk";
-import ora4 from "ora";
+import chalk9 from "chalk";
+import ora5 from "ora";
 import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5, existsSync as existsSync9, writeFileSync } from "fs";
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs19 from "fs";
-import path16 from "path";
+import fs22 from "fs";
+import path19 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs19.existsSync(claudeMdPath)) {
+  const claudeMdPath = path19.join(dir, "CLAUDE.md");
+  if (fs22.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -4715,10 +5549,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs19.existsSync(skillsDir)) {
-    for (const file of fs19.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  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);
       items.push({
         type: "skill",
         platform: "claude",
@@ -4728,10 +5562,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs19.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path19.join(dir, ".mcp.json");
+  if (fs22.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4746,8 +5580,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs19.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path19.join(dir, ".cursorrules");
+  if (fs22.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4756,10 +5590,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs19.existsSync(cursorRulesDir)) {
-    for (const file of fs19.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  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);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -4769,12 +5603,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs19.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
+  if (fs22.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs19.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs19.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(cursorSkillsDir)) {
+        const skillFile = path19.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4787,10 +5621,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs19.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
+  if (fs22.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs19.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4808,7 +5642,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs19.readFileSync(filePath, "utf-8");
+  const text = fs22.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -4966,7 +5800,7 @@ async function searchAllProviders(technologies, platform) {
   }
   return combined;
 }
-async function scoreWithLLM(candidates, projectContext, technologies) {
+async function scoreWithLLM2(candidates, projectContext, technologies) {
   const candidateList = candidates.map((c, i) => `${i}. "${c.name}" \u2014 ${c.reason || "no description"}`).join("\n");
   const scored = await llmJsonCall({
     system: `You evaluate whether AI agent skills and tools are relevant to a specific software project.
@@ -5119,11 +5953,11 @@ async function recommendCommand(options) {
     ...extractTopDeps()
   ].filter(Boolean))];
   if (technologies.length === 0) {
-    console.log(chalk8.yellow("Could not detect any languages or dependencies. Try running from a project root."));
+    console.log(chalk9.yellow("Could not detect any languages or dependencies. Try running from a project root."));
     throw new Error("__exit__");
   }
   const primaryPlatform = platforms.includes("claude") ? "claude" : platforms[0];
-  const searchSpinner = ora4("Searching skill registries...").start();
+  const searchSpinner = ora5("Searching skill registries...").start();
   const allCandidates = await searchAllProviders(technologies, primaryPlatform);
   if (!allCandidates.length) {
     searchSpinner.succeed("No skills found matching your tech stack.");
@@ -5136,15 +5970,15 @@ async function recommendCommand(options) {
     return;
   }
   searchSpinner.succeed(
-    `Found ${allCandidates.length} skills` + (filteredCount > 0 ? chalk8.dim(` (${filteredCount} already installed)`) : "")
+    `Found ${allCandidates.length} skills` + (filteredCount > 0 ? chalk9.dim(` (${filteredCount} already installed)`) : "")
   );
   let results;
   const config = loadConfig();
   if (config) {
-    const scoreSpinner = ora4("Scoring relevance for your project...").start();
+    const scoreSpinner = ora5("Scoring relevance for your project...").start();
     try {
       const projectContext = buildProjectContext(process.cwd());
-      results = await scoreWithLLM(newCandidates, projectContext, technologies);
+      results = await scoreWithLLM2(newCandidates, projectContext, technologies);
       if (results.length === 0) {
         scoreSpinner.succeed("No highly relevant skills found for your specific project.");
         return;
@@ -5157,7 +5991,7 @@ async function recommendCommand(options) {
   } else {
     results = newCandidates.slice(0, 20);
   }
-  const fetchSpinner = ora4("Verifying skill availability...").start();
+  const fetchSpinner = ora5("Verifying skill availability...").start();
   const contentMap = /* @__PURE__ */ new Map();
   await Promise.all(results.map(async (rec) => {
     const content = await fetchSkillContent(rec);
@@ -5170,14 +6004,14 @@ async function recommendCommand(options) {
   }
   const unavailableCount = results.length - available.length;
   fetchSpinner.succeed(
-    `${available.length} installable skill${available.length > 1 ? "s" : ""}` + (unavailableCount > 0 ? chalk8.dim(` (${unavailableCount} unavailable)`) : "")
+    `${available.length} installable skill${available.length > 1 ? "s" : ""}` + (unavailableCount > 0 ? chalk9.dim(` (${unavailableCount} unavailable)`) : "")
   );
-  const selected = await interactiveSelect(available);
+  const selected = await interactiveSelect2(available);
   if (selected?.length) {
     await installSkills(selected, platforms, contentMap);
   }
 }
-async function interactiveSelect(recs) {
+async function interactiveSelect2(recs) {
   if (!process.stdin.isTTY) {
     printRecommendations(recs);
     return null;
@@ -5189,27 +6023,27 @@ async function interactiveSelect(recs) {
   const hasScores = recs.some((r) => r.score > 0);
   function render() {
     const lines = [];
-    lines.push(chalk8.bold("  Recommendations"));
+    lines.push(chalk9.bold("  Recommendations"));
     lines.push("");
     if (hasScores) {
-      lines.push(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+      lines.push(`  ${chalk9.dim("Score".padEnd(7))} ${chalk9.dim("Name".padEnd(28))} ${chalk9.dim("Why")}`);
     } else {
-      lines.push(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+      lines.push(`  ${chalk9.dim("Name".padEnd(30))} ${chalk9.dim("Technology".padEnd(18))} ${chalk9.dim("Source")}`);
     }
-    lines.push(chalk8.dim("  " + "\u2500".repeat(70)));
+    lines.push(chalk9.dim("  " + "\u2500".repeat(70)));
     for (let i = 0; i < recs.length; i++) {
       const rec = recs[i];
-      const check = selected.has(i) ? chalk8.green("[x]") : "[ ]";
-      const ptr = i === cursor ? chalk8.cyan(">") : " ";
+      const check = selected.has(i) ? chalk9.green("[x]") : "[ ]";
+      const ptr = i === cursor ? chalk9.cyan(">") : " ";
       if (hasScores) {
-        const scoreColor = rec.score >= 90 ? chalk8.green : rec.score >= 70 ? chalk8.yellow : chalk8.dim;
-        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 40))}`);
+        const scoreColor = rec.score >= 90 ? chalk9.green : rec.score >= 70 ? chalk9.yellow : chalk9.dim;
+        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(26)} ${chalk9.dim(rec.reason.slice(0, 40))}`);
       } else {
-        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk9.dim(rec.source_url || "")}`);
       }
     }
     lines.push("");
-    lines.push(chalk8.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
+    lines.push(chalk9.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all  n none  \u23CE install  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -5258,7 +6092,7 @@ async function interactiveSelect(recs) {
         case "\n":
           cleanup();
           if (selected.size === 0) {
-            console.log(chalk8.dim("\n  No skills selected.\n"));
+            console.log(chalk9.dim("\n  No skills selected.\n"));
             resolve2(null);
           } else {
             resolve2(Array.from(selected).sort().map((i) => recs[i]));
@@ -5268,7 +6102,7 @@ async function interactiveSelect(recs) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk8.dim("\n  Cancelled.\n"));
+          console.log(chalk9.dim("\n  Cancelled.\n"));
           resolve2(null);
           break;
       }
@@ -5314,7 +6148,7 @@ async function fetchSkillContent(rec) {
   return null;
 }
 async function installSkills(recs, platforms, contentMap) {
-  const spinner = ora4(`Installing ${recs.length} skill${recs.length > 1 ? "s" : ""}...`).start();
+  const spinner = ora5(`Installing ${recs.length} skill${recs.length > 1 ? "s" : ""}...`).start();
   const installed = [];
   for (const rec of recs) {
     const content = contentMap.get(rec.slug);
@@ -5330,7 +6164,7 @@ async function installSkills(recs, platforms, contentMap) {
   if (installed.length > 0) {
     spinner.succeed(`Installed ${installed.length} file${installed.length > 1 ? "s" : ""}`);
     for (const p of installed) {
-      console.log(chalk8.green(`  \u2713 ${p}`));
+      console.log(chalk9.green(`  \u2713 ${p}`));
     }
   } else {
     spinner.fail("No skills were installed");
@@ -5339,25 +6173,25 @@ async function installSkills(recs, platforms, contentMap) {
 }
 function printRecommendations(recs) {
   const hasScores = recs.some((r) => r.score > 0);
-  console.log(chalk8.bold("\n  Recommendations\n"));
+  console.log(chalk9.bold("\n  Recommendations\n"));
   if (hasScores) {
-    console.log(`  ${chalk8.dim("Score".padEnd(7))} ${chalk8.dim("Name".padEnd(28))} ${chalk8.dim("Why")}`);
+    console.log(`  ${chalk9.dim("Score".padEnd(7))} ${chalk9.dim("Name".padEnd(28))} ${chalk9.dim("Why")}`);
   } else {
-    console.log(`  ${chalk8.dim("Name".padEnd(30))} ${chalk8.dim("Technology".padEnd(18))} ${chalk8.dim("Source")}`);
+    console.log(`  ${chalk9.dim("Name".padEnd(30))} ${chalk9.dim("Technology".padEnd(18))} ${chalk9.dim("Source")}`);
   }
-  console.log(chalk8.dim("  " + "\u2500".repeat(70)));
+  console.log(chalk9.dim("  " + "\u2500".repeat(70)));
   for (const rec of recs) {
     if (hasScores) {
-      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(26)} ${chalk8.dim(rec.reason.slice(0, 50))}`);
+      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(26)} ${chalk9.dim(rec.reason.slice(0, 50))}`);
     } else {
-      console.log(`  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk8.dim(rec.source_url || "")}`);
+      console.log(`  ${rec.name.padEnd(28)} ${rec.detected_technology.padEnd(16)} ${chalk9.dim(rec.source_url || "")}`);
     }
   }
   console.log("");
 }
 
 // src/commands/score.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 async function scoreCommand(options) {
   const dir = process.cwd();
   const target = options.agent ?? readState()?.targetAgent;
@@ -5371,23 +6205,23 @@ async function scoreCommand(options) {
     return;
   }
   displayScore(result);
-  const separator = chalk9.gray("  " + "\u2500".repeat(53));
+  const separator = chalk10.gray("  " + "\u2500".repeat(53));
   console.log(separator);
   if (result.score < 40) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber onboard") + chalk9.gray(" to generate a complete, optimized setup."));
+    console.log(chalk10.gray("  Run ") + chalk10.hex("#83D1EB")("caliber onboard") + chalk10.gray(" to generate a complete, optimized setup."));
   } else if (result.score < 70) {
-    console.log(chalk9.gray("  Run ") + chalk9.hex("#f97316")("caliber onboard") + chalk9.gray(" to improve your setup."));
+    console.log(chalk10.gray("  Run ") + chalk10.hex("#83D1EB")("caliber onboard") + chalk10.gray(" to improve your setup."));
   } else {
-    console.log(chalk9.green("  Looking good!") + chalk9.gray(" Run ") + chalk9.hex("#f97316")("caliber update") + chalk9.gray(" to keep it fresh."));
+    console.log(chalk10.green("  Looking good!") + chalk10.gray(" Run ") + chalk10.hex("#83D1EB")("caliber update") + chalk10.gray(" to keep it fresh."));
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
-import fs21 from "fs";
-import path18 from "path";
-import chalk10 from "chalk";
-import ora5 from "ora";
+import fs24 from "fs";
+import path21 from "path";
+import chalk11 from "chalk";
+import ora6 from "ora";
 
 // src/lib/git-diff.ts
 import { execSync as execSync8 } from "child_process";
@@ -5462,37 +6296,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs20 from "fs";
-import path17 from "path";
+import fs23 from "fs";
+import path20 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs20.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs23.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs20.writeFileSync("README.md", docs.readmeMd);
+    fs23.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs20.writeFileSync(".cursorrules", docs.cursorrules);
+    fs23.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path17.join(".cursor", "rules");
-    if (!fs20.existsSync(rulesDir)) fs20.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path20.join(".cursor", "rules");
+    if (!fs23.existsSync(rulesDir)) fs23.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path17.join(rulesDir, rule.filename);
-      fs20.writeFileSync(filePath, rule.content);
+      const filePath = path20.join(rulesDir, rule.filename);
+      fs23.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path17.join(".claude", "skills");
-    if (!fs20.existsSync(skillsDir)) fs20.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path20.join(".claude", "skills");
+    if (!fs23.existsSync(skillsDir)) fs23.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path17.join(skillsDir, skill.filename);
-      fs20.writeFileSync(filePath, skill.content);
+      const filePath = path20.join(skillsDir, skill.filename);
+      fs23.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -5567,11 +6401,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs21.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs24.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path18.join(parentDir, entry.name);
-      if (fs21.existsSync(path18.join(childPath, ".git"))) {
+      const childPath = path21.join(parentDir, entry.name);
+      if (fs24.existsSync(path21.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -5581,7 +6415,7 @@ function discoverGitRepos(parentDir) {
 }
 async function refreshSingleRepo(repoDir, options) {
   const quiet = !!options.quiet;
-  const prefix = options.label ? `${chalk10.bold(options.label)} ` : "";
+  const prefix = options.label ? `${chalk11.bold(options.label)} ` : "";
   const state = readState();
   const lastSha = state?.lastRefreshSha ?? null;
   const diff = collectDiff(lastSha);
@@ -5590,10 +6424,10 @@ async function refreshSingleRepo(repoDir, options) {
     if (currentSha) {
       writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
     }
-    log(quiet, chalk10.dim(`${prefix}No changes since last refresh.`));
+    log(quiet, chalk11.dim(`${prefix}No changes since last refresh.`));
     return;
   }
-  const spinner = quiet ? null : ora5(`${prefix}Analyzing changes...`).start();
+  const spinner = quiet ? null : ora6(`${prefix}Analyzing changes...`).start();
   const existingDocs = readExistingConfigs(repoDir);
   const fingerprint = collectFingerprint(repoDir);
   const projectContext = {
@@ -5622,10 +6456,10 @@ async function refreshSingleRepo(repoDir, options) {
   if (options.dryRun) {
     spinner?.info(`${prefix}Dry run \u2014 would update:`);
     for (const doc of response.docsUpdated) {
-      console.log(`  ${chalk10.yellow("~")} ${doc}`);
+      console.log(`  ${chalk11.yellow("~")} ${doc}`);
     }
     if (response.changesSummary) {
-      console.log(chalk10.dim(`
+      console.log(chalk11.dim(`
   ${response.changesSummary}`));
     }
     return;
@@ -5633,10 +6467,10 @@ async function refreshSingleRepo(repoDir, options) {
   const written = writeRefreshDocs(response.updatedDocs);
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
   for (const file of written) {
-    log(quiet, `  ${chalk10.green("\u2713")} ${file}`);
+    log(quiet, `  ${chalk11.green("\u2713")} ${file}`);
   }
   if (response.changesSummary) {
-    log(quiet, chalk10.dim(`
+    log(quiet, chalk11.dim(`
   ${response.changesSummary}`));
   }
   if (currentSha) {
@@ -5649,7 +6483,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk10.red("No LLM provider configured. Run `caliber config` (e.g. choose Cursor) or set an API key."));
+      console.log(chalk11.red("No LLM provider configured. Run ") + chalk11.hex("#83D1EB")("caliber config") + chalk11.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     if (isGitRepo()) {
@@ -5659,20 +6493,20 @@ async function refreshCommand(options) {
     const repos = discoverGitRepos(process.cwd());
     if (repos.length === 0) {
       if (quiet) return;
-      console.log(chalk10.red("Not inside a git repository and no git repos found in child directories."));
+      console.log(chalk11.red("Not inside a git repository and no git repos found in child directories."));
       throw new Error("__exit__");
     }
-    log(quiet, chalk10.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
+    log(quiet, chalk11.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path18.basename(repo);
+      const repoName = path21.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
       } catch (err) {
         if (err instanceof Error && err.message === "__exit__") continue;
-        log(quiet, chalk10.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+        log(quiet, chalk11.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
       }
     }
     process.chdir(originalDir);
@@ -5680,13 +6514,13 @@ async function refreshCommand(options) {
     if (err instanceof Error && err.message === "__exit__") throw err;
     if (quiet) return;
     const msg = err instanceof Error ? err.message : "Unknown error";
-    console.log(chalk10.red(`Refresh failed: ${msg}`));
+    console.log(chalk11.red(`Refresh failed: ${msg}`));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/hooks.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 var HOOKS = [
   {
     id: "session-end",
@@ -5706,13 +6540,13 @@ var HOOKS = [
   }
 ];
 function printStatus() {
-  console.log(chalk11.bold("\n  Hooks\n"));
+  console.log(chalk12.bold("\n  Hooks\n"));
   for (const hook of HOOKS) {
     const installed = hook.isInstalled();
-    const icon = installed ? chalk11.green("\u2713") : chalk11.dim("\u2717");
-    const state = installed ? chalk11.green("enabled") : chalk11.dim("disabled");
+    const icon = installed ? chalk12.green("\u2713") : chalk12.dim("\u2717");
+    const state = installed ? chalk12.green("enabled") : chalk12.dim("disabled");
     console.log(`  ${icon} ${hook.label.padEnd(26)} ${state}`);
-    console.log(chalk11.dim(`    ${hook.description}`));
+    console.log(chalk12.dim(`    ${hook.description}`));
   }
   console.log("");
 }
@@ -5721,9 +6555,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.install();
       if (result.alreadyInstalled) {
-        console.log(chalk11.dim(`  ${hook.label} already enabled.`));
+        console.log(chalk12.dim(`  ${hook.label} already enabled.`));
       } else {
-        console.log(chalk11.green("  \u2713") + ` ${hook.label} enabled`);
+        console.log(chalk12.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
     return;
@@ -5732,9 +6566,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.remove();
       if (result.notFound) {
-        console.log(chalk11.dim(`  ${hook.label} already disabled.`));
+        console.log(chalk12.dim(`  ${hook.label} already disabled.`));
       } else {
-        console.log(chalk11.green("  \u2713") + ` ${hook.label} removed`);
+        console.log(chalk12.green("  \u2713") + ` ${hook.label} removed`);
       }
     }
     return;
@@ -5749,18 +6583,18 @@ async function hooksCommand(options) {
   const states = HOOKS.map((h) => h.isInstalled());
   function render() {
     const lines = [];
-    lines.push(chalk11.bold("  Hooks"));
+    lines.push(chalk12.bold("  Hooks"));
     lines.push("");
     for (let i = 0; i < HOOKS.length; i++) {
       const hook = HOOKS[i];
       const enabled = states[i];
-      const toggle = enabled ? chalk11.green("[on] ") : chalk11.dim("[off]");
-      const ptr = i === cursor ? chalk11.cyan(">") : " ";
+      const toggle = enabled ? chalk12.green("[on] ") : chalk12.dim("[off]");
+      const ptr = i === cursor ? chalk12.cyan(">") : " ";
       lines.push(`  ${ptr} ${toggle} ${hook.label}`);
-      lines.push(chalk11.dim(`        ${hook.description}`));
+      lines.push(chalk12.dim(`        ${hook.description}`));
     }
     lines.push("");
-    lines.push(chalk11.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
+    lines.push(chalk12.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -5791,16 +6625,16 @@ async function hooksCommand(options) {
         const wantEnabled = states[i];
         if (wantEnabled && !wasInstalled) {
           hook.install();
-          console.log(chalk11.green("  \u2713") + ` ${hook.label} enabled`);
+          console.log(chalk12.green("  \u2713") + ` ${hook.label} enabled`);
           changed++;
         } else if (!wantEnabled && wasInstalled) {
           hook.remove();
-          console.log(chalk11.green("  \u2713") + ` ${hook.label} disabled`);
+          console.log(chalk12.green("  \u2713") + ` ${hook.label} disabled`);
           changed++;
         }
       }
       if (changed === 0) {
-        console.log(chalk11.dim("  No changes."));
+        console.log(chalk12.dim("  No changes."));
       }
       console.log("");
     }
@@ -5836,7 +6670,7 @@ async function hooksCommand(options) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk11.dim("\n  Cancelled.\n"));
+          console.log(chalk12.dim("\n  Cancelled.\n"));
           resolve2();
           break;
       }
@@ -5846,43 +6680,43 @@ async function hooksCommand(options) {
 }
 
 // src/commands/config.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 async function configCommand() {
   const existing = loadConfig();
   if (existing) {
-    console.log(chalk12.bold("\nCurrent Configuration\n"));
-    console.log(`  Provider: ${chalk12.cyan(existing.provider)}`);
-    console.log(`  Model:    ${chalk12.cyan(existing.model)}`);
+    console.log(chalk13.bold("\nCurrent Configuration\n"));
+    console.log(`  Provider: ${chalk13.cyan(existing.provider)}`);
+    console.log(`  Model:    ${chalk13.cyan(existing.model)}`);
     if (existing.apiKey) {
       const masked = existing.apiKey.slice(0, 8) + "..." + existing.apiKey.slice(-4);
-      console.log(`  API Key:  ${chalk12.dim(masked)}`);
+      console.log(`  API Key:  ${chalk13.dim(masked)}`);
     }
     if (existing.provider === "cursor") {
-      console.log(`  Seat:     ${chalk12.dim("Cursor (agent acp)")}`);
+      console.log(`  Seat:     ${chalk13.dim("Cursor (agent acp)")}`);
     }
     if (existing.provider === "claude-cli") {
-      console.log(`  Seat:     ${chalk12.dim("Claude Code (claude -p)")}`);
+      console.log(`  Seat:     ${chalk13.dim("Claude Code (claude -p)")}`);
     }
     if (existing.baseUrl) {
-      console.log(`  Base URL: ${chalk12.dim(existing.baseUrl)}`);
+      console.log(`  Base URL: ${chalk13.dim(existing.baseUrl)}`);
     }
     if (existing.vertexProjectId) {
-      console.log(`  Vertex Project: ${chalk12.dim(existing.vertexProjectId)}`);
-      console.log(`  Vertex Region:  ${chalk12.dim(existing.vertexRegion || "us-east5")}`);
+      console.log(`  Vertex Project: ${chalk13.dim(existing.vertexProjectId)}`);
+      console.log(`  Vertex Region:  ${chalk13.dim(existing.vertexRegion || "us-east5")}`);
     }
-    console.log(`  Source:   ${chalk12.dim(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.VERTEX_PROJECT_ID || process.env.CALIBER_USE_CURSOR_SEAT || process.env.CALIBER_USE_CLAUDE_CLI ? "environment variables" : getConfigFilePath())}`);
+    console.log(`  Source:   ${chalk13.dim(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.VERTEX_PROJECT_ID || process.env.CALIBER_USE_CURSOR_SEAT || process.env.CALIBER_USE_CLAUDE_CLI ? "environment variables" : getConfigFilePath())}`);
     console.log("");
   }
   await runInteractiveProviderSetup();
-  console.log(chalk12.green("\n\u2713 Configuration saved"));
-  console.log(chalk12.dim(`  ${getConfigFilePath()}
+  console.log(chalk13.green("\n\u2713 Configuration saved"));
+  console.log(chalk13.dim(`  ${getConfigFilePath()}
 `));
-  console.log(chalk12.dim("  You can also set environment variables instead:"));
-  console.log(chalk12.dim("  ANTHROPIC_API_KEY, OPENAI_API_KEY, VERTEX_PROJECT_ID, CALIBER_USE_CURSOR_SEAT=1, or CALIBER_USE_CLAUDE_CLI=1\n"));
+  console.log(chalk13.dim("  You can also set environment variables instead:"));
+  console.log(chalk13.dim("  ANTHROPIC_API_KEY, OPENAI_API_KEY, VERTEX_PROJECT_ID, CALIBER_USE_CURSOR_SEAT=1, or CALIBER_USE_CLAUDE_CLI=1\n"));
 }
 
 // src/commands/learn.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 
 // src/learner/stdin.ts
 var STDIN_TIMEOUT_MS = 5e3;
@@ -5913,8 +6747,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs22 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path22 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -5922,15 +6756,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs22.existsSync(LEARNING_DIR)) {
-    fs22.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs25.existsSync(LEARNING_DIR)) {
+    fs25.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path22.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path22.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -5941,50 +6775,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs22.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs25.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs25.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs22.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs25.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return [];
-  const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs25.existsSync(filePath)) return [];
+  const lines = fs25.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return 0;
-  const content = fs22.readFileSync(filePath, "utf-8");
+  if (!fs25.existsSync(filePath)) return 0;
+  const content = fs25.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs22.existsSync(filePath)) fs22.unlinkSync(filePath);
+  if (fs25.existsSync(filePath)) fs25.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs22.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs25.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs25.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs22.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs25.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs26 from "fs";
+import path23 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6004,8 +6838,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs23.existsSync(claudeMdPath)) {
-    existing = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (fs26.existsSync(claudeMdPath)) {
+    existing = fs26.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6019,15 +6853,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs23.writeFileSync(claudeMdPath, updated);
+  fs26.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path20.join(".claude", "skills", skill.name);
-  if (!fs23.existsSync(skillDir)) fs23.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path20.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs23.existsSync(skillPath)) {
-    const existing = fs23.readFileSync(skillPath, "utf-8");
-    fs23.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  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);
   } else {
     const frontmatter = [
       "---",
@@ -6036,14 +6870,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs23.writeFileSync(skillPath, frontmatter + skill.content);
+    fs26.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs23.existsSync(claudeMdPath)) return null;
-  const content = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (!fs26.existsSync(claudeMdPath)) return null;
+  const content = fs26.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6183,53 +7017,53 @@ async function learnFinalizeCommand() {
 async function learnInstallCommand() {
   const result = installLearningHooks();
   if (result.alreadyInstalled) {
-    console.log(chalk13.dim("Learning hooks already installed."));
+    console.log(chalk14.dim("Learning hooks already installed."));
     return;
   }
-  console.log(chalk13.green("\u2713") + " Learning hooks installed in .claude/settings.json");
-  console.log(chalk13.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
-  console.log(chalk13.dim("  Session learnings will be written to CLAUDE.md and skills."));
+  console.log(chalk14.green("\u2713") + " Learning hooks installed in .claude/settings.json");
+  console.log(chalk14.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
+  console.log(chalk14.dim("  Session learnings will be written to CLAUDE.md and skills."));
 }
 async function learnRemoveCommand() {
   const result = removeLearningHooks();
   if (result.notFound) {
-    console.log(chalk13.dim("Learning hooks not found."));
+    console.log(chalk14.dim("Learning hooks not found."));
     return;
   }
-  console.log(chalk13.green("\u2713") + " Learning hooks removed from .claude/settings.json");
+  console.log(chalk14.green("\u2713") + " Learning hooks removed from .claude/settings.json");
 }
 async function learnStatusCommand() {
   const installed = areLearningHooksInstalled();
   const state = readState2();
   const eventCount = getEventCount();
-  console.log(chalk13.bold("Session Learning Status"));
+  console.log(chalk14.bold("Session Learning Status"));
   console.log();
   if (installed) {
-    console.log(chalk13.green("\u2713") + " Learning hooks are " + chalk13.green("installed"));
+    console.log(chalk14.green("\u2713") + " Learning hooks are " + chalk14.green("installed"));
   } else {
-    console.log(chalk13.dim("\u2717") + " Learning hooks are " + chalk13.yellow("not installed"));
-    console.log(chalk13.dim("  Run `caliber learn install` to enable session learning."));
+    console.log(chalk14.dim("\u2717") + " Learning hooks are " + chalk14.yellow("not installed"));
+    console.log(chalk14.dim("  Run `caliber learn install` to enable session learning."));
   }
   console.log();
-  console.log(`Events recorded: ${chalk13.cyan(String(eventCount))}`);
-  console.log(`Total this session: ${chalk13.cyan(String(state.eventCount))}`);
+  console.log(`Events recorded: ${chalk14.cyan(String(eventCount))}`);
+  console.log(`Total this session: ${chalk14.cyan(String(state.eventCount))}`);
   if (state.lastAnalysisTimestamp) {
-    console.log(`Last analysis: ${chalk13.cyan(state.lastAnalysisTimestamp)}`);
+    console.log(`Last analysis: ${chalk14.cyan(state.lastAnalysisTimestamp)}`);
   } else {
-    console.log(`Last analysis: ${chalk13.dim("none")}`);
+    console.log(`Last analysis: ${chalk14.dim("none")}`);
   }
   const learnedSection = readLearnedSection();
   if (learnedSection) {
     const lineCount = learnedSection.split("\n").filter(Boolean).length;
     console.log(`
-Learned items in CLAUDE.md: ${chalk13.cyan(String(lineCount))}`);
+Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
   }
 }
 
 // src/cli.ts
-var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var __dirname = path24.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs24.readFileSync(path21.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs27.readFileSync(path24.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -6251,22 +7085,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 fs25 from "fs";
-import path22 from "path";
+import fs28 from "fs";
+import path25 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
-import chalk14 from "chalk";
-import ora6 from "ora";
+import chalk15 from "chalk";
+import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path25.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs25.readFileSync(path22.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs28.readFileSync(path25.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 = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs25.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path25.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs28.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -6289,17 +7123,17 @@ async function checkForUpdates() {
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk14.yellow(
+        chalk15.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk14.bold("npm install -g @rely-ai/caliber")} to upgrade.
+Run ${chalk15.bold("npm install -g @rely-ai/caliber")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk14.yellow(`
+      chalk15.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
@@ -6307,7 +7141,7 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
-    const spinner = ora6("Updating caliber...").start();
+    const spinner = ora7("Updating caliber...").start();
     try {
       execSync9(`npm install -g @rely-ai/caliber@${latest}`, {
         stdio: "pipe",
@@ -6317,13 +7151,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk14.yellow(`Run ${chalk14.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
+        console.log(chalk15.yellow(`Run ${chalk15.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk14.green(`Updated to ${latest}`));
+      spinner.succeed(chalk15.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk14.dim(`
+      console.log(chalk15.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync9(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -6336,11 +7170,11 @@ Restarting: caliber ${args.join(" ")}
       if (err instanceof Error) {
         const stderr = err.stderr;
         const errMsg = stderr ? String(stderr).trim().split("\n").pop() : err.message.split("\n")[0];
-        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk14.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk15.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk14.yellow(
-          `Run ${chalk14.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
+        chalk15.yellow(
+          `Run ${chalk15.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
 `
         )
       );