@rely-ai/caliber 1.41.3 → 1.42.0

package/dist/bin.js

@@ -169,19 +169,44 @@ import fs6 from "fs";
 import { execSync as execSync4 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
+  const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
+  const whichNpxCmd = process.platform === "win32" ? "where npx" : "which npx";
   const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
   if (isNpx) {
+    try {
+      const out = execSync4(whichCmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      const caliberPath = out.split("\n")[0].trim();
+      if (caliberPath) {
+        _resolved = caliberPath;
+        return _resolved;
+      }
+    } catch {
+    }
+    try {
+      const out = execSync4(whichNpxCmd, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const npxPath = out.split("\n")[0].trim();
+      if (npxPath) {
+        _resolved = `${npxPath} --yes @rely-ai/caliber`;
+        return _resolved;
+      }
+    } catch {
+    }
     _resolved = "npx --yes @rely-ai/caliber";
     return _resolved;
   }
   try {
-    const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    execSync4(whichCmd, {
+    const out = execSync4(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
-    });
-    _resolved = "caliber";
-    return _resolved;
+    }).trim();
+    const caliberPath = out.split("\n")[0].trim();
+    if (caliberPath) {
+      _resolved = caliberPath;
+      return _resolved;
+    }
   } catch {
   }
   const binPath = process.argv[1];
@@ -193,7 +218,8 @@ function resolveCaliber() {
   return _resolved;
 }
 function isNpxResolution() {
-  return resolveCaliber().startsWith("npx ");
+  const r = resolveCaliber();
+  return r === "npx --yes @rely-ai/caliber" || r.endsWith("/npx --yes @rely-ai/caliber");
 }
 function resetResolvedCaliber() {
   _resolved = null;
@@ -203,6 +229,8 @@ function isCaliberCommand(command, subcommandTail) {
   if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
   if (command === `npx --yes @rely-ai/caliber ${subcommandTail}`) return true;
   if (command === `npx @rely-ai/caliber ${subcommandTail}`) return true;
+  if (command.endsWith(`/npx --yes @rely-ai/caliber ${subcommandTail}`)) return true;
+  if (command.endsWith(`/npx @rely-ai/caliber ${subcommandTail}`)) return true;
   return false;
 }
 var _resolved;
@@ -445,7 +473,7 @@ __export(builtin_skills_exports, {
   buildSkillContent: () => buildSkillContent,
   ensureBuiltinSkills: () => ensureBuiltinSkills
 });
-import fs16 from "fs";
+import fs17 from "fs";
 import path16 from "path";
 function buildSkillContent(skill) {
   const frontmatter = `---
@@ -779,11 +807,11 @@ From now on, every commit keeps all your agent configs in sync automatically.
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs16.existsSync(platformDir)) continue;
+    if (!fs17.existsSync(platformDir)) continue;
     for (const skill of BUILTIN_SKILLS) {
       const skillPath = path16.join(skillsDir, skill.name, "SKILL.md");
-      fs16.mkdirSync(path16.dirname(skillPath), { recursive: true });
-      fs16.writeFileSync(skillPath, buildSkillContent(skill));
+      fs17.mkdirSync(path16.dirname(skillPath), { recursive: true });
+      fs17.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -828,13 +856,13 @@ var init_builtin_skills = __esm({
 
 // src/utils/editor.ts
 import { execSync as execSync14, spawn as spawn3 } from "child_process";
-import fs28 from "fs";
+import fs29 from "fs";
 import path25 from "path";
 import os6 from "os";
 function getEmptyFilePath(proposedPath) {
-  fs28.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  fs29.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
   const tempPath = path25.join(DIFF_TEMP_DIR, path25.basename(proposedPath));
-  fs28.writeFileSync(tempPath, "");
+  fs29.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
@@ -886,10 +914,11 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs29 from "fs";
+import fs30 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
+  if (!process.stdin.isTTY) return false;
   return select4({
     message: "Would you like to review the diffs before deciding?",
     choices: [
@@ -901,6 +930,7 @@ async function promptWantsReview() {
 async function promptReviewMethod() {
   const available = detectAvailableEditors();
   if (available.length === 1) return "terminal";
+  if (!process.stdin.isTTY) return "terminal";
   const choices = available.map((method) => {
     switch (method) {
       case "cursor":
@@ -915,16 +945,19 @@ async function promptReviewMethod() {
 }
 async function openReview(method, stagedFiles) {
   if (method === "cursor" || method === "vscode") {
-    openDiffsInEditor(method, stagedFiles.map((f) => ({
-      originalPath: f.originalPath,
-      proposedPath: f.proposedPath
-    })));
+    openDiffsInEditor(
+      method,
+      stagedFiles.map((f) => ({
+        originalPath: f.originalPath,
+        proposedPath: f.proposedPath
+      }))
+    );
     console.log(chalk10.dim("  Diffs opened in your editor.\n"));
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs29.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs29.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs30.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs30.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -1099,7 +1132,7 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs40 from "fs";
+import fs41 from "fs";
 import path33 from "path";
 import os8 from "os";
 import crypto5 from "crypto";
@@ -1115,8 +1148,8 @@ function getLockFile() {
 function isCaliberRunning() {
   try {
     const lockFile = buildLockPath();
-    if (!fs40.existsSync(lockFile)) return false;
-    const raw = fs40.readFileSync(lockFile, "utf-8").trim();
+    if (!fs41.existsSync(lockFile)) return false;
+    const raw = fs41.readFileSync(lockFile, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (pid === process.pid) return false;
     if (Date.now() - ts > STALE_MS) return false;
@@ -1132,14 +1165,14 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs40.writeFileSync(getLockFile(), JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs41.writeFileSync(getLockFile(), JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
     const lockFile = getLockFile();
-    if (fs40.existsSync(lockFile)) fs40.unlinkSync(lockFile);
+    if (fs41.existsSync(lockFile)) fs41.unlinkSync(lockFile);
   } catch {
   }
 }
@@ -1154,17 +1187,17 @@ var init_lock = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs51 from "fs";
+import fs52 from "fs";
 import path42 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
 import path28 from "path";
 import chalk14 from "chalk";
-import fs34 from "fs";
+import fs35 from "fs";
 
 // src/fingerprint/index.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path8 from "path";
 
 // src/fingerprint/git.ts
@@ -2358,7 +2391,7 @@ var OpenAICompatProvider = class {
 };
 
 // src/llm/cursor-acp.ts
-import { spawn, execSync as execSync5 } from "child_process";
+import { spawn, execSync as execSync5, execFileSync } from "child_process";
 import os3 from "os";
 
 // src/llm/seat-based-errors.ts
@@ -2430,8 +2463,23 @@ function estimateTokens(text) {
 }
 
 // src/llm/cursor-acp.ts
-var AGENT_BIN = "agent";
 var IS_WINDOWS = process.platform === "win32";
+var _agentBin = null;
+function resolveAgentBin() {
+  if (_agentBin !== null) return _agentBin;
+  try {
+    const whichCmd = IS_WINDOWS ? "where agent" : "which agent";
+    const out = execSync5(whichCmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const p = out.split("\n")[0].trim();
+    if (p) {
+      _agentBin = p;
+      return _agentBin;
+    }
+  } catch {
+  }
+  _agentBin = "agent";
+  return _agentBin;
+}
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 var SIGKILL_DELAY_MS = 5e3;
 var STDERR_MAX_BYTES = 10 * 1024;
@@ -2489,7 +2537,7 @@ var CursorAcpProvider = class {
     const targetModel = model || this.defaultModel;
     if (this.warmProcess && !this.warmProcess.killed && this.warmModel === targetModel) return;
     const args = this.buildArgs(targetModel, false);
-    this.warmProcess = spawn(AGENT_BIN, args, {
+    this.warmProcess = spawn(resolveAgentBin(), args, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
       ...IS_WINDOWS && { shell: true }
@@ -2536,7 +2584,7 @@ var CursorAcpProvider = class {
       return { child: warm, stderrChunks: stderrChunks2 };
     }
     const args = this.buildArgs(model, streaming);
-    const child = spawn(AGENT_BIN, args, {
+    const child = spawn(resolveAgentBin(), args, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
       ...IS_WINDOWS && { shell: true }
@@ -2710,9 +2758,9 @@ var CursorAcpProvider = class {
   }
 };
 function isCursorAgentAvailable() {
+  if (resolveAgentBin() !== "agent") return true;
   try {
-    const cmd = IS_WINDOWS ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
-    execSync5(cmd, { stdio: "ignore" });
+    execSync5(IS_WINDOWS ? "where agent" : "which agent", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -2720,7 +2768,7 @@ function isCursorAgentAvailable() {
 }
 function isCursorLoggedIn() {
   try {
-    const result = execSync5(`${AGENT_BIN} status`, {
+    const result = execFileSync(resolveAgentBin(), ["status"], {
       input: "",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5e3
@@ -2732,18 +2780,56 @@ function isCursorLoggedIn() {
 }
 
 // src/llm/claude-cli.ts
-import { spawn as spawn2, execSync as execSync6 } from "child_process";
-var CLAUDE_CLI_BIN = "claude";
+import fs7 from "fs";
+import { spawn as spawn2, execSync as execSync6, execFileSync as execFileSync2 } from "child_process";
 var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var IS_WINDOWS2 = process.platform === "win32";
+function candidateClaudePaths() {
+  if (IS_WINDOWS2) return [];
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return [
+    `${home}/.local/bin/claude`,
+    // Claude Code default installer path
+    "/usr/local/bin/claude",
+    // Homebrew / manual install
+    "/opt/homebrew/bin/claude"
+    // Apple Silicon Homebrew
+  ].filter(Boolean);
+}
+var _claudeBin = null;
+function resolveClaudeBin() {
+  if (_claudeBin !== null) return _claudeBin;
+  try {
+    const whichCmd = IS_WINDOWS2 ? "where claude" : "which claude";
+    const out = execSync6(whichCmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const p = out.split("\n")[0].trim();
+    if (p) {
+      _claudeBin = p;
+      return _claudeBin;
+    }
+  } catch {
+  }
+  for (const candidate of candidateClaudePaths()) {
+    try {
+      fs7.accessSync(candidate, fs7.constants.X_OK);
+      _claudeBin = candidate;
+      return _claudeBin;
+    } catch {
+    }
+  }
+  _claudeBin = "claude";
+  return _claudeBin;
+}
 function spawnClaude(args) {
-  const env = { ...process.env, CLAUDE_CODE_SIMPLE: "1" };
-  return IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
+  const bin = resolveClaudeBin();
+  const { CLAUDE_CODE_SIMPLE: _stripped, ...parentEnv } = process.env;
+  const env = parentEnv;
+  return IS_WINDOWS2 ? spawn2([bin, ...args].join(" "), {
     cwd: process.cwd(),
     stdio: ["pipe", "pipe", "pipe"],
     env,
     shell: true
-  }) : spawn2(CLAUDE_CLI_BIN, args, {
+  }) : spawn2(bin, args, {
     cwd: process.cwd(),
     stdio: ["pipe", "pipe", "pipe"],
     env
@@ -2818,8 +2904,8 @@ var ClaudeCliProvider = class {
         callbacks.onEnd({ stopReason: "end_turn" });
       } else {
         const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-        const friendly = parseSeatBasedError(stderr, code);
         const stdout = Buffer.concat(chunks).toString("utf-8").trim();
+        const friendly = parseSeatBasedError(stderr || stdout, code);
         const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
         const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
         callbacks.onError(new Error(detail ? `${base}. ${detail}` : base));
@@ -2879,7 +2965,7 @@ var ClaudeCliProvider = class {
           resolve3(stdout);
         } else {
           const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-          const friendly = parseSeatBasedError(stderr, code);
+          const friendly = parseSeatBasedError(stderr || stdout, code);
           const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
           const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
           reject(new Error(detail ? `${base}. ${detail}` : base));
@@ -2889,9 +2975,9 @@ var ClaudeCliProvider = class {
   }
 };
 function isClaudeCliAvailable() {
+  if (resolveClaudeBin() !== "claude") return true;
   try {
-    const cmd = process.platform === "win32" ? `where ${CLAUDE_CLI_BIN}` : `which ${CLAUDE_CLI_BIN}`;
-    execSync6(cmd, { stdio: "ignore" });
+    execSync6(IS_WINDOWS2 ? "where claude" : "which claude", { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -2901,7 +2987,7 @@ var cachedLoggedIn = null;
 function isClaudeCliLoggedIn() {
   if (cachedLoggedIn !== null) return cachedLoggedIn;
   try {
-    const result = execSync6(`${CLAUDE_CLI_BIN} auth status`, {
+    const result = execFileSync2(resolveClaudeBin(), ["auth", "status"], {
       input: "",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: 5e3
@@ -3720,7 +3806,7 @@ async function detectProjectStack(fileTree, suffixCounts) {
 init_config();
 
 // src/fingerprint/cache.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 import crypto from "crypto";
 import { execSync as execSync7 } from "child_process";
@@ -3765,8 +3851,8 @@ function computeTreeSignature(fileTree, dir) {
 function loadFingerprintCache(dir, fileTree) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return null;
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return null;
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (cache.version !== CACHE_VERSION) return null;
     const currentHead = getGitHead(dir);
@@ -3788,8 +3874,8 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
   const cachePath = getCachePath(dir);
   try {
     const cacheDir = path7.dirname(cachePath);
-    if (!fs7.existsSync(cacheDir)) {
-      fs7.mkdirSync(cacheDir, { recursive: true });
+    if (!fs8.existsSync(cacheDir)) {
+      fs8.mkdirSync(cacheDir, { recursive: true });
     }
     const cache = {
       version: CACHE_VERSION,
@@ -3801,15 +3887,15 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       tools,
       workspaces
     };
-    fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    fs8.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 function getDetectedWorkspaces(dir) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return [];
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return [];
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     return cache.workspaces ?? [];
   } catch {
@@ -3862,8 +3948,8 @@ async function collectFingerprint(dir) {
 function readPackageName(dir) {
   try {
     const pkgPath = path8.join(dir, "package.json");
-    if (!fs8.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+    if (!fs9.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -3893,23 +3979,23 @@ async function enrichWithLLM(fingerprint) {
 }
 
 // src/scanner/index.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path9 from "path";
 import crypto2 from "crypto";
 import os4 from "os";
 function detectPlatforms() {
   const home = os4.homedir();
   return {
-    claude: fs9.existsSync(path9.join(home, ".claude")),
-    cursor: fs9.existsSync(getCursorConfigDir()),
-    codex: fs9.existsSync(path9.join(home, ".codex")),
-    opencode: fs9.existsSync(path9.join(home, ".config", "opencode"))
+    claude: fs10.existsSync(path9.join(home, ".claude")),
+    cursor: fs10.existsSync(getCursorConfigDir()),
+    codex: fs10.existsSync(path9.join(home, ".codex")),
+    opencode: fs10.existsSync(path9.join(home, ".config", "opencode"))
   };
 }
 function scanLocalState(dir) {
   const items = [];
   const claudeMdPath = path9.join(dir, "CLAUDE.md");
-  if (fs9.existsSync(claudeMdPath)) {
+  if (fs10.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -3919,8 +4005,8 @@ function scanLocalState(dir) {
     });
   }
   const skillsDir = path9.join(dir, ".claude", "skills");
-  if (fs9.existsSync(skillsDir)) {
-    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+  if (fs10.existsSync(skillsDir)) {
+    for (const file of fs10.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
       const filePath = path9.join(skillsDir, file);
       items.push({
         type: "skill",
@@ -3932,9 +4018,9 @@ function scanLocalState(dir) {
     }
   }
   const mcpJsonPath = path9.join(dir, ".mcp.json");
-  if (fs9.existsSync(mcpJsonPath)) {
+  if (fs10.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3951,7 +4037,7 @@ function scanLocalState(dir) {
     }
   }
   const agentsMdPath = path9.join(dir, "AGENTS.md");
-  if (fs9.existsSync(agentsMdPath)) {
+  if (fs10.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -3961,11 +4047,11 @@ function scanLocalState(dir) {
     });
   }
   const codexSkillsDir = path9.join(dir, ".agents", "skills");
-  if (fs9.existsSync(codexSkillsDir)) {
+  if (fs10.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(codexSkillsDir)) {
+      for (const name of fs10.readdirSync(codexSkillsDir)) {
         const skillFile = path9.join(codexSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -3980,11 +4066,11 @@ function scanLocalState(dir) {
     }
   }
   const opencodeSkillsDir = path9.join(dir, ".opencode", "skills");
-  if (fs9.existsSync(opencodeSkillsDir)) {
+  if (fs10.existsSync(opencodeSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(opencodeSkillsDir)) {
+      for (const name of fs10.readdirSync(opencodeSkillsDir)) {
         const skillFile = path9.join(opencodeSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "opencode",
@@ -3999,7 +4085,7 @@ function scanLocalState(dir) {
     }
   }
   const cursorrulesPath = path9.join(dir, ".cursorrules");
-  if (fs9.existsSync(cursorrulesPath)) {
+  if (fs10.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4009,8 +4095,8 @@ function scanLocalState(dir) {
     });
   }
   const cursorRulesDir = path9.join(dir, ".cursor", "rules");
-  if (fs9.existsSync(cursorRulesDir)) {
-    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+  if (fs10.existsSync(cursorRulesDir)) {
+    for (const file of fs10.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
       const filePath = path9.join(cursorRulesDir, file);
       items.push({
         type: "rule",
@@ -4022,11 +4108,11 @@ function scanLocalState(dir) {
     }
   }
   const cursorSkillsDir = path9.join(dir, ".cursor", "skills");
-  if (fs9.existsSync(cursorSkillsDir)) {
+  if (fs10.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(cursorSkillsDir)) {
+      for (const name of fs10.readdirSync(cursorSkillsDir)) {
         const skillFile = path9.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4041,9 +4127,9 @@ function scanLocalState(dir) {
     }
   }
   const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
-  if (fs9.existsSync(cursorMcpPath)) {
+  if (fs10.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4062,7 +4148,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs9.readFileSync(filePath, "utf-8");
+  const text = fs10.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -4085,7 +4171,7 @@ function getCursorConfigDir() {
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs10 from "fs";
+import fs11 from "fs";
 import path10 from "path";
 import { execSync as execSync8 } from "child_process";
 var SETTINGS_PATH = path10.join(".claude", "settings.json");
@@ -4095,17 +4181,17 @@ function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs10.existsSync(SETTINGS_PATH)) return {};
+  if (!fs11.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs11.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
   const dir = path10.dirname(SETTINGS_PATH);
-  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -4153,7 +4239,8 @@ function removeHook() {
   return { removed: true, notFound: false };
 }
 function createScriptHook(config) {
-  const { eventName, scriptPath, scriptContent, description } = config;
+  const { eventName, scriptPath, description } = config;
+  const getContent = () => typeof config.scriptContent === "function" ? config.scriptContent() : config.scriptContent;
   const hasHook = (matchers) => matchers.some((entry) => entry.hooks?.some((h) => h.description === description));
   function isInstalled() {
     const settings = readSettings();
@@ -4168,9 +4255,9 @@ function createScriptHook(config) {
       return { installed: false, alreadyInstalled: true };
     }
     const scriptDir = path10.dirname(scriptPath);
-    if (!fs10.existsSync(scriptDir)) fs10.mkdirSync(scriptDir, { recursive: true });
-    fs10.writeFileSync(scriptPath, scriptContent);
-    fs10.chmodSync(scriptPath, 493);
+    if (!fs11.existsSync(scriptDir)) fs11.mkdirSync(scriptDir, { recursive: true });
+    fs11.writeFileSync(scriptPath, getContent());
+    fs11.chmodSync(scriptPath, 493);
     if (!Array.isArray(settings.hooks[eventName])) {
       settings.hooks[eventName] = [];
     }
@@ -4194,7 +4281,7 @@ function createScriptHook(config) {
     if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
     writeSettings(settings);
     try {
-      fs10.unlinkSync(scriptPath);
+      fs11.unlinkSync(scriptPath);
     } catch {
     }
     return { removed: true, notFound: false };
@@ -4221,7 +4308,9 @@ var stopHook = createScriptHook({
 });
 var installStopHook = stopHook.install;
 var removeStopHook = stopHook.remove;
-var FRESHNESS_SCRIPT = `#!/bin/sh
+function getFreshnessScript() {
+  const bin = resolveCaliber();
+  return `#!/bin/sh
 STATE_FILE=".caliber/.caliber-state.json"
 [ ! -f "$STATE_FILE" ] && exit 0
 LAST_SHA=$(grep -o '"lastRefreshSha":"[^"]*"' "$STATE_FILE" 2>/dev/null | cut -d'"' -f4)
@@ -4230,13 +4319,14 @@ CURRENT_SHA=$(git rev-parse HEAD 2>/dev/null)
 [ "$LAST_SHA" = "$CURRENT_SHA" ] && exit 0
 COMMITS_BEHIND=$(git rev-list --count "$LAST_SHA".."$CURRENT_SHA" 2>/dev/null || echo 0)
 if [ "$COMMITS_BEHIND" -gt 15 ]; then
-  printf '{"systemMessage":"Caliber: agent configs are %s commits behind. Run caliber refresh to sync."}' "$COMMITS_BEHIND"
+  printf '{"systemMessage":"Caliber: agent configs are %s commits behind. Run ${bin} refresh to sync."}' "$COMMITS_BEHIND"
 fi
 `;
+}
 var sessionStartHook = createScriptHook({
   eventName: "SessionStart",
   scriptPath: path10.join(".claude", "hooks", "caliber-session-freshness.sh"),
-  scriptContent: FRESHNESS_SCRIPT,
+  scriptContent: getFreshnessScript,
   description: "Caliber: check config freshness on session start"
 });
 var isSessionStartHookInstalled = sessionStartHook.isInstalled;
@@ -4245,7 +4335,7 @@ var removeSessionStartHook = sessionStartHook.remove;
 var notificationHook = createScriptHook({
   eventName: "Notification",
   scriptPath: path10.join(".claude", "hooks", "caliber-freshness-notify.sh"),
-  scriptContent: FRESHNESS_SCRIPT,
+  scriptContent: getFreshnessScript,
   description: "Caliber: warn when agent configs are stale"
 });
 var isNotificationHookInstalled = notificationHook.isInstalled;
@@ -4254,10 +4344,28 @@ var removeNotificationHook = notificationHook.remove;
 var PRECOMMIT_START = "# caliber:pre-commit:start";
 var PRECOMMIT_END = "# caliber:pre-commit:end";
 function getPrecommitBlock() {
-  const bin = resolveCaliber();
+  const cmd = resolveCaliber();
   const npx = isNpxResolution();
-  const guard = npx ? "command -v npx >/dev/null 2>&1" : `[ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1`;
-  const invoke = npx ? bin : `"${bin}"`;
+  let guard;
+  let invoke;
+  if (npx) {
+    const npxBin = cmd.split(" ")[0];
+    if (npxBin.startsWith("/")) {
+      guard = `[ -x "${npxBin}" ]`;
+      const npxArgs = cmd.slice(npxBin.length);
+      invoke = `"${npxBin}"${npxArgs}`;
+    } else {
+      guard = "command -v npx >/dev/null 2>&1";
+      invoke = cmd;
+    }
+  } else {
+    if (cmd.startsWith("/")) {
+      guard = `[ -x "${cmd}" ]`;
+    } else {
+      guard = `[ -x "${cmd}" ] || command -v "${cmd}" >/dev/null 2>&1`;
+    }
+    invoke = `"${cmd}"`;
+  }
   return `${PRECOMMIT_START}
 if ${guard}; then
   mkdir -p .caliber
@@ -4285,8 +4393,8 @@ function getPreCommitPath() {
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) return false;
-  const content = fs10.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs11.existsSync(hookPath)) return false;
+  const content = fs11.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -4296,45 +4404,45 @@ function installPreCommitHook() {
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
   const hooksDir = path10.dirname(hookPath);
-  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
+  if (!fs11.existsSync(hooksDir)) fs11.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs10.existsSync(hookPath)) {
-    content = fs10.readFileSync(hookPath, "utf-8");
+  if (fs11.existsSync(hookPath)) {
+    content = fs11.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs10.writeFileSync(hookPath, content);
-  fs10.chmodSync(hookPath, 493);
+  fs11.writeFileSync(hookPath, content);
+  fs11.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) {
+  if (!hookPath || !fs11.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs10.readFileSync(hookPath, "utf-8");
+  let content = fs11.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs10.unlinkSync(hookPath);
+    fs11.unlinkSync(hookPath);
   } else {
-    fs10.writeFileSync(hookPath, content);
+    fs11.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/fingerprint/sources.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path11 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 import { join, relative } from "path";
 function readFileOrNull(filePath) {
   try {
@@ -4384,7 +4492,7 @@ var IGNORED_FILES = /* @__PURE__ */ new Set([
 ]);
 function isGitRepo2(dir) {
   try {
-    execFileSync("git", ["rev-parse", "--git-dir"], {
+    execFileSync3("git", ["rev-parse", "--git-dir"], {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4397,7 +4505,7 @@ function isGitRepo2(dir) {
 function checkGitIgnored(dir, paths) {
   if (paths.length === 0) return /* @__PURE__ */ new Set();
   try {
-    const result = execFileSync("git", ["check-ignore", ...paths], {
+    const result = execFileSync3("git", ["check-ignore", ...paths], {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4678,15 +4786,15 @@ function loadSourcesConfig(dir) {
 }
 function writeSourcesConfig(dir, sources2) {
   const configDir = path11.join(dir, ".caliber");
-  if (!fs11.existsSync(configDir)) {
-    fs11.mkdirSync(configDir, { recursive: true });
+  if (!fs12.existsSync(configDir)) {
+    fs12.mkdirSync(configDir, { recursive: true });
   }
   const configPath = path11.join(configDir, "sources.json");
-  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  fs12.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs12.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
@@ -4730,7 +4838,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs11.statSync(absPath);
+      stat = fs12.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -4785,7 +4893,7 @@ function collectRepoSummary(resolved, _projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs11.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs12.readdirSync(absPath, { withFileTypes: true });
     topLevelDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, 20);
     keyFiles = entries.filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => e.name).slice(0, 15);
   } catch {
@@ -5646,32 +5754,32 @@ ${f.content}
 }
 
 // src/writers/index.ts
-import fs20 from "fs";
+import fs21 from "fs";
 
 // src/writers/claude/index.ts
 init_pre_commit_block();
-import fs12 from "fs";
+import fs13 from "fs";
 import path12 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs12.writeFileSync(
+  fs13.writeFileSync(
     "CLAUDE.md",
     appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.claudeMd)))
   );
   written.push("CLAUDE.md");
   if (config.rules?.length) {
     const rulesDir = path12.join(".claude", "rules");
-    if (!fs12.existsSync(rulesDir)) fs12.mkdirSync(rulesDir, { recursive: true });
+    if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
       const rulePath = path12.join(rulesDir, rule.filename);
-      fs12.writeFileSync(rulePath, rule.content);
+      fs13.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path12.join(".claude", "skills", skill.name);
-      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
       const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatterLines = ["---", `name: ${skill.name}`, `description: ${skill.description}`];
       if (skill.paths?.length) {
@@ -5682,21 +5790,21 @@ function writeClaudeConfig(config) {
       }
       frontmatterLines.push("---", "");
       const frontmatter = frontmatterLines.join("\n");
-      fs12.writeFileSync(skillPath, frontmatter + skill.content);
+      fs13.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs12.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
+      if (fs13.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs13.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs13.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
@@ -5704,12 +5812,12 @@ function writeClaudeConfig(config) {
 
 // src/writers/cursor/index.ts
 init_pre_commit_block();
-import fs13 from "fs";
+import fs14 from "fs";
 import path13 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs13.writeFileSync(".cursorrules", config.cursorrules);
+    fs14.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
@@ -5717,16 +5825,16 @@ function writeCursorConfig(config) {
   const syncRule = getCursorSyncRule();
   const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule];
   const rulesDir = path13.join(".cursor", "rules");
-  if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
+  if (!fs14.existsSync(rulesDir)) fs14.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
     const rulePath = path13.join(rulesDir, rule.filename);
-    fs13.writeFileSync(rulePath, rule.content);
+    fs14.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path13.join(".cursor", "skills", skill.name);
-      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
       const skillPath = path13.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -5735,24 +5843,24 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs13.existsSync(cursorDir)) fs13.mkdirSync(cursorDir, { recursive: true });
+    if (!fs14.existsSync(cursorDir)) fs14.mkdirSync(cursorDir, { recursive: true });
     const mcpPath = path13.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs13.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
+      if (fs14.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs14.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs14.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -5760,11 +5868,11 @@ function writeCursorConfig(config) {
 
 // src/writers/codex/index.ts
 init_pre_commit_block();
-import fs14 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs14.writeFileSync(
+  fs15.writeFileSync(
     "AGENTS.md",
     appendLearningsBlock(appendPreCommitBlock(config.agentsMd, "codex"))
   );
@@ -5772,7 +5880,7 @@ function writeCodexConfig(config) {
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path14.join(".agents", "skills", skill.name);
-      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      if (!fs15.existsSync(skillDir)) fs15.mkdirSync(skillDir, { recursive: true });
       const skillPath = path14.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -5781,7 +5889,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs14.writeFileSync(skillPath, frontmatter + skill.content);
+      fs15.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -5790,13 +5898,13 @@ function writeCodexConfig(config) {
 
 // src/writers/github-copilot/index.ts
 init_pre_commit_block();
-import fs15 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs15.mkdirSync(".github", { recursive: true });
-    fs15.writeFileSync(
+    fs16.mkdirSync(".github", { recursive: true });
+    fs16.writeFileSync(
       path15.join(".github", "copilot-instructions.md"),
       appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.instructions, "copilot")))
     );
@@ -5804,9 +5912,9 @@ function writeGithubCopilotConfig(config) {
   }
   if (config.instructionFiles?.length) {
     const instructionsDir = path15.join(".github", "instructions");
-    fs15.mkdirSync(instructionsDir, { recursive: true });
+    fs16.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs15.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
+      fs16.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -5816,12 +5924,12 @@ function writeGithubCopilotConfig(config) {
 // src/writers/opencode/index.ts
 init_pre_commit_block();
 init_builtin_skills();
-import fs17 from "fs";
+import fs18 from "fs";
 import path17 from "path";
 function writeOpencodeConfig(config, agentsMdAlreadyWritten = false) {
   const written = [];
   if (!agentsMdAlreadyWritten) {
-    fs17.writeFileSync(
+    fs18.writeFileSync(
       "AGENTS.md",
       appendLearningsBlock(appendPreCommitBlock(config.agentsMd, "codex"))
     );
@@ -5830,9 +5938,9 @@ function writeOpencodeConfig(config, agentsMdAlreadyWritten = false) {
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path17.join(".opencode", "skills", skill.name);
-      if (!fs17.existsSync(skillDir)) fs17.mkdirSync(skillDir, { recursive: true });
+      if (!fs18.existsSync(skillDir)) fs18.mkdirSync(skillDir, { recursive: true });
       const skillPath = path17.join(skillDir, "SKILL.md");
-      fs17.writeFileSync(skillPath, buildSkillContent(skill));
+      fs18.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -5840,30 +5948,30 @@ function writeOpencodeConfig(config, agentsMdAlreadyWritten = false) {
 }
 
 // src/writers/backup.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path18 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupDir = path18.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs18.existsSync(file)) continue;
+    if (!fs19.existsSync(file)) continue;
     const dest = path18.join(backupDir, file);
     const destDir = path18.dirname(dest);
-    if (!fs18.existsSync(destDir)) {
-      fs18.mkdirSync(destDir, { recursive: true });
+    if (!fs19.existsSync(destDir)) {
+      fs19.mkdirSync(destDir, { recursive: true });
     }
-    fs18.copyFileSync(file, dest);
+    fs19.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
   const backupFile = path18.join(backupDir, file);
-  if (!fs18.existsSync(backupFile)) return false;
+  if (!fs19.existsSync(backupFile)) return false;
   const destDir = path18.dirname(file);
-  if (!fs18.existsSync(destDir)) {
-    fs18.mkdirSync(destDir, { recursive: true });
+  if (!fs19.existsSync(destDir)) {
+    fs19.mkdirSync(destDir, { recursive: true });
   }
-  fs18.copyFileSync(backupFile, file);
+  fs19.copyFileSync(backupFile, file);
   return true;
 }
 
@@ -5871,32 +5979,32 @@ function restoreBackup(backupDir, file) {
 init_builtin_skills();
 
 // src/writers/manifest.ts
-import fs19 from "fs";
+import fs20 from "fs";
 import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs19.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs19.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs20.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs20.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs20.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs19.readFileSync(filePath);
+  const content = fs20.readFileSync(filePath);
   return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs20.existsSync(f));
-  const existingFiles = [...filesToWrite.filter((f) => fs20.existsSync(f)), ...filesToDelete];
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs21.existsSync(f));
+  const existingFiles = [...filesToWrite.filter((f) => fs21.existsSync(f)), ...filesToDelete];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
   const written = [];
   if (setup.targetAgent.includes("claude") && setup.claude) {
@@ -5917,7 +6025,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs20.unlinkSync(filePath);
+    fs21.unlinkSync(filePath);
     deleted.push(filePath);
   }
   written.push(...ensureBuiltinSkills());
@@ -5948,8 +6056,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs20.existsSync(entry.path)) {
-        fs20.unlinkSync(entry.path);
+      if (fs21.existsSync(entry.path)) {
+        fs21.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -5958,8 +6066,8 @@ function undoSetup() {
       }
     }
   }
-  if (fs20.existsSync(MANIFEST_FILE)) {
-    fs20.unlinkSync(MANIFEST_FILE);
+  if (fs21.existsSync(MANIFEST_FILE)) {
+    fs21.unlinkSync(MANIFEST_FILE);
   }
   return { restored, removed };
 }
@@ -6012,18 +6120,18 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs20.existsSync(gitignorePath)) {
-    const content = fs20.readFileSync(gitignorePath, "utf-8");
+  if (fs21.existsSync(gitignorePath)) {
+    const content = fs21.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs20.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs21.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs20.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs21.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import path19 from "path";
 var STAGED_DIR = path19.join(CALIBER_DIR, "staged");
 var PROPOSED_DIR = path19.join(STAGED_DIR, "proposed");
@@ -6039,19 +6147,19 @@ function stageFiles(files, projectDir) {
   for (const file of files) {
     assertPathWithinDir(file.path, projectDir);
     const originalPath = path19.join(projectDir, file.path);
-    if (fs21.existsSync(originalPath)) {
-      const existing = fs21.readFileSync(originalPath, "utf-8");
+    if (fs22.existsSync(originalPath)) {
+      const existing = fs22.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
     const proposedPath = path19.join(PROPOSED_DIR, file.path);
-    fs21.mkdirSync(path19.dirname(proposedPath), { recursive: true });
-    fs21.writeFileSync(proposedPath, file.content);
-    if (fs21.existsSync(originalPath)) {
+    fs22.mkdirSync(path19.dirname(proposedPath), { recursive: true });
+    fs22.writeFileSync(proposedPath, file.content);
+    if (fs22.existsSync(originalPath)) {
       const currentPath = path19.join(CURRENT_DIR, file.path);
-      fs21.mkdirSync(path19.dirname(currentPath), { recursive: true });
-      fs21.copyFileSync(originalPath, currentPath);
+      fs22.mkdirSync(path19.dirname(currentPath), { recursive: true });
+      fs22.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({
         relativePath: file.path,
@@ -6068,14 +6176,14 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs21.existsSync(STAGED_DIR)) {
-    fs21.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs22.existsSync(STAGED_DIR)) {
+    fs22.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
 init_builtin_skills();
-import fs22 from "fs";
+import fs23 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -6182,7 +6290,7 @@ function collectSetupFiles(setup, targetAgent) {
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
   const opencodeTargeted = targetAgent ? targetAgent.includes("opencode") : false;
-  if ((codexTargeted || opencodeTargeted) && !fs22.existsSync("AGENTS.md") && !(codex && codex.agentsMd) && !(opencode && opencode.agentsMd)) {
+  if ((codexTargeted || opencodeTargeted) && !fs23.existsSync("AGENTS.md") && !(codex && codex.agentsMd) && !(opencode && opencode.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -6201,7 +6309,7 @@ ${agentRefs.join(" ")}
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs23 from "fs";
+import fs24 from "fs";
 import path20 from "path";
 var SETTINGS_PATH2 = path20.join(".claude", "settings.json");
 var HOOK_TAILS = [
@@ -6220,17 +6328,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings2() {
-  if (!fs23.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs24.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs23.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs24.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
   const dir = path20.dirname(SETTINGS_PATH2);
-  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
-  fs23.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
+  fs24.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -6272,17 +6380,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs23.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs24.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs23.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs24.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
   const dir = path20.dirname(CURSOR_HOOKS_PATH);
-  if (!fs23.existsSync(dir)) fs23.mkdirSync(dir, { recursive: true });
-  fs23.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
+  fs24.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -6354,7 +6462,7 @@ function removeLearningHooks() {
 init_resolve_caliber();
 
 // src/lib/state.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import path21 from "path";
 import { execSync as execSync9 } from "child_process";
 var STATE_FILE = path21.join(CALIBER_DIR, ".caliber-state.json");
@@ -6368,8 +6476,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs24.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs24.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs25.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs25.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -6377,10 +6485,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs24.existsSync(CALIBER_DIR)) {
-    fs24.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs25.existsSync(CALIBER_DIR)) {
+    fs25.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs24.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs25.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -6397,6 +6505,7 @@ function getCurrentHeadSha() {
 import chalk2 from "chalk";
 import readline from "readline";
 function promptInput(question) {
+  if (!process.stdin.isTTY) return Promise.resolve("");
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve3) => {
     rl.question(chalk2.cyan(`${question} `), (answer) => {
@@ -7487,7 +7596,7 @@ function checkSources(dir) {
 }
 
 // src/scoring/dismissed.ts
-import fs25 from "fs";
+import fs26 from "fs";
 import path22 from "path";
 var DISMISSED_FILE = path22.join(CALIBER_DIR, "dismissed-checks.json");
 function dismissedFilePath(dir) {
@@ -7496,17 +7605,17 @@ function dismissedFilePath(dir) {
 function readDismissedChecks(dir) {
   try {
     const filePath = dismissedFilePath(dir);
-    if (!fs25.existsSync(filePath)) return [];
-    return JSON.parse(fs25.readFileSync(filePath, "utf-8"));
+    if (!fs26.existsSync(filePath)) return [];
+    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs25.existsSync(CALIBER_DIR)) {
-    fs25.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs26.existsSync(CALIBER_DIR)) {
+    fs26.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs25.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs26.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds(dir) {
   return new Set(readDismissedChecks(dir).map((c) => c.id));
@@ -7765,7 +7874,7 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs26 from "fs";
+import fs27 from "fs";
 import path23 from "path";
 import os5 from "os";
 import crypto4 from "crypto";
@@ -7775,17 +7884,17 @@ var CONFIG_FILE2 = path23.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs26.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs26.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs27.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs27.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs26.existsSync(CONFIG_DIR2)) {
-    fs26.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs27.existsSync(CONFIG_DIR2)) {
+    fs27.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs26.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs27.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -8458,6 +8567,10 @@ async function recommendCommand(options) {
     await querySkills(options.query);
     return;
   }
+  if (!process.stdin.isTTY) {
+    console.log(chalk6.dim("  Skills search requires an interactive terminal."));
+    return;
+  }
   const proceed = await select3({
     message: "Search public repos for relevant skills to add to this project?",
     choices: [
@@ -9125,7 +9238,7 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory, options) {
 }
 
 // src/lib/debug-report.ts
-import fs27 from "fs";
+import fs28 from "fs";
 import path24 from "path";
 var DebugReport = class {
   sections = [];
@@ -9196,10 +9309,10 @@ var DebugReport = class {
       lines.push("");
     }
     const dir = path24.dirname(outputPath);
-    if (!fs27.existsSync(dir)) {
-      fs27.mkdirSync(dir, { recursive: true });
+    if (!fs28.existsSync(dir)) {
+      fs28.mkdirSync(dir, { recursive: true });
     }
-    fs27.writeFileSync(outputPath, lines.join("\n"));
+    fs28.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -9600,7 +9713,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs30 from "fs";
+import fs31 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -9776,11 +9889,11 @@ init_config();
 init_review();
 function detectAgents(dir) {
   const agents = [];
-  if (fs30.existsSync(`${dir}/.claude`)) agents.push("claude");
-  if (fs30.existsSync(`${dir}/.cursor`)) agents.push("cursor");
-  if (fs30.existsSync(`${dir}/.agents`) || fs30.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
-  if (fs30.existsSync(`${dir}/.opencode`)) agents.push("opencode");
-  if (fs30.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
+  if (fs31.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs31.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs31.existsSync(`${dir}/.agents`) || fs31.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs31.existsSync(`${dir}/.opencode`)) agents.push("opencode");
+  if (fs31.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
@@ -9884,7 +9997,7 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs31 from "fs";
+import fs32 from "fs";
 init_types();
 function formatWhatChanged(setup) {
   const lines = [];
@@ -9892,12 +10005,12 @@ function formatWhatChanged(setup) {
   const codex = setup.codex;
   const cursor = setup.cursor;
   if (claude?.claudeMd) {
-    const action = fs31.existsSync("CLAUDE.md") ? "Updated" : "Created";
+    const action = fs32.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   const opencode = setup.opencode;
   if (codex?.agentsMd || opencode?.agentsMd) {
-    const action = fs31.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs32.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -9941,7 +10054,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs31.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs32.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk12.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -9951,7 +10064,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs31.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs32.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -9962,7 +10075,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs31.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs32.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -9972,7 +10085,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs31.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs32.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -9983,7 +10096,7 @@ function printSetupSummary(setup) {
   const opencode = setup.opencode;
   if (opencode) {
     if (opencode.agentsMd && !codex?.agentsMd) {
-      const icon = fs31.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs32.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")} ${chalk12.dim("(OpenCode)")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -9993,7 +10106,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(opencodeSkills) && opencodeSkills.length > 0) {
       for (const skill of opencodeSkills) {
         const skillPath = `.opencode/skills/${skill.name}/SKILL.md`;
-        const icon = fs31.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs32.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -10003,7 +10116,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs31.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs32.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -10013,7 +10126,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs31.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs32.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -10024,7 +10137,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rulesArr) && rulesArr.length > 0) {
       for (const rule of rulesArr) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs31.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs32.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -10086,12 +10199,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs32 from "fs";
+import fs33 from "fs";
 import path26 from "path";
 function isFirstRun(dir) {
   const caliberDir = path26.join(dir, ".caliber");
   try {
-    const stat = fs32.statSync(caliberDir);
+    const stat = fs33.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -10144,8 +10257,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs32.existsSync(settingsPath)) {
-      settings = JSON.parse(fs32.readFileSync(settingsPath, "utf-8"));
+    if (fs33.existsSync(settingsPath)) {
+      settings = JSON.parse(fs33.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -10154,8 +10267,8 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs32.existsSync(".claude")) fs32.mkdirSync(".claude", { recursive: true });
-  fs32.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs33.existsSync(".claude")) fs33.mkdirSync(".claude", { recursive: true });
+  fs33.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
@@ -10184,8 +10297,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("```");
       lines.push("", "If timeouts persist, try a different model.");
     }
-    fs32.mkdirSync(path26.join(process.cwd(), ".caliber"), { recursive: true });
-    fs32.writeFileSync(logPath, lines.join("\n"));
+    fs33.mkdirSync(path26.join(process.cwd(), ".caliber"), { recursive: true });
+    fs33.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -10238,7 +10351,7 @@ ${JSON.stringify(checkList, null, 2)}`,
 }
 
 // src/scoring/history.ts
-import fs33 from "fs";
+import fs34 from "fs";
 import path27 from "path";
 var HISTORY_FILE = "score-history.jsonl";
 var MAX_ENTRIES = 500;
@@ -10255,14 +10368,14 @@ function recordScore(result, trigger) {
     trigger
   };
   try {
-    fs33.mkdirSync(CALIBER_DIR, { recursive: true });
+    fs34.mkdirSync(CALIBER_DIR, { recursive: true });
     const filePath = historyFilePath();
-    fs33.appendFileSync(filePath, JSON.stringify(entry) + "\n");
-    const stat = fs33.statSync(filePath);
+    fs34.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+    const stat = fs34.statSync(filePath);
     if (stat.size > TRIM_THRESHOLD * 120) {
-      const lines = fs33.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+      const lines = fs34.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
       if (lines.length > MAX_ENTRIES) {
-        fs33.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
+        fs34.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
       }
     }
   } catch {
@@ -10271,7 +10384,7 @@ function recordScore(result, trigger) {
 function readScoreHistory() {
   const filePath = historyFilePath();
   try {
-    const content = fs33.readFileSync(filePath, "utf-8");
+    const content = fs34.readFileSync(filePath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       if (!line) continue;
@@ -10450,12 +10563,12 @@ async function initCommand(options) {
   }
   const { ensureBuiltinSkills: ensureBuiltinSkills2 } = await Promise.resolve().then(() => (init_builtin_skills(), builtin_skills_exports));
   for (const agent of targetAgent) {
-    if (agent === "claude" && !fs34.existsSync(".claude"))
-      fs34.mkdirSync(".claude", { recursive: true });
-    if (agent === "cursor" && !fs34.existsSync(".cursor"))
-      fs34.mkdirSync(".cursor", { recursive: true });
-    if (agent === "codex" && !fs34.existsSync(".agents"))
-      fs34.mkdirSync(".agents", { recursive: true });
+    if (agent === "claude" && !fs35.existsSync(".claude"))
+      fs35.mkdirSync(".claude", { recursive: true });
+    if (agent === "cursor" && !fs35.existsSync(".cursor"))
+      fs35.mkdirSync(".cursor", { recursive: true });
+    if (agent === "codex" && !fs35.existsSync(".agents"))
+      fs35.mkdirSync(".agents", { recursive: true });
   }
   const skillsWritten = ensureBuiltinSkills2();
   if (skillsWritten.length > 0) {
@@ -10544,7 +10657,7 @@ async function initCommand(options) {
     const claudeMdPath = "CLAUDE.md";
     let claudeContent = "";
     try {
-      claudeContent = fs34.readFileSync(claudeMdPath, "utf-8");
+      claudeContent = fs35.readFileSync(claudeMdPath, "utf-8");
     } catch {
     }
     if (!claudeContent) {
@@ -10552,20 +10665,20 @@ async function initCommand(options) {
 `;
     }
     const updatedClaude = appendManagedBlocks2(claudeContent, "claude");
-    if (updatedClaude !== claudeContent || !fs34.existsSync(claudeMdPath)) {
-      fs34.writeFileSync(claudeMdPath, updatedClaude);
+    if (updatedClaude !== claudeContent || !fs35.existsSync(claudeMdPath)) {
+      fs35.writeFileSync(claudeMdPath, updatedClaude);
       console.log(`  ${chalk14.green("\u2713")} CLAUDE.md \u2014 added Caliber sync instructions`);
     }
     if (targetAgent.includes("cursor")) {
       const rulesDir = path28.join(".cursor", "rules");
-      if (!fs34.existsSync(rulesDir)) fs34.mkdirSync(rulesDir, { recursive: true });
+      if (!fs35.existsSync(rulesDir)) fs35.mkdirSync(rulesDir, { recursive: true });
       for (const rule of [
         getCursorPreCommitRule2(),
         getCursorLearningsRule2(),
         getCursorSyncRule2(),
         getCursorSetupRule2()
       ]) {
-        fs34.writeFileSync(path28.join(rulesDir, rule.filename), rule.content);
+        fs35.writeFileSync(path28.join(rulesDir, rule.filename), rule.content);
       }
       console.log(`  ${chalk14.green("\u2713")} Cursor rules \u2014 added Caliber sync rules`);
     }
@@ -10573,17 +10686,17 @@ async function initCommand(options) {
       const copilotPath = path28.join(".github", "copilot-instructions.md");
       let copilotContent = "";
       try {
-        copilotContent = fs34.readFileSync(copilotPath, "utf-8");
+        copilotContent = fs35.readFileSync(copilotPath, "utf-8");
       } catch {
       }
       if (!copilotContent) {
-        fs34.mkdirSync(".github", { recursive: true });
+        fs35.mkdirSync(".github", { recursive: true });
         copilotContent = `# ${path28.basename(process.cwd())}
 `;
       }
       const updatedCopilot = appendManagedBlocks2(copilotContent, "copilot");
       if (updatedCopilot !== copilotContent) {
-        fs34.writeFileSync(copilotPath, updatedCopilot);
+        fs35.writeFileSync(copilotPath, updatedCopilot);
         console.log(`  ${chalk14.green("\u2713")} Copilot instructions \u2014 added Caliber sync instructions`);
       }
     }
@@ -10930,7 +11043,7 @@ async function initCommand(options) {
   const { default: ora9 } = await import("ora");
   const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs34.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs35.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -11120,7 +11233,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs35 from "fs";
+import fs36 from "fs";
 init_config();
 init_resolve_caliber();
 async function statusCommand(options) {
@@ -11149,7 +11262,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs35.existsSync(entry.path);
+    const exists = fs36.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -11306,42 +11419,42 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs36 from "fs";
+import fs37 from "fs";
 import os7 from "os";
 import path29 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import chalk18 from "chalk";
 init_resolve_caliber();
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs36.mkdtempSync(path29.join(os7.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs37.mkdtempSync(path29.join(os7.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
-        const content = execFileSync2("git", ["show", `${ref}:${file}`], {
+        const content = execFileSync4("git", ["show", `${ref}:${file}`], {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
-        fs36.writeFileSync(path29.join(tmpDir, file), content);
+        fs37.writeFileSync(path29.join(tmpDir, file), content);
       } catch {
       }
     }
     for (const dir of CONFIG_DIRS) {
       try {
-        const files = execFileSync2("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], {
+        const files = execFileSync4("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         }).trim().split("\n").filter(Boolean);
         for (const file of files) {
           const filePath = path29.join(tmpDir, file);
-          fs36.mkdirSync(path29.dirname(filePath), { recursive: true });
-          const content = execFileSync2("git", ["show", `${ref}:${file}`], {
+          fs37.mkdirSync(path29.dirname(filePath), { recursive: true });
+          const content = execFileSync4("git", ["show", `${ref}:${file}`], {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"]
           });
-          fs36.writeFileSync(filePath, content);
+          fs37.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -11351,7 +11464,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs36.rmSync(tmpDir, { recursive: true, force: true });
+    fs37.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -11444,10 +11557,11 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs41 from "fs";
+import fs42 from "fs";
 import path34 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
+import pLimit from "p-limit";
 
 // src/lib/git-diff.ts
 import { execSync as execSync15 } from "child_process";
@@ -11560,13 +11674,13 @@ function scopeDiffToDir(diff, dir, allConfigDirs) {
 
 // src/writers/refresh.ts
 init_pre_commit_block();
-import fs37 from "fs";
+import fs38 from "fs";
 import path30 from "path";
 function writeFileGroup(groupDir, files) {
-  fs37.mkdirSync(groupDir, { recursive: true });
+  fs38.mkdirSync(groupDir, { recursive: true });
   return files.map((file) => {
     const filePath = path30.join(groupDir, file.filename);
-    fs37.writeFileSync(filePath, file.content);
+    fs38.writeFileSync(filePath, file.content);
     return filePath.replace(/\\/g, "/");
   });
 }
@@ -11575,18 +11689,18 @@ function writeRefreshDocs(docs, dir = ".") {
   const p = (relPath) => (dir === "." ? relPath : path30.join(dir, relPath)).replace(/\\/g, "/");
   const ensureParent = (filePath) => {
     const parent = path30.dirname(filePath);
-    if (parent !== "." && !fs37.existsSync(parent)) fs37.mkdirSync(parent, { recursive: true });
+    if (parent !== "." && !fs38.existsSync(parent)) fs38.mkdirSync(parent, { recursive: true });
   };
   if (docs.agentsMd) {
     const filePath = p("AGENTS.md");
     ensureParent(filePath);
-    fs37.writeFileSync(filePath, appendManagedBlocks(docs.agentsMd, "codex"));
+    fs38.writeFileSync(filePath, appendManagedBlocks(docs.agentsMd, "codex"));
     written.push(filePath);
   }
   if (docs.claudeMd) {
     const filePath = p("CLAUDE.md");
     ensureParent(filePath);
-    fs37.writeFileSync(filePath, appendManagedBlocks(docs.claudeMd));
+    fs38.writeFileSync(filePath, appendManagedBlocks(docs.claudeMd));
     written.push(filePath);
   }
   if (docs.claudeRules) {
@@ -11595,13 +11709,13 @@ function writeRefreshDocs(docs, dir = ".") {
   if (docs.readmeMd) {
     const filePath = p("README.md");
     ensureParent(filePath);
-    fs37.writeFileSync(filePath, docs.readmeMd);
+    fs38.writeFileSync(filePath, docs.readmeMd);
     written.push(filePath);
   }
   if (docs.cursorrules) {
     const filePath = p(".cursorrules");
     ensureParent(filePath);
-    fs37.writeFileSync(filePath, docs.cursorrules);
+    fs38.writeFileSync(filePath, docs.cursorrules);
     written.push(filePath);
   }
   if (docs.cursorRules) {
@@ -11610,7 +11724,7 @@ function writeRefreshDocs(docs, dir = ".") {
   if (docs.copilotInstructions) {
     const filePath = p(path30.join(".github", "copilot-instructions.md"));
     ensureParent(filePath);
-    fs37.writeFileSync(filePath, appendManagedBlocks(docs.copilotInstructions, "copilot"));
+    fs38.writeFileSync(filePath, appendManagedBlocks(docs.copilotInstructions, "copilot"));
     written.push(filePath);
   }
   if (docs.copilotInstructionFiles) {
@@ -11752,7 +11866,7 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs38 from "fs";
+import fs39 from "fs";
 import path31 from "path";
 
 // src/learner/utils.ts
@@ -11870,8 +11984,8 @@ function deduplicateLearnedItems(existing, incoming) {
 }
 function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
   const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
-  fs38.writeFileSync(filePath, header + merged + "\n");
-  if (mode) fs38.chmodSync(filePath, mode);
+  fs39.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs39.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
 function writeLearnedSection(content) {
@@ -11879,11 +11993,11 @@ function writeLearnedSection(content) {
 }
 function writeLearnedSkill(skill) {
   const skillDir = path31.join(".claude", "skills", skill.name);
-  if (!fs38.existsSync(skillDir)) fs38.mkdirSync(skillDir, { recursive: true });
+  if (!fs39.existsSync(skillDir)) fs39.mkdirSync(skillDir, { recursive: true });
   const skillPath = path31.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs38.existsSync(skillPath)) {
-    const existing = fs38.readFileSync(skillPath, "utf-8");
-    fs38.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  if (!skill.isNew && fs39.existsSync(skillPath)) {
+    const existing = fs39.readFileSync(skillPath, "utf-8");
+    fs39.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -11892,12 +12006,12 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs38.writeFileSync(skillPath, frontmatter + skill.content);
+    fs39.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function writePersonalLearnedSection(content) {
-  if (!fs38.existsSync(AUTH_DIR)) fs38.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs39.existsSync(AUTH_DIR)) fs39.mkdirSync(AUTH_DIR, { recursive: true });
   return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
 }
 function addLearning(bullet, scope = "project") {
@@ -11910,38 +12024,38 @@ function addLearning(bullet, scope = "project") {
   return { file: LEARNINGS_FILE, added: result.newCount > 0 };
 }
 function readPersonalLearnings() {
-  if (!fs38.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
-  const content = fs38.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  if (!fs39.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs39.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
   const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
   return bullets || null;
 }
 function readLearnedSection() {
-  if (fs38.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs38.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs39.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs39.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs38.existsSync(claudeMdPath)) return null;
-  const content = fs38.readFileSync(claudeMdPath, "utf-8");
+  if (!fs39.existsSync(claudeMdPath)) return null;
+  const content = fs39.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 (fs38.existsSync(LEARNINGS_FILE)) return false;
+  if (fs39.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs38.existsSync(claudeMdPath)) return false;
-  const content = fs38.readFileSync(claudeMdPath, "utf-8");
+  if (!fs39.existsSync(claudeMdPath)) return false;
+  const content = fs39.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;
-  fs38.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs39.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs38.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs39.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -11951,7 +12065,7 @@ init_resolve_caliber();
 init_builtin_skills();
 
 // src/lib/config-discovery.ts
-import fs39 from "fs";
+import fs40 from "fs";
 import path32 from "path";
 var CONFIG_FILE_MARKERS = [
   "CLAUDE.md",
@@ -11978,11 +12092,11 @@ var IGNORE_DIRS3 = /* @__PURE__ */ new Set([
 var MAX_DEPTH = 4;
 function hasConfigFiles(dir) {
   for (const marker of CONFIG_FILE_MARKERS) {
-    if (fs39.existsSync(path32.join(dir, marker))) return true;
+    if (fs40.existsSync(path32.join(dir, marker))) return true;
   }
   for (const marker of CONFIG_DIR_MARKERS) {
     const markerPath = path32.join(dir, marker);
-    if (fs39.existsSync(markerPath) && fs39.statSync(markerPath).isDirectory()) return true;
+    if (fs40.existsSync(markerPath) && fs40.statSync(markerPath).isDirectory()) return true;
   }
   return false;
 }
@@ -11999,7 +12113,7 @@ function walkForConfigs(baseDir, currentDir, depth, result) {
   if (depth >= MAX_DEPTH) return;
   let entries;
   try {
-    entries = fs39.readdirSync(currentDir, { withFileTypes: true });
+    entries = fs40.readdirSync(currentDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -12018,8 +12132,8 @@ function walkForConfigs(baseDir, currentDir, depth, result) {
 // src/commands/refresh.ts
 function writeRefreshError(error) {
   try {
-    if (!fs41.existsSync(CALIBER_DIR)) fs41.mkdirSync(CALIBER_DIR, { recursive: true });
-    fs41.writeFileSync(
+    if (!fs42.existsSync(CALIBER_DIR)) fs42.mkdirSync(CALIBER_DIR, { recursive: true });
+    fs42.writeFileSync(
       REFRESH_LAST_ERROR_FILE,
       JSON.stringify(
         {
@@ -12038,15 +12152,15 @@ function writeRefreshError(error) {
 }
 function readRefreshError() {
   try {
-    if (!fs41.existsSync(REFRESH_LAST_ERROR_FILE)) return null;
-    return JSON.parse(fs41.readFileSync(REFRESH_LAST_ERROR_FILE, "utf-8"));
+    if (!fs42.existsSync(REFRESH_LAST_ERROR_FILE)) return null;
+    return JSON.parse(fs42.readFileSync(REFRESH_LAST_ERROR_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function clearRefreshError() {
   try {
-    if (fs41.existsSync(REFRESH_LAST_ERROR_FILE)) fs41.unlinkSync(REFRESH_LAST_ERROR_FILE);
+    if (fs42.existsSync(REFRESH_LAST_ERROR_FILE)) fs42.unlinkSync(REFRESH_LAST_ERROR_FILE);
   } catch {
   }
 }
@@ -12066,11 +12180,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs41.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs42.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const childPath = path34.join(parentDir, entry.name);
-      if (fs41.existsSync(path34.join(childPath, ".git"))) {
+      if (fs42.existsSync(path34.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -12101,12 +12215,15 @@ function collectFilesToWrite(updatedDocs, dir = ".") {
   return files;
 }
 var REFRESH_COOLDOWN_MS = 3e4;
+var PARALLEL_DIR_CONCURRENCY = 4;
 async function refreshDir(repoDir, dir, diff, options) {
   const quiet = !!options.quiet;
+  const suppress = !!options.suppressSpinner;
+  const effectiveQuiet = quiet || suppress;
   const prefix = options.label ? `${chalk19.bold(options.label)} ` : "";
   const absDir = dir === "." ? repoDir : path34.resolve(repoDir, dir);
   const scope = dir === "." ? void 0 : dir;
-  const spinner = quiet ? null : ora6(`${prefix}Analyzing changes...`).start();
+  const spinner = effectiveQuiet ? null : ora6(`${prefix}Analyzing changes...`).start();
   const learnedSection = readLearnedSection();
   const fingerprint = await collectFingerprint(absDir);
   const existingDocs = fingerprint.existingConfigs;
@@ -12155,7 +12272,7 @@ async function refreshDir(repoDir, dir, diff, options) {
   }
   if (!response.docsUpdated || response.docsUpdated.length === 0) {
     spinner?.succeed(`${prefix}No doc updates needed`);
-    return { written: [] };
+    return { written: [], fileChanges: [], syncedAgents: [], changesSummary: null };
   }
   if (options.dryRun) {
     spinner?.info(`${prefix}Dry run \u2014 would update:`);
@@ -12166,14 +12283,14 @@ async function refreshDir(repoDir, dir, diff, options) {
       console.log(chalk19.dim(`
   ${response.changesSummary}`));
     }
-    return { written: [] };
+    return { written: [], fileChanges: [], syncedAgents: [], changesSummary: null };
   }
   const allFilesToWrite = collectFilesToWrite(response.updatedDocs, dir);
   const preRefreshContents = /* @__PURE__ */ new Map();
   for (const filePath of allFilesToWrite) {
     const fullPath = path34.resolve(repoDir, filePath);
     try {
-      preRefreshContents.set(filePath, fs41.readFileSync(fullPath, "utf-8"));
+      preRefreshContents.set(filePath, fs42.readFileSync(fullPath, "utf-8"));
     } catch {
       preRefreshContents.set(filePath, null);
     }
@@ -12192,43 +12309,47 @@ async function refreshDir(repoDir, dir, diff, options) {
         const fullPath = path34.resolve(repoDir, filePath);
         if (content === null) {
           try {
-            fs41.unlinkSync(fullPath);
+            fs42.unlinkSync(fullPath);
           } catch {
           }
         } else {
-          fs41.writeFileSync(fullPath, content);
+          fs42.writeFileSync(fullPath, content);
         }
       }
       spinner?.warn(
         `${prefix}Refresh reverted \u2014 score would drop from ${preScore.score} to ${postScore.score}`
       );
-      log2(quiet, chalk19.dim(`  Config quality gate prevented a regression. No files were changed.`));
-      return { written: [] };
+      log2(
+        effectiveQuiet,
+        chalk19.dim(`  Config quality gate prevented a regression. No files were changed.`)
+      );
+      return { written: [], fileChanges: [], syncedAgents: [], changesSummary: null };
     }
     recordScore(postScore, "refresh");
   }
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
-  const fileChangesMap = new Map(
-    (response.fileChanges || []).map((fc) => [
-      fc.file,
-      fc.description
-    ])
-  );
-  for (const file of written) {
-    const desc = fileChangesMap.get(file);
-    const suffix = desc ? chalk19.dim(` \u2014 ${desc}`) : "";
-    log2(quiet, `  ${chalk19.green("\u2713")} ${file}${suffix}`);
-  }
-  const agents = detectSyncedAgents(written);
-  if (agents.length > 1) {
-    log2(quiet, chalk19.cyan(`
-  ${agents.length} agent formats in sync (${agents.join(", ")})`));
-  }
-  if (response.changesSummary) {
-    log2(quiet, chalk19.dim(`
+  const fileChanges = response.fileChanges || [];
+  const fileChangesMap = new Map(fileChanges.map((fc) => [fc.file, fc.description]));
+  const syncedAgents = detectSyncedAgents(written);
+  if (!suppress) {
+    for (const file of written) {
+      const desc = fileChangesMap.get(file);
+      const suffix = desc ? chalk19.dim(` \u2014 ${desc}`) : "";
+      log2(effectiveQuiet, `  ${chalk19.green("\u2713")} ${file}${suffix}`);
+    }
+    if (syncedAgents.length > 1) {
+      log2(
+        effectiveQuiet,
+        chalk19.cyan(`
+  ${syncedAgents.length} agent formats in sync (${syncedAgents.join(", ")})`)
+      );
+    }
+    if (response.changesSummary) {
+      log2(effectiveQuiet, chalk19.dim(`
   ${response.changesSummary}`));
+    }
   }
-  return { written };
+  return { written, fileChanges, syncedAgents, changesSummary: response.changesSummary };
 }
 async function refreshSingleRepo(repoDir, options) {
   const quiet = !!options.quiet;
@@ -12260,21 +12381,57 @@ async function refreshSingleRepo(repoDir, options) {
   } else {
     log2(quiet, chalk19.dim(`${prefix}Found configs in ${configDirs.length} directories
 `));
+    const dirsWithChanges = configDirs.map((dir) => ({ dir, scopedDiff: scopeDiffToDir(diff, dir, configDirs) })).filter(({ scopedDiff }) => scopedDiff.hasChanges);
+    const parallelSpinner = quiet ? null : ora6(
+      `${prefix}Refreshing ${dirsWithChanges.length} director${dirsWithChanges.length === 1 ? "y" : "ies"}...`
+    ).start();
+    const limit = pLimit(PARALLEL_DIR_CONCURRENCY);
+    const results = await Promise.allSettled(
+      dirsWithChanges.map(({ dir, scopedDiff }) => {
+        const dirLabel = dir === "." ? "root" : dir;
+        return limit(
+          () => refreshDir(repoDir, dir, scopedDiff, {
+            ...options,
+            suppressSpinner: true,
+            label: dirLabel
+          })
+        );
+      })
+    );
+    parallelSpinner?.stop();
     let hadFailure = false;
-    for (const dir of configDirs) {
-      const scopedDiff = scopeDiffToDir(diff, dir, configDirs);
-      if (!scopedDiff.hasChanges) continue;
+    for (const [i, result] of results.entries()) {
+      const { dir } = dirsWithChanges[i];
       const dirLabel = dir === "." ? "root" : dir;
-      try {
-        await refreshDir(repoDir, dir, scopedDiff, { ...options, label: dirLabel });
-      } catch (err) {
+      if (result.status === "rejected") {
         hadFailure = true;
         log2(
           quiet,
           chalk19.yellow(
-            `  ${dirLabel}: refresh failed \u2014 ${err instanceof Error ? err.message : "unknown error"}`
+            `  ${dirLabel}: refresh failed \u2014 ${result.reason instanceof Error ? result.reason.message : "unknown error"}`
           )
         );
+      } else {
+        const { written, fileChanges, syncedAgents, changesSummary } = result.value;
+        const fileChangesMap = new Map(fileChanges.map((fc) => [fc.file, fc.description]));
+        for (const file of written) {
+          const desc = fileChangesMap.get(file);
+          const suffix = desc ? chalk19.dim(` \u2014 ${desc}`) : "";
+          log2(quiet, `  ${chalk19.green("\u2713")} ${dirLabel}/${file}${suffix}`);
+        }
+        if (syncedAgents.length > 1) {
+          log2(
+            quiet,
+            chalk19.cyan(
+              `
+  ${syncedAgents.length} agent formats in sync (${syncedAgents.join(", ")})`
+            )
+          );
+        }
+        if (changesSummary) {
+          log2(quiet, chalk19.dim(`
+  ${changesSummary}`));
+        }
       }
     }
     if (hadFailure) {
@@ -12366,7 +12523,7 @@ async function refreshCommand(options) {
 
 // src/commands/hooks.ts
 import chalk20 from "chalk";
-import fs42 from "fs";
+import fs43 from "fs";
 var HOOKS = [
   {
     id: "session-end",
@@ -12430,11 +12587,11 @@ async function hooksCommand(options) {
         console.log(chalk20.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
-    if (fs42.existsSync(".claude")) {
+    if (fs43.existsSync(".claude")) {
       const r = installLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Claude Code learning hooks enabled");
     }
-    if (fs42.existsSync(".cursor")) {
+    if (fs43.existsSync(".cursor")) {
       const r = installCursorLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Cursor learning hooks enabled");
     }
@@ -12602,7 +12759,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs46 from "fs";
+import fs47 from "fs";
 import path38 from "path";
 import chalk23 from "chalk";
 
@@ -12634,7 +12791,7 @@ function readStdin() {
 }
 
 // src/learner/storage.ts
-import fs43 from "fs";
+import fs44 from "fs";
 import path35 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var MAX_PROMPT_LENGTH = 2e3;
@@ -12646,8 +12803,8 @@ var DEFAULT_STATE = {
   lastAnalysisEventCount: 0
 };
 function ensureLearningDir() {
-  if (!fs43.existsSync(getLearningDir())) {
-    fs43.mkdirSync(getLearningDir(), { recursive: true });
+  if (!fs44.existsSync(getLearningDir())) {
+    fs44.mkdirSync(getLearningDir(), { recursive: true });
   }
 }
 function sessionFilePath() {
@@ -12663,9 +12820,9 @@ function truncateResponse(response) {
 }
 function trimSessionFileIfNeeded(filePath) {
   try {
-    const stat = fs43.statSync(filePath);
+    const stat = fs44.statSync(filePath);
     if (stat.size > MAX_SESSION_FILE_BYTES) {
-      fs43.writeFileSync(filePath, "");
+      fs44.writeFileSync(filePath, "");
       resetState();
       return;
     }
@@ -12674,10 +12831,10 @@ function trimSessionFileIfNeeded(filePath) {
   }
   const state = readState2();
   if (state.eventCount + 1 > LEARNING_MAX_EVENTS) {
-    const lines = fs43.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs44.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     if (lines.length > LEARNING_MAX_EVENTS) {
       const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-      fs43.writeFileSync(filePath, kept.join("\n") + "\n");
+      fs44.writeFileSync(filePath, kept.join("\n") + "\n");
     }
   }
 }
@@ -12685,7 +12842,7 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs43.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs44.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   trimSessionFileIfNeeded(filePath);
 }
 function appendPromptEvent(event) {
@@ -12695,22 +12852,22 @@ function appendPromptEvent(event) {
     prompt_content: event.prompt_content.length > MAX_PROMPT_LENGTH ? event.prompt_content.slice(0, MAX_PROMPT_LENGTH) : event.prompt_content
   };
   const filePath = sessionFilePath();
-  fs43.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs44.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   trimSessionFileIfNeeded(filePath);
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
   try {
-    const stat = fs43.statSync(filePath);
+    const stat = fs44.statSync(filePath);
     if (stat.size > MAX_SESSION_FILE_BYTES) {
-      fs43.writeFileSync(filePath, "");
+      fs44.writeFileSync(filePath, "");
       resetState();
       return [];
     }
   } catch {
     return [];
   }
-  const lines = fs43.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  const lines = fs44.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -12723,33 +12880,33 @@ function readAllEvents() {
 function getEventCount() {
   const filePath = sessionFilePath();
   try {
-    const stat = fs43.statSync(filePath);
+    const stat = fs44.statSync(filePath);
     if (stat.size > MAX_SESSION_FILE_BYTES) return 0;
   } catch {
     return 0;
   }
-  const content = fs43.readFileSync(filePath, "utf-8");
+  const content = fs44.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
   try {
-    fs43.writeFileSync(filePath, "");
+    fs44.writeFileSync(filePath, "");
   } catch {
   }
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs43.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs44.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs43.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs44.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs43.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs44.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -12762,11 +12919,11 @@ function lockFilePath() {
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs43.existsSync(lockPath)) {
+  if (fs44.existsSync(lockPath)) {
     try {
-      const stat = fs43.statSync(lockPath);
+      const stat = fs44.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
-        const pid = parseInt(fs43.readFileSync(lockPath, "utf-8").trim(), 10);
+        const pid = parseInt(fs44.readFileSync(lockPath, "utf-8").trim(), 10);
         if (!isNaN(pid) && isProcessAlive(pid)) {
           return false;
         }
@@ -12774,12 +12931,12 @@ function acquireFinalizeLock() {
     } catch {
     }
     try {
-      fs43.unlinkSync(lockPath);
+      fs44.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    fs43.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs44.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -12796,13 +12953,13 @@ function isProcessAlive(pid) {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs43.existsSync(lockPath)) fs43.unlinkSync(lockPath);
+    if (fs44.existsSync(lockPath)) fs44.unlinkSync(lockPath);
   } catch {
   }
 }
 
 // src/lib/notifications.ts
-import fs44 from "fs";
+import fs45 from "fs";
 import path36 from "path";
 import chalk22 from "chalk";
 function notificationFilePath() {
@@ -12811,15 +12968,15 @@ function notificationFilePath() {
 function writeFinalizeSummary(summary) {
   try {
     ensureLearningDir();
-    fs44.writeFileSync(notificationFilePath(), JSON.stringify(summary, null, 2));
+    fs45.writeFileSync(notificationFilePath(), JSON.stringify(summary, null, 2));
   } catch {
   }
 }
 function checkPendingNotifications() {
   try {
-    if (!fs44.existsSync(notificationFilePath())) return;
-    const raw = fs44.readFileSync(notificationFilePath(), "utf-8");
-    fs44.unlinkSync(notificationFilePath());
+    if (!fs45.existsSync(notificationFilePath())) return;
+    const raw = fs45.readFileSync(notificationFilePath(), "utf-8");
+    fs45.unlinkSync(notificationFilePath());
     const summary = JSON.parse(raw);
     if (!summary.newItemCount || summary.newItemCount === 0) return;
     const wasteLabel = summary.wasteTokens > 0 ? ` (~${summary.wasteTokens.toLocaleString()} wasted tokens captured)` : "";
@@ -12835,7 +12992,7 @@ function checkPendingNotifications() {
     console.log("");
   } catch {
     try {
-      fs44.unlinkSync(notificationFilePath());
+      fs45.unlinkSync(notificationFilePath());
     } catch {
     }
   }
@@ -12987,7 +13144,7 @@ function calculateSessionWaste(events) {
 init_config();
 
 // src/learner/roi.ts
-import fs45 from "fs";
+import fs46 from "fs";
 import path37 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
@@ -13006,15 +13163,15 @@ function roiFilePath() {
 }
 function readROIStats() {
   const filePath = roiFilePath();
-  if (!fs45.existsSync(filePath)) {
+  if (!fs46.existsSync(filePath)) {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
   try {
-    return JSON.parse(fs45.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs46.readFileSync(filePath, "utf-8"));
   } catch {
     try {
       const corruptPath = filePath + ".corrupt";
-      fs45.renameSync(filePath, corruptPath);
+      fs46.renameSync(filePath, corruptPath);
       console.error(`caliber: roi-stats.json was corrupt \u2014 renamed to ${corruptPath}`);
     } catch {
     }
@@ -13023,7 +13180,7 @@ function readROIStats() {
 }
 function writeROIStats(stats) {
   ensureLearningDir();
-  fs45.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
+  fs46.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
 }
 function recalculateTotals(stats) {
   const totals = stats.totals;
@@ -13233,20 +13390,27 @@ var INCREMENTAL_INTERVAL = 50;
 function writeFinalizeError(message) {
   try {
     const errorPath = path38.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
-    if (!fs46.existsSync(getLearningDir())) fs46.mkdirSync(getLearningDir(), { recursive: true });
-    fs46.writeFileSync(errorPath, JSON.stringify({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      error: message,
-      pid: process.pid
-    }, null, 2));
+    if (!fs47.existsSync(getLearningDir())) fs47.mkdirSync(getLearningDir(), { recursive: true });
+    fs47.writeFileSync(
+      errorPath,
+      JSON.stringify(
+        {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          error: message,
+          pid: process.pid
+        },
+        null,
+        2
+      )
+    );
   } catch {
   }
 }
 function readFinalizeError() {
   try {
     const errorPath = path38.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
-    if (!fs46.existsSync(errorPath)) return null;
-    return JSON.parse(fs46.readFileSync(errorPath, "utf-8"));
+    if (!fs47.existsSync(errorPath)) return null;
+    return JSON.parse(fs47.readFileSync(errorPath, "utf-8"));
   } catch {
     return null;
   }
@@ -13294,17 +13458,19 @@ async function learnObserveCommand(options) {
     const eventsSinceLastAnalysis = state.eventCount - (state.lastAnalysisEventCount || 0);
     if (eventsSinceLastAnalysis >= INCREMENTAL_INTERVAL) {
       try {
-        const { resolveCaliber: resolveCaliber2 } = await Promise.resolve().then(() => (init_resolve_caliber(), resolve_caliber_exports));
+        const { resolveCaliber: resolveCaliber2, isNpxResolution: isNpxResolution2 } = await Promise.resolve().then(() => (init_resolve_caliber(), resolve_caliber_exports));
         const bin = resolveCaliber2();
         const { spawn: spawn4 } = await import("child_process");
         const logPath = path38.join(getLearningDir(), LEARNING_FINALIZE_LOG);
-        if (!fs46.existsSync(getLearningDir())) fs46.mkdirSync(getLearningDir(), { recursive: true });
-        const logFd = fs46.openSync(logPath, "a");
-        spawn4(bin, ["learn", "finalize", "--auto", "--incremental"], {
+        if (!fs47.existsSync(getLearningDir())) fs47.mkdirSync(getLearningDir(), { recursive: true });
+        const logFd = fs47.openSync(logPath, "a");
+        const NPX_SUFFIX = " --yes @rely-ai/caliber";
+        const [exe, binArgs] = isNpxResolution2() ? [bin.slice(0, -NPX_SUFFIX.length) || "npx", ["--yes", "@rely-ai/caliber"]] : [bin, []];
+        spawn4(exe, [...binArgs, "learn", "finalize", "--auto", "--incremental"], {
           detached: true,
           stdio: ["ignore", logFd, logFd]
         }).unref();
-        fs46.closeSync(logFd);
+        fs47.closeSync(logFd);
       } catch {
       }
     }
@@ -13317,7 +13483,8 @@ async function learnFinalizeCommand(options) {
   if (!options?.force && !isAuto) {
     const { isCaliberRunning: isCaliberRunning2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
     if (isCaliberRunning2()) {
-      if (!isAuto) console.log(chalk23.dim("caliber: skipping finalize \u2014 another caliber process is running"));
+      if (!isAuto)
+        console.log(chalk23.dim("caliber: skipping finalize \u2014 another caliber process is running"));
       return;
     }
   }
@@ -13325,7 +13492,8 @@ async function learnFinalizeCommand(options) {
     await new Promise((r) => setTimeout(r, AUTO_SETTLE_MS));
   }
   if (!acquireFinalizeLock()) {
-    if (!isAuto) console.log(chalk23.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
+    if (!isAuto)
+      console.log(chalk23.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
     return;
   }
   let analyzed = false;
@@ -13333,7 +13501,11 @@ async function learnFinalizeCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (isAuto) return;
-      console.log(chalk23.yellow(`caliber: no LLM provider configured \u2014 run \`${resolveCaliber()} config\` first`));
+      console.log(
+        chalk23.yellow(
+          `caliber: no LLM provider configured \u2014 run \`${resolveCaliber()} config\` first`
+        )
+      );
       clearSession();
       resetState();
       return;
@@ -13341,7 +13513,12 @@ async function learnFinalizeCommand(options) {
     const allEvents = readAllEvents();
     const threshold = isAuto ? MIN_EVENTS_AUTO : MIN_EVENTS_FOR_ANALYSIS;
     if (allEvents.length < threshold) {
-      if (!isAuto) console.log(chalk23.dim(`caliber: ${allEvents.length}/${threshold} events recorded \u2014 need more before analysis`));
+      if (!isAuto)
+        console.log(
+          chalk23.dim(
+            `caliber: ${allEvents.length}/${threshold} events recorded \u2014 need more before analysis`
+          )
+        );
       return;
     }
     await validateModel({ fast: true });
@@ -13350,7 +13527,12 @@ async function learnFinalizeCommand(options) {
     const analysisOffset = isIncremental ? state.lastAnalysisEventCount || 0 : 0;
     const events = analysisOffset > 0 ? allEvents.slice(analysisOffset) : allEvents;
     if (events.length < threshold) {
-      if (!isAuto) console.log(chalk23.dim(`caliber: ${events.length}/${threshold} new events since last analysis \u2014 need more`));
+      if (!isAuto)
+        console.log(
+          chalk23.dim(
+            `caliber: ${events.length}/${threshold} new events since last analysis \u2014 need more`
+          )
+        );
       return;
     }
     const existingConfigs = readExistingConfigs(process.cwd());
@@ -13386,7 +13568,11 @@ async function learnFinalizeCommand(options) {
           });
         } else {
           const wasteLabel = waste.totalWasteTokens > 0 ? ` (~${waste.totalWasteTokens.toLocaleString()} wasted tokens captured)` : "";
-          console.log(chalk23.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}${wasteLabel}`));
+          console.log(
+            chalk23.dim(
+              `caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}${wasteLabel}`
+            )
+          );
           for (const item of result.newItems) {
             console.log(chalk23.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
           }
@@ -13481,12 +13667,20 @@ async function learnFinalizeCommand(options) {
     if (!isIncremental) {
       const staleLearnings = findStaleLearnings(roiStats);
       if (staleLearnings.length > 0 && !isAuto) {
-        console.log(chalk23.yellow(`caliber: ${staleLearnings.length} learning${staleLearnings.length === 1 ? "" : "s"} never activated \u2014 run \`${resolveCaliber()} learn list --verbose\` to review`));
+        console.log(
+          chalk23.yellow(
+            `caliber: ${staleLearnings.length} learning${staleLearnings.length === 1 ? "" : "s"} never activated \u2014 run \`${resolveCaliber()} learn list --verbose\` to review`
+          )
+        );
       }
     }
     if (!isAuto && t.estimatedSavingsTokens > 0) {
       const totalLearnings = existingLearnedItems + newLearningsProduced;
-      console.log(chalk23.dim(`caliber: ${totalLearnings} learnings active \u2014 est. ~${t.estimatedSavingsTokens.toLocaleString()} tokens saved across ${t.totalSessionsWithLearnings} sessions`));
+      console.log(
+        chalk23.dim(
+          `caliber: ${totalLearnings} learnings active \u2014 est. ~${t.estimatedSavingsTokens.toLocaleString()} tokens saved across ${t.totalSessionsWithLearnings} sessions`
+        )
+      );
     }
   } catch (err) {
     const errorMsg = err instanceof Error ? err.message : String(err);
@@ -13511,7 +13705,7 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs46.existsSync(".claude")) {
+  if (fs47.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Claude Code learning hooks installed");
@@ -13520,7 +13714,7 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs46.existsSync(".cursor")) {
+  if (fs47.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Cursor learning hooks installed");
@@ -13529,13 +13723,19 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs46.existsSync(".claude") && !fs46.existsSync(".cursor")) {
+  if (!fs47.existsSync(".claude") && !fs47.existsSync(".cursor")) {
     console.log(chalk23.yellow("No .claude/ or .cursor/ directory found."));
-    console.log(chalk23.dim(`  Run \`${resolveCaliber()} init\` first, or create the directory manually.`));
+    console.log(
+      chalk23.dim(`  Run \`${resolveCaliber()} init\` first, or create the directory manually.`)
+    );
     return;
   }
   if (anyInstalled) {
-    console.log(chalk23.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
+    console.log(
+      chalk23.dim(
+        `  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`
+      )
+    );
     console.log(chalk23.dim("  Learnings written to CALIBER_LEARNINGS.md."));
   }
 }
@@ -13573,7 +13773,9 @@ async function learnStatusCommand() {
     console.log(chalk23.dim("\u2717") + " Cursor hooks " + chalk23.dim("not installed"));
   }
   if (!claudeInstalled && !cursorInstalled) {
-    console.log(chalk23.dim(`  Run \`${resolveCaliber()} learn install\` to enable session learning.`));
+    console.log(
+      chalk23.dim(`  Run \`${resolveCaliber()} learn install\` to enable session learning.`)
+    );
   }
   console.log();
   console.log(`Events recorded: ${chalk23.cyan(String(eventCount))}`);
@@ -13588,7 +13790,7 @@ async function learnStatusCommand() {
     console.log(`Last error: ${chalk23.red(lastError.error)}`);
     console.log(chalk23.dim(`  at ${lastError.timestamp}`));
     const logPath = path38.join(getLearningDir(), LEARNING_FINALIZE_LOG);
-    if (fs46.existsSync(logPath)) {
+    if (fs47.existsSync(logPath)) {
       console.log(chalk23.dim(`  Full log: ${logPath}`));
     }
   }
@@ -13657,7 +13859,11 @@ async function learnListCommand(options) {
 async function learnDeleteCommand(indexStr) {
   const index = parseInt(indexStr, 10);
   if (isNaN(index) || index < 1) {
-    console.log(chalk23.red(`Invalid index: "${indexStr}". Use a number from \`${resolveCaliber()} learn list\`.`));
+    console.log(
+      chalk23.red(
+        `Invalid index: "${indexStr}". Use a number from \`${resolveCaliber()} learn list\`.`
+      )
+    );
     return;
   }
   const items = getAllLearnings();
@@ -13668,11 +13874,11 @@ async function learnDeleteCommand(indexStr) {
   }
   const item = items[targetIdx];
   const filePath = item.source === "personal" ? PERSONAL_LEARNINGS_FILE : "CALIBER_LEARNINGS.md";
-  if (!fs46.existsSync(filePath)) {
+  if (!fs47.existsSync(filePath)) {
     console.log(chalk23.red("Learnings file not found."));
     return;
   }
-  const content = fs46.readFileSync(filePath, "utf-8");
+  const content = fs47.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const bulletsOfSource = items.filter((i) => i.source === item.source);
   const posInFile = bulletsOfSource.indexOf(item);
@@ -13693,9 +13899,9 @@ async function learnDeleteCommand(indexStr) {
   }
   const bulletToRemove = lines[lineToRemove];
   const newLines = lines.filter((_, i) => i !== lineToRemove);
-  fs46.writeFileSync(filePath, newLines.join("\n"));
+  fs47.writeFileSync(filePath, newLines.join("\n"));
   if (item.source === "personal") {
-    fs46.chmodSync(filePath, 384);
+    fs47.chmodSync(filePath, 384);
   }
   const roiStats = readROIStats();
   const cleanText = bulletToRemove.replace(/^- /, "").replace(/^\*\*\[[^\]]+\]\*\*\s*/, "").trim();
@@ -13868,7 +14074,7 @@ async function insightsCommand(options) {
 }
 
 // src/commands/sources.ts
-import fs47 from "fs";
+import fs48 from "fs";
 import path39 from "path";
 import chalk25 from "chalk";
 init_resolve_caliber();
@@ -13886,9 +14092,9 @@ async function sourcesListCommand() {
   if (configSources.length > 0) {
     for (const source of configSources) {
       const sourcePath = source.path || source.url || "";
-      const exists = source.path ? fs47.existsSync(path39.resolve(dir, source.path)) : false;
+      const exists = source.path ? fs48.existsSync(path39.resolve(dir, source.path)) : false;
       const status = exists ? chalk25.green("reachable") : chalk25.red("not found");
-      const hasSummary = source.path && fs47.existsSync(path39.join(path39.resolve(dir, source.path), ".caliber", "summary.json"));
+      const hasSummary = source.path && fs48.existsSync(path39.join(path39.resolve(dir, source.path), ".caliber", "summary.json"));
       console.log(`  ${chalk25.bold(source.role || source.type)}  ${chalk25.dim(sourcePath)}`);
       console.log(`    Type: ${source.type}  Status: ${status}${hasSummary ? "  " + chalk25.cyan("has summary.json") : ""}`);
       if (source.description) console.log(`    ${chalk25.dim(source.description)}`);
@@ -13898,7 +14104,7 @@ async function sourcesListCommand() {
   if (workspaces.length > 0) {
     console.log(chalk25.dim("  Auto-detected workspaces:"));
     for (const ws of workspaces) {
-      const exists = fs47.existsSync(path39.resolve(dir, ws));
+      const exists = fs48.existsSync(path39.resolve(dir, ws));
       console.log(`    ${exists ? chalk25.green("\u25CF") : chalk25.red("\u25CF")} ${ws}`);
     }
     console.log("");
@@ -13907,7 +14113,7 @@ async function sourcesListCommand() {
 async function sourcesAddCommand(sourcePath) {
   const dir = process.cwd();
   const absPath = path39.resolve(dir, sourcePath);
-  if (!fs47.existsSync(absPath)) {
+  if (!fs48.existsSync(absPath)) {
     console.log(chalk25.red(`
   Path not found: ${sourcePath}
 `));
@@ -13970,7 +14176,7 @@ async function sourcesRemoveCommand(name) {
 }
 
 // src/commands/publish.ts
-import fs48 from "fs";
+import fs49 from "fs";
 import path40 from "path";
 import chalk26 from "chalk";
 import ora7 from "ora";
@@ -14015,11 +14221,11 @@ async function publishCommand() {
     } catch {
     }
     const outputDir = path40.join(dir, ".caliber");
-    if (!fs48.existsSync(outputDir)) {
-      fs48.mkdirSync(outputDir, { recursive: true });
+    if (!fs49.existsSync(outputDir)) {
+      fs49.mkdirSync(outputDir, { recursive: true });
     }
     const outputPath = path40.join(outputDir, "summary.json");
-    fs48.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+    fs49.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
     spinner.succeed("Project summary published");
     console.log(`  ${chalk26.green("\u2713")} ${path40.relative(dir, outputPath)}`);
     console.log(chalk26.dim("\n  Other projects can now reference this repo as a source."));
@@ -14034,7 +14240,7 @@ async function publishCommand() {
 
 // src/commands/bootstrap.ts
 init_builtin_skills();
-import fs49 from "fs";
+import fs50 from "fs";
 import chalk27 from "chalk";
 var PLATFORM_SKILL_DIRS = {
   claude: ".claude/skills",
@@ -14055,8 +14261,8 @@ async function bootstrapCommand() {
     for (const skill of BUILTIN_SKILLS) {
       const skillDir = `${skillsDir}/${skill.name}`;
       const skillPath = `${skillDir}/SKILL.md`;
-      fs49.mkdirSync(skillDir, { recursive: true });
-      fs49.writeFileSync(skillPath, buildSkillContent(skill));
+      fs50.mkdirSync(skillDir, { recursive: true });
+      fs50.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -14073,7 +14279,7 @@ async function bootstrapCommand() {
 }
 
 // src/commands/uninstall.ts
-import fs50 from "fs";
+import fs51 from "fs";
 import path41 from "path";
 import chalk28 from "chalk";
 import confirm3 from "@inquirer/confirm";
@@ -14090,11 +14296,11 @@ var CURSOR_RULES_DIR = path41.join(".cursor", "rules");
 var CLAUDE_RULES_DIR = path41.join(".claude", "rules");
 function removeCaliberManagedFiles(dir, extension) {
   const removed = [];
-  if (!fs50.existsSync(dir)) return removed;
-  for (const file of fs50.readdirSync(dir)) {
+  if (!fs51.existsSync(dir)) return removed;
+  for (const file of fs51.readdirSync(dir)) {
     if (file.startsWith(CALIBER_MANAGED_PREFIX) && file.endsWith(extension)) {
       const fullPath = path41.join(dir, file);
-      fs50.unlinkSync(fullPath);
+      fs51.unlinkSync(fullPath);
       removed.push(fullPath);
     }
   }
@@ -14103,11 +14309,11 @@ function removeCaliberManagedFiles(dir, extension) {
 function removeBuiltinSkills() {
   const removed = [];
   for (const skillsDir of SKILL_DIRS) {
-    if (!fs50.existsSync(skillsDir)) continue;
+    if (!fs51.existsSync(skillsDir)) continue;
     for (const name of BUILTIN_SKILL_NAMES) {
       const skillDir = path41.join(skillsDir, name);
-      if (fs50.existsSync(skillDir)) {
-        fs50.rmSync(skillDir, { recursive: true });
+      if (fs51.existsSync(skillDir)) {
+        fs51.rmSync(skillDir, { recursive: true });
         removed.push(skillDir);
       }
     }
@@ -14117,15 +14323,15 @@ function removeBuiltinSkills() {
 function stripManagedBlocksFromFiles() {
   const modified = [];
   for (const filePath of MANAGED_DOC_FILES) {
-    if (!fs50.existsSync(filePath)) continue;
-    const original = fs50.readFileSync(filePath, "utf-8");
+    if (!fs51.existsSync(filePath)) continue;
+    const original = fs51.readFileSync(filePath, "utf-8");
     const stripped = stripManagedBlocks(original);
     if (stripped !== original) {
       const trimmed = stripped.trim();
       if (!trimmed || /^#\s*\S*$/.test(trimmed)) {
-        fs50.unlinkSync(filePath);
+        fs51.unlinkSync(filePath);
       } else {
-        fs50.writeFileSync(filePath, stripped);
+        fs51.writeFileSync(filePath, stripped);
       }
       modified.push(filePath);
     }
@@ -14133,8 +14339,8 @@ function stripManagedBlocksFromFiles() {
   return modified;
 }
 function removeDirectory(dir) {
-  if (!fs50.existsSync(dir)) return false;
-  fs50.rmSync(dir, { recursive: true });
+  if (!fs51.existsSync(dir)) return false;
+  fs51.rmSync(dir, { recursive: true });
   return true;
 }
 async function uninstallCommand(options) {
@@ -14206,8 +14412,8 @@ async function uninstallCommand(options) {
     console.log(`  ${chalk28.red("\u2717")} ${skill}/`);
   }
   if (removedSkills.length > 0) actions.push("builtin skills");
-  if (fs50.existsSync("CALIBER_LEARNINGS.md")) {
-    fs50.unlinkSync("CALIBER_LEARNINGS.md");
+  if (fs51.existsSync("CALIBER_LEARNINGS.md")) {
+    fs51.unlinkSync("CALIBER_LEARNINGS.md");
     console.log(`  ${chalk28.red("\u2717")} CALIBER_LEARNINGS.md`);
     actions.push("learnings file");
   }
@@ -14221,18 +14427,18 @@ async function uninstallCommand(options) {
   }
   trackUninstallExecuted();
   const configPath = getConfigFilePath();
-  if (fs50.existsSync(configPath)) {
+  if (fs51.existsSync(configPath)) {
     console.log("");
     const removeConfig = options.force || await confirm3({
       message: `Remove global config (~/.caliber/config.json)? This affects all projects.`
     });
     if (removeConfig) {
-      fs50.unlinkSync(configPath);
+      fs51.unlinkSync(configPath);
       console.log(`  ${chalk28.red("\u2717")} ${configPath}`);
       const configDir = path41.dirname(configPath);
       try {
-        const remaining = fs50.readdirSync(configDir);
-        if (remaining.length === 0) fs50.rmdirSync(configDir);
+        const remaining = fs51.readdirSync(configDir);
+        if (remaining.length === 0) fs51.rmdirSync(configDir);
       } catch {
       }
     }
@@ -14244,7 +14450,7 @@ async function uninstallCommand(options) {
 
 // src/cli.ts
 var __dirname = path42.dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(fs51.readFileSync(path42.resolve(__dirname, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(fs52.readFileSync(path42.resolve(__dirname, "..", "package.json"), "utf-8"));
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
 program.name(process.env.CALIBER_LOCAL ? "caloc" : "caliber").description("AI context infrastructure for coding agents").version(displayVersion).option("--no-traces", "Disable anonymous telemetry for this run");
@@ -14355,15 +14561,15 @@ learn.command("delete <index>").description("Delete a learning by its index numb
 learn.command("add <content>").description("Add a learning directly (used by agent skills)").option("--personal", "Save as a personal learning instead of project-level").action(tracked("learn:add", learnAddCommand));
 
 // src/utils/version-check.ts
-import fs52 from "fs";
+import fs53 from "fs";
 import path43 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync16, execFileSync as execFileSync3 } from "child_process";
+import { execSync as execSync16, execFileSync as execFileSync5 } from "child_process";
 import chalk29 from "chalk";
 import ora8 from "ora";
 import confirm4 from "@inquirer/confirm";
 var __dirname_vc = path43.dirname(fileURLToPath2(import.meta.url));
-var pkg2 = JSON.parse(fs52.readFileSync(path43.resolve(__dirname_vc, "..", "package.json"), "utf-8"));
+var pkg2 = JSON.parse(fs53.readFileSync(path43.resolve(__dirname_vc, "..", "package.json"), "utf-8"));
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
   return match ? match[1] : "latest";
@@ -14391,7 +14597,7 @@ function getInstalledVersion() {
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     const pkgPath = path43.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs52.readFileSync(pkgPath, "utf-8")).version;
+    return JSON.parse(fs53.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -14439,7 +14645,7 @@ Update available: ${current} -> ${latest}`));
     if (!/^[\w.-]+$/.test(tag)) return;
     const spinner = ora8("Updating caliber...").start();
     try {
-      execFileSync3("npm", ["install", "-g", `@rely-ai/caliber@${tag}`], {
+      execFileSync5("npm", ["install", "-g", `@rely-ai/caliber@${tag}`], {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -14458,7 +14664,7 @@ Update available: ${current} -> ${latest}`));
       console.log(chalk29.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execFileSync3("caliber", args, {
+      execFileSync5("caliber", args, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });