@rely-ai/caliber 1.20.0-dev.1773685589 → 1.20.0-dev.1773686430

package/dist/bin.js

@@ -177,13 +177,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs28 from "fs";
-import path22 from "path";
-import os4 from "os";
+import fs29 from "fs";
+import path23 from "path";
+import os5 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs28.existsSync(LOCK_FILE)) return false;
-    const raw = fs28.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs29.existsSync(LOCK_FILE)) return false;
+    const raw = fs29.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -198,13 +198,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs28.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs29.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs28.existsSync(LOCK_FILE)) fs28.unlinkSync(LOCK_FILE);
+    if (fs29.existsSync(LOCK_FILE)) fs29.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -212,24 +212,24 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path22.join(os4.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path23.join(os5.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs32 from "fs";
-import path25 from "path";
+import fs33 from "fs";
+import path26 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path19 from "path";
-import chalk9 from "chalk";
+import path20 from "path";
+import chalk10 from "chalk";
 import ora2 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs24 from "fs";
+import fs25 from "fs";
 
 // src/fingerprint/index.ts
 import fs6 from "fs";
@@ -2262,15 +2262,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path27) {
+function readFileOrNull(path28) {
   try {
-    return readFileSync(path27, "utf-8");
+    return readFileSync(path28, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path27) {
-  const content = readFileOrNull(path27);
+function readJsonOrNull(path28) {
+  const content = readFileOrNull(path28);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -2686,6 +2686,37 @@ async function generateMonolithic(fingerprint, targetAgent, prompt, callbacks, f
   };
   return attemptGeneration();
 }
+async function generateSkillsForSetup(setup, fingerprint, targetAgent, onStatus) {
+  const skillTopics = collectSkillTopics(setup, targetAgent, fingerprint);
+  if (skillTopics.length === 0) return 0;
+  onStatus?.(`Generating ${skillTopics.length} skills...`);
+  const allDeps = extractAllDeps(process.cwd());
+  const skillContext = buildSkillContext(fingerprint, setup, allDeps);
+  const fastModel = getFastModel();
+  const skillResults = await Promise.allSettled(
+    skillTopics.map(
+      ({ platform, topic }) => generateSkill(skillContext, topic, fastModel).then((skill) => ({ platform, skill }))
+    )
+  );
+  for (const result of skillResults) {
+    if (result.status === "fulfilled") {
+      const { platform, skill } = result.value;
+      const platformObj = setup[platform] ?? {};
+      const skills = platformObj.skills ?? [];
+      skills.push(skill);
+      platformObj.skills = skills;
+      setup[platform] = platformObj;
+      const skillPath = platform === "codex" ? `.agents/skills/${skill.name}/SKILL.md` : `.${platform}/skills/${skill.name}/SKILL.md`;
+      const descriptions = setup.fileDescriptions ?? {};
+      descriptions[skillPath] = skill.description.slice(0, 80);
+      setup.fileDescriptions = descriptions;
+    }
+  }
+  const succeeded = skillResults.filter((r) => r.status === "fulfilled").length;
+  const failed = skillResults.filter((r) => r.status === "rejected").length;
+  if (failed > 0) onStatus?.(`${succeeded} generated, ${failed} failed`);
+  return succeeded;
+}
 var LIMITS = {
   FILE_TREE_ENTRIES: 500,
   EXISTING_CONFIG_CHARS: 8e3,
@@ -3205,13 +3236,23 @@ function cleanupStaging() {
 
 // src/utils/review.ts
 import chalk2 from "chalk";
-import fs14 from "fs";
+import fs15 from "fs";
 import select2 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 
 // src/utils/editor.ts
 import { execSync as execSync5, spawn as spawn3 } from "child_process";
+import fs14 from "fs";
+import path12 from "path";
+import os3 from "os";
 var IS_WINDOWS3 = process.platform === "win32";
+var DIFF_TEMP_DIR = path12.join(os3.tmpdir(), "caliber-diff");
+function getEmptyFilePath(proposedPath) {
+  fs14.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path12.join(DIFF_TEMP_DIR, path12.basename(proposedPath));
+  fs14.writeFileSync(tempPath, "");
+  return tempPath;
+}
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
@@ -3232,13 +3273,12 @@ function openDiffsInEditor(editor, files) {
   const cmd = editor === "cursor" ? "cursor" : "code";
   for (const file of files) {
     try {
+      const leftPath = file.originalPath ?? getEmptyFilePath(file.proposedPath);
       if (IS_WINDOWS3) {
         const quote = (s) => `"${s}"`;
-        const parts = file.originalPath ? [cmd, "--diff", quote(file.originalPath), quote(file.proposedPath)] : [cmd, quote(file.proposedPath)];
-        spawn3(parts.join(" "), { shell: true, stdio: "ignore", detached: true }).unref();
+        spawn3([cmd, "--diff", quote(leftPath), quote(file.proposedPath)].join(" "), { shell: true, stdio: "ignore", detached: true }).unref();
       } else {
-        const args = file.originalPath ? ["--diff", file.originalPath, file.proposedPath] : [file.proposedPath];
-        spawn3(cmd, args, { stdio: "ignore", detached: true }).unref();
+        spawn3(cmd, ["--diff", leftPath, file.proposedPath], { stdio: "ignore", detached: true }).unref();
       }
     } catch {
       continue;
@@ -3281,8 +3321,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs14.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs14.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs15.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs15.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -3445,7 +3485,7 @@ async function interactiveDiffExplorer(files) {
 }
 
 // src/commands/setup-files.ts
-import fs15 from "fs";
+import fs16 from "fs";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -3494,7 +3534,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs15.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs16.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -3511,12 +3551,12 @@ ${agentRefs.join(" ")}
 }
 
 // src/lib/hooks.ts
-import fs17 from "fs";
-import path12 from "path";
+import fs18 from "fs";
+import path13 from "path";
 import { execSync as execSync7 } from "child_process";
 
 // src/lib/resolve-caliber.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import { execSync as execSync6 } from "child_process";
 var _resolved = null;
 function resolveCaliber() {
@@ -3539,7 +3579,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs16.existsSync(binPath)) {
+  if (binPath && fs17.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -3555,24 +3595,24 @@ function isCaliberCommand(command, subcommandTail) {
 }
 
 // src/lib/hooks.ts
-var SETTINGS_PATH = path12.join(".claude", "settings.json");
+var SETTINGS_PATH = path13.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs17.existsSync(SETTINGS_PATH)) return {};
+  if (!fs18.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs18.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path12.dirname(SETTINGS_PATH);
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path13.dirname(SETTINGS_PATH);
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3635,19 +3675,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync7("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path12.join(gitDir, "hooks");
+    return path13.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path12.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) return false;
-  const content = fs17.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs18.existsSync(hookPath)) return false;
+  const content = fs18.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3656,43 +3696,43 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path12.dirname(hookPath);
-  if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path13.dirname(hookPath);
+  if (!fs18.existsSync(hooksDir)) fs18.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs17.existsSync(hookPath)) {
-    content = fs17.readFileSync(hookPath, "utf-8");
+  if (fs18.existsSync(hookPath)) {
+    content = fs18.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs17.writeFileSync(hookPath, content);
-  fs17.chmodSync(hookPath, 493);
+  fs18.writeFileSync(hookPath, content);
+  fs18.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) {
+  if (!hookPath || !fs18.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs17.readFileSync(hookPath, "utf-8");
+  let content = fs18.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
-  const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
-  content = content.replace(regex, "\n");
+  const regex2 = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
+  content = content.replace(regex2, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs17.unlinkSync(hookPath);
+    fs18.unlinkSync(hookPath);
   } else {
-    fs17.writeFileSync(hookPath, content);
+    fs18.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs18 from "fs";
-import path13 from "path";
-var SETTINGS_PATH2 = path13.join(".claude", "settings.json");
+import fs19 from "fs";
+import path14 from "path";
+var SETTINGS_PATH2 = path14.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -3709,17 +3749,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings2() {
-  if (!fs18.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs19.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs19.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path13.dirname(SETTINGS_PATH2);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path14.dirname(SETTINGS_PATH2);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -3753,7 +3793,7 @@ function installLearningHooks() {
   writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path13.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path14.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -3761,17 +3801,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize" }
 ];
 function readCursorHooks() {
-  if (!fs18.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs19.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs18.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs19.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path13.dirname(CURSOR_HOOKS_PATH);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path14.dirname(CURSOR_HOOKS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -3841,10 +3881,10 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs19 from "fs";
-import path14 from "path";
+import fs20 from "fs";
+import path15 from "path";
 import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -3855,8 +3895,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs19.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs19.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs20.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs20.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -3864,10 +3904,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs20.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -5224,22 +5264,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs20 from "fs";
-import path15 from "path";
-var DISMISSED_FILE = path15.join(CALIBER_DIR, "dismissed-checks.json");
+import fs21 from "fs";
+import path16 from "path";
+var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs20.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs20.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs21.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs21.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs20.existsSync(CALIBER_DIR)) {
-    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs20.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs21.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -5435,13 +5475,13 @@ import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4,
 import { join as join9, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs21 from "fs";
-import path16 from "path";
+import fs22 from "fs";
+import path17 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs21.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs22.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5450,10 +5490,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs21.existsSync(skillsDir)) {
-    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs22.existsSync(skillsDir)) {
+    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -5463,10 +5503,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs21.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs22.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.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({
@@ -5481,8 +5521,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path16.join(dir, "AGENTS.md");
-  if (fs21.existsSync(agentsMdPath)) {
+  const agentsMdPath = path17.join(dir, "AGENTS.md");
+  if (fs22.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -5491,12 +5531,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path16.join(dir, ".agents", "skills");
-  if (fs21.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path17.join(dir, ".agents", "skills");
+  if (fs22.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(codexSkillsDir)) {
-        const skillFile = path16.join(codexSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(codexSkillsDir)) {
+        const skillFile = path17.join(codexSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -5509,8 +5549,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs21.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs22.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5519,10 +5559,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs21.existsSync(cursorRulesDir)) {
-    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs22.existsSync(cursorRulesDir)) {
+    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -5532,12 +5572,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs21.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs22.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -5550,10 +5590,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs21.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs22.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.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({
@@ -5571,7 +5611,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs21.readFileSync(filePath, "utf-8");
+  const text = fs22.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5586,27 +5626,27 @@ import { PostHog } from "posthog-node";
 import chalk7 from "chalk";
 
 // src/telemetry/config.ts
-import fs22 from "fs";
-import path17 from "path";
-import os3 from "os";
+import fs23 from "fs";
+import path18 from "path";
+import os4 from "os";
 import crypto3 from "crypto";
 import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path17.join(os3.homedir(), ".caliber");
-var CONFIG_FILE2 = path17.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = path18.join(os4.homedir(), ".caliber");
+var CONFIG_FILE2 = path18.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs22.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs22.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs23.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs23.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs22.existsSync(CONFIG_DIR2)) {
-    fs22.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs23.existsSync(CONFIG_DIR2)) {
+    fs23.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs22.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs23.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6007,6 +6047,51 @@ function extractTopDeps() {
     return [];
   }
 }
+async function searchSkills(fingerprint, targetPlatforms, onStatus) {
+  const installedSkills = getInstalledSkills(targetPlatforms);
+  const technologies = [...new Set([
+    ...fingerprint.languages,
+    ...fingerprint.frameworks,
+    ...extractTopDeps()
+  ].filter(Boolean))];
+  if (technologies.length === 0) {
+    return { results: [], contentMap: /* @__PURE__ */ new Map() };
+  }
+  const primaryPlatform = targetPlatforms.includes("claude") ? "claude" : targetPlatforms[0];
+  onStatus?.("Searching skill registries...");
+  const allCandidates = await searchAllProviders(technologies, primaryPlatform);
+  if (!allCandidates.length) {
+    return { results: [], contentMap: /* @__PURE__ */ new Map() };
+  }
+  const newCandidates = allCandidates.filter((c) => !installedSkills.has(c.slug.toLowerCase()));
+  if (!newCandidates.length) {
+    return { results: [], contentMap: /* @__PURE__ */ new Map() };
+  }
+  onStatus?.(`Scoring ${newCandidates.length} candidates...`);
+  let results;
+  const config = loadConfig();
+  if (config) {
+    try {
+      const projectContext = buildProjectContext(fingerprint, targetPlatforms);
+      results = await scoreWithLLM(newCandidates, projectContext, technologies);
+    } catch {
+      results = newCandidates.slice(0, 20);
+    }
+  } else {
+    results = newCandidates.slice(0, 20);
+  }
+  if (results.length === 0) {
+    return { results: [], contentMap: /* @__PURE__ */ new Map() };
+  }
+  onStatus?.("Fetching skill content...");
+  const contentMap = /* @__PURE__ */ new Map();
+  await Promise.all(results.map(async (rec) => {
+    const content = await fetchSkillContent(rec);
+    if (content) contentMap.set(rec.slug, content);
+  }));
+  const available = results.filter((r) => contentMap.has(r.slug));
+  return { results: available, contentMap };
+}
 async function recommendCommand() {
   const proceed = await select4({
     message: "Search public repos for relevant skills to add to this project?",
@@ -6285,8 +6370,8 @@ function printSkills(recs) {
 }
 
 // src/lib/debug-report.ts
-import fs23 from "fs";
-import path18 from "path";
+import fs24 from "fs";
+import path19 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -6355,11 +6440,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path18.dirname(outputPath);
-    if (!fs23.existsSync(dir)) {
-      fs23.mkdirSync(dir, { recursive: true });
+    const dir = path19.dirname(outputPath);
+    if (!fs24.existsSync(dir)) {
+      fs24.mkdirSync(dir, { recursive: true });
     }
-    fs23.writeFileSync(outputPath, lines.join("\n"));
+    fs24.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -6371,13 +6456,144 @@ function formatMs(ms) {
   return `${secs}s`;
 }
 
+// src/utils/parallel-tasks.ts
+import chalk9 from "chalk";
+
+// node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// src/utils/parallel-tasks.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+var ParallelTaskDisplay = class {
+  tasks = [];
+  lineCount = 0;
+  spinnerFrame = 0;
+  timer = null;
+  startTime = 0;
+  rendered = false;
+  add(name) {
+    const index = this.tasks.length;
+    this.tasks.push({ name, status: "pending", message: "" });
+    return index;
+  }
+  start() {
+    this.startTime = Date.now();
+    this.draw(true);
+    this.timer = setInterval(() => {
+      this.spinnerFrame = (this.spinnerFrame + 1) % SPINNER_FRAMES.length;
+      this.draw(false);
+    }, SPINNER_INTERVAL_MS);
+  }
+  update(index, status, message) {
+    const task = this.tasks[index];
+    if (!task) return;
+    if (status === "running" && task.status === "pending") {
+      task.startTime = Date.now();
+    }
+    if ((status === "done" || status === "failed") && !task.endTime) {
+      task.endTime = Date.now();
+    }
+    task.status = status;
+    if (message !== void 0) task.message = message;
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.draw(false);
+  }
+  formatTime(ms) {
+    const secs = Math.floor(ms / 1e3);
+    if (secs < 60) return `${secs}s`;
+    return `${Math.floor(secs / 60)}m ${secs % 60}s`;
+  }
+  truncate(text, maxVisible) {
+    const plain = stripAnsi(text);
+    if (plain.length <= maxVisible) return text;
+    let visible = 0;
+    let i = 0;
+    while (i < text.length && visible < maxVisible - 3) {
+      if (text[i] === "\x1B") {
+        const end = text.indexOf("m", i);
+        if (end !== -1) {
+          i = end + 1;
+          continue;
+        }
+      }
+      visible++;
+      i++;
+    }
+    return text.slice(0, i) + "...";
+  }
+  renderLine(task) {
+    const maxWidth = process.stdout.columns || 80;
+    const elapsed = task.startTime ? this.formatTime((task.endTime ?? Date.now()) - task.startTime) : "";
+    let line;
+    switch (task.status) {
+      case "pending":
+        line = `  ${chalk9.dim("\u25CB")} ${chalk9.dim(task.name)}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}`;
+        break;
+      case "running": {
+        const spinner = chalk9.cyan(SPINNER_FRAMES[this.spinnerFrame]);
+        const time = elapsed ? chalk9.dim(` (${elapsed})`) : "";
+        line = `  ${spinner} ${task.name}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}${time}`;
+        break;
+      }
+      case "done": {
+        const time = elapsed ? chalk9.dim(` (${elapsed})`) : "";
+        line = `  ${chalk9.green("\u2713")} ${task.name}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}${time}`;
+        break;
+      }
+      case "failed":
+        line = `  ${chalk9.red("\u2717")} ${task.name}${task.message ? chalk9.red(` \u2014 ${task.message}`) : ""}`;
+        break;
+    }
+    return this.truncate(line, maxWidth - 1);
+  }
+  draw(initial) {
+    const { stdout } = process;
+    if (!initial && this.rendered && this.lineCount > 0) {
+      stdout.write(`\x1B[${this.lineCount}A`);
+    }
+    stdout.write("\x1B[0J");
+    const lines = this.tasks.map((t) => this.renderLine(t));
+    const totalElapsed = this.formatTime(Date.now() - this.startTime);
+    lines.push(chalk9.dim(`
+  Total: ${totalElapsed}`));
+    const output = lines.join("\n");
+    stdout.write(output + "\n");
+    this.lineCount = output.split("\n").length;
+    this.rendered = true;
+  }
+};
+
 // src/commands/init.ts
 function log(verbose, ...args) {
-  if (verbose) console.log(chalk9.dim(`  [verbose] ${args.map(String).join(" ")}`));
+  if (verbose) console.log(chalk10.dim(`  [verbose] ${args.map(String).join(" ")}`));
 }
 async function initCommand(options) {
-  const brand = chalk9.hex("#EB9D83");
-  const title = chalk9.hex("#83D1EB");
+  const brand = chalk10.hex("#EB9D83");
+  const title = chalk10.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
@@ -6386,34 +6602,33 @@ 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(chalk9.dim("  Scan your project and generate tailored config files for"));
-  console.log(chalk9.dim("  Claude Code, Cursor, and Codex.\n"));
+  console.log(chalk10.dim("  Scan your project and generate tailored config files for"));
+  console.log(chalk10.dim("  Claude Code, Cursor, and Codex.\n"));
   const report = options.debugReport ? new DebugReport() : null;
   console.log(title.bold("  How it works:\n"));
-  console.log(chalk9.dim("  1. Connect    Choose your LLM provider"));
-  console.log(chalk9.dim("  2. Discover   Scan code, dependencies, and existing configs"));
-  console.log(chalk9.dim("  3. Generate   Build CLAUDE.md, rules, and skills for your codebase"));
-  console.log(chalk9.dim("  4. Review     See a diff \u2014 accept, refine via chat, or decline"));
-  console.log(chalk9.dim("  5. Skills     Search community registries and install skills\n"));
-  console.log(title.bold("  Step 1/5 \u2014 Connect\n"));
+  console.log(chalk10.dim("  1. Setup      Connect your LLM provider and select your agents"));
+  console.log(chalk10.dim("  2. Engine     Detect stack, generate configs & skills in parallel"));
+  console.log(chalk10.dim("  3. Review     See all changes \u2014 accept, refine, or decline"));
+  console.log(chalk10.dim("  4. Finalize   Score check and auto-sync hooks\n"));
+  console.log(title.bold("  Step 1/4 \u2014 Setup\n"));
   let config = loadConfig();
   if (!config) {
-    console.log(chalk9.dim("  No LLM provider set yet. Choose how to run Caliber:\n"));
+    console.log(chalk10.dim("  No LLM provider configured yet.\n"));
     await runInteractiveProviderSetup({
       selectMessage: "How do you want to use Caliber? (choose LLM provider)"
     });
     config = loadConfig();
     if (!config) {
-      console.log(chalk9.red("  Setup was cancelled or failed.\n"));
+      console.log(chalk10.red("  Setup was cancelled or failed.\n"));
       throw new Error("__exit__");
     }
-    console.log(chalk9.green("  \u2713 Provider saved. Let's continue.\n"));
+    console.log(chalk10.green("  \u2713 Provider saved\n"));
   }
   trackInitProviderSelected(config.provider, config.model);
   const displayModel = getDisplayModel(config);
   const fastModel = getFastModel();
   const modelLine = fastModel ? `  Provider: ${config.provider} | Model: ${displayModel} | Scan: ${fastModel}` : `  Provider: ${config.provider} | Model: ${displayModel}`;
-  console.log(chalk9.dim(modelLine + "\n"));
+  console.log(chalk10.dim(modelLine + "\n"));
   if (report) {
     report.markStep("Provider setup");
     report.addSection("LLM Provider", `- **Provider**: ${config.provider}
@@ -6421,30 +6636,6 @@ async function initCommand(options) {
 - **Fast model**: ${fastModel || "none"}`);
   }
   await validateModel({ fast: true });
-  console.log(title.bold("  Step 2/5 \u2014 Discover\n"));
-  const spinner = ora2("Scanning code, dependencies, and existing configs...").start();
-  const fingerprint = await collectFingerprint(process.cwd());
-  spinner.succeed("Project scanned");
-  log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
-  if (options.verbose && fingerprint.codeAnalysis) {
-    log(options.verbose, `Code analysis: ${fingerprint.codeAnalysis.filesIncluded}/${fingerprint.codeAnalysis.filesAnalyzed} files, ~${fingerprint.codeAnalysis.includedTokens.toLocaleString()} tokens, ${fingerprint.codeAnalysis.duplicateGroups} dedup groups`);
-  }
-  trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
-  const langDisplay = fingerprint.languages.join(", ") || "none detected";
-  const frameworkDisplay = fingerprint.frameworks.length > 0 ? ` (${fingerprint.frameworks.join(", ")})` : "";
-  console.log(chalk9.dim(`  Languages: ${langDisplay}${frameworkDisplay}`));
-  console.log(chalk9.dim(`  Files: ${fingerprint.fileTree.length} found
-`));
-  if (report) {
-    report.markStep("Fingerprint");
-    report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
-    report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
-    report.addJson("Fingerprint: Detected Stack", { languages: fingerprint.languages, frameworks: fingerprint.frameworks, tools: fingerprint.tools });
-    report.addJson("Fingerprint: Existing Configs", fingerprint.existingConfigs);
-    if (fingerprint.codeAnalysis) {
-      report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
-    }
-  }
   let targetAgent;
   if (options.agent) {
     targetAgent = options.agent;
@@ -6454,30 +6645,27 @@ async function initCommand(options) {
   } else {
     targetAgent = await promptAgent();
   }
-  console.log(chalk9.dim(`  Target: ${targetAgent.join(", ")}
+  console.log(chalk10.dim(`  Target: ${targetAgent.join(", ")}
 `));
   trackInitAgentSelected(targetAgent);
-  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);
-    }
+  let wantsSkills = false;
+  if (!options.autoApprove) {
+    wantsSkills = await select5({
+      message: "Discover community-maintained skills that match your stack?",
+      choices: [
+        { name: "Yes, find skills for my project", value: true },
+        { name: "Skip for now", value: false }
+      ]
+    });
   }
-  const baselineScore = computeLocalScore(process.cwd(), targetAgent);
-  console.log(chalk9.dim("  Current setup score:"));
+  let baselineScore = computeLocalScore(process.cwd(), targetAgent);
+  console.log(chalk10.dim("\n  Current setup score:"));
   displayScoreSummary(baselineScore);
   if (options.verbose) {
     for (const c of baselineScore.checks) {
       log(options.verbose, `  ${c.passed ? "\u2713" : "\u2717"} ${c.name}: ${c.earnedPoints}/${c.maxPoints}${c.suggestion ? ` \u2014 ${c.suggestion}` : ""}`);
     }
   }
-  const passingCount = baselineScore.checks.filter((c) => c.passed).length;
-  const failingCount = baselineScore.checks.filter((c) => !c.passed).length;
   if (report) {
     report.markStep("Baseline scoring");
     report.addSection("Scoring: Baseline", `**Score**: ${baselineScore.score}/100
@@ -6487,7 +6675,7 @@ async function initCommand(options) {
 ` + baselineScore.checks.map((c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.earnedPoints} | ${c.maxPoints} |`).join("\n"));
     report.addSection("Generation: Target Agents", targetAgent.join(", "));
   }
-  const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length || fingerprint.existingConfigs.agentsMd);
+  const hasExistingConfig = !!(baselineScore.checks.some((c) => c.id === "claude_md_exists" && c.passed) || baselineScore.checks.some((c) => c.id === "cursorrules_exists" && c.passed));
   const NON_LLM_CHECKS = /* @__PURE__ */ new Set([
     "hooks_configured",
     "agents_md_exists",
@@ -6496,111 +6684,175 @@ async function initCommand(options) {
     "service_coverage",
     "mcp_completeness"
   ]);
+  const passingCount = baselineScore.checks.filter((c) => c.passed).length;
+  const failingCount = baselineScore.checks.filter((c) => !c.passed).length;
   if (hasExistingConfig && baselineScore.score === 100) {
     trackInitScoreComputed(baselineScore.score, passingCount, failingCount, true);
-    console.log(chalk9.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk9.dim("  Run ") + chalk9.hex("#83D1EB")("caliber init --force") + chalk9.dim(" to regenerate anyway.\n"));
+    console.log(chalk10.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
+    console.log(chalk10.dim("  Run ") + chalk10.hex("#83D1EB")("caliber init --force") + chalk10.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
   const llmFixableChecks = allFailingChecks.filter((c) => !NON_LLM_CHECKS.has(c.id));
   trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
   if (hasExistingConfig && llmFixableChecks.length === 0 && allFailingChecks.length > 0 && !options.force) {
-    console.log(chalk9.bold.green("\n  Your config is fully optimized for LLM generation.\n"));
-    console.log(chalk9.dim("  Remaining items need CLI actions:\n"));
+    console.log(chalk10.bold.green("\n  Your config is fully optimized for LLM generation.\n"));
+    console.log(chalk10.dim("  Remaining items need CLI actions:\n"));
     for (const check of allFailingChecks) {
-      console.log(chalk9.dim(`    \u2022 ${check.name}`));
+      console.log(chalk10.dim(`    \u2022 ${check.name}`));
       if (check.suggestion) {
-        console.log(`      ${chalk9.hex("#83D1EB")(check.suggestion)}`);
+        console.log(`      ${chalk10.hex("#83D1EB")(check.suggestion)}`);
       }
     }
     console.log("");
-    console.log(chalk9.dim("  Run ") + chalk9.hex("#83D1EB")("caliber init --force") + chalk9.dim(" to regenerate anyway.\n"));
+    console.log(chalk10.dim("  Run ") + chalk10.hex("#83D1EB")("caliber init --force") + chalk10.dim(" to regenerate anyway.\n"));
     return;
   }
+  console.log(title.bold("  Step 2/4 \u2014 Engine\n"));
+  const genModelInfo = fastModel ? `  Using ${displayModel} for docs, ${fastModel} for skills` : `  Using ${displayModel}`;
+  console.log(chalk10.dim(genModelInfo + "\n"));
+  if (report) report.markStep("Generation");
+  trackInitGenerationStarted(false);
+  const genStartTime = Date.now();
+  let generatedSetup = null;
+  let rawOutput;
+  let genStopReason;
+  let skillSearchResult = { results: [], contentMap: /* @__PURE__ */ new Map() };
+  let fingerprint;
+  const fpSpinner = ora2("Scanning project...").start();
+  try {
+    fingerprint = await collectFingerprint(process.cwd());
+    fpSpinner.succeed(`Stack detected \u2014 ${fingerprint.languages.join(", ") || "no languages"}${fingerprint.frameworks.length > 0 ? `, ${fingerprint.frameworks.join(", ")}` : ""}`);
+  } catch (err) {
+    fpSpinner.fail("Failed to scan project");
+    throw new Error("__exit__");
+  }
+  trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
+  log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
+  if (report) {
+    report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
+    report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
+    report.addJson("Fingerprint: Detected Stack", { languages: fingerprint.languages, frameworks: fingerprint.frameworks, tools: fingerprint.tools });
+    report.addJson("Fingerprint: Existing Configs", fingerprint.existingConfigs);
+    if (fingerprint.codeAnalysis) report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
+  }
   const isEmpty = fingerprint.fileTree.length < 3;
   if (isEmpty) {
     fingerprint.description = await promptInput("What will you build in this project?");
   }
+  const failingForDismissal = baselineScore.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);
+      baselineScore = computeLocalScore(process.cwd(), targetAgent);
+    }
+  }
   let failingChecks;
   let passingChecks;
   let currentScore;
   if (hasExistingConfig && baselineScore.score >= 95 && !options.force) {
-    failingChecks = llmFixableChecks.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
+    const currentLlmFixable = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
+    failingChecks = currentLlmFixable.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
     passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
     currentScore = baselineScore.score;
-    if (failingChecks.length > 0) {
-      console.log(title.bold("  Step 3/5 \u2014 Generate\n"));
-      console.log(chalk9.dim(`  Score is ${baselineScore.score}/100 \u2014 fine-tuning ${failingChecks.length} remaining issue${failingChecks.length === 1 ? "" : "s"}:
-`));
-      for (const check of failingChecks) {
-        console.log(chalk9.dim(`    \u2022 ${check.name}`));
-      }
-      console.log("");
-    }
-  } else if (hasExistingConfig) {
-    console.log(title.bold("  Step 3/5 \u2014 Generate\n"));
-    console.log(chalk9.dim("  Auditing your existing configs against your codebase and improving them.\n"));
-  } else {
-    console.log(title.bold("  Step 3/5 \u2014 Generate\n"));
-    console.log(chalk9.dim("  Building CLAUDE.md, rules, and skills tailored to your project.\n"));
   }
-  const genModelInfo = fastModel ? `  Using ${displayModel} for docs, ${fastModel} for skills` : `  Using ${displayModel}`;
-  console.log(chalk9.dim(genModelInfo));
-  console.log(chalk9.dim("  This can take a couple of minutes depending on your model and provider.\n"));
   if (report) {
-    report.markStep("Generation");
     const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
     report.addCodeBlock("Generation: Full LLM Prompt", fullPrompt);
   }
-  trackInitGenerationStarted(!!failingChecks);
-  const genStartTime = Date.now();
-  const genSpinner = ora2("Generating setup...").start();
-  const genMessages = new SpinnerMessages(genSpinner, GENERATION_MESSAGES, { showElapsedTime: true });
-  genMessages.start();
-  let generatedSetup = null;
-  let rawOutput;
-  let genStopReason;
+  const display = new ParallelTaskDisplay();
+  const TASK_CONFIG = display.add("Generating configs");
+  const TASK_SKILLS_GEN = display.add("Generating skills");
+  const TASK_SKILLS_SEARCH = wantsSkills ? display.add("Searching community skills") : -1;
+  display.start();
   try {
-    const result = await generateSetup(
-      fingerprint,
-      targetAgent,
-      fingerprint.description,
-      {
-        onStatus: (status) => {
-          genMessages.handleServerStatus(status);
-        },
-        onComplete: (setup) => {
-          generatedSetup = setup;
+    display.update(TASK_CONFIG, "running");
+    const generatePromise = (async () => {
+      const result = await generateSetup(
+        fingerprint,
+        targetAgent,
+        fingerprint.description,
+        {
+          onStatus: (status) => display.update(TASK_CONFIG, "running", status),
+          onComplete: (setup) => {
+            generatedSetup = setup;
+          },
+          onError: (error) => display.update(TASK_CONFIG, "failed", error)
         },
-        onError: (error) => {
-          genMessages.stop();
-          genSpinner.fail(`Generation error: ${error}`);
-        }
-      },
-      failingChecks,
-      currentScore,
-      passingChecks
-    );
-    if (!generatedSetup) {
-      generatedSetup = result.setup;
+        failingChecks,
+        currentScore,
+        passingChecks,
+        { skipSkills: true }
+      );
+      if (!generatedSetup) generatedSetup = result.setup;
       rawOutput = result.raw;
-    }
-    genStopReason = result.stopReason;
+      genStopReason = result.stopReason;
+      if (!generatedSetup) {
+        display.update(TASK_CONFIG, "failed", "Could not parse LLM response");
+        display.update(TASK_SKILLS_GEN, "failed", "Skipped");
+        return;
+      }
+      display.update(TASK_CONFIG, "done");
+      display.update(TASK_SKILLS_GEN, "running");
+      const skillCount = await generateSkillsForSetup(
+        generatedSetup,
+        fingerprint,
+        targetAgent,
+        (status) => display.update(TASK_SKILLS_GEN, "running", status)
+      );
+      display.update(TASK_SKILLS_GEN, "done", `${skillCount} skills`);
+    })();
+    const SEARCH_TIMEOUT_MS = 6e4;
+    const searchPromise = wantsSkills ? (async () => {
+      display.update(TASK_SKILLS_SEARCH, "running");
+      try {
+        const searchWithTimeout = Promise.race([
+          searchSkills(
+            fingerprint,
+            targetAgent,
+            (status) => display.update(TASK_SKILLS_SEARCH, "running", status)
+          ),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("timeout")), SEARCH_TIMEOUT_MS)
+          )
+        ]);
+        skillSearchResult = await searchWithTimeout;
+        const count = skillSearchResult.results.length;
+        display.update(TASK_SKILLS_SEARCH, "done", count > 0 ? `${count} skills found` : "No matches");
+      } catch (err) {
+        const reason = err instanceof Error && err.message === "timeout" ? "Timed out" : "Search failed";
+        display.update(TASK_SKILLS_SEARCH, "failed", reason);
+      }
+    })() : Promise.resolve();
+    await Promise.all([generatePromise, searchPromise]);
   } catch (err) {
-    genMessages.stop();
+    display.stop();
     const msg = err instanceof Error ? err.message : "Unknown error";
-    genSpinner.fail(`Generation failed: ${msg}`);
+    console.log(chalk10.red(`
+  Engine failed: ${msg}
+`));
     writeErrorLog(config, void 0, msg, "exception");
     throw new Error("__exit__");
   }
-  genMessages.stop();
+  display.stop();
+  const elapsedMs = Date.now() - genStartTime;
+  trackInitGenerationCompleted(elapsedMs, 0);
+  const mins = Math.floor(elapsedMs / 6e4);
+  const secs = Math.floor(elapsedMs % 6e4 / 1e3);
+  const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+  console.log(chalk10.dim(`
+  Completed in ${timeStr}
+`));
   if (!generatedSetup) {
-    genSpinner.fail("Failed to generate setup.");
+    console.log(chalk10.red("  Failed to generate setup."));
     writeErrorLog(config, rawOutput, void 0, genStopReason);
     if (rawOutput) {
-      console.log(chalk9.dim("\nRaw LLM output (JSON parse failed):"));
-      console.log(chalk9.dim(rawOutput.slice(0, 500)));
+      console.log(chalk10.dim("\nRaw LLM output (JSON parse failed):"));
+      console.log(chalk10.dim(rawOutput.slice(0, 500)));
     }
     throw new Error("__exit__");
   }
@@ -6608,12 +6860,6 @@ async function initCommand(options) {
     if (rawOutput) report.addCodeBlock("Generation: Raw LLM Response", rawOutput);
     report.addJson("Generation: Parsed Setup", generatedSetup);
   }
-  const elapsedMs = Date.now() - genStartTime;
-  trackInitGenerationCompleted(elapsedMs, 0);
-  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 ${chalk9.dim(`in ${timeStr}`)}`);
   log(options.verbose, `Generation completed: ${elapsedMs}ms, stopReason: ${genStopReason || "end_turn"}`);
   printSetupSummary(generatedSetup);
   const sessionHistory = [];
@@ -6621,15 +6867,20 @@ async function initCommand(options) {
     role: "assistant",
     content: summarizeSetup("Initial generation", generatedSetup)
   });
-  console.log(title.bold("  Step 4/5 \u2014 Review\n"));
+  console.log(title.bold("  Step 3/4 \u2014 Review\n"));
   const setupFiles = collectSetupFiles(generatedSetup, targetAgent);
   const staged = stageFiles(setupFiles, process.cwd());
   const totalChanges = staged.newFiles + staged.modifiedFiles;
-  console.log(chalk9.dim(`  ${chalk9.green(`${staged.newFiles} new`)} / ${chalk9.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}
+  console.log(chalk10.dim(`  ${chalk10.green(`${staged.newFiles} new`)} / ${chalk10.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}`));
+  if (skillSearchResult.results.length > 0) {
+    console.log(chalk10.dim(`  ${chalk10.cyan(`${skillSearchResult.results.length}`)} community skills available to install
 `));
+  } else {
+    console.log("");
+  }
   let action;
-  if (totalChanges === 0) {
-    console.log(chalk9.dim("  No changes needed \u2014 your configs are already up to date.\n"));
+  if (totalChanges === 0 && skillSearchResult.results.length === 0) {
+    console.log(chalk10.dim("  No changes needed \u2014 your configs are already up to date.\n"));
     cleanupStaging();
     action = "accept";
   } else if (options.autoApprove) {
@@ -6637,13 +6888,15 @@ async function initCommand(options) {
     action = "accept";
     trackInitReviewAction(action, "auto-approved");
   } else {
-    const wantsReview = await promptWantsReview();
-    if (wantsReview) {
-      const reviewMethod = await promptReviewMethod();
-      await openReview(reviewMethod, staged.stagedFiles);
+    if (totalChanges > 0) {
+      const wantsReview = await promptWantsReview();
+      if (wantsReview) {
+        const reviewMethod = await promptReviewMethod();
+        await openReview(reviewMethod, staged.stagedFiles);
+      }
     }
     action = await promptReviewAction();
-    trackInitReviewAction(action, wantsReview ? "reviewed" : "skipped");
+    trackInitReviewAction(action, totalChanges > 0 ? "reviewed" : "skipped");
   }
   let refinementRound = 0;
   while (action === "refine") {
@@ -6652,12 +6905,12 @@ async function initCommand(options) {
     trackInitRefinementRound(refinementRound, !!generatedSetup);
     if (!generatedSetup) {
       cleanupStaging();
-      console.log(chalk9.dim("Refinement cancelled. No files were modified."));
+      console.log(chalk10.dim("Refinement cancelled. No files were modified."));
       return;
     }
     const updatedFiles = collectSetupFiles(generatedSetup, targetAgent);
     const restaged = stageFiles(updatedFiles, process.cwd());
-    console.log(chalk9.dim(`  ${chalk9.green(`${restaged.newFiles} new`)} / ${chalk9.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
+    console.log(chalk10.dim(`  ${chalk10.green(`${restaged.newFiles} new`)} / ${chalk10.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
 `));
     printSetupSummary(generatedSetup);
     await openReview("terminal", restaged.stagedFiles);
@@ -6666,17 +6919,18 @@ async function initCommand(options) {
   }
   cleanupStaging();
   if (action === "decline") {
-    console.log(chalk9.dim("Setup declined. No files were modified."));
+    console.log(chalk10.dim("Setup declined. No files were modified."));
     return;
   }
+  console.log(title.bold("\n  Step 4/4 \u2014 Finalize\n"));
   if (options.dryRun) {
-    console.log(chalk9.yellow("\n[Dry run] Would write the following files:"));
+    console.log(chalk10.yellow("\n[Dry run] Would write the following files:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
     return;
   }
   const writeSpinner = ora2("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs24.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs25.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -6699,85 +6953,45 @@ ${agentRefs.join(" ")}
       0,
       result.deleted.length
     );
-    console.log(chalk9.bold("\nFiles created/updated:"));
+    console.log(chalk10.bold("\nFiles created/updated:"));
     for (const file of result.written) {
-      console.log(`  ${chalk9.green("\u2713")} ${file}`);
+      console.log(`  ${chalk10.green("\u2713")} ${file}`);
     }
     if (result.deleted.length > 0) {
-      console.log(chalk9.bold("\nFiles removed:"));
+      console.log(chalk10.bold("\nFiles removed:"));
       for (const file of result.deleted) {
-        console.log(`  ${chalk9.red("\u2717")} ${file}`);
+        console.log(`  ${chalk10.red("\u2717")} ${file}`);
       }
     }
     if (result.backupDir) {
-      console.log(chalk9.dim(`
+      console.log(chalk10.dim(`
   Backups saved to ${result.backupDir}`));
     }
   } catch (err) {
     writeSpinner.fail("Failed to write files");
-    console.error(chalk9.red(err instanceof Error ? err.message : "Unknown error"));
+    console.error(chalk10.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
-  ensurePermissions(fingerprint);
+  if (fingerprint) ensurePermissions(fingerprint);
   const sha = getCurrentHeadSha();
   writeState({
     lastRefreshSha: sha ?? "",
     lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
     targetAgent
   });
-  console.log("");
-  console.log(chalk9.dim("  Auto-refresh: keep your configs in sync as your code changes.\n"));
-  let hookChoice;
-  if (options.autoApprove) {
-    hookChoice = "skip";
-    log(options.verbose, "Auto-approve: skipping hook installation");
-  } else {
-    hookChoice = await promptHookType(targetAgent);
-  }
-  trackInitHookSelected(hookChoice);
-  if (hookChoice === "claude" || hookChoice === "both") {
-    const hookResult = installHook();
-    if (hookResult.installed) {
-      console.log(`  ${chalk9.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-      console.log(chalk9.dim("    Run ") + chalk9.hex("#83D1EB")("caliber hooks --remove") + chalk9.dim(" to disable"));
-    } else if (hookResult.alreadyInstalled) {
-      console.log(chalk9.dim("  Claude Code hook already installed"));
-    }
-    const learnResult = installLearningHooks();
-    if (learnResult.installed) {
-      console.log(`  ${chalk9.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
-      console.log(chalk9.dim("    Run ") + chalk9.hex("#83D1EB")("caliber learn remove") + chalk9.dim(" to disable"));
-    } else if (learnResult.alreadyInstalled) {
-      console.log(chalk9.dim("  Learning hooks already installed"));
-    }
-  }
-  if (hookChoice === "precommit" || hookChoice === "both") {
-    const precommitResult = installPreCommitHook();
-    if (precommitResult.installed) {
-      console.log(`  ${chalk9.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk9.dim("    Run ") + chalk9.hex("#83D1EB")("caliber hooks --remove") + chalk9.dim(" to disable"));
-    } else if (precommitResult.alreadyInstalled) {
-      console.log(chalk9.dim("  Pre-commit hook already installed"));
-    } else {
-      console.log(chalk9.yellow("  Could not install pre-commit hook (not a git repository?)"));
-    }
-  }
-  if (hookChoice === "skip") {
-    console.log(chalk9.dim("  Skipped auto-refresh hooks. Run ") + chalk9.hex("#83D1EB")("caliber hooks --install") + chalk9.dim(" later to enable."));
-  }
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
     trackInitScoreRegression(baselineScore.score, afterScore.score);
     console.log("");
-    console.log(chalk9.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
+    console.log(chalk10.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(chalk9.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
+        console.log(chalk10.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
       }
     } catch {
     }
-    console.log(chalk9.dim("  Run ") + chalk9.hex("#83D1EB")("caliber init --force") + chalk9.dim(" to override.\n"));
+    console.log(chalk10.dim("  Run ") + chalk10.hex("#83D1EB")("caliber init --force") + chalk10.dim(" to override.\n"));
     return;
   }
   if (report) {
@@ -6795,39 +7009,57 @@ ${agentRefs.join(" ")}
       log(options.verbose, `  Still failing: ${c.name} (${c.earnedPoints}/${c.maxPoints})${c.suggestion ? ` \u2014 ${c.suggestion}` : ""}`);
     }
   }
-  console.log(title.bold("\n  Step 5/5 \u2014 Skills\n"));
-  console.log(chalk9.dim("  Search community registries for skills that match your tech stack.\n"));
-  let wantsSkills;
+  if (skillSearchResult.results.length > 0 && !options.autoApprove) {
+    console.log(chalk10.dim("  Community skills matched to your project:\n"));
+    const selected = await interactiveSelect(skillSearchResult.results);
+    if (selected?.length) {
+      await installSkills(selected, targetAgent, skillSearchResult.contentMap);
+      trackInitSkillsSearch(true, selected.length);
+    }
+  }
+  console.log("");
+  let hookChoice;
   if (options.autoApprove) {
-    wantsSkills = false;
-    log(options.verbose, "Auto-approve: skipping skills search");
+    hookChoice = "skip";
+    log(options.verbose, "Auto-approve: skipping hook installation");
   } else {
-    wantsSkills = await select5({
-      message: "Search public repos for relevant skills to add to this project?",
-      choices: [
-        { name: "Yes, find skills for my project", value: true },
-        { name: "Skip for now", value: false }
-      ]
-    });
+    hookChoice = await promptHookType(targetAgent);
   }
-  if (wantsSkills) {
-    trackInitSkillsSearch(true, 0);
-    try {
-      await searchAndInstallSkills(targetAgent);
-    } catch (err) {
-      if (err.message !== "__exit__") {
-        console.log(chalk9.dim("  Skills search failed: " + (err.message || "unknown error")));
-      }
-      console.log(chalk9.dim("  Run ") + chalk9.hex("#83D1EB")("caliber skills") + chalk9.dim(" later to try again.\n"));
+  trackInitHookSelected(hookChoice);
+  if (hookChoice === "claude" || hookChoice === "both") {
+    const hookResult = installHook();
+    if (hookResult.installed) {
+      console.log(`  ${chalk10.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
+      console.log(chalk10.dim("    Run ") + chalk10.hex("#83D1EB")("caliber hooks --remove") + chalk10.dim(" to disable"));
+    } else if (hookResult.alreadyInstalled) {
+      console.log(chalk10.dim("  Claude Code hook already installed"));
+    }
+    const learnResult = installLearningHooks();
+    if (learnResult.installed) {
+      console.log(`  ${chalk10.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
+      console.log(chalk10.dim("    Run ") + chalk10.hex("#83D1EB")("caliber learn remove") + chalk10.dim(" to disable"));
+    } else if (learnResult.alreadyInstalled) {
+      console.log(chalk10.dim("  Learning hooks already installed"));
+    }
+  }
+  if (hookChoice === "precommit" || hookChoice === "both") {
+    const precommitResult = installPreCommitHook();
+    if (precommitResult.installed) {
+      console.log(`  ${chalk10.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
+      console.log(chalk10.dim("    Run ") + chalk10.hex("#83D1EB")("caliber hooks --remove") + chalk10.dim(" to disable"));
+    } else if (precommitResult.alreadyInstalled) {
+      console.log(chalk10.dim("  Pre-commit hook already installed"));
+    } else {
+      console.log(chalk10.yellow("  Could not install pre-commit hook (not a git repository?)"));
     }
-  } else {
-    trackInitSkillsSearch(false, 0);
-    console.log(chalk9.dim("  Skipped. Run ") + chalk9.hex("#83D1EB")("caliber skills") + chalk9.dim(" later to browse.\n"));
   }
-  console.log(chalk9.bold.green("  Setup complete!"));
-  console.log(chalk9.dim("  Your AI agents now understand your project's architecture, build commands,"));
-  console.log(chalk9.dim("  testing patterns, and conventions. All changes are backed up automatically.\n"));
-  console.log(chalk9.bold("  Next steps:\n"));
+  if (hookChoice === "skip") {
+    console.log(chalk10.dim("  Skipped auto-sync hooks. Run ") + chalk10.hex("#83D1EB")("caliber hooks --install") + chalk10.dim(" later to enable."));
+  }
+  console.log(chalk10.bold.green("\n  Setup complete!"));
+  console.log(chalk10.dim("  Your AI agents now understand your project's architecture, build commands,"));
+  console.log(chalk10.dim("  testing patterns, and conventions. All changes are backed up automatically.\n"));
+  console.log(chalk10.bold("  Next steps:\n"));
   console.log(`    ${title("caliber score")}        See your full config breakdown`);
   console.log(`    ${title("caliber refresh")}      Update docs after code changes`);
   console.log(`    ${title("caliber hooks")}        Toggle auto-refresh hooks`);
@@ -6839,9 +7071,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path19.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path20.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk9.dim(`  Debug report written to ${path19.relative(process.cwd(), reportPath)}
+    console.log(chalk10.dim(`  Debug report written to ${path20.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -6856,9 +7088,9 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
     }
     const isValid = await classifyRefineIntent(message);
     if (!isValid) {
-      console.log(chalk9.dim("  This doesn't look like a config change request."));
-      console.log(chalk9.dim("  Describe what to add, remove, or modify in your configs."));
-      console.log(chalk9.dim('  Type "done" to accept the current setup.\n'));
+      console.log(chalk10.dim("  This doesn't look like a config change request."));
+      console.log(chalk10.dim("  Describe what to add, remove, or modify in your configs."));
+      console.log(chalk10.dim('  Type "done" to accept the current setup.\n'));
       continue;
     }
     const refineSpinner = ora2("Refining setup...").start();
@@ -6879,16 +7111,16 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
       });
       refineSpinner.succeed("Setup updated");
       printSetupSummary(refined);
-      console.log(chalk9.dim('Type "done" to accept, or describe more changes.'));
+      console.log(chalk10.dim('Type "done" to accept, or describe more changes.'));
     } else {
       refineSpinner.fail("Refinement failed \u2014 could not parse AI response.");
-      console.log(chalk9.dim('Try rephrasing your request, or type "done" to keep the current setup.'));
+      console.log(chalk10.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(([path27, desc]) => `  ${path27}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path28, desc]) => `  ${path28}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -6910,6 +7142,7 @@ Return {"valid": true} or {"valid": false}. Nothing else.`,
   }
 }
 async function evaluateDismissals(failingChecks, fingerprint) {
+  if (failingChecks.length === 0) return [];
   const fastModel = getFastModel();
   const checkList = failingChecks.map((c) => ({
     id: c.id,
@@ -6977,7 +7210,7 @@ async function promptHookType(targetAgent) {
   }
   choices.push({ name: "Skip for now", value: "skip" });
   return select5({
-    message: "How would you like to auto-refresh your setup?",
+    message: "Keep your AI docs & skills in sync as your code evolves?",
     choices
   });
 }
@@ -6997,26 +7230,26 @@ function printSetupSummary(setup) {
   const fileDescriptions = setup.fileDescriptions;
   const deletions = setup.deletions;
   console.log("");
-  console.log(chalk9.bold("  Proposed changes:\n"));
+  console.log(chalk10.bold("  Proposed changes:\n"));
   const getDescription = (filePath) => {
     return fileDescriptions?.[filePath];
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs24.existsSync("CLAUDE.md") ? chalk9.yellow("~") : chalk9.green("+");
+      const icon = fs25.existsSync("CLAUDE.md") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription("CLAUDE.md");
-      console.log(`  ${icon} ${chalk9.bold("CLAUDE.md")}`);
-      if (desc) console.log(chalk9.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk10.bold("CLAUDE.md")}`);
+      if (desc) console.log(chalk10.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 = fs24.existsSync(skillPath) ? chalk9.yellow("~") : chalk9.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk9.bold(skillPath)}`);
-        console.log(chalk9.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
+        console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
@@ -7024,40 +7257,40 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs24.existsSync("AGENTS.md") ? chalk9.yellow("~") : chalk9.green("+");
+      const icon = fs25.existsSync("AGENTS.md") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription("AGENTS.md");
-      console.log(`  ${icon} ${chalk9.bold("AGENTS.md")}`);
-      if (desc) console.log(chalk9.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk10.bold("AGENTS.md")}`);
+      if (desc) console.log(chalk10.dim(`    ${desc}`));
       console.log("");
     }
     const codexSkills = codex.skills;
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs24.existsSync(skillPath) ? chalk9.yellow("~") : chalk9.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk9.bold(skillPath)}`);
-        console.log(chalk9.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
+        console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs24.existsSync(".cursorrules") ? chalk9.yellow("~") : chalk9.green("+");
+      const icon = fs25.existsSync(".cursorrules") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription(".cursorrules");
-      console.log(`  ${icon} ${chalk9.bold(".cursorrules")}`);
-      if (desc) console.log(chalk9.dim(`    ${desc}`));
+      console.log(`  ${icon} ${chalk10.bold(".cursorrules")}`);
+      if (desc) console.log(chalk10.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 = fs24.existsSync(skillPath) ? chalk9.yellow("~") : chalk9.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
-        console.log(`  ${icon} ${chalk9.bold(skillPath)}`);
-        console.log(chalk9.dim(`    ${desc || skill.description || skill.name}`));
+        console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
+        console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
         console.log("");
       }
     }
@@ -7065,14 +7298,14 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs24.existsSync(rulePath) ? chalk9.yellow("~") : chalk9.green("+");
+        const icon = fs25.existsSync(rulePath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(rulePath);
-        console.log(`  ${icon} ${chalk9.bold(rulePath)}`);
+        console.log(`  ${icon} ${chalk10.bold(rulePath)}`);
         if (desc) {
-          console.log(chalk9.dim(`    ${desc}`));
+          console.log(chalk10.dim(`    ${desc}`));
         } else {
           const firstLine = rule.content.split("\n").filter((l) => l.trim() && !l.trim().startsWith("#"))[0];
-          if (firstLine) console.log(chalk9.dim(`    ${firstLine.trim().slice(0, 80)}`));
+          if (firstLine) console.log(chalk10.dim(`    ${firstLine.trim().slice(0, 80)}`));
         }
         console.log("");
       }
@@ -7080,12 +7313,12 @@ function printSetupSummary(setup) {
   }
   if (Array.isArray(deletions) && deletions.length > 0) {
     for (const del of deletions) {
-      console.log(`  ${chalk9.red("-")} ${chalk9.bold(del.filePath)}`);
-      console.log(chalk9.dim(`    ${del.reason}`));
+      console.log(`  ${chalk10.red("-")} ${chalk10.bold(del.filePath)}`);
+      console.log(chalk10.dim(`    ${del.reason}`));
       console.log("");
     }
   }
-  console.log(`  ${chalk9.green("+")} ${chalk9.dim("new")}  ${chalk9.yellow("~")} ${chalk9.dim("modified")}  ${chalk9.red("-")} ${chalk9.dim("removed")}`);
+  console.log(`  ${chalk10.green("+")} ${chalk10.dim("new")}  ${chalk10.yellow("~")} ${chalk10.dim("modified")}  ${chalk10.red("-")} ${chalk10.dim("removed")}`);
   console.log("");
 }
 function derivePermissions(fingerprint) {
@@ -7129,8 +7362,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs24.existsSync(settingsPath)) {
-      settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+    if (fs25.existsSync(settingsPath)) {
+      settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -7139,32 +7372,32 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs24.existsSync(".claude")) fs24.mkdirSync(".claude", { recursive: true });
-  fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs25.existsSync(".claude")) fs25.mkdirSync(".claude", { recursive: true });
+  fs25.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function displayTokenUsage() {
   const summary = getUsageSummary();
   if (summary.length === 0) {
-    console.log(chalk9.dim("  Token tracking not available for this provider.\n"));
+    console.log(chalk10.dim("  Token tracking not available for this provider.\n"));
     return;
   }
-  console.log(chalk9.bold("  Token usage:\n"));
+  console.log(chalk10.bold("  Token usage:\n"));
   let totalIn = 0;
   let totalOut = 0;
   for (const m of summary) {
     totalIn += m.inputTokens;
     totalOut += m.outputTokens;
-    const cacheInfo = m.cacheReadTokens > 0 || m.cacheWriteTokens > 0 ? chalk9.dim(` (cache: ${m.cacheReadTokens.toLocaleString()} read, ${m.cacheWriteTokens.toLocaleString()} write)`) : "";
-    console.log(`    ${chalk9.dim(m.model)}: ${m.inputTokens.toLocaleString()} in / ${m.outputTokens.toLocaleString()} out  (${m.calls} call${m.calls === 1 ? "" : "s"})${cacheInfo}`);
+    const cacheInfo = m.cacheReadTokens > 0 || m.cacheWriteTokens > 0 ? chalk10.dim(` (cache: ${m.cacheReadTokens.toLocaleString()} read, ${m.cacheWriteTokens.toLocaleString()} write)`) : "";
+    console.log(`    ${chalk10.dim(m.model)}: ${m.inputTokens.toLocaleString()} in / ${m.outputTokens.toLocaleString()} out  (${m.calls} call${m.calls === 1 ? "" : "s"})${cacheInfo}`);
   }
   if (summary.length > 1) {
-    console.log(`    ${chalk9.dim("Total")}: ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out`);
+    console.log(`    ${chalk10.dim("Total")}: ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out`);
   }
   console.log("");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path19.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path20.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -7177,16 +7410,16 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs24.mkdirSync(path19.join(process.cwd(), ".caliber"), { recursive: true });
-    fs24.writeFileSync(logPath, lines.join("\n"));
-    console.log(chalk9.dim(`
+    fs25.mkdirSync(path20.join(process.cwd(), ".caliber"), { recursive: true });
+    fs25.writeFileSync(logPath, lines.join("\n"));
+    console.log(chalk10.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
   }
 }
 
 // src/commands/undo.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 import ora3 from "ora";
 function undoCommand() {
   const spinner = ora3("Reverting setup...").start();
@@ -7199,27 +7432,27 @@ function undoCommand() {
     trackUndoExecuted();
     spinner.succeed("Setup reverted successfully.\n");
     if (restored.length > 0) {
-      console.log(chalk10.cyan("  Restored from backup:"));
+      console.log(chalk11.cyan("  Restored from backup:"));
       for (const file of restored) {
-        console.log(`    ${chalk10.green("\u21A9")} ${file}`);
+        console.log(`    ${chalk11.green("\u21A9")} ${file}`);
       }
     }
     if (removed.length > 0) {
-      console.log(chalk10.cyan("  Removed:"));
+      console.log(chalk11.cyan("  Removed:"));
       for (const file of removed) {
-        console.log(`    ${chalk10.red("\u2717")} ${file}`);
+        console.log(`    ${chalk11.red("\u2717")} ${file}`);
       }
     }
     console.log("");
   } catch (err) {
-    spinner.fail(chalk10.red(err instanceof Error ? err.message : "Undo failed"));
+    spinner.fail(chalk11.red(err instanceof Error ? err.message : "Undo failed"));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/status.ts
-import chalk11 from "chalk";
-import fs25 from "fs";
+import chalk12 from "chalk";
+import fs26 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -7233,40 +7466,40 @@ async function statusCommand(options) {
     }, null, 2));
     return;
   }
-  console.log(chalk11.bold("\nCaliber Status\n"));
+  console.log(chalk12.bold("\nCaliber Status\n"));
   if (config) {
-    console.log(`  LLM: ${chalk11.green(config.provider)} (${config.model})`);
+    console.log(`  LLM: ${chalk12.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk11.yellow("Not configured")} \u2014 run ${chalk11.hex("#83D1EB")("caliber config")}`);
+    console.log(`  LLM: ${chalk12.yellow("Not configured")} \u2014 run ${chalk12.hex("#83D1EB")("caliber config")}`);
   }
   if (!manifest) {
-    console.log(`  Setup: ${chalk11.dim("No setup applied")}`);
-    console.log(chalk11.dim("\n  Run ") + chalk11.hex("#83D1EB")("caliber init") + chalk11.dim(" to get started.\n"));
+    console.log(`  Setup: ${chalk12.dim("No setup applied")}`);
+    console.log(chalk12.dim("\n  Run ") + chalk12.hex("#83D1EB")("caliber init") + chalk12.dim(" to get started.\n"));
     return;
   }
-  console.log(`  Files managed: ${chalk11.cyan(manifest.entries.length.toString())}`);
+  console.log(`  Files managed: ${chalk12.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs25.existsSync(entry.path);
-    const icon = exists ? chalk11.green("\u2713") : chalk11.red("\u2717");
+    const exists = fs26.existsSync(entry.path);
+    const icon = exists ? chalk12.green("\u2713") : chalk12.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
   console.log("");
 }
 
 // src/commands/regenerate.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 import ora4 from "ora";
 import select6 from "@inquirer/select";
 init_config();
 async function regenerateCommand(options) {
   const config = loadConfig();
   if (!config) {
-    console.log(chalk12.red("No LLM provider configured. Run ") + chalk12.hex("#83D1EB")("caliber config") + chalk12.red(" first."));
+    console.log(chalk13.red("No LLM provider configured. Run ") + chalk13.hex("#83D1EB")("caliber config") + chalk13.red(" first."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk12.yellow("No existing setup found. Run ") + chalk12.hex("#83D1EB")("caliber init") + chalk12.yellow(" first."));
+    console.log(chalk13.yellow("No existing setup found. Run ") + chalk13.hex("#83D1EB")("caliber init") + chalk13.yellow(" first."));
     throw new Error("__exit__");
   }
   const targetAgent = readState()?.targetAgent ?? ["claude", "cursor"];
@@ -7277,7 +7510,7 @@ async function regenerateCommand(options) {
   const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreSummary(baselineScore);
   if (baselineScore.score === 100) {
-    console.log(chalk12.green("  Your setup is already at 100/100 \u2014 nothing to regenerate.\n"));
+    console.log(chalk13.green("  Your setup is already at 100/100 \u2014 nothing to regenerate.\n"));
     return;
   }
   const genSpinner = ora4("Regenerating setup...").start();
@@ -7318,18 +7551,18 @@ async function regenerateCommand(options) {
   const setupFiles = collectSetupFiles(generatedSetup, targetAgent);
   const staged = stageFiles(setupFiles, process.cwd());
   const totalChanges = staged.newFiles + staged.modifiedFiles;
-  console.log(chalk12.dim(`
-  ${chalk12.green(`${staged.newFiles} new`)} / ${chalk12.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}
+  console.log(chalk13.dim(`
+  ${chalk13.green(`${staged.newFiles} new`)} / ${chalk13.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}
 `));
   if (totalChanges === 0) {
-    console.log(chalk12.dim("  No changes needed \u2014 your configs are already up to date.\n"));
+    console.log(chalk13.dim("  No changes needed \u2014 your configs are already up to date.\n"));
     cleanupStaging();
     return;
   }
   if (options.dryRun) {
-    console.log(chalk12.yellow("[Dry run] Would write:"));
+    console.log(chalk13.yellow("[Dry run] Would write:"));
     for (const f of staged.stagedFiles) {
-      console.log(`  ${f.isNew ? chalk12.green("+") : chalk12.yellow("~")} ${f.relativePath}`);
+      console.log(`  ${f.isNew ? chalk13.green("+") : chalk13.yellow("~")} ${f.relativePath}`);
     }
     cleanupStaging();
     return;
@@ -7348,7 +7581,7 @@ async function regenerateCommand(options) {
   });
   cleanupStaging();
   if (action === "decline") {
-    console.log(chalk12.dim("Regeneration cancelled. No files were modified."));
+    console.log(chalk13.dim("Regeneration cancelled. No files were modified."));
     return;
   }
   const writeSpinner = ora4("Writing config files...").start();
@@ -7356,20 +7589,20 @@ async function regenerateCommand(options) {
     const result = writeSetup(generatedSetup);
     writeSpinner.succeed("Config files written");
     for (const file of result.written) {
-      console.log(`  ${chalk12.green("\u2713")} ${file}`);
+      console.log(`  ${chalk13.green("\u2713")} ${file}`);
     }
     if (result.deleted.length > 0) {
       for (const file of result.deleted) {
-        console.log(`  ${chalk12.red("\u2717")} ${file}`);
+        console.log(`  ${chalk13.red("\u2717")} ${file}`);
       }
     }
     if (result.backupDir) {
-      console.log(chalk12.dim(`
+      console.log(chalk13.dim(`
   Backups saved to ${result.backupDir}`));
     }
   } catch (err) {
     writeSpinner.fail("Failed to write files");
-    console.error(chalk12.red(err instanceof Error ? err.message : "Unknown error"));
+    console.error(chalk13.red(err instanceof Error ? err.message : "Unknown error"));
     throw new Error("__exit__");
   }
   const sha = getCurrentHeadSha();
@@ -7381,25 +7614,25 @@ async function regenerateCommand(options) {
   const afterScore = computeLocalScore(process.cwd(), targetAgent);
   if (afterScore.score < baselineScore.score) {
     console.log("");
-    console.log(chalk12.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
+    console.log(chalk13.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(chalk12.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
+        console.log(chalk13.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
       }
     } catch {
     }
-    console.log(chalk12.dim("  Run ") + chalk12.hex("#83D1EB")("caliber init --force") + chalk12.dim(" to override.\n"));
+    console.log(chalk13.dim("  Run ") + chalk13.hex("#83D1EB")("caliber init --force") + chalk13.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
   trackRegenerateCompleted(action, Date.now());
-  console.log(chalk12.bold.green("  Regeneration complete!"));
-  console.log(chalk12.dim("  Run ") + chalk12.hex("#83D1EB")("caliber undo") + chalk12.dim(" to revert changes.\n"));
+  console.log(chalk13.bold.green("  Regeneration complete!"));
+  console.log(chalk13.dim("  Run ") + chalk13.hex("#83D1EB")("caliber undo") + chalk13.dim(" to revert changes.\n"));
 }
 
 // src/commands/score.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 async function scoreCommand(options) {
   const dir = process.cwd();
   const target = options.agent ?? readState()?.targetAgent;
@@ -7414,22 +7647,22 @@ async function scoreCommand(options) {
     return;
   }
   displayScore(result);
-  const separator = chalk13.gray("  " + "\u2500".repeat(53));
+  const separator = chalk14.gray("  " + "\u2500".repeat(53));
   console.log(separator);
   if (result.score < 40) {
-    console.log(chalk13.gray("  Run ") + chalk13.hex("#83D1EB")("caliber init") + chalk13.gray(" to generate a complete, optimized setup."));
+    console.log(chalk14.gray("  Run ") + chalk14.hex("#83D1EB")("caliber init") + chalk14.gray(" to generate a complete, optimized setup."));
   } else if (result.score < 70) {
-    console.log(chalk13.gray("  Run ") + chalk13.hex("#83D1EB")("caliber init") + chalk13.gray(" to improve your setup."));
+    console.log(chalk14.gray("  Run ") + chalk14.hex("#83D1EB")("caliber init") + chalk14.gray(" to improve your setup."));
   } else {
-    console.log(chalk13.green("  Looking good!") + chalk13.gray(" Run ") + chalk13.hex("#83D1EB")("caliber regenerate") + chalk13.gray(" to rebuild from scratch."));
+    console.log(chalk14.green("  Looking good!") + chalk14.gray(" Run ") + chalk14.hex("#83D1EB")("caliber regenerate") + chalk14.gray(" to rebuild from scratch."));
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
-import fs29 from "fs";
-import path23 from "path";
-import chalk14 from "chalk";
+import fs30 from "fs";
+import path24 from "path";
+import chalk15 from "chalk";
 import ora5 from "ora";
 
 // src/lib/git-diff.ts
@@ -7506,37 +7739,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs26 from "fs";
-import path20 from "path";
+import fs27 from "fs";
+import path21 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs26.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs27.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs26.writeFileSync("README.md", docs.readmeMd);
+    fs27.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs26.writeFileSync(".cursorrules", docs.cursorrules);
+    fs27.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path20.join(".cursor", "rules");
-    if (!fs26.existsSync(rulesDir)) fs26.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path21.join(".cursor", "rules");
+    if (!fs27.existsSync(rulesDir)) fs27.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path20.join(rulesDir, rule.filename);
-      fs26.writeFileSync(filePath, rule.content);
+      const filePath = path21.join(rulesDir, rule.filename);
+      fs27.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path20.join(".claude", "skills");
-    if (!fs26.existsSync(skillsDir)) fs26.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path21.join(".claude", "skills");
+    if (!fs27.existsSync(skillsDir)) fs27.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path20.join(skillsDir, skill.filename);
-      fs26.writeFileSync(filePath, skill.content);
+      const filePath = path21.join(skillsDir, skill.filename);
+      fs27.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -7613,8 +7846,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs27 from "fs";
-import path21 from "path";
+import fs28 from "fs";
+import path22 from "path";
 var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
 var LEARNINGS_HEADER = `# Caliber Learnings
 
@@ -7698,16 +7931,16 @@ function deduplicateLearnedItems(existing, incoming) {
 function writeLearnedSection(content) {
   const existingSection = readLearnedSection();
   const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
-  fs27.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+  fs28.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
   return { newCount, newItems };
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path21.join(".claude", "skills", skill.name);
-  if (!fs27.existsSync(skillDir)) fs27.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path21.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs27.existsSync(skillPath)) {
-    const existing = fs27.readFileSync(skillPath, "utf-8");
-    fs27.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path22.join(".claude", "skills", skill.name);
+  if (!fs28.existsSync(skillDir)) fs28.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path22.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs28.existsSync(skillPath)) {
+    const existing = fs28.readFileSync(skillPath, "utf-8");
+    fs28.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -7716,37 +7949,37 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs27.writeFileSync(skillPath, frontmatter + skill.content);
+    fs28.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
-  if (fs27.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs27.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs28.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs28.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs27.existsSync(claudeMdPath)) return null;
-  const content = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (!fs28.existsSync(claudeMdPath)) return null;
+  const content = fs28.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
   return content.slice(startIdx + LEARNED_START.length, endIdx).trim() || null;
 }
 function migrateInlineLearnings() {
-  if (fs27.existsSync(LEARNINGS_FILE)) return false;
+  if (fs28.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs27.existsSync(claudeMdPath)) return false;
-  const content = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (!fs28.existsSync(claudeMdPath)) return false;
+  const content = fs28.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return false;
   const section = content.slice(startIdx + LEARNED_START.length, endIdx).trim();
   if (!section) return false;
-  fs27.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs28.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs27.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs28.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -7758,11 +7991,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs29.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs30.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path23.join(parentDir, entry.name);
-      if (fs29.existsSync(path23.join(childPath, ".git"))) {
+      const childPath = path24.join(parentDir, entry.name);
+      if (fs30.existsSync(path24.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -7772,7 +8005,7 @@ function discoverGitRepos(parentDir) {
 }
 async function refreshSingleRepo(repoDir, options) {
   const quiet = !!options.quiet;
-  const prefix = options.label ? `${chalk14.bold(options.label)} ` : "";
+  const prefix = options.label ? `${chalk15.bold(options.label)} ` : "";
   const state = readState();
   const lastSha = state?.lastRefreshSha ?? null;
   const diff = collectDiff(lastSha);
@@ -7781,7 +8014,7 @@ async function refreshSingleRepo(repoDir, options) {
     if (currentSha) {
       writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
     }
-    log2(quiet, chalk14.dim(`${prefix}No changes since last refresh.`));
+    log2(quiet, chalk15.dim(`${prefix}No changes since last refresh.`));
     return;
   }
   const spinner = quiet ? null : ora5(`${prefix}Analyzing changes...`).start();
@@ -7815,10 +8048,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(`  ${chalk14.yellow("~")} ${doc}`);
+      console.log(`  ${chalk15.yellow("~")} ${doc}`);
     }
     if (response.changesSummary) {
-      console.log(chalk14.dim(`
+      console.log(chalk15.dim(`
   ${response.changesSummary}`));
     }
     return;
@@ -7827,10 +8060,10 @@ async function refreshSingleRepo(repoDir, options) {
   trackRefreshCompleted(written.length, Date.now());
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
   for (const file of written) {
-    log2(quiet, `  ${chalk14.green("\u2713")} ${file}`);
+    log2(quiet, `  ${chalk15.green("\u2713")} ${file}`);
   }
   if (response.changesSummary) {
-    log2(quiet, chalk14.dim(`
+    log2(quiet, chalk15.dim(`
   ${response.changesSummary}`));
   }
   if (currentSha) {
@@ -7847,7 +8080,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk14.red("No LLM provider configured. Run ") + chalk14.hex("#83D1EB")("caliber config") + chalk14.red(" (e.g. choose Cursor) or set an API key."));
+      console.log(chalk15.red("No LLM provider configured. Run ") + chalk15.hex("#83D1EB")("caliber config") + chalk15.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     await validateModel({ fast: true });
@@ -7858,20 +8091,20 @@ async function refreshCommand(options) {
     const repos = discoverGitRepos(process.cwd());
     if (repos.length === 0) {
       if (quiet) return;
-      console.log(chalk14.red("Not inside a git repository and no git repos found in child directories."));
+      console.log(chalk15.red("Not inside a git repository and no git repos found in child directories."));
       throw new Error("__exit__");
     }
-    log2(quiet, chalk14.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
+    log2(quiet, chalk15.dim(`Found ${repos.length} git repo${repos.length === 1 ? "" : "s"}
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path23.basename(repo);
+      const repoName = path24.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
       } catch (err) {
         if (err instanceof Error && err.message === "__exit__") continue;
-        log2(quiet, chalk14.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
+        log2(quiet, chalk15.yellow(`${repoName}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`));
       }
     }
     process.chdir(originalDir);
@@ -7879,13 +8112,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(chalk14.red(`Refresh failed: ${msg}`));
+    console.log(chalk15.red(`Refresh failed: ${msg}`));
     throw new Error("__exit__");
   }
 }
 
 // src/commands/hooks.ts
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 var HOOKS = [
   {
     id: "session-end",
@@ -7905,13 +8138,13 @@ var HOOKS = [
   }
 ];
 function printStatus() {
-  console.log(chalk15.bold("\n  Hooks\n"));
+  console.log(chalk16.bold("\n  Hooks\n"));
   for (const hook of HOOKS) {
     const installed = hook.isInstalled();
-    const icon = installed ? chalk15.green("\u2713") : chalk15.dim("\u2717");
-    const state = installed ? chalk15.green("enabled") : chalk15.dim("disabled");
+    const icon = installed ? chalk16.green("\u2713") : chalk16.dim("\u2717");
+    const state = installed ? chalk16.green("enabled") : chalk16.dim("disabled");
     console.log(`  ${icon} ${hook.label.padEnd(26)} ${state}`);
-    console.log(chalk15.dim(`    ${hook.description}`));
+    console.log(chalk16.dim(`    ${hook.description}`));
   }
   console.log("");
 }
@@ -7920,9 +8153,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.install();
       if (result.alreadyInstalled) {
-        console.log(chalk15.dim(`  ${hook.label} already enabled.`));
+        console.log(chalk16.dim(`  ${hook.label} already enabled.`));
       } else {
-        console.log(chalk15.green("  \u2713") + ` ${hook.label} enabled`);
+        console.log(chalk16.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
     return;
@@ -7931,9 +8164,9 @@ async function hooksCommand(options) {
     for (const hook of HOOKS) {
       const result = hook.remove();
       if (result.notFound) {
-        console.log(chalk15.dim(`  ${hook.label} already disabled.`));
+        console.log(chalk16.dim(`  ${hook.label} already disabled.`));
       } else {
-        console.log(chalk15.green("  \u2713") + ` ${hook.label} removed`);
+        console.log(chalk16.green("  \u2713") + ` ${hook.label} removed`);
       }
     }
     return;
@@ -7948,18 +8181,18 @@ async function hooksCommand(options) {
   const states = HOOKS.map((h) => h.isInstalled());
   function render() {
     const lines = [];
-    lines.push(chalk15.bold("  Hooks"));
+    lines.push(chalk16.bold("  Hooks"));
     lines.push("");
     for (let i = 0; i < HOOKS.length; i++) {
       const hook = HOOKS[i];
       const enabled = states[i];
-      const toggle = enabled ? chalk15.green("[on] ") : chalk15.dim("[off]");
-      const ptr = i === cursor ? chalk15.cyan(">") : " ";
+      const toggle = enabled ? chalk16.green("[on] ") : chalk16.dim("[off]");
+      const ptr = i === cursor ? chalk16.cyan(">") : " ";
       lines.push(`  ${ptr} ${toggle} ${hook.label}`);
-      lines.push(chalk15.dim(`        ${hook.description}`));
+      lines.push(chalk16.dim(`        ${hook.description}`));
     }
     lines.push("");
-    lines.push(chalk15.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
+    lines.push(chalk16.dim("  \u2191\u2193 navigate  \u23B5 toggle  a all on  n all off  \u23CE apply  q cancel"));
     return lines.join("\n");
   }
   function draw(initial) {
@@ -7990,16 +8223,16 @@ async function hooksCommand(options) {
         const wantEnabled = states[i];
         if (wantEnabled && !wasInstalled) {
           hook.install();
-          console.log(chalk15.green("  \u2713") + ` ${hook.label} enabled`);
+          console.log(chalk16.green("  \u2713") + ` ${hook.label} enabled`);
           changed++;
         } else if (!wantEnabled && wasInstalled) {
           hook.remove();
-          console.log(chalk15.green("  \u2713") + ` ${hook.label} disabled`);
+          console.log(chalk16.green("  \u2713") + ` ${hook.label} disabled`);
           changed++;
         }
       }
       if (changed === 0) {
-        console.log(chalk15.dim("  No changes."));
+        console.log(chalk16.dim("  No changes."));
       }
       console.log("");
     }
@@ -8035,7 +8268,7 @@ async function hooksCommand(options) {
         case "\x1B":
         case "":
           cleanup();
-          console.log(chalk15.dim("\n  Cancelled.\n"));
+          console.log(chalk16.dim("\n  Cancelled.\n"));
           resolve2();
           break;
       }
@@ -8046,51 +8279,51 @@ async function hooksCommand(options) {
 
 // src/commands/config.ts
 init_config();
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 async function configCommand() {
   const existing = loadConfig();
   if (existing) {
     const displayModel = getDisplayModel(existing);
     const fastModel = getFastModel();
-    console.log(chalk16.bold("\nCurrent Configuration\n"));
-    console.log(`  Provider: ${chalk16.cyan(existing.provider)}`);
-    console.log(`  Model:    ${chalk16.cyan(displayModel)}`);
+    console.log(chalk17.bold("\nCurrent Configuration\n"));
+    console.log(`  Provider: ${chalk17.cyan(existing.provider)}`);
+    console.log(`  Model:    ${chalk17.cyan(displayModel)}`);
     if (fastModel) {
-      console.log(`  Scan:     ${chalk16.cyan(fastModel)}`);
+      console.log(`  Scan:     ${chalk17.cyan(fastModel)}`);
     }
     if (existing.apiKey) {
       const masked = existing.apiKey.slice(0, 8) + "..." + existing.apiKey.slice(-4);
-      console.log(`  API Key:  ${chalk16.dim(masked)}`);
+      console.log(`  API Key:  ${chalk17.dim(masked)}`);
     }
     if (existing.provider === "cursor") {
-      console.log(`  Seat:     ${chalk16.dim("Cursor (agent acp)")}`);
+      console.log(`  Seat:     ${chalk17.dim("Cursor (agent acp)")}`);
     }
     if (existing.provider === "claude-cli") {
-      console.log(`  Seat:     ${chalk16.dim("Claude Code (claude -p)")}`);
+      console.log(`  Seat:     ${chalk17.dim("Claude Code (claude -p)")}`);
     }
     if (existing.baseUrl) {
-      console.log(`  Base URL: ${chalk16.dim(existing.baseUrl)}`);
+      console.log(`  Base URL: ${chalk17.dim(existing.baseUrl)}`);
     }
     if (existing.vertexProjectId) {
-      console.log(`  Vertex Project: ${chalk16.dim(existing.vertexProjectId)}`);
-      console.log(`  Vertex Region:  ${chalk16.dim(existing.vertexRegion || "us-east5")}`);
+      console.log(`  Vertex Project: ${chalk17.dim(existing.vertexProjectId)}`);
+      console.log(`  Vertex Region:  ${chalk17.dim(existing.vertexRegion || "us-east5")}`);
     }
-    console.log(`  Source:   ${chalk16.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:   ${chalk17.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();
   const updated = loadConfig();
   if (updated) trackConfigProviderSet(updated.provider);
-  console.log(chalk16.green("\n\u2713 Configuration saved"));
-  console.log(chalk16.dim(`  ${getConfigFilePath()}
+  console.log(chalk17.green("\n\u2713 Configuration saved"));
+  console.log(chalk17.dim(`  ${getConfigFilePath()}
 `));
-  console.log(chalk16.dim("  You can also set environment variables instead:"));
-  console.log(chalk16.dim("  ANTHROPIC_API_KEY, OPENAI_API_KEY, VERTEX_PROJECT_ID, CALIBER_USE_CURSOR_SEAT=1, or CALIBER_USE_CLAUDE_CLI=1\n"));
+  console.log(chalk17.dim("  You can also set environment variables instead:"));
+  console.log(chalk17.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 fs31 from "fs";
-import chalk17 from "chalk";
+import fs32 from "fs";
+import chalk18 from "chalk";
 
 // src/learner/stdin.ts
 var STDIN_TIMEOUT_MS = 5e3;
@@ -8121,8 +8354,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs30 from "fs";
-import path24 from "path";
+import fs31 from "fs";
+import path25 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -8130,15 +8363,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs30.existsSync(LEARNING_DIR)) {
-    fs30.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs31.existsSync(LEARNING_DIR)) {
+    fs31.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path24.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path25.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path24.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path25.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -8149,29 +8382,29 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs30.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs31.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs30.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs30.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  fs31.appendFileSync(filePath, JSON.stringify(event) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs30.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs30.existsSync(filePath)) return [];
-  const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs31.existsSync(filePath)) return [];
+  const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -8183,26 +8416,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs30.existsSync(filePath)) return 0;
-  const content = fs30.readFileSync(filePath, "utf-8");
+  if (!fs31.existsSync(filePath)) return 0;
+  const content = fs31.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs30.existsSync(filePath)) fs30.unlinkSync(filePath);
+  if (fs31.existsSync(filePath)) fs31.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs30.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs31.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs30.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs31.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -8210,14 +8443,14 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path24.join(LEARNING_DIR, LOCK_FILE2);
+  return path25.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs30.existsSync(lockPath)) {
+  if (fs31.existsSync(lockPath)) {
     try {
-      const stat = fs30.statSync(lockPath);
+      const stat = fs31.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
         return false;
       }
@@ -8225,7 +8458,7 @@ function acquireFinalizeLock() {
     }
   }
   try {
-    fs30.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs31.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -8234,7 +8467,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs30.existsSync(lockPath)) fs30.unlinkSync(lockPath);
+    if (fs31.existsSync(lockPath)) fs31.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -8406,26 +8639,26 @@ async function learnFinalizeCommand(options) {
   if (!options?.force) {
     const { isCaliberRunning: isCaliberRunning2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
     if (isCaliberRunning2()) {
-      console.log(chalk17.dim("caliber: skipping finalize \u2014 another caliber process is running"));
+      console.log(chalk18.dim("caliber: skipping finalize \u2014 another caliber process is running"));
       return;
     }
   }
   if (!acquireFinalizeLock()) {
-    console.log(chalk17.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
+    console.log(chalk18.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
     return;
   }
   let analyzed = false;
   try {
     const config = loadConfig();
     if (!config) {
-      console.log(chalk17.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
+      console.log(chalk18.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
       clearSession();
       resetState();
       return;
     }
     const events = readAllEvents();
     if (events.length < MIN_EVENTS_FOR_ANALYSIS) {
-      console.log(chalk17.dim(`caliber: ${events.length}/${MIN_EVENTS_FOR_ANALYSIS} events recorded \u2014 need more before analysis`));
+      console.log(chalk18.dim(`caliber: ${events.length}/${MIN_EVENTS_FOR_ANALYSIS} events recorded \u2014 need more before analysis`));
       return;
     }
     await validateModel({ fast: true });
@@ -8446,15 +8679,15 @@ async function learnFinalizeCommand(options) {
         skills: response.skills
       });
       if (result.newItemCount > 0) {
-        console.log(chalk17.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}`));
+        console.log(chalk18.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}`));
         for (const item of result.newItems) {
-          console.log(chalk17.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
+          console.log(chalk18.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
         }
       }
     }
   } catch (err) {
     if (options?.force) {
-      console.error(chalk17.red("caliber: finalize failed \u2014"), err instanceof Error ? err.message : err);
+      console.error(chalk18.red("caliber: finalize failed \u2014"), err instanceof Error ? err.message : err);
     }
   } finally {
     if (analyzed) {
@@ -8466,48 +8699,48 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs31.existsSync(".claude")) {
+  if (fs32.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
-      console.log(chalk17.green("\u2713") + " Claude Code learning hooks installed");
+      console.log(chalk18.green("\u2713") + " Claude Code learning hooks installed");
       anyInstalled = true;
     } else if (r.alreadyInstalled) {
-      console.log(chalk17.dim("  Claude Code hooks already installed"));
+      console.log(chalk18.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs31.existsSync(".cursor")) {
+  if (fs32.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
-      console.log(chalk17.green("\u2713") + " Cursor learning hooks installed");
+      console.log(chalk18.green("\u2713") + " Cursor learning hooks installed");
       anyInstalled = true;
     } else if (r.alreadyInstalled) {
-      console.log(chalk17.dim("  Cursor hooks already installed"));
+      console.log(chalk18.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs31.existsSync(".claude") && !fs31.existsSync(".cursor")) {
-    console.log(chalk17.yellow("No .claude/ or .cursor/ directory found."));
-    console.log(chalk17.dim("  Run `caliber init` first, or create the directory manually."));
+  if (!fs32.existsSync(".claude") && !fs32.existsSync(".cursor")) {
+    console.log(chalk18.yellow("No .claude/ or .cursor/ directory found."));
+    console.log(chalk18.dim("  Run `caliber init` first, or create the directory manually."));
     return;
   }
   if (anyInstalled) {
-    console.log(chalk17.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
-    console.log(chalk17.dim("  Learnings written to CALIBER_LEARNINGS.md."));
+    console.log(chalk18.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
+    console.log(chalk18.dim("  Learnings written to CALIBER_LEARNINGS.md."));
   }
 }
 async function learnRemoveCommand() {
   let anyRemoved = false;
   const r1 = removeLearningHooks();
   if (r1.removed) {
-    console.log(chalk17.green("\u2713") + " Claude Code learning hooks removed");
+    console.log(chalk18.green("\u2713") + " Claude Code learning hooks removed");
     anyRemoved = true;
   }
   const r2 = removeCursorLearningHooks();
   if (r2.removed) {
-    console.log(chalk17.green("\u2713") + " Cursor learning hooks removed");
+    console.log(chalk18.green("\u2713") + " Cursor learning hooks removed");
     anyRemoved = true;
   }
   if (!anyRemoved) {
-    console.log(chalk17.dim("No learning hooks found."));
+    console.log(chalk18.dim("No learning hooks found."));
   }
 }
 async function learnStatusCommand() {
@@ -8515,41 +8748,41 @@ async function learnStatusCommand() {
   const cursorInstalled = areCursorLearningHooksInstalled();
   const state = readState2();
   const eventCount = getEventCount();
-  console.log(chalk17.bold("Session Learning Status"));
+  console.log(chalk18.bold("Session Learning Status"));
   console.log();
   if (claudeInstalled) {
-    console.log(chalk17.green("\u2713") + " Claude Code hooks " + chalk17.green("installed"));
+    console.log(chalk18.green("\u2713") + " Claude Code hooks " + chalk18.green("installed"));
   } else {
-    console.log(chalk17.dim("\u2717") + " Claude Code hooks " + chalk17.dim("not installed"));
+    console.log(chalk18.dim("\u2717") + " Claude Code hooks " + chalk18.dim("not installed"));
   }
   if (cursorInstalled) {
-    console.log(chalk17.green("\u2713") + " Cursor hooks " + chalk17.green("installed"));
+    console.log(chalk18.green("\u2713") + " Cursor hooks " + chalk18.green("installed"));
   } else {
-    console.log(chalk17.dim("\u2717") + " Cursor hooks " + chalk17.dim("not installed"));
+    console.log(chalk18.dim("\u2717") + " Cursor hooks " + chalk18.dim("not installed"));
   }
   if (!claudeInstalled && !cursorInstalled) {
-    console.log(chalk17.dim("  Run `caliber learn install` to enable session learning."));
+    console.log(chalk18.dim("  Run `caliber learn install` to enable session learning."));
   }
   console.log();
-  console.log(`Events recorded: ${chalk17.cyan(String(eventCount))}`);
-  console.log(`Threshold for analysis: ${chalk17.cyan(String(MIN_EVENTS_FOR_ANALYSIS))}`);
+  console.log(`Events recorded: ${chalk18.cyan(String(eventCount))}`);
+  console.log(`Threshold for analysis: ${chalk18.cyan(String(MIN_EVENTS_FOR_ANALYSIS))}`);
   if (state.lastAnalysisTimestamp) {
-    console.log(`Last analysis: ${chalk17.cyan(state.lastAnalysisTimestamp)}`);
+    console.log(`Last analysis: ${chalk18.cyan(state.lastAnalysisTimestamp)}`);
   } else {
-    console.log(`Last analysis: ${chalk17.dim("none")}`);
+    console.log(`Last analysis: ${chalk18.dim("none")}`);
   }
   const learnedSection = readLearnedSection();
   if (learnedSection) {
     const lineCount = learnedSection.split("\n").filter(Boolean).length;
     console.log(`
-Learned items in CALIBER_LEARNINGS.md: ${chalk17.cyan(String(lineCount))}`);
+Learned items in CALIBER_LEARNINGS.md: ${chalk18.cyan(String(lineCount))}`);
   }
 }
 
 // src/cli.ts
-var __dirname = path25.dirname(fileURLToPath(import.meta.url));
+var __dirname = path26.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs32.readFileSync(path25.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs33.readFileSync(path26.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -8623,22 +8856,42 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 
 // src/utils/version-check.ts
-import fs33 from "fs";
-import path26 from "path";
+import fs34 from "fs";
+import path27 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync14 } from "child_process";
-import chalk18 from "chalk";
+import chalk19 from "chalk";
 import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path26.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path27.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs33.readFileSync(path26.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs34.readFileSync(path27.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
+function getChannel(version) {
+  const match = version.match(/-(dev|next)\./);
+  return match ? match[1] : "latest";
+}
+function isNewer(registry, current) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-");
+    const parts = core.split(".").map(Number);
+    return { major: parts[0], minor: parts[1], patch: parts[2], pre };
+  };
+  const r = parse(registry);
+  const c = parse(current);
+  if (r.major !== c.major) return r.major > c.major;
+  if (r.minor !== c.minor) return r.minor > c.minor;
+  if (r.patch !== c.patch) return r.patch > c.patch;
+  if (!r.pre && c.pre) return true;
+  if (r.pre && !c.pre) return false;
+  if (r.pre && c.pre) return r.pre > c.pre;
+  return false;
+}
 function getInstalledVersion() {
   try {
     const globalRoot = execSync14("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path26.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs33.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path27.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs34.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -8646,9 +8899,11 @@ function getInstalledVersion() {
 async function checkForUpdates() {
   if (process.env.CALIBER_SKIP_UPDATE_CHECK) return;
   try {
+    const current = pkg2.version;
+    const channel = getChannel(current);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 2e3);
-    const res = await fetch("https://registry.npmjs.org/@rely-ai/caliber/latest", {
+    const res = await fetch(`https://registry.npmjs.org/@rely-ai/caliber/${channel}`, {
       signal: controller.signal
     });
     clearTimeout(timeout);
@@ -8656,22 +8911,22 @@ async function checkForUpdates() {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = pkg2.version;
-    if (current === latest) return;
+    if (!isNewer(latest, current)) return;
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
+      const installTag = channel === "latest" ? "" : `@${channel}`;
       console.log(
-        chalk18.yellow(
+        chalk19.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk18.bold("npm install -g @rely-ai/caliber")} to upgrade.
+Run ${chalk19.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk18.yellow(`
+      chalk19.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
@@ -8679,9 +8934,10 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
+    const tag = channel === "latest" ? latest : channel;
     const spinner = ora6("Updating caliber...").start();
     try {
-      execSync14(`npm install -g @rely-ai/caliber@${latest}`, {
+      execSync14(`npm install -g @rely-ai/caliber@${tag}`, {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -8689,13 +8945,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk18.yellow(`Run ${chalk18.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
+        console.log(chalk19.yellow(`Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk18.green(`Updated to ${latest}`));
+      spinner.succeed(chalk19.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk18.dim(`
+      console.log(chalk19.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync14(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -8708,11 +8964,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(chalk18.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk19.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk18.yellow(
-          `Run ${chalk18.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
+        chalk19.yellow(
+          `Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
 `
         )
       );