npm - @rely-ai/caliber - Versions diffs - 1.22.1 → 1.23.0-dev.1773793983 - Mend

@rely-ai/caliber 1.22.1 → 1.23.0-dev.1773793983

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/bin.js +662 -534
package/package.json +1 -1

package/dist/bin.js CHANGED Viewed

@@ -25,9 +25,11 @@ var config_exports = {};
 __export(config_exports, {
   DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
   DEFAULT_MODELS: () => DEFAULT_MODELS,
+  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
   getConfigFilePath: () => getConfigFilePath,
   getDisplayModel: () => getDisplayModel,
   getFastModel: () => getFastModel,
+  getMaxPromptTokens: () => getMaxPromptTokens,
   loadConfig: () => loadConfig,
   readConfigFile: () => readConfigFile,
   resolveFromEnv: () => resolveFromEnv,
@@ -36,6 +38,13 @@ __export(config_exports, {
 import fs4 from "fs";
 import path4 from "path";
 import os from "os";
+function getMaxPromptTokens() {
+  const config = loadConfig();
+  const model = process.env.CALIBER_MODEL || config?.model;
+  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
+  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
+  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
+}
 function loadConfig() {
   const envConfig = resolveFromEnv();
   if (envConfig) return envConfig;
@@ -123,7 +132,7 @@ function getFastModel() {
   if (provider) return DEFAULT_FAST_MODELS[provider];
   return void 0;
 }
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, DEFAULT_FAST_MODELS;
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
 var init_config = __esm({
   "src/llm/config.ts"() {
     "use strict";
@@ -136,6 +145,21 @@ var init_config = __esm({
       cursor: "sonnet-4.6",
       "claude-cli": "default"
     };
+    MODEL_CONTEXT_WINDOWS = {
+      "claude-sonnet-4-6": 2e5,
+      "claude-opus-4-6": 2e5,
+      "claude-haiku-4-5-20251001": 2e5,
+      "claude-sonnet-4-5-20250514": 2e5,
+      "gpt-4.1": 1e6,
+      "gpt-4.1-mini": 1e6,
+      "gpt-4o": 128e3,
+      "gpt-4o-mini": 128e3,
+      "sonnet-4.6": 2e5
+    };
+    DEFAULT_CONTEXT_WINDOW = 2e5;
+    INPUT_BUDGET_FRACTION = 0.6;
+    MAX_PROMPT_TOKENS_CAP = 3e5;
+    MIN_PROMPT_TOKENS = 3e4;
     DEFAULT_FAST_MODELS = {
       anthropic: "claude-haiku-4-5-20251001",
       vertex: "claude-haiku-4-5-20251001",
@@ -158,17 +182,17 @@ __export(constants_exports, {
   LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
-import path9 from "path";
+import path10 from "path";
 import os3 from "os";
 var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS, LEARNING_ROI_FILE;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    AUTH_DIR = path9.join(os3.homedir(), ".caliber");
+    AUTH_DIR = path10.join(os3.homedir(), ".caliber");
     CALIBER_DIR = ".caliber";
-    MANIFEST_FILE = path9.join(CALIBER_DIR, "manifest.json");
-    BACKUPS_DIR = path9.join(CALIBER_DIR, "backups");
-    LEARNING_DIR = path9.join(CALIBER_DIR, "learning");
+    MANIFEST_FILE = path10.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path10.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path10.join(CALIBER_DIR, "learning");
     LEARNING_SESSION_FILE = "current-session.jsonl";
     LEARNING_STATE_FILE = "state.json";
     LEARNING_MAX_EVENTS = 500;
@@ -183,13 +207,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs29 from "fs";
-import path23 from "path";
+import fs30 from "fs";
+import path24 from "path";
 import os6 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs29.existsSync(LOCK_FILE)) return false;
-    const raw = fs29.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs30.existsSync(LOCK_FILE)) return false;
+    const raw = fs30.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -204,13 +228,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs29.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs30.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs29.existsSync(LOCK_FILE)) fs29.unlinkSync(LOCK_FILE);
+    if (fs30.existsSync(LOCK_FILE)) fs30.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -218,28 +242,28 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path23.join(os6.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path24.join(os6.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 // src/cli.ts
 import { Command } from "commander";
-import fs34 from "fs";
-import path27 from "path";
+import fs35 from "fs";
+import path28 from "path";
 import { fileURLToPath } from "url";
 // src/commands/init.ts
-import path20 from "path";
+import path21 from "path";
 import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs25 from "fs";
+import fs26 from "fs";
 // src/fingerprint/index.ts
-import fs6 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path6 from "path";
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -292,15 +316,23 @@ function getFileTree(dir, maxDepth = 3) {
   for (const e of entries) {
     (e.isDir ? dirs : files).push(e);
   }
-  for (const d of dirs) {
-    const prefix = d.relPath;
-    let maxChildMtime = d.mtime;
-    for (const f of files) {
-      if (f.relPath.startsWith(prefix) && f.mtime > maxChildMtime) {
-        maxChildMtime = f.mtime;
+  const dirMaxMtime = /* @__PURE__ */ new Map();
+  for (const d of dirs) dirMaxMtime.set(d.relPath, d.mtime);
+  for (const f of files) {
+    let remaining = f.relPath;
+    while (true) {
+      const lastSlash = remaining.lastIndexOf("/");
+      if (lastSlash === -1) break;
+      const dirPrefix = remaining.slice(0, lastSlash + 1);
+      const current = dirMaxMtime.get(dirPrefix);
+      if (current !== void 0 && f.mtime > current) {
+        dirMaxMtime.set(dirPrefix, f.mtime);
       }
+      remaining = remaining.slice(0, lastSlash);
     }
-    d.mtime = maxChildMtime;
+  }
+  for (const d of dirs) {
+    d.mtime = dirMaxMtime.get(d.relPath) ?? d.mtime;
   }
   dirs.sort((a, b) => b.mtime - a.mtime);
   files.sort((a, b) => b.mtime - a.mtime);
@@ -2212,12 +2244,112 @@ async function detectProjectStack(fileTree, suffixCounts) {
 // src/fingerprint/index.ts
 init_config();
+// src/fingerprint/cache.ts
+import fs6 from "fs";
+import path5 from "path";
+import crypto from "crypto";
+import { execSync as execSync5 } from "child_process";
+var CACHE_VERSION = 1;
+var CACHE_DIR = ".caliber/cache";
+var CACHE_FILE = "fingerprint.json";
+function getCachePath(dir) {
+  return path5.join(dir, CACHE_DIR, CACHE_FILE);
+}
+function getGitHead(dir) {
+  try {
+    return execSync5("git rev-parse HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e3
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function getDirtySignature(dir) {
+  try {
+    const output = execSync5("git diff --name-only HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e3
+    }).trim();
+    return output.split("\n").slice(0, 100).join("\n");
+  } catch {
+    return "";
+  }
+}
+function computeTreeSignature(fileTree, dir) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fileTree.join("\0"));
+  hash.update("\n");
+  hash.update(getDirtySignature(dir));
+  return hash.digest("hex").slice(0, 16);
+}
+function loadFingerprintCache(dir, fileTree) {
+  const cachePath = getCachePath(dir);
+  try {
+    if (!fs6.existsSync(cachePath)) return null;
+    const raw = fs6.readFileSync(cachePath, "utf-8");
+    const cache = JSON.parse(raw);
+    if (cache.version !== CACHE_VERSION) return null;
+    const currentHead = getGitHead(dir);
+    if (currentHead && cache.gitHead !== currentHead) return null;
+    const currentSig = computeTreeSignature(fileTree, dir);
+    if (cache.treeSignature !== currentSig) return null;
+    return {
+      codeAnalysis: cache.codeAnalysis,
+      languages: cache.languages,
+      frameworks: cache.frameworks,
+      tools: cache.tools
+    };
+  } catch {
+    return null;
+  }
+}
+function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks, tools) {
+  const cachePath = getCachePath(dir);
+  try {
+    const cacheDir = path5.dirname(cachePath);
+    if (!fs6.existsSync(cacheDir)) {
+      fs6.mkdirSync(cacheDir, { recursive: true });
+    }
+    const cache = {
+      version: CACHE_VERSION,
+      gitHead: getGitHead(dir),
+      treeSignature: computeTreeSignature(fileTree, dir),
+      codeAnalysis,
+      languages,
+      frameworks,
+      tools
+    };
+    fs6.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+  } catch {
+  }
+}
+// src/fingerprint/index.ts
 async function collectFingerprint(dir) {
   const gitRemoteUrl = getGitRemoteUrl();
   const fileTree = getFileTree(dir);
   const existingConfigs = readExistingConfigs(dir);
-  const codeAnalysis = analyzeCode(dir);
   const packageName = readPackageName(dir);
+  const cached = loadFingerprintCache(dir, fileTree);
+  if (cached) {
+    return {
+      gitRemoteUrl,
+      packageName,
+      languages: cached.languages,
+      frameworks: cached.frameworks,
+      tools: cached.tools,
+      fileTree,
+      existingConfigs,
+      codeAnalysis: cached.codeAnalysis
+    };
+  }
+  const codeAnalysis = analyzeCode(dir);
   const fingerprint = {
     gitRemoteUrl,
     packageName,
@@ -2229,13 +2361,21 @@ async function collectFingerprint(dir) {
     codeAnalysis
   };
   await enrichWithLLM(fingerprint);
+  saveFingerprintCache(
+    dir,
+    fileTree,
+    codeAnalysis,
+    fingerprint.languages,
+    fingerprint.frameworks,
+    fingerprint.tools
+  );
   return fingerprint;
 }
 function readPackageName(dir) {
   try {
-    const pkgPath = path5.join(dir, "package.json");
-    if (!fs6.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path6.join(dir, "package.json");
+    if (!fs7.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -2249,7 +2389,7 @@ async function enrichWithLLM(fingerprint) {
     const suffixCounts = {};
     for (const entry of fingerprint.fileTree) {
       if (entry.endsWith("/")) continue;
-      const ext = path5.extname(entry).toLowerCase();
+      const ext = path6.extname(entry).toLowerCase();
       if (ext) {
         suffixCounts[ext] = (suffixCounts[ext] || 0) + 1;
       }
@@ -2268,15 +2408,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path29) {
+function readFileOrNull(path30) {
   try {
-    return readFileSync(path29, "utf-8");
+    return readFileSync(path30, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path29) {
-  const content = readFileOrNull(path29);
+function readJsonOrNull(path30) {
+  const content = readFileOrNull(path30);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -2500,15 +2640,14 @@ Generate the skill content following the instructions in the system prompt.`;
     content
   };
 }
-async function generateCore(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
+async function streamGeneration(config) {
   const provider = getProvider();
-  const userMessage = buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks);
   let attempt = 0;
   const attemptGeneration = async () => {
     attempt++;
     const maxTokensForAttempt = Math.min(
-      CORE_MAX_TOKENS + attempt * 8e3,
-      GENERATION_MAX_TOKENS
+      config.baseMaxTokens + attempt * config.tokenIncrement,
+      config.maxTokensCap
     );
     return new Promise((resolve2) => {
       let preJsonBuffer = "";
@@ -2518,8 +2657,8 @@ async function generateCore(fingerprint, targetAgent, prompt, callbacks, failing
       let stopReason = null;
       provider.stream(
         {
-          system: CORE_GENERATION_PROMPT,
-          prompt: userMessage,
+          system: config.systemPrompt,
+          prompt: config.userMessage,
           maxTokens: maxTokensForAttempt
         },
         {
@@ -2532,7 +2671,7 @@ async function generateCore(fingerprint, targetAgent, prompt, callbacks, failing
                 const trimmed = completedLines[i].trim();
                 if (trimmed.startsWith("STATUS:")) {
                   const status = trimmed.slice(7).trim();
-                  if (status && callbacks) callbacks.onStatus(status);
+                  if (status && config.callbacks) config.callbacks.onStatus(status);
                 }
               }
               sentStatuses = completedLines.length;
@@ -2562,7 +2701,7 @@ async function generateCore(fingerprint, targetAgent, prompt, callbacks, failing
             } catch {
             }
             if (!setup && stopReason === "max_tokens" && attempt < MAX_RETRIES2) {
-              if (callbacks) callbacks.onStatus("Output was truncated, retrying with higher token limit...");
+              if (config.callbacks) config.callbacks.onStatus("Output was truncated, retrying with higher token limit...");
               setTimeout(() => attemptGeneration().then(resolve2), 1e3);
               return;
             }
@@ -2572,7 +2711,7 @@ async function generateCore(fingerprint, targetAgent, prompt, callbacks, failing
               explanation = explainMatch[1].trim();
             }
             if (setup) {
-              if (callbacks) callbacks.onComplete(setup, explanation);
+              if (config.callbacks) config.callbacks.onComplete(setup, explanation);
               resolve2({ setup, explanation, stopReason: stopReason ?? void 0 });
             } else {
               resolve2({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
@@ -2580,117 +2719,43 @@ async function generateCore(fingerprint, targetAgent, prompt, callbacks, failing
           },
           onError: (error) => {
             if (isTransientError2(error) && attempt < MAX_RETRIES2) {
-              if (callbacks) callbacks.onStatus("Connection interrupted, retrying...");
+              if (config.callbacks) config.callbacks.onStatus("Connection interrupted, retrying...");
               setTimeout(() => attemptGeneration().then(resolve2), 2e3);
               return;
             }
-            if (callbacks) callbacks.onError(error.message);
+            if (config.callbacks) config.callbacks.onError(error.message);
             resolve2({ setup: null, raw: error.message, stopReason: "error" });
           }
         }
       ).catch((error) => {
-        if (callbacks) callbacks.onError(error.message);
+        if (config.callbacks) config.callbacks.onError(error.message);
         resolve2({ setup: null, raw: error.message, stopReason: "error" });
       });
     });
   };
   return attemptGeneration();
 }
+async function generateCore(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
+  const userMessage = buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks);
+  return streamGeneration({
+    systemPrompt: CORE_GENERATION_PROMPT,
+    userMessage,
+    baseMaxTokens: CORE_MAX_TOKENS,
+    tokenIncrement: 8e3,
+    maxTokensCap: GENERATION_MAX_TOKENS,
+    callbacks
+  });
+}
 async function generateMonolithic(fingerprint, targetAgent, prompt, callbacks, failingChecks, currentScore, passingChecks) {
-  const provider = getProvider();
   const userMessage = buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks);
-  let attempt = 0;
-  const attemptGeneration = async () => {
-    attempt++;
-    const maxTokensForAttempt = Math.min(
-      GENERATION_MAX_TOKENS + attempt * 16e3,
-      MODEL_MAX_OUTPUT_TOKENS
-    );
-    return new Promise((resolve2) => {
-      let preJsonBuffer = "";
-      let jsonContent = "";
-      let inJson = false;
-      let sentStatuses = 0;
-      let stopReason = null;
-      provider.stream(
-        {
-          system: GENERATION_SYSTEM_PROMPT,
-          prompt: userMessage,
-          maxTokens: maxTokensForAttempt
-        },
-        {
-          onText: (text) => {
-            if (!inJson) {
-              preJsonBuffer += text;
-              const lines = preJsonBuffer.split("\n");
-              const completedLines = lines.slice(0, -1);
-              for (let i = sentStatuses; i < completedLines.length; i++) {
-                const trimmed = completedLines[i].trim();
-                if (trimmed.startsWith("STATUS:")) {
-                  const status = trimmed.slice(7).trim();
-                  if (status && callbacks) callbacks.onStatus(status);
-                }
-              }
-              sentStatuses = completedLines.length;
-              const jsonStartMatch = preJsonBuffer.match(/(?:^|\n)\s*(?:```json\s*\n\s*)?\{(?=\s*")/);
-              if (jsonStartMatch) {
-                const matchIndex = preJsonBuffer.indexOf("{", jsonStartMatch.index);
-                inJson = true;
-                jsonContent = preJsonBuffer.slice(matchIndex);
-              }
-            } else {
-              jsonContent += text;
-            }
-          },
-          onEnd: (meta) => {
-            stopReason = meta?.stopReason ?? null;
-            let setup = null;
-            let jsonToParse = (jsonContent || preJsonBuffer).replace(/```\s*$/g, "").trim();
-            if (!jsonContent && preJsonBuffer) {
-              const fallbackMatch = preJsonBuffer.match(/(?:^|\n)\s*(?:```json\s*\n\s*)?\{(?=\s*")/);
-              if (fallbackMatch) {
-                const matchIndex = preJsonBuffer.indexOf("{", fallbackMatch.index);
-                jsonToParse = preJsonBuffer.slice(matchIndex).replace(/```\s*$/g, "").trim();
-              }
-            }
-            try {
-              setup = JSON.parse(jsonToParse);
-            } catch {
-            }
-            if (!setup && stopReason === "max_tokens" && attempt < MAX_RETRIES2) {
-              if (callbacks) callbacks.onStatus("Output was truncated, retrying with higher token limit...");
-              setTimeout(() => attemptGeneration().then(resolve2), 1e3);
-              return;
-            }
-            let explanation;
-            const explainMatch = preJsonBuffer.match(/EXPLAIN:\s*\n([\s\S]*?)(?=\n\s*(`{3}|\{))/);
-            if (explainMatch) {
-              explanation = explainMatch[1].trim();
-            }
-            if (setup) {
-              if (callbacks) callbacks.onComplete(setup, explanation);
-              resolve2({ setup, explanation, stopReason: stopReason ?? void 0 });
-            } else {
-              resolve2({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
-            }
-          },
-          onError: (error) => {
-            if (isTransientError2(error) && attempt < MAX_RETRIES2) {
-              if (callbacks) callbacks.onStatus("Connection interrupted, retrying...");
-              setTimeout(() => attemptGeneration().then(resolve2), 2e3);
-              return;
-            }
-            if (callbacks) callbacks.onError(error.message);
-            resolve2({ setup: null, raw: error.message, stopReason: "error" });
-          }
-        }
-      ).catch((error) => {
-        if (callbacks) callbacks.onError(error.message);
-        resolve2({ setup: null, raw: error.message, stopReason: "error" });
-      });
-    });
-  };
-  return attemptGeneration();
+  return streamGeneration({
+    systemPrompt: GENERATION_SYSTEM_PROMPT,
+    userMessage,
+    baseMaxTokens: GENERATION_MAX_TOKENS,
+    tokenIncrement: 16e3,
+    maxTokensCap: MODEL_MAX_OUTPUT_TOKENS,
+    callbacks
+  });
 }
 async function generateSkillsForSetup(setup, fingerprint, targetAgent, onStatus) {
   const skillTopics = collectSkillTopics(setup, targetAgent, fingerprint);
@@ -2723,7 +2788,6 @@ async function generateSkillsForSetup(setup, fingerprint, targetAgent, onStatus)
   if (failed > 0) onStatus?.(`${succeeded} generated, ${failed} failed`);
   return succeeded;
 }
-var MAX_PROMPT_TOKENS = 12e4;
 var LIMITS = {
   FILE_TREE_ENTRIES: 500,
   EXISTING_CONFIG_CHARS: 8e3,
@@ -2738,6 +2802,7 @@ function truncate(text, maxChars) {
 }
 function sampleFileTree(fileTree, codeAnalysisPaths, limit) {
   if (fileTree.length <= limit) return fileTree;
+  const fileTreeSet = new Set(fileTree);
   const dirs = [];
   const rootFiles = [];
   const nestedFiles = [];
@@ -2763,7 +2828,7 @@ function sampleFileTree(fileTree, codeAnalysisPaths, limit) {
   for (const f of rootFiles.slice(0, 50)) add(f);
   for (const p of codeAnalysisPaths) {
     if (result.length >= limit) break;
-    if (fileTree.includes(p)) add(p);
+    if (fileTreeSet.has(p)) add(p);
   }
   for (const f of nestedFiles) {
     if (result.length >= limit) break;
@@ -2887,20 +2952,25 @@ User instructions: ${prompt}`);
   if (fingerprint.codeAnalysis) {
     const ca = fingerprint.codeAnalysis;
     const basePrompt = parts.join("\n");
+    const maxPromptTokens = getMaxPromptTokens();
     const baseTokens = estimateTokens(basePrompt);
-    const tokenBudgetForCode = Math.max(0, MAX_PROMPT_TOKENS - baseTokens);
+    const tokenBudgetForCode = Math.max(0, maxPromptTokens - baseTokens);
     const codeLines = [];
     let codeChars = 0;
-    codeLines.push("Study these files to extract patterns for skills. Use the exact code patterns you see here.\n");
+    const introLine = "Study these files to extract patterns for skills. Use the exact code patterns you see here.\n";
+    codeLines.push(introLine);
+    let runningCodeLen = introLine.length;
     const sortedFiles = [...ca.files].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
     let includedFiles = 0;
     for (const f of sortedFiles) {
       const entry = `[${f.path}]
 ${f.content}
 `;
-      if (estimateTokens(codeLines.join("\n") + entry) > tokenBudgetForCode && includedFiles > 0) break;
+      const projectedLen = runningCodeLen + 1 + entry.length;
+      if (Math.ceil(projectedLen / 4) > tokenBudgetForCode && includedFiles > 0) break;
       codeLines.push(entry);
       codeChars += f.content.length;
+      runningCodeLen = projectedLen;
       includedFiles++;
     }
     const includedTokens = Math.ceil(codeChars / 4);
@@ -2971,20 +3041,20 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
 }
 // src/writers/index.ts
-import fs12 from "fs";
+import fs13 from "fs";
 // src/writers/claude/index.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs7.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs8.writeFileSync("CLAUDE.md", config.claudeMd);
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path6.join(".claude", "skills", skill.name);
-      if (!fs7.existsSync(skillDir)) fs7.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path6.join(skillDir, "SKILL.md");
+      const skillDir = path7.join(".claude", "skills", skill.name);
+      if (!fs8.existsSync(skillDir)) fs8.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path7.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -2992,49 +3062,49 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs7.writeFileSync(skillPath, frontmatter + skill.content);
+      fs8.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs7.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs7.readFileSync(".mcp.json", "utf-8"));
+      if (fs8.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs8.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs7.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs8.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 // src/writers/cursor/index.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs8.writeFileSync(".cursorrules", config.cursorrules);
+    fs9.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   if (config.rules?.length) {
-    const rulesDir = path7.join(".cursor", "rules");
-    if (!fs8.existsSync(rulesDir)) fs8.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path8.join(".cursor", "rules");
+    if (!fs9.existsSync(rulesDir)) fs9.mkdirSync(rulesDir, { recursive: true });
     for (const rule of config.rules) {
-      const rulePath = path7.join(rulesDir, rule.filename);
-      fs8.writeFileSync(rulePath, rule.content);
+      const rulePath = path8.join(rulesDir, rule.filename);
+      fs9.writeFileSync(rulePath, rule.content);
       written.push(rulePath);
     }
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path7.join(".cursor", "skills", skill.name);
-      if (!fs8.existsSync(skillDir)) fs8.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path7.join(skillDir, "SKILL.md");
+      const skillDir = path8.join(".cursor", "skills", skill.name);
+      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path8.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -3042,41 +3112,41 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs8.writeFileSync(skillPath, frontmatter + skill.content);
+      fs9.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs8.existsSync(cursorDir)) fs8.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path7.join(cursorDir, "mcp.json");
+    if (!fs9.existsSync(cursorDir)) fs9.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path8.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs8.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs8.readFileSync(mcpPath, "utf-8"));
+      if (fs9.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs9.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs8.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs9.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
 }
 // src/writers/codex/index.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs9.writeFileSync("AGENTS.md", config.agentsMd);
+  fs10.writeFileSync("AGENTS.md", config.agentsMd);
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path8.join(".agents", "skills", skill.name);
-      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path8.join(skillDir, "SKILL.md");
+      const skillDir = path9.join(".agents", "skills", skill.name);
+      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path9.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -3084,7 +3154,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs9.writeFileSync(skillPath, frontmatter + skill.content);
+      fs10.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -3093,62 +3163,62 @@ function writeCodexConfig(config) {
 // src/writers/backup.ts
 init_constants();
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path10.join(BACKUPS_DIR, timestamp);
+  const backupDir = path11.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs10.existsSync(file)) continue;
-    const dest = path10.join(backupDir, file);
-    const destDir = path10.dirname(dest);
-    if (!fs10.existsSync(destDir)) {
-      fs10.mkdirSync(destDir, { recursive: true });
+    if (!fs11.existsSync(file)) continue;
+    const dest = path11.join(backupDir, file);
+    const destDir = path11.dirname(dest);
+    if (!fs11.existsSync(destDir)) {
+      fs11.mkdirSync(destDir, { recursive: true });
     }
-    fs10.copyFileSync(file, dest);
+    fs11.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path10.join(backupDir, file);
-  if (!fs10.existsSync(backupFile)) return false;
-  const destDir = path10.dirname(file);
-  if (!fs10.existsSync(destDir)) {
-    fs10.mkdirSync(destDir, { recursive: true });
+  const backupFile = path11.join(backupDir, file);
+  if (!fs11.existsSync(backupFile)) return false;
+  const destDir = path11.dirname(file);
+  if (!fs11.existsSync(destDir)) {
+    fs11.mkdirSync(destDir, { recursive: true });
   }
-  fs10.copyFileSync(backupFile, file);
+  fs11.copyFileSync(backupFile, file);
   return true;
 }
 // src/writers/manifest.ts
 init_constants();
-import fs11 from "fs";
-import crypto from "crypto";
+import fs12 from "fs";
+import crypto2 from "crypto";
 function readManifest() {
   try {
-    if (!fs11.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs11.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs12.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs12.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs11.existsSync(CALIBER_DIR)) {
-    fs11.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs12.existsSync(CALIBER_DIR)) {
+    fs12.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs11.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs12.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs11.readFileSync(filePath);
-  return crypto.createHash("sha256").update(content).digest("hex");
+  const content = fs12.readFileSync(filePath);
+  return crypto2.createHash("sha256").update(content).digest("hex");
 }
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs12.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs13.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs12.existsSync(f)),
+    ...filesToWrite.filter((f) => fs13.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -3164,7 +3234,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs12.unlinkSync(filePath);
+    fs13.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -3194,8 +3264,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs12.existsSync(entry.path)) {
-        fs12.unlinkSync(entry.path);
+      if (fs13.existsSync(entry.path)) {
+        fs13.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -3205,8 +3275,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs12.existsSync(MANIFEST_FILE2)) {
-    fs12.unlinkSync(MANIFEST_FILE2);
+  if (fs13.existsSync(MANIFEST_FILE2)) {
+    fs13.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -3241,23 +3311,23 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs12.existsSync(gitignorePath)) {
-    const content = fs12.readFileSync(gitignorePath, "utf-8");
+  if (fs13.existsSync(gitignorePath)) {
+    const content = fs13.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs12.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs13.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs12.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs13.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 // src/writers/staging.ts
 init_constants();
-import fs13 from "fs";
-import path11 from "path";
-var STAGED_DIR = path11.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path11.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path11.join(STAGED_DIR, "current");
+import fs14 from "fs";
+import path12 from "path";
+var STAGED_DIR = path12.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path12.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path12.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -3267,20 +3337,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path11.join(projectDir, file.path);
-    if (fs13.existsSync(originalPath)) {
-      const existing = fs13.readFileSync(originalPath, "utf-8");
+    const originalPath = path12.join(projectDir, file.path);
+    if (fs14.existsSync(originalPath)) {
+      const existing = fs14.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path11.join(PROPOSED_DIR, file.path);
-    fs13.mkdirSync(path11.dirname(proposedPath), { recursive: true });
-    fs13.writeFileSync(proposedPath, file.content);
-    if (fs13.existsSync(originalPath)) {
-      const currentPath = path11.join(CURRENT_DIR, file.path);
-      fs13.mkdirSync(path11.dirname(currentPath), { recursive: true });
-      fs13.copyFileSync(originalPath, currentPath);
+    const proposedPath = path12.join(PROPOSED_DIR, file.path);
+    fs14.mkdirSync(path12.dirname(proposedPath), { recursive: true });
+    fs14.writeFileSync(proposedPath, file.content);
+    if (fs14.existsSync(originalPath)) {
+      const currentPath = path12.join(CURRENT_DIR, file.path);
+      fs14.mkdirSync(path12.dirname(currentPath), { recursive: true });
+      fs14.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -3291,34 +3361,34 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs13.existsSync(STAGED_DIR)) {
-    fs13.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs14.existsSync(STAGED_DIR)) {
+    fs14.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 // src/utils/review.ts
 import chalk2 from "chalk";
-import fs15 from "fs";
+import fs16 from "fs";
 import select2 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 // src/utils/editor.ts
-import { execSync as execSync5, spawn as spawn3 } from "child_process";
-import fs14 from "fs";
-import path12 from "path";
+import { execSync as execSync6, spawn as spawn3 } from "child_process";
+import fs15 from "fs";
+import path13 from "path";
 import os4 from "os";
 var IS_WINDOWS3 = process.platform === "win32";
-var DIFF_TEMP_DIR = path12.join(os4.tmpdir(), "caliber-diff");
+var DIFF_TEMP_DIR = path13.join(os4.tmpdir(), "caliber-diff");
 function getEmptyFilePath(proposedPath) {
-  fs14.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path12.join(DIFF_TEMP_DIR, path12.basename(proposedPath));
-  fs14.writeFileSync(tempPath, "");
+  fs15.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path13.join(DIFF_TEMP_DIR, path13.basename(proposedPath));
+  fs15.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync5(check, { stdio: "ignore" });
+    execSync6(check, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -3383,8 +3453,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs15.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs15.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs16.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs16.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -3547,7 +3617,7 @@ async function interactiveDiffExplorer(files) {
 }
 // src/commands/setup-files.ts
-import fs16 from "fs";
+import fs17 from "fs";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -3596,7 +3666,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs16.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs17.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -3613,13 +3683,13 @@ ${agentRefs.join(" ")}
 }
 // src/lib/hooks.ts
-import fs18 from "fs";
-import path13 from "path";
-import { execSync as execSync7 } from "child_process";
+import fs19 from "fs";
+import path14 from "path";
+import { execSync as execSync8 } from "child_process";
 // src/lib/resolve-caliber.ts
-import fs17 from "fs";
-import { execSync as execSync6 } from "child_process";
+import fs18 from "fs";
+import { execSync as execSync7 } from "child_process";
 var _resolved = null;
 function resolveCaliber() {
   if (_resolved) return _resolved;
@@ -3630,7 +3700,7 @@ function resolveCaliber() {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    const found = execSync6(whichCmd, {
+    const found = execSync7(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -3641,7 +3711,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs17.existsSync(binPath)) {
+  if (binPath && fs18.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -3657,24 +3727,24 @@ function isCaliberCommand(command, subcommandTail) {
 }
 // src/lib/hooks.ts
-var SETTINGS_PATH = path13.join(".claude", "settings.json");
+var SETTINGS_PATH = path14.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs18.existsSync(SETTINGS_PATH)) return {};
+  if (!fs19.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs19.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path13.dirname(SETTINGS_PATH);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path14.dirname(SETTINGS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3736,20 +3806,20 @@ ${PRECOMMIT_END}`;
 }
 function getGitHooksDir() {
   try {
-    const gitDir = execSync7("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path13.join(gitDir, "hooks");
+    const gitDir = execSync8("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return path14.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path14.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs18.existsSync(hookPath)) return false;
-  const content = fs18.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs19.existsSync(hookPath)) return false;
+  const content = fs19.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3758,43 +3828,43 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path13.dirname(hookPath);
-  if (!fs18.existsSync(hooksDir)) fs18.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path14.dirname(hookPath);
+  if (!fs19.existsSync(hooksDir)) fs19.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs18.existsSync(hookPath)) {
-    content = fs18.readFileSync(hookPath, "utf-8");
+  if (fs19.existsSync(hookPath)) {
+    content = fs19.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs18.writeFileSync(hookPath, content);
-  fs18.chmodSync(hookPath, 493);
+  fs19.writeFileSync(hookPath, content);
+  fs19.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs18.existsSync(hookPath)) {
+  if (!hookPath || !fs19.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs18.readFileSync(hookPath, "utf-8");
+  let content = fs19.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() === "") {
-    fs18.unlinkSync(hookPath);
+    fs19.unlinkSync(hookPath);
   } else {
-    fs18.writeFileSync(hookPath, content);
+    fs19.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 // src/lib/learning-hooks.ts
-import fs19 from "fs";
-import path14 from "path";
-var SETTINGS_PATH2 = path14.join(".claude", "settings.json");
+import fs20 from "fs";
+import path15 from "path";
+var SETTINGS_PATH2 = path15.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -3811,17 +3881,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings2() {
-  if (!fs19.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs20.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs19.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs20.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path14.dirname(SETTINGS_PATH2);
-  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
-  fs19.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path15.dirname(SETTINGS_PATH2);
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -3855,7 +3925,7 @@ function installLearningHooks() {
   writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path14.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path15.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -3863,17 +3933,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize" }
 ];
 function readCursorHooks() {
-  if (!fs19.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs19.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs20.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path14.dirname(CURSOR_HOOKS_PATH);
-  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
-  fs19.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path15.dirname(CURSOR_HOOKS_PATH);
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -3943,10 +4013,10 @@ function removeLearningHooks() {
 // src/lib/state.ts
 init_constants();
-import fs20 from "fs";
-import path15 from "path";
-import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
+import fs21 from "fs";
+import path16 from "path";
+import { execSync as execSync9 } from "child_process";
+var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -3957,8 +4027,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs20.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs20.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs21.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs21.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -3966,14 +4036,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs20.existsSync(CALIBER_DIR)) {
-    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs20.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs21.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync8("git rev-parse HEAD", {
+    return execSync9("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -4918,7 +4988,7 @@ function checkGrounding(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync4, statSync as statSync2 } from "fs";
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import { join as join5 } from "path";
 function validateReferences(dir) {
   const configContent = collectPrimaryConfigContent(dir);
@@ -4927,13 +4997,13 @@ function validateReferences(dir) {
 }
 function detectGitDrift(dir) {
   try {
-    execSync9("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync10("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
   } catch {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: false };
   }
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules", ".cursor/rules"];
   try {
-    const headTimestamp = execSync9(
+    const headTimestamp = execSync10(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -4954,7 +5024,7 @@ function detectGitDrift(dir) {
   let latestConfigCommitHash = null;
   for (const file of configFiles) {
     try {
-      const hash = execSync9(
+      const hash = execSync10(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -4963,7 +5033,7 @@ function detectGitDrift(dir) {
         latestConfigCommitHash = hash;
       } else {
         try {
-          execSync9(
+          execSync10(
             `git merge-base --is-ancestor ${latestConfigCommitHash} ${hash}`,
             { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }
           );
@@ -4978,12 +5048,12 @@ function detectGitDrift(dir) {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: true };
   }
   try {
-    const countStr = execSync9(
+    const countStr = execSync10(
       `git rev-list --count ${latestConfigCommitHash}..HEAD`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     const commitsSince = parseInt(countStr, 10) || 0;
-    const lastDate = execSync9(
+    const lastDate = execSync10(
       `git log -1 --format=%ci ${latestConfigCommitHash}`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5055,12 +5125,12 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 import { existsSync as existsSync5, statSync as statSync3 } from "fs";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import { join as join6 } from "path";
 function getCommitsSinceConfigUpdate(dir) {
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules"];
   try {
-    const headTimestamp = execSync10(
+    const headTimestamp = execSync11(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5080,12 +5150,12 @@ function getCommitsSinceConfigUpdate(dir) {
   }
   for (const file of configFiles) {
     try {
-      const hash = execSync10(
+      const hash = execSync11(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
       if (hash) {
-        const countStr = execSync10(
+        const countStr = execSync11(
           `git rev-list --count ${hash}..HEAD`,
           { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -5203,11 +5273,11 @@ function checkFreshness(dir) {
 // src/scoring/checks/bonus.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
-import { execSync as execSync11 } from "child_process";
+import { execSync as execSync12 } from "child_process";
 import { join as join7 } from "path";
 function hasPreCommitHook(dir) {
   try {
-    const gitDir = execSync11("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync12("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join7(gitDir, "hooks", "pre-commit");
     const content = readFileOrNull2(hookPath);
     return content ? content.includes("caliber") : false;
@@ -5321,22 +5391,22 @@ function checkBonus(dir) {
 // src/scoring/dismissed.ts
 init_constants();
-import fs21 from "fs";
-import path16 from "path";
-var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
+import fs22 from "fs";
+import path17 from "path";
+var DISMISSED_FILE = path17.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs21.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs21.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs22.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs22.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs21.existsSync(CALIBER_DIR)) {
-    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs22.existsSync(CALIBER_DIR)) {
+    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs21.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs22.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -5581,13 +5651,13 @@ import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4,
 import { join as join9, dirname as dirname2 } from "path";
 // src/scanner/index.ts
-import fs22 from "fs";
-import path17 from "path";
-import crypto2 from "crypto";
+import fs23 from "fs";
+import path18 from "path";
+import crypto3 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path17.join(dir, "CLAUDE.md");
-  if (fs22.existsSync(claudeMdPath)) {
+  const claudeMdPath = path18.join(dir, "CLAUDE.md");
+  if (fs23.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5596,10 +5666,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path17.join(dir, ".claude", "skills");
-  if (fs22.existsSync(skillsDir)) {
-    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path17.join(skillsDir, file);
+  const skillsDir = path18.join(dir, ".claude", "skills");
+  if (fs23.existsSync(skillsDir)) {
+    for (const file of fs23.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path18.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -5609,10 +5679,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path17.join(dir, ".mcp.json");
-  if (fs22.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path18.join(dir, ".mcp.json");
+  if (fs23.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5627,8 +5697,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path17.join(dir, "AGENTS.md");
-  if (fs22.existsSync(agentsMdPath)) {
+  const agentsMdPath = path18.join(dir, "AGENTS.md");
+  if (fs23.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -5637,12 +5707,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path17.join(dir, ".agents", "skills");
-  if (fs22.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path18.join(dir, ".agents", "skills");
+  if (fs23.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs22.readdirSync(codexSkillsDir)) {
-        const skillFile = path17.join(codexSkillsDir, name, "SKILL.md");
-        if (fs22.existsSync(skillFile)) {
+      for (const name of fs23.readdirSync(codexSkillsDir)) {
+        const skillFile = path18.join(codexSkillsDir, name, "SKILL.md");
+        if (fs23.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -5655,8 +5725,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path17.join(dir, ".cursorrules");
-  if (fs22.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path18.join(dir, ".cursorrules");
+  if (fs23.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5665,10 +5735,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
-  if (fs22.existsSync(cursorRulesDir)) {
-    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path17.join(cursorRulesDir, file);
+  const cursorRulesDir = path18.join(dir, ".cursor", "rules");
+  if (fs23.existsSync(cursorRulesDir)) {
+    for (const file of fs23.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path18.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -5678,12 +5748,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
-  if (fs22.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path18.join(dir, ".cursor", "skills");
+  if (fs23.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs22.readdirSync(cursorSkillsDir)) {
-        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs22.existsSync(skillFile)) {
+      for (const name of fs23.readdirSync(cursorSkillsDir)) {
+        const skillFile = path18.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs23.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -5696,10 +5766,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
-  if (fs22.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path18.join(dir, ".cursor", "mcp.json");
+  if (fs23.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5717,11 +5787,11 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs22.readFileSync(filePath, "utf-8");
-  return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
+  const text = fs23.readFileSync(filePath, "utf-8");
+  return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
-  return crypto2.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
+  return crypto3.createHash("sha256").update(JSON.stringify(obj)).digest("hex");
 }
 // src/commands/recommend.ts
@@ -5732,40 +5802,40 @@ import { PostHog } from "posthog-node";
 import chalk7 from "chalk";
 // src/telemetry/config.ts
-import fs23 from "fs";
-import path18 from "path";
+import fs24 from "fs";
+import path19 from "path";
 import os5 from "os";
-import crypto3 from "crypto";
-import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path18.join(os5.homedir(), ".caliber");
-var CONFIG_FILE2 = path18.join(CONFIG_DIR2, "config.json");
+import crypto4 from "crypto";
+import { execSync as execSync13 } from "child_process";
+var CONFIG_DIR2 = path19.join(os5.homedir(), ".caliber");
+var CONFIG_FILE2 = path19.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs23.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs23.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs24.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs24.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs23.existsSync(CONFIG_DIR2)) {
-    fs23.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs24.existsSync(CONFIG_DIR2)) {
+    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs23.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
   if (config.machineId) return config.machineId;
-  const machineId = crypto3.randomUUID();
+  const machineId = crypto4.randomUUID();
   writeConfig({ ...config, machineId });
   return machineId;
 }
 function getGitEmailHash() {
   try {
-    const email = execSync12("git config user.email", { encoding: "utf-8" }).trim();
+    const email = execSync13("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
-    return crypto3.createHash("sha256").update(email).digest("hex");
+    return crypto4.createHash("sha256").update(email).digest("hex");
   } catch {
     return void 0;
   }
@@ -6708,11 +6778,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path29) => {
-    const cached = existsCache.get(path29);
+  const cachedExists = (path30) => {
+    const cached = existsCache.get(path30);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path29);
-    existsCache.set(path29, result);
+    const result = existsSync9(path30);
+    existsCache.set(path30, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -6851,8 +6921,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 // src/lib/debug-report.ts
-import fs24 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path20 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -6921,11 +6991,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path19.dirname(outputPath);
-    if (!fs24.existsSync(dir)) {
-      fs24.mkdirSync(dir, { recursive: true });
+    const dir = path20.dirname(outputPath);
+    if (!fs25.existsSync(dir)) {
+      fs25.mkdirSync(dir, { recursive: true });
     }
-    fs24.writeFileSync(outputPath, lines.join("\n"));
+    fs25.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -7050,9 +7120,17 @@ var ParallelTaskDisplay = class {
   cachedCardLines = null;
   cachedCardIndex = -1;
   cachedCardCols = -1;
+  cachedConnectors = null;
   add(name, options) {
     const index = this.tasks.length;
-    this.tasks.push({ name, status: "pending", message: "", depth: options?.depth ?? 0 });
+    this.tasks.push({
+      name,
+      status: "pending",
+      message: "",
+      depth: options?.depth ?? 0,
+      pipelineLabel: options?.pipelineLabel,
+      pipelineRow: options?.pipelineRow ?? 0
+    });
     return index;
   }
   start() {
@@ -7159,42 +7237,84 @@ var ParallelTaskDisplay = class {
     const boundary = lastSpace > max * 0.5 ? lastSpace : max - 1;
     return text.slice(0, boundary) + "\u2026";
   }
-  renderLine(task) {
-    const cols = process.stdout.columns || 80;
-    const elapsed = task.startTime ? this.formatTime((task.endTime ?? Date.now()) - task.startTime) : "";
-    const timeStr = elapsed ? ` ${chalk10.dim(elapsed)}` : "";
-    const timePlain = elapsed ? ` ${elapsed}` : "";
-    let icon;
-    let nameStyle;
-    let msgStyle;
+  statusIcon(task) {
     switch (task.status) {
       case "pending":
-        icon = chalk10.dim("\u25CB");
-        nameStyle = chalk10.dim;
-        msgStyle = chalk10.dim;
-        break;
-      case "running":
-        icon = chalk10.cyan(SPINNER_FRAMES[this.spinnerFrame]);
-        nameStyle = chalk10.white;
-        msgStyle = chalk10.dim;
-        break;
+        return { char: "\u25CB", styled: chalk10.dim("\u25CB") };
+      case "running": {
+        const frame = SPINNER_FRAMES[this.spinnerFrame];
+        return { char: frame, styled: chalk10.cyan(frame) };
+      }
       case "done":
-        icon = chalk10.green("\u2713");
-        nameStyle = chalk10.white;
-        msgStyle = chalk10.dim;
-        break;
+        return { char: "\u2713", styled: chalk10.green("\u2713") };
       case "failed":
-        icon = chalk10.red("\u2717");
-        nameStyle = chalk10.white;
-        msgStyle = chalk10.red;
-        break;
-    }
-    const indent = "  ".repeat(task.depth);
-    const paddedName = task.name.padEnd(Math.max(0, NAME_COL_WIDTH - indent.length));
-    const usedByFixed = PREFIX.length + indent.length + 2 + NAME_COL_WIDTH + timePlain.length;
+        return { char: "\u2717", styled: chalk10.red("\u2717") };
+    }
+  }
+  renderPipelineHeader() {
+    const mainTasks = this.tasks.filter((t) => t.pipelineLabel && t.pipelineRow === 0);
+    const branchTasks = this.tasks.filter((t) => t.pipelineLabel && t.pipelineRow === 1);
+    if (mainTasks.length === 0) return [];
+    const arrow = " \u2192 ";
+    const styledArrow = chalk10.dim(arrow);
+    const renderNode = (t) => {
+      const { char, styled: icon } = this.statusIcon(t);
+      const label = t.pipelineLabel;
+      const styledLabel = t.status === "pending" ? chalk10.dim(label) : label;
+      return {
+        plain: `[${char} ${label}]`,
+        styled: chalk10.dim("[") + icon + " " + styledLabel + chalk10.dim("]")
+      };
+    };
+    const mainNodes = mainTasks.map(renderNode);
+    const mainLine = PREFIX + mainNodes.map((n) => n.styled).join(styledArrow);
+    const lines = [mainLine];
+    if (branchTasks.length > 0) {
+      const firstNodePlainWidth = mainNodes[0].plain.length;
+      const indent = " ".repeat(PREFIX.length + firstNodePlainWidth + arrow.length);
+      const branchNodes = branchTasks.map(renderNode);
+      const branchLine = indent + chalk10.dim("\u2198 ") + branchNodes.map((n) => n.styled).join(styledArrow) + chalk10.dim(" \u2197");
+      lines.push(branchLine);
+    }
+    return lines;
+  }
+  hasSiblingAfter(startIdx, depth) {
+    for (let i = startIdx; i < this.tasks.length; i++) {
+      if (this.tasks[i].depth < depth) return false;
+      if (this.tasks[i].depth === depth) return true;
+    }
+    return false;
+  }
+  getTreeConnector(index) {
+    const task = this.tasks[index];
+    if (task.depth === 0) return "";
+    if (task.depth === 1) {
+      return this.hasSiblingAfter(index + 1, 1) ? "\u251C\u2500 " : "\u2514\u2500 ";
+    }
+    if (task.depth === 2) {
+      const pipe = this.hasSiblingAfter(index + 1, 1) ? "\u2502" : " ";
+      return `${pipe}  \u2514\u2500 `;
+    }
+    return "  ".repeat(task.depth);
+  }
+  renderLine(task, index) {
+    const cols = process.stdout.columns || 80;
+    const elapsed = task.startTime ? this.formatTime((task.endTime ?? Date.now()) - task.startTime) : "";
+    const timeStr = elapsed ? ` ${chalk10.dim(elapsed)}` : "";
+    const timePlain = elapsed ? ` ${elapsed}` : "";
+    const { styled: icon } = this.statusIcon(task);
+    const nameStyle = task.status === "pending" ? chalk10.dim : chalk10.white;
+    const msgStyle = task.status === "failed" ? chalk10.red : chalk10.dim;
+    if (!this.cachedConnectors) {
+      this.cachedConnectors = this.tasks.map((_, i) => this.getTreeConnector(i));
+    }
+    const connector = this.cachedConnectors[index];
+    const connectorStyled = connector ? chalk10.dim(connector) : "";
+    const paddedName = task.name.padEnd(Math.max(0, NAME_COL_WIDTH - connector.length));
+    const usedByFixed = PREFIX.length + connector.length + 2 + NAME_COL_WIDTH + timePlain.length;
     const msgMax = Math.max(cols - usedByFixed - 2, 10);
     const msg = task.message ? this.smartTruncate(task.message, msgMax) : "";
-    return `${PREFIX}${indent}${icon} ${nameStyle(paddedName)}${msg ? msgStyle(msg) : ""}${timeStr}`;
+    return `${PREFIX}${connectorStyled}${icon} ${nameStyle(paddedName)}${msg ? msgStyle(msg) : ""}${timeStr}`;
   }
   draw(initial) {
     const { stdout } = process;
@@ -7202,7 +7322,15 @@ var ParallelTaskDisplay = class {
       stdout.write(`\x1B[${this.lineCount}A`);
     }
     stdout.write("\x1B[0J");
-    const lines = this.tasks.map((t) => this.renderLine(t));
+    const pipelineHeader = this.renderPipelineHeader();
+    const taskLines = this.tasks.map((t, i) => this.renderLine(t, i));
+    const lines = [];
+    if (pipelineHeader.length > 0) {
+      lines.push(...pipelineHeader);
+      const cols = stdout.columns || 80;
+      lines.push(PREFIX + chalk10.dim("\u2500".repeat(Math.min(cols - PREFIX.length * 2, 55))));
+    }
+    lines.push(...taskLines);
     if (this.waitingEnabled && this.waitingCards.length > 0 && stdout.isTTY) {
       const cols = stdout.columns || 80;
       if (this.currentCard !== this.cachedCardIndex || cols !== this.cachedCardCols || !this.cachedCardLines) {
@@ -7353,21 +7481,20 @@ async function initCommand(options) {
   let skillSearchResult = { results: [], contentMap: /* @__PURE__ */ new Map() };
   let fingerprint;
   const display = new ParallelTaskDisplay();
-  const TASK_STACK = display.add("Detecting project stack");
-  const TASK_CONFIG = display.add("Generating configs");
-  const TASK_SKILLS_GEN = display.add("Generating skills", { depth: 1 });
-  const TASK_SKILLS_SEARCH = wantsSkills ? display.add("Searching community skills") : -1;
-  const TASK_SCORE_REFINE = display.add("Validating & refining setup");
+  const TASK_STACK = display.add("Detecting project stack", { pipelineLabel: "Scan" });
+  const TASK_CONFIG = display.add("Generating configs", { depth: 1, pipelineLabel: "Generate" });
+  const TASK_SKILLS_GEN = display.add("Generating skills", { depth: 2, pipelineLabel: "Skills" });
+  const TASK_SKILLS_SEARCH = wantsSkills ? display.add("Searching community skills", { depth: 1, pipelineLabel: "Search", pipelineRow: 1 }) : -1;
+  const TASK_SCORE_REFINE = display.add("Validating & refining setup", { pipelineLabel: "Validate" });
   display.start();
   display.enableWaitingContent();
   try {
     display.update(TASK_STACK, "running");
     fingerprint = await collectFingerprint(process.cwd());
-    const stackSummary = [
-      ...fingerprint.languages,
-      ...fingerprint.frameworks
-    ].join(", ") || "no languages";
-    display.update(TASK_STACK, "done", stackSummary);
+    const stackParts = [...fingerprint.languages, ...fingerprint.frameworks];
+    const stackSummary = stackParts.join(", ") || "no languages";
+    const largeRepoNote = fingerprint.fileTree.length > 5e3 ? ` (${fingerprint.fileTree.length.toLocaleString()} files, smart sampling active)` : "";
+    display.update(TASK_STACK, "done", stackSummary + largeRepoNote);
     trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
     log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
     if (report) {
@@ -7385,7 +7512,8 @@ async function initCommand(options) {
     }
     display.update(TASK_CONFIG, "running");
     const generatePromise = (async () => {
-      const failingForDismissal = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+      let localBaseline = baselineScore;
+      const failingForDismissal = localBaseline.checks.filter((c) => !c.passed && c.maxPoints > 0);
       if (failingForDismissal.length > 0) {
         display.update(TASK_CONFIG, "running", "Evaluating baseline checks...");
         try {
@@ -7395,7 +7523,7 @@ async function initCommand(options) {
             const existingIds = new Set(existing.map((d) => d.id));
             const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
             writeDismissedChecks(merged);
-            baselineScore = computeLocalScore(process.cwd(), targetAgent);
+            localBaseline = computeLocalScore(process.cwd(), targetAgent);
           }
         } catch {
           display.update(TASK_CONFIG, "running", "Skipped dismissal evaluation");
@@ -7404,11 +7532,11 @@ async function initCommand(options) {
       let failingChecks;
       let passingChecks;
       let currentScore;
-      if (hasExistingConfig && baselineScore.score >= 95 && !options.force) {
-        const currentLlmFixable = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
+      if (hasExistingConfig && localBaseline.score >= 95 && !options.force) {
+        const currentLlmFixable = localBaseline.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
         failingChecks = currentLlmFixable.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
-        passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
-        currentScore = baselineScore.score;
+        passingChecks = localBaseline.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
+        currentScore = localBaseline.score;
       }
       if (report) {
         const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
@@ -7602,7 +7730,7 @@ async function initCommand(options) {
   }
   const writeSpinner = ora3("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs25.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs26.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -7786,9 +7914,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path20.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path21.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk11.dim(`  Debug report written to ${path20.relative(process.cwd(), reportPath)}
+    console.log(chalk11.dim(`  Debug report written to ${path21.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -7835,7 +7963,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path29, desc]) => `  ${path29}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path30, desc]) => `  ${path30}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -7969,7 +8097,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs25.existsSync("CLAUDE.md") ? chalk11.yellow("~") : chalk11.green("+");
+      const icon = fs26.existsSync("CLAUDE.md") ? chalk11.yellow("~") : chalk11.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk11.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk11.dim(`    ${desc}`));
@@ -7979,7 +8107,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 = fs25.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
+        const icon = fs26.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk11.bold(skillPath)}`);
         console.log(chalk11.dim(`    ${desc || skill.description || skill.name}`));
@@ -7990,7 +8118,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs25.existsSync("AGENTS.md") ? chalk11.yellow("~") : chalk11.green("+");
+      const icon = fs26.existsSync("AGENTS.md") ? chalk11.yellow("~") : chalk11.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk11.bold("AGENTS.md")}`);
       if (desc) console.log(chalk11.dim(`    ${desc}`));
@@ -8000,7 +8128,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 = fs25.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
+        const icon = fs26.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk11.bold(skillPath)}`);
         console.log(chalk11.dim(`    ${desc || skill.description || skill.name}`));
@@ -8010,7 +8138,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs25.existsSync(".cursorrules") ? chalk11.yellow("~") : chalk11.green("+");
+      const icon = fs26.existsSync(".cursorrules") ? chalk11.yellow("~") : chalk11.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk11.bold(".cursorrules")}`);
       if (desc) console.log(chalk11.dim(`    ${desc}`));
@@ -8020,7 +8148,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 = fs25.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
+        const icon = fs26.existsSync(skillPath) ? chalk11.yellow("~") : chalk11.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk11.bold(skillPath)}`);
         console.log(chalk11.dim(`    ${desc || skill.description || skill.name}`));
@@ -8031,7 +8159,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs25.existsSync(rulePath) ? chalk11.yellow("~") : chalk11.green("+");
+        const icon = fs26.existsSync(rulePath) ? chalk11.yellow("~") : chalk11.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk11.bold(rulePath)}`);
         if (desc) {
@@ -8095,8 +8223,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs25.existsSync(settingsPath)) {
-      settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
+    if (fs26.existsSync(settingsPath)) {
+      settings = JSON.parse(fs26.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -8105,8 +8233,8 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs25.existsSync(".claude")) fs25.mkdirSync(".claude", { recursive: true });
-  fs25.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs26.existsSync(".claude")) fs26.mkdirSync(".claude", { recursive: true });
+  fs26.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function displayTokenUsage() {
   const summary = getUsageSummary();
@@ -8130,7 +8258,7 @@ function displayTokenUsage() {
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path20.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path21.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -8143,8 +8271,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs25.mkdirSync(path20.join(process.cwd(), ".caliber"), { recursive: true });
-    fs25.writeFileSync(logPath, lines.join("\n"));
+    fs26.mkdirSync(path21.join(process.cwd(), ".caliber"), { recursive: true });
+    fs26.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk11.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8185,7 +8313,7 @@ function undoCommand() {
 // src/commands/status.ts
 import chalk13 from "chalk";
-import fs26 from "fs";
+import fs27 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -8212,7 +8340,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk13.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs26.existsSync(entry.path);
+    const exists = fs27.existsSync(entry.path);
     const icon = exists ? chalk13.green("\u2713") : chalk13.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -8394,13 +8522,13 @@ async function scoreCommand(options) {
 }
 // src/commands/refresh.ts
-import fs30 from "fs";
-import path24 from "path";
+import fs31 from "fs";
+import path25 from "path";
 import chalk16 from "chalk";
 import ora6 from "ora";
 // src/lib/git-diff.ts
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync14 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -8415,7 +8543,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync13(cmd, {
+    return execSync14(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -8473,37 +8601,37 @@ function collectDiff(lastSha) {
 }
 // src/writers/refresh.ts
-import fs27 from "fs";
-import path21 from "path";
+import fs28 from "fs";
+import path22 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs27.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs28.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs27.writeFileSync("README.md", docs.readmeMd);
+    fs28.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs27.writeFileSync(".cursorrules", docs.cursorrules);
+    fs28.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path21.join(".cursor", "rules");
-    if (!fs27.existsSync(rulesDir)) fs27.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path22.join(".cursor", "rules");
+    if (!fs28.existsSync(rulesDir)) fs28.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path21.join(rulesDir, rule.filename);
-      fs27.writeFileSync(filePath, rule.content);
+      const filePath = path22.join(rulesDir, rule.filename);
+      fs28.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path21.join(".claude", "skills");
-    if (!fs27.existsSync(skillsDir)) fs27.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path22.join(".claude", "skills");
+    if (!fs28.existsSync(skillsDir)) fs28.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path21.join(skillsDir, skill.filename);
-      fs27.writeFileSync(filePath, skill.content);
+      const filePath = path22.join(skillsDir, skill.filename);
+      fs28.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -8580,8 +8708,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 // src/learner/writer.ts
-import fs28 from "fs";
-import path22 from "path";
+import fs29 from "fs";
+import path23 from "path";
 var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
 var LEARNINGS_HEADER = `# Caliber Learnings
@@ -8665,16 +8793,16 @@ function deduplicateLearnedItems(existing, incoming) {
 function writeLearnedSection(content) {
   const existingSection = readLearnedSection();
   const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
-  fs28.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+  fs29.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
   return { newCount, newItems };
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path22.join(".claude", "skills", skill.name);
-  if (!fs28.existsSync(skillDir)) fs28.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path22.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs28.existsSync(skillPath)) {
-    const existing = fs28.readFileSync(skillPath, "utf-8");
-    fs28.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path23.join(".claude", "skills", skill.name);
+  if (!fs29.existsSync(skillDir)) fs29.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path23.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs29.existsSync(skillPath)) {
+    const existing = fs29.readFileSync(skillPath, "utf-8");
+    fs29.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -8683,37 +8811,37 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs28.writeFileSync(skillPath, frontmatter + skill.content);
+    fs29.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
-  if (fs28.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs28.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs29.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs29.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs28.existsSync(claudeMdPath)) return null;
-  const content = fs28.readFileSync(claudeMdPath, "utf-8");
+  if (!fs29.existsSync(claudeMdPath)) return null;
+  const content = fs29.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 (fs28.existsSync(LEARNINGS_FILE)) return false;
+  if (fs29.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs28.existsSync(claudeMdPath)) return false;
-  const content = fs28.readFileSync(claudeMdPath, "utf-8");
+  if (!fs29.existsSync(claudeMdPath)) return false;
+  const content = fs29.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;
-  fs28.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs29.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs28.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs29.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
@@ -8725,11 +8853,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs30.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs31.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path24.join(parentDir, entry.name);
-      if (fs30.existsSync(path24.join(childPath, ".git"))) {
+      const childPath = path25.join(parentDir, entry.name);
+      if (fs31.existsSync(path25.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -8832,7 +8960,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path24.basename(repo);
+      const repoName = path25.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -9056,7 +9184,7 @@ async function configCommand() {
 }
 // src/commands/learn.ts
-import fs33 from "fs";
+import fs34 from "fs";
 import chalk19 from "chalk";
 // src/learner/stdin.ts
@@ -9088,8 +9216,8 @@ function readStdin() {
 // src/learner/storage.ts
 init_constants();
-import fs31 from "fs";
-import path25 from "path";
+import fs32 from "fs";
+import path26 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -9097,15 +9225,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs31.existsSync(LEARNING_DIR)) {
-    fs31.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs32.existsSync(LEARNING_DIR)) {
+    fs32.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path25.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path26.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path25.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path26.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -9116,29 +9244,29 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs31.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs32.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs32.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs31.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  fs32.appendFileSync(filePath, JSON.stringify(event) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs32.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs31.existsSync(filePath)) return [];
-  const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs32.existsSync(filePath)) return [];
+  const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -9150,26 +9278,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs31.existsSync(filePath)) return 0;
-  const content = fs31.readFileSync(filePath, "utf-8");
+  if (!fs32.existsSync(filePath)) return 0;
+  const content = fs32.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs31.existsSync(filePath)) fs31.unlinkSync(filePath);
+  if (fs32.existsSync(filePath)) fs32.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs31.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs32.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs32.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs31.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs32.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -9177,14 +9305,14 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path25.join(LEARNING_DIR, LOCK_FILE2);
+  return path26.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs31.existsSync(lockPath)) {
+  if (fs32.existsSync(lockPath)) {
     try {
-      const stat = fs31.statSync(lockPath);
+      const stat = fs32.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
         return false;
       }
@@ -9192,7 +9320,7 @@ function acquireFinalizeLock() {
     }
   }
   try {
-    fs31.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs32.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -9201,7 +9329,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs31.existsSync(lockPath)) fs31.unlinkSync(lockPath);
+    if (fs32.existsSync(lockPath)) fs32.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -9247,7 +9375,7 @@ function sanitizeSecrets(text) {
 // src/ai/learn.ts
 init_config();
-var MAX_PROMPT_TOKENS2 = 1e5;
+var MAX_PROMPT_TOKENS = 1e5;
 function formatEventsForPrompt(events) {
   return events.map((e, i) => {
     if (e.hook_event_name === "UserPromptSubmit") {
@@ -9295,7 +9423,7 @@ function parseAnalysisResponse(raw) {
   }
 }
 async function analyzeEvents(events, existingClaudeMd, existingLearnedSection, existingSkills) {
-  const fittedEvents = trimEventsToFit(events, MAX_PROMPT_TOKENS2 - 1e4);
+  const fittedEvents = trimEventsToFit(events, MAX_PROMPT_TOKENS - 1e4);
   const eventsText = formatEventsForPrompt(fittedEvents);
   const contextParts = [];
   if (existingClaudeMd) {
@@ -9357,8 +9485,8 @@ init_config();
 // src/learner/roi.ts
 init_constants();
-import fs32 from "fs";
-import path26 from "path";
+import fs33 from "fs";
+import path27 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
   totalWasteSeconds: 0,
@@ -9372,22 +9500,22 @@ var DEFAULT_TOTALS = {
   lastSessionTimestamp: ""
 };
 function roiFilePath() {
-  return path26.join(LEARNING_DIR, LEARNING_ROI_FILE);
+  return path27.join(LEARNING_DIR, LEARNING_ROI_FILE);
 }
 function readROIStats() {
   const filePath = roiFilePath();
-  if (!fs32.existsSync(filePath)) {
+  if (!fs33.existsSync(filePath)) {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
   try {
-    return JSON.parse(fs32.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs33.readFileSync(filePath, "utf-8"));
   } catch {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
 }
 function writeROIStats(stats) {
   ensureLearningDir();
-  fs32.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
+  fs33.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
 }
 function recalculateTotals(stats) {
   const totals = stats.totals;
@@ -9640,7 +9768,7 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs33.existsSync(".claude")) {
+  if (fs34.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
       console.log(chalk19.green("\u2713") + " Claude Code learning hooks installed");
@@ -9649,7 +9777,7 @@ async function learnInstallCommand() {
       console.log(chalk19.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs33.existsSync(".cursor")) {
+  if (fs34.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
       console.log(chalk19.green("\u2713") + " Cursor learning hooks installed");
@@ -9658,7 +9786,7 @@ async function learnInstallCommand() {
       console.log(chalk19.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs33.existsSync(".claude") && !fs33.existsSync(".cursor")) {
+  if (!fs34.existsSync(".claude") && !fs34.existsSync(".cursor")) {
     console.log(chalk19.yellow("No .claude/ or .cursor/ directory found."));
     console.log(chalk19.dim("  Run `caliber init` first, or create the directory manually."));
     return;
@@ -9730,9 +9858,9 @@ Learned items in CALIBER_LEARNINGS.md: ${chalk19.cyan(String(lineCount))}`);
 }
 // src/cli.ts
-var __dirname = path27.dirname(fileURLToPath(import.meta.url));
+var __dirname = path28.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs34.readFileSync(path27.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs35.readFileSync(path28.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -9806,16 +9934,16 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 // src/utils/version-check.ts
-import fs35 from "fs";
-import path28 from "path";
+import fs36 from "fs";
+import path29 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 import chalk20 from "chalk";
 import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path28.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path29.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs35.readFileSync(path28.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs36.readFileSync(path29.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
@@ -9839,9 +9967,9 @@ function isNewer(registry, current) {
 }
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync14("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path28.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs35.readFileSync(pkgPath, "utf-8")).version;
+    const globalRoot = execSync15("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const pkgPath = path29.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs36.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -9887,7 +10015,7 @@ Update available: ${current} -> ${latest}`)
     const tag = channel === "latest" ? latest : channel;
     const spinner = ora7("Updating caliber...").start();
     try {
-      execSync14(`npm install -g @rely-ai/caliber@${tag}`, {
+      execSync15(`npm install -g @rely-ai/caliber@${tag}`, {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -9904,7 +10032,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk20.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync14(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync15(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });