@rely-ai/caliber 1.23.0-dev.1773792440 → 1.23.0-dev.1773794235

package/dist/bin.js

@@ -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",
@@ -145,6 +169,22 @@ var init_config = __esm({
   }
 });
 
+// src/llm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isSeatBased: () => isSeatBased
+});
+function isSeatBased(provider) {
+  return SEAT_BASED_PROVIDERS.has(provider);
+}
+var SEAT_BASED_PROVIDERS;
+var init_types = __esm({
+  "src/llm/types.ts"() {
+    "use strict";
+    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
+  }
+});
+
 // src/constants.ts
 var constants_exports = {};
 __export(constants_exports, {
@@ -158,17 +198,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 +223,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 +244,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 +258,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 +332,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);
@@ -1004,8 +1052,8 @@ var AnthropicProvider = class {
         cacheWriteTokens: u.cache_creation_input_tokens
       });
     }
-    const block = response.content[0];
-    return block.type === "text" ? block.text : "";
+    const block = response.content?.[0];
+    return block?.type === "text" ? block.text : "";
   }
   async listModels() {
     const models = [];
@@ -1108,8 +1156,8 @@ var VertexProvider = class {
         cacheWriteTokens: u.cache_creation_input_tokens
       });
     }
-    const block = response.content[0];
-    return block.type === "text" ? block.text : "";
+    const block = response.content?.[0];
+    return block?.type === "text" ? block.text : "";
   }
   async stream(options, callbacks) {
     const messages = options.messages ? [
@@ -1229,14 +1277,44 @@ var OpenAICompatProvider = class {
 // src/llm/cursor-acp.ts
 import { spawn, execSync as execSync3 } from "child_process";
 import os2 from "os";
+
+// src/llm/seat-based-errors.ts
+var ERROR_PATTERNS = [
+  { pattern: /not logged in|not authenticated|login required|unauthorized/i, message: "Authentication required. Run the login command for your provider to re-authenticate." },
+  { pattern: /rate limit|too many requests|429/i, message: "Rate limit exceeded. Retrying..." },
+  { pattern: /model.*not found|invalid model|model.*unavailable/i, message: "The requested model is not available. Run `caliber config` to select a different model." }
+];
+function parseSeatBasedError(stderr, exitCode) {
+  if (!stderr && exitCode === 0) return null;
+  for (const { pattern, message } of ERROR_PATTERNS) {
+    if (pattern.test(stderr)) return message;
+  }
+  return null;
+}
+function isRateLimitError(stderr) {
+  return /rate limit|too many requests|429/i.test(stderr);
+}
+
+// src/llm/cursor-acp.ts
 var AGENT_BIN = "agent";
 var IS_WINDOWS = process.platform === "win32";
+var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var SIGKILL_DELAY_MS = 5e3;
+var STDERR_MAX_BYTES = 10 * 1024;
 var CursorAcpProvider = class {
   defaultModel;
   cursorApiKey;
+  timeoutMs;
+  warmProcess = null;
+  warmModel = null;
   constructor(config) {
     this.defaultModel = config.model || "sonnet-4.6";
     this.cursorApiKey = process.env.CURSOR_API_KEY ?? process.env.CURSOR_AUTH_TOKEN;
+    const envTimeout = process.env.CALIBER_CURSOR_TIMEOUT_MS;
+    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS;
+    if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 1e3) {
+      this.timeoutMs = DEFAULT_TIMEOUT_MS;
+    }
   }
   async call(options) {
     const prompt = this.buildPrompt(options);
@@ -1248,6 +1326,29 @@ var CursorAcpProvider = class {
     const model = options.model || this.defaultModel;
     return this.runPrintStream(model, prompt, callbacks);
   }
+  /**
+   * Pre-spawn an agent process so it's ready when the first call comes.
+   * Call this during fingerprint collection to hide spawn latency.
+   */
+  prewarm(model) {
+    const targetModel = model || this.defaultModel;
+    if (this.warmProcess && !this.warmProcess.killed && this.warmModel === targetModel) return;
+    const args = this.buildArgs(targetModel, false);
+    this.warmProcess = spawn(AGENT_BIN, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+      ...IS_WINDOWS && { shell: true }
+    });
+    this.warmModel = targetModel;
+    this.warmProcess.on("error", () => {
+      this.warmProcess = null;
+      this.warmModel = null;
+    });
+    this.warmProcess.on("close", () => {
+      this.warmProcess = null;
+      this.warmModel = null;
+    });
+  }
   buildArgs(model, streaming) {
     const args = ["--print", "--trust", "--workspace", os2.tmpdir()];
     if (model && model !== "auto" && model !== "default") {
@@ -1261,23 +1362,78 @@ var CursorAcpProvider = class {
     }
     return args;
   }
+  takeWarmProcess(model, streaming) {
+    if (!streaming && this.warmProcess && !this.warmProcess.killed && this.warmModel === model) {
+      const proc = this.warmProcess;
+      this.warmProcess = null;
+      this.warmModel = null;
+      return proc;
+    }
+    return null;
+  }
+  spawnAgent(model, streaming) {
+    const warm = this.takeWarmProcess(model, streaming);
+    if (warm) {
+      const stderrChunks2 = [];
+      warm.stderr?.on("data", (chunk) => {
+        if (Buffer.concat(stderrChunks2).length < STDERR_MAX_BYTES) stderrChunks2.push(chunk);
+      });
+      return { child: warm, stderrChunks: stderrChunks2 };
+    }
+    const args = this.buildArgs(model, streaming);
+    const child = spawn(AGENT_BIN, args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
+      ...IS_WINDOWS && { shell: true }
+    });
+    const stderrChunks = [];
+    child.stderr.on("data", (chunk) => {
+      if (Buffer.concat(stderrChunks).length < STDERR_MAX_BYTES) stderrChunks.push(chunk);
+    });
+    return { child, stderrChunks };
+  }
+  killWithEscalation(child) {
+    child.kill("SIGTERM");
+    const killTimer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGKILL");
+    }, SIGKILL_DELAY_MS);
+    killTimer.unref();
+  }
+  buildErrorMessage(code, stderrChunks) {
+    const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+    const parsed = parseSeatBasedError(stderr, code);
+    if (parsed) return parsed;
+    const base = `Cursor agent exited with code ${code}`;
+    return stderr ? `${base}: ${stderr.slice(0, 200)}` : base;
+  }
   runPrint(model, prompt) {
     return new Promise((resolve2, reject) => {
-      const args = this.buildArgs(model, false);
-      const child = spawn(AGENT_BIN, args, {
-        stdio: ["pipe", "pipe", "ignore"],
-        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
-        ...IS_WINDOWS && { shell: true }
-      });
+      const { child, stderrChunks } = this.spawnAgent(model, false);
+      let settled = false;
       const chunks = [];
-      child.stdout.on("data", (data) => {
-        chunks.push(data);
+      child.stdout.on("data", (data) => chunks.push(data));
+      const timer = setTimeout(() => {
+        this.killWithEscalation(child);
+        if (!settled) {
+          settled = true;
+          reject(new Error(`Cursor agent timed out after ${this.timeoutMs / 1e3}s. Set CALIBER_CURSOR_TIMEOUT_MS to increase.`));
+        }
+      }, this.timeoutMs);
+      timer.unref();
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
       });
-      child.on("error", reject);
       child.on("close", (code) => {
+        clearTimeout(timer);
+        if (settled) return;
+        settled = true;
         const output = Buffer.concat(chunks).toString("utf-8").trim();
         if (code !== 0 && !output) {
-          reject(new Error(`Cursor agent exited with code ${code}`));
+          reject(new Error(this.buildErrorMessage(code, stderrChunks)));
         } else {
           resolve2(output);
         }
@@ -1288,14 +1444,20 @@ var CursorAcpProvider = class {
   }
   runPrintStream(model, prompt, callbacks) {
     return new Promise((resolve2, reject) => {
-      const args = this.buildArgs(model, true);
-      const child = spawn(AGENT_BIN, args, {
-        stdio: ["pipe", "pipe", "ignore"],
-        env: { ...process.env, ...this.cursorApiKey && { CURSOR_API_KEY: this.cursorApiKey } },
-        ...IS_WINDOWS && { shell: true }
-      });
+      const { child, stderrChunks } = this.spawnAgent(model, true);
       let buffer = "";
       let endCalled = false;
+      let settled = false;
+      const timer = setTimeout(() => {
+        this.killWithEscalation(child);
+        if (!settled) {
+          settled = true;
+          const err = new Error(`Cursor agent timed out after ${this.timeoutMs / 1e3}s. Set CALIBER_CURSOR_TIMEOUT_MS to increase.`);
+          callbacks.onError(err);
+          reject(err);
+        }
+      }, this.timeoutMs);
+      timer.unref();
       child.stdout.on("data", (data) => {
         buffer += data.toString("utf-8");
         const lines = buffer.split("\n");
@@ -1320,16 +1482,26 @@ var CursorAcpProvider = class {
         }
       });
       child.on("error", (err) => {
-        callbacks.onError(err);
-        reject(err);
+        clearTimeout(timer);
+        if (!settled) {
+          settled = true;
+          callbacks.onError(err);
+          reject(err);
+        }
       });
       child.on("close", (code) => {
+        clearTimeout(timer);
+        if (settled) return;
+        settled = true;
         if (buffer.trim()) {
           try {
             const event = JSON.parse(buffer);
             if (event.type === "assistant") {
-              const text = event.message?.content?.[0]?.text || event.content;
-              if (text) callbacks.onText(text);
+              const isDelta = "timestamp_ms" in event;
+              if (isDelta) {
+                const text = event.message?.content?.[0]?.text || event.content;
+                if (text) callbacks.onText(text);
+              }
             } else if (event.type === "result") {
               endCalled = true;
               callbacks.onEnd({ stopReason: event.is_error ? "error" : "end_turn" });
@@ -1342,9 +1514,16 @@ var CursorAcpProvider = class {
           callbacks.onEnd({ stopReason: code === 0 ? "end_turn" : "error" });
         }
         if (code !== 0 && code !== null) {
-          const err = new Error(`Cursor agent exited with code ${code}`);
-          callbacks.onError(err);
-          reject(err);
+          const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+          if (isRateLimitError(stderr)) {
+            const err = new Error("Rate limit exceeded");
+            callbacks.onError(err);
+            reject(err);
+          } else {
+            const err = new Error(this.buildErrorMessage(code, stderrChunks));
+            callbacks.onError(err);
+            reject(err);
+          }
         } else {
           resolve2();
         }
@@ -1371,28 +1550,48 @@ var CursorAcpProvider = class {
 };
 function isCursorAgentAvailable() {
   try {
-    const cmd = process.platform === "win32" ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
+    const cmd = IS_WINDOWS ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
     execSync3(cmd, { stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
+function isCursorLoggedIn() {
+  try {
+    const result = execSync3(`${AGENT_BIN} status`, { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+    return !result.toString().includes("not logged in");
+  } catch {
+    return false;
+  }
+}
 
 // src/llm/claude-cli.ts
 import { spawn as spawn2, execSync as execSync4 } from "child_process";
 var CLAUDE_CLI_BIN = "claude";
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var IS_WINDOWS2 = process.platform === "win32";
+function spawnClaude(args) {
+  return IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env,
+    shell: true
+  }) : spawn2(CLAUDE_CLI_BIN, args, {
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+}
 var ClaudeCliProvider = class {
   defaultModel;
   timeoutMs;
   constructor(config) {
     this.defaultModel = config.model || "default";
     const envTimeout = process.env.CALIBER_CLAUDE_CLI_TIMEOUT_MS;
-    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS;
+    this.timeoutMs = envTimeout ? parseInt(envTimeout, 10) : DEFAULT_TIMEOUT_MS2;
     if (!Number.isFinite(this.timeoutMs) || this.timeoutMs < 1e3) {
-      this.timeoutMs = DEFAULT_TIMEOUT_MS;
+      this.timeoutMs = DEFAULT_TIMEOUT_MS2;
     }
   }
   async call(options) {
@@ -1403,23 +1602,16 @@ var ClaudeCliProvider = class {
     const combined = this.buildCombinedPrompt(options);
     const args = ["-p"];
     if (options.model) args.push("--model", options.model);
-    const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "inherit"],
-      env: process.env,
-      shell: true
-    }) : spawn2(CLAUDE_CLI_BIN, args, {
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "inherit"],
-      env: process.env
-    });
+    const child = spawnClaude(args);
     child.stdin.end(combined);
     let settled = false;
     const chunks = [];
+    const stderrChunks = [];
     child.stdout.on("data", (chunk) => {
       chunks.push(chunk);
       callbacks.onText(chunk.toString("utf-8"));
     });
+    child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
       if (!settled) {
@@ -1445,45 +1637,40 @@ var ClaudeCliProvider = class {
       if (code === 0) {
         callbacks.onEnd({ stopReason: "end_turn" });
       } else {
+        const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+        const friendly = parseSeatBasedError(stderr, code);
         const stdout = Buffer.concat(chunks).toString("utf-8").trim();
-        const msg = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
-        callbacks.onError(new Error(stdout ? `${msg}. Output: ${stdout.slice(0, 200)}` : msg));
+        const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
+        const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
+        callbacks.onError(new Error(detail ? `${base}. ${detail}` : base));
       }
     });
   }
   buildCombinedPrompt(options) {
     const streamOpts = options;
     const hasHistory = streamOpts.messages && streamOpts.messages.length > 0;
-    let combined = "";
-    combined += "[[System]]\n" + options.system + "\n\n";
+    let combined = options.system + "\n\n";
     if (hasHistory) {
       for (const msg of streamOpts.messages) {
-        combined += `[[${msg.role === "user" ? "User" : "Assistant"}]]
-${msg.content}
+        const label = msg.role === "user" ? "User" : "Assistant";
+        combined += `${label}: ${msg.content}
 
 `;
       }
     }
-    combined += "[[User]]\n" + options.prompt;
+    combined += options.prompt;
     return combined;
   }
   runClaudePrint(combinedPrompt, model) {
     return new Promise((resolve2, reject) => {
       const args = ["-p"];
       if (model) args.push("--model", model);
-      const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "inherit"],
-        env: process.env,
-        shell: true
-      }) : spawn2(CLAUDE_CLI_BIN, args, {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "inherit"],
-        env: process.env
-      });
+      const child = spawnClaude(args);
       child.stdin.end(combinedPrompt);
       const chunks = [];
+      const stderrChunks = [];
       child.stdout.on("data", (chunk) => chunks.push(chunk));
+      child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
       child.on("error", (err) => {
         clearTimeout(timer);
         reject(err);
@@ -1494,8 +1681,11 @@ ${msg.content}
         if (code === 0) {
           resolve2(stdout);
         } else {
-          const msg = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
-          reject(new Error(stdout ? `${msg}. Output: ${stdout.slice(0, 200)}` : msg));
+          const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+          const friendly = parseSeatBasedError(stderr, code);
+          const base = signal ? `Claude CLI killed (${signal})` : code != null ? `Claude CLI exited with code ${code}` : "Claude CLI exited";
+          const detail = friendly || stderr || (stdout ? stdout.slice(0, 200) : "");
+          reject(new Error(detail ? `${base}. ${detail}` : base));
         }
       });
       const timer = setTimeout(() => {
@@ -1669,6 +1859,7 @@ async function handleModelNotAvailable(failedModel, provider, config) {
 }
 
 // src/llm/index.ts
+init_types();
 init_config();
 var cachedProvider = null;
 var cachedConfig = null;
@@ -1744,11 +1935,11 @@ async function llmCall(options) {
         throw error;
       }
       if (isOverloaded(error) && attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, 2e3));
+        await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt - 1)));
         continue;
       }
       if (isTransientError(error) && attempt < MAX_RETRIES) {
-        await new Promise((r) => setTimeout(r, 2e3));
+        await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt - 1)));
         continue;
       }
       throw error;
@@ -1764,7 +1955,8 @@ async function validateModel(options) {
   const provider = getProvider();
   const config = cachedConfig;
   if (!config) return;
-  if (config.provider === "cursor" || config.provider === "claude-cli") return;
+  const { isSeatBased: isSeatBased2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+  if (isSeatBased2(config.provider)) return;
   const modelsToCheck = [config.model];
   if (options?.fast) {
     const { getFastModel: getFastModel2 } = await Promise.resolve().then(() => (init_config(), config_exports));
@@ -2212,12 +2404,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 +2521,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 +2549,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 +2568,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 +2800,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 +2817,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 +2831,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 +2861,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 +2871,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 +2879,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 +2948,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 +2962,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 +2988,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 +3112,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 +3201,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 +3222,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 +3272,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 +3314,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs9.writeFileSync(skillPath, frontmatter + skill.content);
+      fs10.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -3093,62 +3323,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 +3394,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs12.unlinkSync(filePath);
+    fs13.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -3194,8 +3424,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 +3435,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 +3471,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 +3497,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 +3521,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 +3613,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 +3777,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 +3826,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 +3843,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 +3860,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 +3871,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 +3887,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 +3966,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 +3988,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 +4041,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 +4085,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 +4093,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 +4173,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 +4187,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 +4196,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();
@@ -4126,8 +4356,11 @@ async function runInteractiveProviderSetup(options) {
         console.log(chalk5.dim("  Then run ") + chalk5.hex("#83D1EB")("agent login") + chalk5.dim(" to authenticate.\n"));
         const proceed = await confirm({ message: "Continue anyway?" });
         if (!proceed) throw new Error("__exit__");
-      } else {
-        console.log(chalk5.dim("  Run `agent login` if you haven't, or set CURSOR_API_KEY."));
+      } else if (!isCursorLoggedIn()) {
+        console.log(chalk5.yellow("\n  Cursor Agent CLI found but not logged in."));
+        console.log(chalk5.dim("  Run ") + chalk5.hex("#83D1EB")("agent login") + chalk5.dim(" to authenticate.\n"));
+        const proceed = await confirm({ message: "Continue anyway?" });
+        if (!proceed) throw new Error("__exit__");
       }
       break;
     }
@@ -4918,7 +5151,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 +5160,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 +5187,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 +5196,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 +5211,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 +5288,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 +5313,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 +5436,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 +5554,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 +5814,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 +5829,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 +5842,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 +5860,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 +5870,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 +5888,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 +5898,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 +5911,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 +5929,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 +5950,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 +5965,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 +6941,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 +7084,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 +7154,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) {
@@ -7421,11 +7654,10 @@ async function initCommand(options) {
   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) {
@@ -7661,7 +7893,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 = [];
@@ -7845,9 +8077,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)}
 `));
   }
 }
@@ -7894,7 +8126,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}`;
 }
@@ -8028,7 +8260,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}`));
@@ -8038,7 +8270,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}`));
@@ -8049,7 +8281,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}`));
@@ -8059,7 +8291,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}`));
@@ -8069,7 +8301,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}`));
@@ -8079,7 +8311,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}`));
@@ -8090,7 +8322,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) {
@@ -8154,8 +8386,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 {
   }
@@ -8164,8 +8396,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();
@@ -8189,7 +8421,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()}`,
       "",
@@ -8202,8 +8434,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 {
@@ -8244,7 +8476,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();
@@ -8271,7 +8503,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})`);
   }
@@ -8453,13 +8685,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",
@@ -8474,7 +8706,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync13(cmd, {
+    return execSync14(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -8532,37 +8764,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);
     }
   }
@@ -8639,8 +8871,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
 
@@ -8724,16 +8956,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 = [
       "---",
@@ -8742,37 +8974,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;
 }
 
@@ -8784,11 +9016,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);
       }
     }
@@ -8891,7 +9123,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 });
@@ -9115,7 +9347,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs33 from "fs";
+import fs34 from "fs";
 import chalk19 from "chalk";
 
 // src/learner/stdin.ts
@@ -9147,8 +9379,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,
@@ -9156,15 +9388,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);
@@ -9175,29 +9407,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 {
@@ -9209,26 +9441,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 });
@@ -9236,14 +9468,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;
       }
@@ -9251,7 +9483,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;
@@ -9260,7 +9492,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs31.existsSync(lockPath)) fs31.unlinkSync(lockPath);
+    if (fs32.existsSync(lockPath)) fs32.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -9306,7 +9538,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") {
@@ -9354,7 +9586,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) {
@@ -9416,8 +9648,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,
@@ -9431,22 +9663,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;
@@ -9699,7 +9931,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");
@@ -9708,7 +9940,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");
@@ -9717,7 +9949,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;
@@ -9789,9 +10021,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;
@@ -9865,16 +10097,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)\./);
@@ -9898,9 +10130,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;
   }
@@ -9946,7 +10178,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" }
@@ -9963,7 +10195,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" }
       });