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

package/dist/bin.js

@@ -169,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, {
@@ -200,6 +216,56 @@ var init_constants = __esm({
   }
 });
 
+// src/lib/resolve-caliber.ts
+var resolve_caliber_exports = {};
+__export(resolve_caliber_exports, {
+  isCaliberCommand: () => isCaliberCommand,
+  resolveCaliber: () => resolveCaliber
+});
+import fs18 from "fs";
+import { execSync as execSync7 } from "child_process";
+function resolveCaliber() {
+  if (_resolved) return _resolved;
+  const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
+  if (isNpx) {
+    _resolved = "npx --yes @rely-ai/caliber";
+    return _resolved;
+  }
+  try {
+    const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
+    const found = execSync7(whichCmd, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (found) {
+      _resolved = found;
+      return _resolved;
+    }
+  } catch {
+  }
+  const binPath = process.argv[1];
+  if (binPath && fs18.existsSync(binPath)) {
+    _resolved = binPath;
+    return _resolved;
+  }
+  _resolved = "caliber";
+  return _resolved;
+}
+function isCaliberCommand(command, subcommandTail) {
+  if (command === `caliber ${subcommandTail}`) return true;
+  if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
+  if (command === `npx --yes @rely-ai/caliber ${subcommandTail}`) return true;
+  if (command === `npx @rely-ai/caliber ${subcommandTail}`) return true;
+  return false;
+}
+var _resolved;
+var init_resolve_caliber = __esm({
+  "src/lib/resolve-caliber.ts"() {
+    "use strict";
+    _resolved = null;
+  }
+});
+
 // src/lib/lock.ts
 var lock_exports = {};
 __export(lock_exports, {
@@ -207,13 +273,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs30 from "fs";
-import path24 from "path";
-import os6 from "os";
+import fs31 from "fs";
+import path25 from "path";
+import os7 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs30.existsSync(LOCK_FILE)) return false;
-    const raw = fs30.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs31.existsSync(LOCK_FILE)) return false;
+    const raw = fs31.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -228,13 +294,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs30.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs31.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs30.existsSync(LOCK_FILE)) fs30.unlinkSync(LOCK_FILE);
+    if (fs31.existsSync(LOCK_FILE)) fs31.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -242,15 +308,15 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path24.join(os6.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path25.join(os7.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs35 from "fs";
-import path28 from "path";
+import fs38 from "fs";
+import path30 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
@@ -1036,8 +1102,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 = [];
@@ -1140,8 +1206,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 ? [
@@ -1261,14 +1327,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);
@@ -1280,6 +1376,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") {
@@ -1293,23 +1412,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);
         }
@@ -1320,14 +1494,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");
@@ -1352,16 +1532,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" });
@@ -1374,9 +1564,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();
         }
@@ -1403,28 +1600,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) {
@@ -1435,23 +1652,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) {
@@ -1477,45 +1687,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);
@@ -1526,8 +1731,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(() => {
@@ -1701,6 +1909,7 @@ async function handleModelNotAvailable(failedModel, provider, config) {
 }
 
 // src/llm/index.ts
+init_types();
 init_config();
 var cachedProvider = null;
 var cachedConfig = null;
@@ -1776,11 +1985,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;
@@ -1796,7 +2005,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));
@@ -2408,15 +2618,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path30) {
+function readFileOrNull(path32) {
   try {
-    return readFileSync(path30, "utf-8");
+    return readFileSync(path32, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path30) {
-  const content = readFileOrNull(path30);
+function readJsonOrNull(path32) {
+  const content = readFileOrNull(path32);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3683,50 +3893,10 @@ ${agentRefs.join(" ")}
 }
 
 // src/lib/hooks.ts
+init_resolve_caliber();
 import fs19 from "fs";
 import path14 from "path";
 import { execSync as execSync8 } from "child_process";
-
-// src/lib/resolve-caliber.ts
-import fs18 from "fs";
-import { execSync as execSync7 } from "child_process";
-var _resolved = null;
-function resolveCaliber() {
-  if (_resolved) return _resolved;
-  const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
-  if (isNpx) {
-    _resolved = "npx --yes @rely-ai/caliber";
-    return _resolved;
-  }
-  try {
-    const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    const found = execSync7(whichCmd, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (found) {
-      _resolved = found;
-      return _resolved;
-    }
-  } catch {
-  }
-  const binPath = process.argv[1];
-  if (binPath && fs18.existsSync(binPath)) {
-    _resolved = binPath;
-    return _resolved;
-  }
-  _resolved = "caliber";
-  return _resolved;
-}
-function isCaliberCommand(command, subcommandTail) {
-  if (command === `caliber ${subcommandTail}`) return true;
-  if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
-  if (command === `npx --yes @rely-ai/caliber ${subcommandTail}`) return true;
-  if (command === `npx @rely-ai/caliber ${subcommandTail}`) return true;
-  return false;
-}
-
-// src/lib/hooks.ts
 var SETTINGS_PATH = path14.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
@@ -3862,6 +4032,7 @@ function removePreCommitHook() {
 }
 
 // src/lib/learning-hooks.ts
+init_resolve_caliber();
 import fs20 from "fs";
 import path15 from "path";
 var SETTINGS_PATH2 = path15.join(".claude", "settings.json");
@@ -3869,7 +4040,7 @@ 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" },
   { event: "UserPromptSubmit", tail: "learn observe --prompt", description: "Caliber: recording user prompt for correction detection" },
-  { event: "SessionEnd", tail: "learn finalize", description: "Caliber: finalizing session learnings" }
+  { event: "SessionEnd", tail: "learn finalize --auto", description: "Caliber: finalizing session learnings" }
 ];
 function getHookConfigs() {
   const bin = resolveCaliber();
@@ -3930,7 +4101,7 @@ var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
   { event: "userPromptSubmit", tail: "learn observe --prompt" },
-  { event: "sessionEnd", tail: "learn finalize" }
+  { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
   if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
@@ -4196,8 +4367,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;
     }
@@ -5991,6 +6165,9 @@ function trackLearnNewLearning(props) {
     source_event_count: props.sourceEventCount
   });
 }
+function trackInsightsViewed(totalSessions, learningCount) {
+  trackEvent("insights_viewed", { total_sessions: totalSessions, learning_count: learningCount });
+}
 
 // src/commands/recommend.ts
 function detectLocalPlatforms() {
@@ -6778,11 +6955,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path30) => {
-    const cached = existsCache.get(path30);
+  const cachedExists = (path32) => {
+    const cached = existsCache.get(path32);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path30);
-    existsCache.set(path30, result);
+    const result = existsSync9(path32);
+    existsCache.set(path32, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -7963,7 +8140,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path30, desc]) => `  ${path30}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path32, desc]) => `  ${path32}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -8068,6 +8245,7 @@ async function promptLearnInstall(targetAgent) {
 `));
   return select5({
     message: "Enable session learning?",
+    default: true,
     choices: [
       { name: "Enable session learning (recommended)", value: true },
       { name: "Skip for now", value: false }
@@ -8494,12 +8672,79 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
+import fs28 from "fs";
+import os6 from "os";
+import path22 from "path";
+import { execFileSync } from "child_process";
 import chalk15 from "chalk";
+var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
+var CONFIG_DIRS = [".claude", ".cursor"];
+function scoreBaseRef(ref, target) {
+  if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
+  const tmpDir = fs28.mkdtempSync(path22.join(os6.tmpdir(), "caliber-compare-"));
+  try {
+    for (const file of CONFIG_FILES) {
+      try {
+        const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        fs28.writeFileSync(path22.join(tmpDir, file), content);
+      } catch {
+      }
+    }
+    for (const dir of CONFIG_DIRS) {
+      try {
+        const files = execFileSync("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean);
+        for (const file of files) {
+          const filePath = path22.join(tmpDir, file);
+          fs28.mkdirSync(path22.dirname(filePath), { recursive: true });
+          const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+          fs28.writeFileSync(filePath, content);
+        }
+      } catch {
+      }
+    }
+    const result = computeLocalScore(tmpDir, target);
+    return { score: result.score, grade: result.grade };
+  } catch {
+    return null;
+  } finally {
+    fs28.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
 async function scoreCommand(options) {
   const dir = process.cwd();
   const target = options.agent ?? readState()?.targetAgent;
   const result = computeLocalScore(dir, target);
   trackScoreComputed(result.score, target);
+  if (options.compare) {
+    const baseResult = scoreBaseRef(options.compare, target);
+    if (!baseResult) {
+      console.error(chalk15.red(`Could not score ref "${options.compare}" \u2014 branch or ref not found.`));
+      process.exitCode = 1;
+      return;
+    }
+    const delta = result.score - baseResult.score;
+    if (options.json) {
+      console.log(JSON.stringify({ current: result, base: { score: baseResult.score, grade: baseResult.grade, ref: options.compare }, delta }, null, 2));
+      return;
+    }
+    if (options.quiet) {
+      const sign = delta > 0 ? "+" : "";
+      console.log(`${result.score}/100 (${result.grade}) ${sign}${delta} from ${options.compare}`);
+      return;
+    }
+    displayScore(result);
+    const separator2 = chalk15.gray("  " + "\u2500".repeat(53));
+    console.log(separator2);
+    if (delta > 0) {
+      console.log(chalk15.green(`  +${delta}`) + chalk15.gray(` from ${options.compare} (${baseResult.score}/100)`));
+    } else if (delta < 0) {
+      console.log(chalk15.red(`  ${delta}`) + chalk15.gray(` from ${options.compare} (${baseResult.score}/100)`));
+    } else {
+      console.log(chalk15.gray(`  No change from ${options.compare} (${baseResult.score}/100)`));
+    }
+    console.log("");
+    return;
+  }
   if (options.json) {
     console.log(JSON.stringify(result, null, 2));
     return;
@@ -8522,8 +8767,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs31 from "fs";
-import path25 from "path";
+import fs32 from "fs";
+import path26 from "path";
 import chalk16 from "chalk";
 import ora6 from "ora";
 
@@ -8601,37 +8846,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs28 from "fs";
-import path22 from "path";
+import fs29 from "fs";
+import path23 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs28.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs29.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs28.writeFileSync("README.md", docs.readmeMd);
+    fs29.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs28.writeFileSync(".cursorrules", docs.cursorrules);
+    fs29.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path22.join(".cursor", "rules");
-    if (!fs28.existsSync(rulesDir)) fs28.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path23.join(".cursor", "rules");
+    if (!fs29.existsSync(rulesDir)) fs29.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path22.join(rulesDir, rule.filename);
-      fs28.writeFileSync(filePath, rule.content);
+      const filePath = path23.join(rulesDir, rule.filename);
+      fs29.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path22.join(".claude", "skills");
-    if (!fs28.existsSync(skillsDir)) fs28.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path23.join(".claude", "skills");
+    if (!fs29.existsSync(skillsDir)) fs29.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path22.join(skillsDir, skill.filename);
-      fs28.writeFileSync(filePath, skill.content);
+      const filePath = path23.join(skillsDir, skill.filename);
+      fs29.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -8708,8 +8953,29 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs29 from "fs";
-import path23 from "path";
+import fs30 from "fs";
+import path24 from "path";
+
+// src/learner/utils.ts
+var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
+function normalizeBullet(bullet) {
+  return bullet.replace(/^- /, "").replace(TYPE_PREFIX_RE, "").replace(/`[^`]*`/g, "").replace(/\s+/g, " ").toLowerCase().trim();
+}
+function hasTypePrefix(bullet) {
+  return TYPE_PREFIX_RE.test(bullet.replace(/^- /, ""));
+}
+var SIMILARITY_THRESHOLD = 0.7;
+function isSimilarLearning(a, b) {
+  const normA = normalizeBullet(a);
+  const normB = normalizeBullet(b);
+  if (!normA || !normB) return false;
+  const shorter = Math.min(normA.length, normB.length);
+  const longer = Math.max(normA.length, normB.length);
+  if (!(normA.includes(normB) || normB.includes(normA))) return false;
+  return shorter / longer > SIMILARITY_THRESHOLD;
+}
+
+// src/learner/writer.ts
 var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
 var LEARNINGS_HEADER = `# Caliber Learnings
 
@@ -8756,13 +9022,6 @@ function parseBullets(content) {
   if (current) bullets.push(current);
   return bullets;
 }
-var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
-function normalizeBullet(bullet) {
-  return bullet.replace(/^- /, "").replace(TYPE_PREFIX_RE, "").replace(/`[^`]*`/g, "").replace(/\s+/g, " ").toLowerCase().trim();
-}
-function hasTypePrefix(bullet) {
-  return TYPE_PREFIX_RE.test(bullet.replace(/^- /, ""));
-}
 function deduplicateLearnedItems(existing, incoming) {
   const existingBullets = existing ? parseBullets(existing) : [];
   const incomingBullets = parseBullets(incoming);
@@ -8771,13 +9030,7 @@ function deduplicateLearnedItems(existing, incoming) {
   for (const bullet of incomingBullets) {
     const norm = normalizeBullet(bullet);
     if (!norm) continue;
-    const dupIdx = merged.findIndex((e) => {
-      const eNorm = normalizeBullet(e);
-      const shorter = Math.min(norm.length, eNorm.length);
-      const longer = Math.max(norm.length, eNorm.length);
-      if (!(eNorm.includes(norm) || norm.includes(eNorm))) return false;
-      return shorter / longer > 0.7;
-    });
+    const dupIdx = merged.findIndex((e) => isSimilarLearning(bullet, e));
     if (dupIdx !== -1) {
       if (hasTypePrefix(bullet) && !hasTypePrefix(merged[dupIdx])) {
         merged[dupIdx] = bullet;
@@ -8793,16 +9046,16 @@ function deduplicateLearnedItems(existing, incoming) {
 function writeLearnedSection(content) {
   const existingSection = readLearnedSection();
   const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
-  fs29.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+  fs30.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
   return { newCount, newItems };
 }
 function writeLearnedSkill(skill) {
-  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);
+  const skillDir = path24.join(".claude", "skills", skill.name);
+  if (!fs30.existsSync(skillDir)) fs30.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path24.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs30.existsSync(skillPath)) {
+    const existing = fs30.readFileSync(skillPath, "utf-8");
+    fs30.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -8811,37 +9064,37 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs29.writeFileSync(skillPath, frontmatter + skill.content);
+    fs30.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
-  if (fs29.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs29.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs30.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs30.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs29.existsSync(claudeMdPath)) return null;
-  const content = fs29.readFileSync(claudeMdPath, "utf-8");
+  if (!fs30.existsSync(claudeMdPath)) return null;
+  const content = fs30.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 (fs29.existsSync(LEARNINGS_FILE)) return false;
+  if (fs30.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs29.existsSync(claudeMdPath)) return false;
-  const content = fs29.readFileSync(claudeMdPath, "utf-8");
+  if (!fs30.existsSync(claudeMdPath)) return false;
+  const content = fs30.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;
-  fs29.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs30.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs29.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs30.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -8853,11 +9106,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs31.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs32.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path25.join(parentDir, entry.name);
-      if (fs31.existsSync(path25.join(childPath, ".git"))) {
+      const childPath = path26.join(parentDir, entry.name);
+      if (fs32.existsSync(path26.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -8960,7 +9213,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path25.basename(repo);
+      const repoName = path26.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -8981,6 +9234,7 @@ async function refreshCommand(options) {
 
 // src/commands/hooks.ts
 import chalk17 from "chalk";
+import fs33 from "fs";
 var HOOKS = [
   {
     id: "session-end",
@@ -9020,6 +9274,14 @@ async function hooksCommand(options) {
         console.log(chalk17.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
+    if (fs33.existsSync(".claude")) {
+      const r = installLearningHooks();
+      if (r.installed) console.log(chalk17.green("  \u2713") + " Claude Code learning hooks enabled");
+    }
+    if (fs33.existsSync(".cursor")) {
+      const r = installCursorLearningHooks();
+      if (r.installed) console.log(chalk17.green("  \u2713") + " Cursor learning hooks enabled");
+    }
     return;
   }
   if (options.remove) {
@@ -9184,8 +9446,8 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs34 from "fs";
-import chalk19 from "chalk";
+import fs37 from "fs";
+import chalk20 from "chalk";
 
 // src/learner/stdin.ts
 var STDIN_TIMEOUT_MS = 5e3;
@@ -9216,24 +9478,25 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs32 from "fs";
-import path26 from "path";
+import fs34 from "fs";
+import path27 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
   eventCount: 0,
-  lastAnalysisTimestamp: null
+  lastAnalysisTimestamp: null,
+  lastAnalysisEventCount: 0
 };
 function ensureLearningDir() {
-  if (!fs32.existsSync(LEARNING_DIR)) {
-    fs32.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs34.existsSync(LEARNING_DIR)) {
+    fs34.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path26.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path27.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path26.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path27.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -9244,29 +9507,29 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs32.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs34.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs34.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs32.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs34.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs32.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  fs34.appendFileSync(filePath, JSON.stringify(event) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs34.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs32.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs34.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs32.existsSync(filePath)) return [];
-  const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs34.existsSync(filePath)) return [];
+  const lines = fs34.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -9278,26 +9541,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs32.existsSync(filePath)) return 0;
-  const content = fs32.readFileSync(filePath, "utf-8");
+  if (!fs34.existsSync(filePath)) return 0;
+  const content = fs34.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs32.existsSync(filePath)) fs32.unlinkSync(filePath);
+  if (fs34.existsSync(filePath)) fs34.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs32.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs34.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs32.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs34.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs32.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs34.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -9305,14 +9568,14 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path26.join(LEARNING_DIR, LOCK_FILE2);
+  return path27.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs32.existsSync(lockPath)) {
+  if (fs34.existsSync(lockPath)) {
     try {
-      const stat = fs32.statSync(lockPath);
+      const stat = fs34.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
         return false;
       }
@@ -9320,7 +9583,7 @@ function acquireFinalizeLock() {
     }
   }
   try {
-    fs32.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs34.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -9329,7 +9592,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs32.existsSync(lockPath)) fs32.unlinkSync(lockPath);
+    if (fs34.existsSync(lockPath)) fs34.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -9373,6 +9636,45 @@ function sanitizeSecrets(text) {
   return result;
 }
 
+// src/lib/notifications.ts
+init_constants();
+import fs35 from "fs";
+import path28 from "path";
+import chalk19 from "chalk";
+var NOTIFICATION_FILE = path28.join(LEARNING_DIR, "last-finalize-summary.json");
+function writeFinalizeSummary(summary) {
+  try {
+    ensureLearningDir();
+    fs35.writeFileSync(NOTIFICATION_FILE, JSON.stringify(summary, null, 2));
+  } catch {
+  }
+}
+function checkPendingNotifications() {
+  try {
+    if (!fs35.existsSync(NOTIFICATION_FILE)) return;
+    const raw = fs35.readFileSync(NOTIFICATION_FILE, "utf-8");
+    fs35.unlinkSync(NOTIFICATION_FILE);
+    const summary = JSON.parse(raw);
+    if (!summary.newItemCount || summary.newItemCount === 0) return;
+    const wasteLabel = summary.wasteTokens > 0 ? ` (~${summary.wasteTokens.toLocaleString()} wasted tokens captured)` : "";
+    console.log(
+      chalk19.dim(`caliber: learned ${summary.newItemCount} new pattern${summary.newItemCount === 1 ? "" : "s"} from your last session${wasteLabel}`)
+    );
+    for (const item of summary.newItems.slice(0, 3)) {
+      console.log(chalk19.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
+    }
+    if (summary.newItems.length > 3) {
+      console.log(chalk19.dim(`  ... and ${summary.newItems.length - 3} more`));
+    }
+    console.log("");
+  } catch {
+    try {
+      fs35.unlinkSync(NOTIFICATION_FILE);
+    } catch {
+    }
+  }
+}
+
 // src/ai/learn.ts
 init_config();
 var MAX_PROMPT_TOKENS = 1e5;
@@ -9442,14 +9744,29 @@ ${existingLearnedSection}`);
 
 ${skillsSummary}`);
   }
-  const prompt = `${contextParts.length ? contextParts.join("\n\n---\n\n") + "\n\n---\n\n" : ""}## Tool Events from Session (${fittedEvents.length} events)
+  contextParts.push(`## Task Segmentation & Attribution Instructions
+
+Analyze the event timeline and identify logical tasks (a task = one user intent, from their prompt through the agent's work until the next user prompt or session end).
+
+For each task, determine:
+- "summary": what the user was trying to accomplish (1 sentence)
+- "outcome": "success" (completed without issues), "corrected" (user had to redirect the agent), or "failed" (task was abandoned or produced errors)
+- "startEventIdx" and "endEventIdx": 0-based indices in the event list
+- "attribution": if the task was corrected or failed, identify which section of CLAUDE.md (by ## heading) SHOULD have contained guidance that would have prevented the issue. Include "configSection" (the heading text) and "relevance" (0-1).
+
+Include the "tasks" array in your JSON response alongside "claudeMdLearnedSection", "skills", and "explanations".`);
+  const prompt = `${contextParts.join("\n\n---\n\n")}
+
+---
+
+## Tool Events from Session (${fittedEvents.length} events)
 
 ${eventsText}`;
   const fastModel = getFastModel();
   const raw = await llmCall({
     system: LEARN_SYSTEM_PROMPT,
     prompt,
-    maxTokens: 4096,
+    maxTokens: 8192,
     ...fastModel ? { model: fastModel } : {}
   });
   return parseAnalysisResponse(raw);
@@ -9485,8 +9802,8 @@ init_config();
 
 // src/learner/roi.ts
 init_constants();
-import fs33 from "fs";
-import path27 from "path";
+import fs36 from "fs";
+import path29 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
   totalWasteSeconds: 0,
@@ -9500,22 +9817,22 @@ var DEFAULT_TOTALS = {
   lastSessionTimestamp: ""
 };
 function roiFilePath() {
-  return path27.join(LEARNING_DIR, LEARNING_ROI_FILE);
+  return path29.join(LEARNING_DIR, LEARNING_ROI_FILE);
 }
 function readROIStats() {
   const filePath = roiFilePath();
-  if (!fs33.existsSync(filePath)) {
+  if (!fs36.existsSync(filePath)) {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
   try {
-    return JSON.parse(fs33.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs36.readFileSync(filePath, "utf-8"));
   } catch {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
 }
 function writeROIStats(stats) {
   ensureLearningDir();
-  fs33.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
+  fs36.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
 }
 function recalculateTotals(stats) {
   const totals = stats.totals;
@@ -9548,7 +9865,16 @@ function recordSession(summary, learnings) {
   const stats = readROIStats();
   stats.sessions.push(summary);
   if (learnings?.length) {
-    stats.learnings.push(...learnings);
+    for (const entry of learnings) {
+      const existingIdx = stats.learnings.findIndex((e) => isSimilarLearning(e.summary, entry.summary));
+      if (existingIdx !== -1) {
+        stats.learnings[existingIdx].occurrences = (stats.learnings[existingIdx].occurrences || 1) + 1;
+        stats.learnings[existingIdx].timestamp = entry.timestamp;
+      } else {
+        entry.occurrences = 1;
+        stats.learnings.push(entry);
+      }
+    }
   }
   if (stats.sessions.length > MAX_SESSIONS) {
     stats.sessions = stats.sessions.slice(-MAX_SESSIONS);
@@ -9597,6 +9923,9 @@ function formatROISummary(stats) {
 
 // src/commands/learn.ts
 var MIN_EVENTS_FOR_ANALYSIS = 25;
+var MIN_EVENTS_AUTO = 10;
+var AUTO_SETTLE_MS = 200;
+var INCREMENTAL_INTERVAL = 50;
 async function learnObserveCommand(options) {
   try {
     const raw = await readStdin();
@@ -9633,33 +9962,53 @@ async function learnObserveCommand(options) {
     state.eventCount++;
     if (!state.sessionId) state.sessionId = sessionId;
     writeState2(state);
+    const eventsSinceLastAnalysis = state.eventCount - (state.lastAnalysisEventCount || 0);
+    if (eventsSinceLastAnalysis >= INCREMENTAL_INTERVAL) {
+      try {
+        const { resolveCaliber: resolveCaliber2 } = await Promise.resolve().then(() => (init_resolve_caliber(), resolve_caliber_exports));
+        const bin = resolveCaliber2();
+        const { spawn: spawn4 } = await import("child_process");
+        spawn4(bin, ["learn", "finalize", "--auto", "--incremental"], {
+          detached: true,
+          stdio: "ignore"
+        }).unref();
+      } catch {
+      }
+    }
   } catch {
   }
 }
 async function learnFinalizeCommand(options) {
-  if (!options?.force) {
+  const isAuto = options?.auto === true;
+  const isIncremental = options?.incremental === true;
+  if (!options?.force && !isAuto) {
     const { isCaliberRunning: isCaliberRunning2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
     if (isCaliberRunning2()) {
-      console.log(chalk19.dim("caliber: skipping finalize \u2014 another caliber process is running"));
+      if (!isAuto) console.log(chalk20.dim("caliber: skipping finalize \u2014 another caliber process is running"));
       return;
     }
   }
+  if (isAuto) {
+    await new Promise((r) => setTimeout(r, AUTO_SETTLE_MS));
+  }
   if (!acquireFinalizeLock()) {
-    console.log(chalk19.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
+    if (!isAuto) console.log(chalk20.dim("caliber: skipping finalize \u2014 another finalize is in progress"));
     return;
   }
   let analyzed = false;
   try {
     const config = loadConfig();
     if (!config) {
-      console.log(chalk19.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
+      if (isAuto) return;
+      console.log(chalk20.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
       clearSession();
       resetState();
       return;
     }
     const events = readAllEvents();
-    if (events.length < MIN_EVENTS_FOR_ANALYSIS) {
-      console.log(chalk19.dim(`caliber: ${events.length}/${MIN_EVENTS_FOR_ANALYSIS} events recorded \u2014 need more before analysis`));
+    const threshold = isAuto ? MIN_EVENTS_AUTO : MIN_EVENTS_FOR_ANALYSIS;
+    if (events.length < threshold) {
+      if (!isAuto) console.log(chalk20.dim(`caliber: ${events.length}/${threshold} events recorded \u2014 need more before analysis`));
       return;
     }
     await validateModel({ fast: true });
@@ -9686,10 +10035,19 @@ async function learnFinalizeCommand(options) {
       });
       newLearningsProduced = result.newItemCount;
       if (result.newItemCount > 0) {
-        const wasteLabel = waste.totalWasteTokens > 0 ? ` (~${waste.totalWasteTokens.toLocaleString()} wasted tokens captured)` : "";
-        console.log(chalk19.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}${wasteLabel}`));
-        for (const item of result.newItems) {
-          console.log(chalk19.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
+        if (isAuto) {
+          writeFinalizeSummary({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            newItemCount: result.newItemCount,
+            newItems: result.newItems,
+            wasteTokens: waste.totalWasteTokens
+          });
+        } else {
+          const wasteLabel = waste.totalWasteTokens > 0 ? ` (~${waste.totalWasteTokens.toLocaleString()} wasted tokens captured)` : "";
+          console.log(chalk20.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}${wasteLabel}`));
+          for (const item of result.newItems) {
+            console.log(chalk20.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
+          }
         }
         const wastePerLearning = Math.round(waste.totalWasteTokens / result.newItemCount);
         const TYPE_RE = /^\*\*\[([^\]]+)\]\*\*/;
@@ -9714,6 +10072,15 @@ async function learnFinalizeCommand(options) {
         roiLearningEntries = learningEntries;
       }
     }
+    const tasks = response.tasks || [];
+    let taskSuccessCount = 0;
+    let taskCorrectionCount = 0;
+    let taskFailureCount = 0;
+    for (const t2 of tasks) {
+      if (t2.outcome === "success") taskSuccessCount++;
+      else if (t2.outcome === "corrected") taskCorrectionCount++;
+      else if (t2.outcome === "failed") taskFailureCount++;
+    }
     const sessionSummary = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       sessionId: readState2().sessionId || "unknown",
@@ -9723,7 +10090,11 @@ async function learnFinalizeCommand(options) {
       wasteSeconds: Math.round(waste.totalWasteSeconds),
       hadLearningsAvailable: hadLearnings,
       learningsCount: existingLearnedItems,
-      newLearningsProduced
+      newLearningsProduced,
+      taskCount: tasks.length > 0 ? tasks.length : void 0,
+      taskSuccessCount: tasks.length > 0 ? taskSuccessCount : void 0,
+      taskCorrectionCount: tasks.length > 0 ? taskCorrectionCount : void 0,
+      taskFailureCount: tasks.length > 0 ? taskFailureCount : void 0
     };
     const roiStats = recordSession(sessionSummary, roiLearningEntries);
     trackLearnSessionAnalyzed({
@@ -9750,66 +10121,73 @@ async function learnFinalizeCommand(options) {
       estimatedSavingsSeconds: t.estimatedSavingsSeconds,
       learningCount: roiStats.learnings.length
     });
-    if (t.estimatedSavingsTokens > 0) {
+    if (!isAuto && t.estimatedSavingsTokens > 0) {
       const totalLearnings = existingLearnedItems + newLearningsProduced;
-      console.log(chalk19.dim(`caliber: ${totalLearnings} learnings active \u2014 est. ~${t.estimatedSavingsTokens.toLocaleString()} tokens saved across ${t.totalSessionsWithLearnings} sessions`));
+      console.log(chalk20.dim(`caliber: ${totalLearnings} learnings active \u2014 est. ~${t.estimatedSavingsTokens.toLocaleString()} tokens saved across ${t.totalSessionsWithLearnings} sessions`));
     }
   } catch (err) {
-    if (options?.force) {
-      console.error(chalk19.red("caliber: finalize failed \u2014"), err instanceof Error ? err.message : err);
+    if (options?.force && !isAuto) {
+      console.error(chalk20.red("caliber: finalize failed \u2014"), err instanceof Error ? err.message : err);
     }
   } finally {
     if (analyzed) {
-      clearSession();
-      resetState();
+      if (isIncremental) {
+        const state = readState2();
+        state.lastAnalysisEventCount = state.eventCount;
+        state.lastAnalysisTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        writeState2(state);
+      } else {
+        clearSession();
+        resetState();
+      }
     }
     releaseFinalizeLock();
   }
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs34.existsSync(".claude")) {
+  if (fs37.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
-      console.log(chalk19.green("\u2713") + " Claude Code learning hooks installed");
+      console.log(chalk20.green("\u2713") + " Claude Code learning hooks installed");
       anyInstalled = true;
     } else if (r.alreadyInstalled) {
-      console.log(chalk19.dim("  Claude Code hooks already installed"));
+      console.log(chalk20.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs34.existsSync(".cursor")) {
+  if (fs37.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
-      console.log(chalk19.green("\u2713") + " Cursor learning hooks installed");
+      console.log(chalk20.green("\u2713") + " Cursor learning hooks installed");
       anyInstalled = true;
     } else if (r.alreadyInstalled) {
-      console.log(chalk19.dim("  Cursor hooks already installed"));
+      console.log(chalk20.dim("  Cursor hooks already installed"));
     }
   }
-  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."));
+  if (!fs37.existsSync(".claude") && !fs37.existsSync(".cursor")) {
+    console.log(chalk20.yellow("No .claude/ or .cursor/ directory found."));
+    console.log(chalk20.dim("  Run `caliber init` first, or create the directory manually."));
     return;
   }
   if (anyInstalled) {
-    console.log(chalk19.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
-    console.log(chalk19.dim("  Learnings written to CALIBER_LEARNINGS.md."));
+    console.log(chalk20.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
+    console.log(chalk20.dim("  Learnings written to CALIBER_LEARNINGS.md."));
   }
 }
 async function learnRemoveCommand() {
   let anyRemoved = false;
   const r1 = removeLearningHooks();
   if (r1.removed) {
-    console.log(chalk19.green("\u2713") + " Claude Code learning hooks removed");
+    console.log(chalk20.green("\u2713") + " Claude Code learning hooks removed");
     anyRemoved = true;
   }
   const r2 = removeCursorLearningHooks();
   if (r2.removed) {
-    console.log(chalk19.green("\u2713") + " Cursor learning hooks removed");
+    console.log(chalk20.green("\u2713") + " Cursor learning hooks removed");
     anyRemoved = true;
   }
   if (!anyRemoved) {
-    console.log(chalk19.dim("No learning hooks found."));
+    console.log(chalk20.dim("No learning hooks found."));
   }
 }
 async function learnStatusCommand() {
@@ -9817,50 +10195,178 @@ async function learnStatusCommand() {
   const cursorInstalled = areCursorLearningHooksInstalled();
   const state = readState2();
   const eventCount = getEventCount();
-  console.log(chalk19.bold("Session Learning Status"));
+  console.log(chalk20.bold("Session Learning Status"));
   console.log();
   if (claudeInstalled) {
-    console.log(chalk19.green("\u2713") + " Claude Code hooks " + chalk19.green("installed"));
+    console.log(chalk20.green("\u2713") + " Claude Code hooks " + chalk20.green("installed"));
   } else {
-    console.log(chalk19.dim("\u2717") + " Claude Code hooks " + chalk19.dim("not installed"));
+    console.log(chalk20.dim("\u2717") + " Claude Code hooks " + chalk20.dim("not installed"));
   }
   if (cursorInstalled) {
-    console.log(chalk19.green("\u2713") + " Cursor hooks " + chalk19.green("installed"));
+    console.log(chalk20.green("\u2713") + " Cursor hooks " + chalk20.green("installed"));
   } else {
-    console.log(chalk19.dim("\u2717") + " Cursor hooks " + chalk19.dim("not installed"));
+    console.log(chalk20.dim("\u2717") + " Cursor hooks " + chalk20.dim("not installed"));
   }
   if (!claudeInstalled && !cursorInstalled) {
-    console.log(chalk19.dim("  Run `caliber learn install` to enable session learning."));
+    console.log(chalk20.dim("  Run `caliber learn install` to enable session learning."));
   }
   console.log();
-  console.log(`Events recorded: ${chalk19.cyan(String(eventCount))}`);
-  console.log(`Threshold for analysis: ${chalk19.cyan(String(MIN_EVENTS_FOR_ANALYSIS))}`);
+  console.log(`Events recorded: ${chalk20.cyan(String(eventCount))}`);
+  console.log(`Threshold for analysis: ${chalk20.cyan(String(MIN_EVENTS_FOR_ANALYSIS))}`);
   if (state.lastAnalysisTimestamp) {
-    console.log(`Last analysis: ${chalk19.cyan(state.lastAnalysisTimestamp)}`);
+    console.log(`Last analysis: ${chalk20.cyan(state.lastAnalysisTimestamp)}`);
   } else {
-    console.log(`Last analysis: ${chalk19.dim("none")}`);
+    console.log(`Last analysis: ${chalk20.dim("none")}`);
   }
   const learnedSection = readLearnedSection();
   if (learnedSection) {
     const lineCount = learnedSection.split("\n").filter(Boolean).length;
     console.log(`
-Learned items in CALIBER_LEARNINGS.md: ${chalk19.cyan(String(lineCount))}`);
+Learned items in CALIBER_LEARNINGS.md: ${chalk20.cyan(String(lineCount))}`);
   }
   const roiStats = readROIStats();
   const roiSummary = formatROISummary(roiStats);
   if (roiSummary) {
     console.log();
-    console.log(chalk19.bold(roiSummary.split("\n")[0]));
+    console.log(chalk20.bold(roiSummary.split("\n")[0]));
     for (const line of roiSummary.split("\n").slice(1)) {
       console.log(line);
     }
   }
 }
 
+// src/commands/insights.ts
+import chalk21 from "chalk";
+var MIN_SESSIONS_FULL = 20;
+function buildInsightsData(stats) {
+  const t = stats.totals;
+  const totalSessions = t.totalSessionsWithLearnings + t.totalSessionsWithoutLearnings;
+  const failureRateWith = t.totalSessionsWithLearnings > 0 ? t.totalFailuresWithLearnings / t.totalSessionsWithLearnings : null;
+  const failureRateWithout = t.totalSessionsWithoutLearnings > 0 ? t.totalFailuresWithoutLearnings / t.totalSessionsWithoutLearnings : null;
+  const failureRateImprovement = failureRateWith !== null && failureRateWithout !== null && failureRateWithout > 0 ? Math.round((1 - failureRateWith / failureRateWithout) * 100) : null;
+  let taskCount = 0;
+  let taskSuccessCount = 0;
+  let taskCorrectionCount = 0;
+  let taskFailureCount = 0;
+  for (const s of stats.sessions) {
+    if (s.taskCount) {
+      taskCount += s.taskCount;
+      taskSuccessCount += s.taskSuccessCount || 0;
+      taskCorrectionCount += s.taskCorrectionCount || 0;
+      taskFailureCount += s.taskFailureCount || 0;
+    }
+  }
+  const taskSuccessRate = taskCount > 0 ? Math.round(taskSuccessCount / taskCount * 100) : null;
+  return {
+    totalSessions,
+    learningCount: stats.learnings.length,
+    failureRateWith,
+    failureRateWithout,
+    failureRateImprovement,
+    taskCount,
+    taskSuccessCount,
+    taskCorrectionCount,
+    taskFailureCount,
+    taskSuccessRate,
+    totalWasteTokens: t.totalWasteTokens,
+    totalWasteSeconds: t.totalWasteSeconds,
+    estimatedSavingsTokens: t.estimatedSavingsTokens,
+    estimatedSavingsSeconds: t.estimatedSavingsSeconds
+  };
+}
+function displayColdStart(score) {
+  console.log(chalk21.bold("\n  Agent Insights\n"));
+  const hooksInstalled = areLearningHooksInstalled() || areCursorLearningHooksInstalled();
+  if (!hooksInstalled) {
+    console.log(chalk21.yellow("  No learning hooks installed."));
+    console.log(chalk21.dim("  Run ") + chalk21.cyan("caliber learn install") + chalk21.dim(" to start tracking agent performance."));
+  } else {
+    console.log(chalk21.dim("  No session data yet. Use your AI agent and insights will appear here."));
+    console.log(chalk21.dim("  Learnings are extracted automatically at the end of each session."));
+  }
+  console.log(chalk21.dim(`
+  Config score: ${score.score}/100 (${score.grade})`));
+  console.log("");
+}
+function displayEarlyData(data, score) {
+  console.log(chalk21.bold("\n  Agent Insights") + chalk21.yellow(" (early data)\n"));
+  console.log(chalk21.dim("  Still collecting data. Insights become more reliable after 20+ sessions.\n"));
+  console.log(`  Sessions tracked:       ${chalk21.cyan(String(data.totalSessions))}`);
+  console.log(`  Learnings accumulated:  ${chalk21.cyan(String(data.learningCount))}`);
+  if (data.totalWasteTokens > 0) {
+    console.log(`  Waste captured:         ${chalk21.cyan(data.totalWasteTokens.toLocaleString())} tokens`);
+  }
+  if (data.failureRateImprovement !== null && data.failureRateImprovement > 0) {
+    console.log(`  Failure rate trend:     ${chalk21.green(`${data.failureRateImprovement}% fewer`)} failures with learnings ${chalk21.dim("(early signal)")}`);
+  }
+  if (data.taskSuccessRate !== null) {
+    console.log(`  Task success rate:      ${chalk21.cyan(`${data.taskSuccessRate}%`)} ${chalk21.dim(`(${data.taskCount} tasks)`)}`);
+  }
+  console.log(`  Config score:           ${chalk21.cyan(`${score.score}/100`)} (${score.grade})`);
+  console.log("");
+}
+function displayFullInsights(data, score) {
+  console.log(chalk21.bold("\n  Agent Insights\n"));
+  console.log(chalk21.bold("  Agent Health"));
+  if (data.taskSuccessRate !== null) {
+    const color = data.taskSuccessRate >= 80 ? chalk21.green : data.taskSuccessRate >= 60 ? chalk21.yellow : chalk21.red;
+    console.log(`    Task success rate:    ${color(`${data.taskSuccessRate}%`)} across ${data.taskCount} tasks`);
+    if (data.taskCorrectionCount > 0) {
+      console.log(`    Corrections needed:   ${chalk21.yellow(String(data.taskCorrectionCount))} tasks required user correction`);
+    }
+  }
+  console.log(`    Sessions tracked:     ${chalk21.cyan(String(data.totalSessions))}`);
+  console.log(chalk21.bold("\n  Learning Impact"));
+  console.log(`    Learnings active:     ${chalk21.cyan(String(data.learningCount))}`);
+  if (data.failureRateWith !== null && data.failureRateWithout !== null) {
+    console.log(`    Failure rate:         ${chalk21.red(data.failureRateWithout.toFixed(1))}/session ${chalk21.dim("\u2192")} ${chalk21.green(data.failureRateWith.toFixed(1))}/session with learnings`);
+    if (data.failureRateImprovement !== null && data.failureRateImprovement > 0) {
+      console.log(`    Improvement:          ${chalk21.green(`${data.failureRateImprovement}%`)} fewer failures`);
+    }
+  }
+  if (data.totalWasteTokens > 0 || data.estimatedSavingsTokens > 0) {
+    console.log(chalk21.bold("\n  Efficiency"));
+    if (data.totalWasteTokens > 0) {
+      console.log(`    Waste captured:       ${chalk21.cyan(data.totalWasteTokens.toLocaleString())} tokens`);
+    }
+    if (data.estimatedSavingsTokens > 0) {
+      console.log(`    Estimated savings:    ~${chalk21.green(data.estimatedSavingsTokens.toLocaleString())} tokens`);
+    }
+    if (data.estimatedSavingsSeconds > 0) {
+      console.log(`    Time saved:           ~${chalk21.green(formatDuration(data.estimatedSavingsSeconds))}`);
+    }
+  }
+  console.log(chalk21.bold("\n  Config Quality"));
+  console.log(`    Score:                ${chalk21.cyan(`${score.score}/100`)} (${score.grade})`);
+  console.log("");
+}
+async function insightsCommand(options) {
+  const stats = readROIStats();
+  const data = buildInsightsData(stats);
+  const score = computeLocalScore(process.cwd(), readState()?.targetAgent);
+  trackInsightsViewed(data.totalSessions, data.learningCount);
+  if (options.json) {
+    console.log(JSON.stringify({
+      ...data,
+      tier: data.totalSessions === 0 ? "cold-start" : data.totalSessions < MIN_SESSIONS_FULL ? "early" : "full",
+      configScore: score.score,
+      configGrade: score.grade
+    }, null, 2));
+    return;
+  }
+  if (data.totalSessions === 0) {
+    displayColdStart(score);
+  } else if (data.totalSessions < MIN_SESSIONS_FULL) {
+    displayEarlyData(data, score);
+  } else {
+    displayFullInsights(data, score);
+  }
+}
+
 // src/cli.ts
-var __dirname = path28.dirname(fileURLToPath(import.meta.url));
+var __dirname = path30.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs35.readFileSync(path28.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs38.readFileSync(path30.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -9905,6 +10411,10 @@ program.hook("preAction", (thisCommand) => {
     setTelemetryDisabled(true);
   }
   initTelemetry();
+  const cmdName = thisCommand.name();
+  if (cmdName !== "learn" && cmdName !== "observe" && cmdName !== "finalize") {
+    checkPendingNotifications();
+  }
 });
 function parseAgentOption(value) {
   if (value === "both") return ["claude", "cursor"];
@@ -9923,27 +10433,28 @@ program.command("status").description("Show current Caliber setup status").optio
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));
 program.command("config").description("Configure LLM provider, API key, and model").action(tracked("config", configCommand));
 program.command("skills").description("Discover and install community skills for your project").action(tracked("skills", recommendCommand));
-program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).action(tracked("score", scoreCommand));
+program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--compare <ref>", "Compare score against a git ref (branch, tag, or SHA)").action(tracked("score", scoreCommand));
 program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(tracked("refresh", refreshCommand));
 program.command("hooks").description("Manage auto-refresh hooks (toggle interactively)").option("--install", "Enable all hooks non-interactively").option("--remove", "Disable all hooks non-interactively").action(tracked("hooks", hooksCommand));
+program.command("insights").description("Show agent performance insights and learning impact").option("--json", "Output as JSON").action(tracked("insights", insightsCommand));
 var learn = program.command("learn", { hidden: true }).description("[dev] Session learning \u2014 observe tool usage and extract reusable instructions");
 learn.command("observe").description("Record a tool event from stdin (called by hooks)").option("--failure", "Mark event as a tool failure").option("--prompt", "Record a user prompt event").action(tracked("learn:observe", learnObserveCommand));
-learn.command("finalize").description("Analyze session events and update CALIBER_LEARNINGS.md (called on SessionEnd)").option("--force", "Skip the running-process check (for manual invocation)").action(tracked("learn:finalize", (opts) => learnFinalizeCommand(opts)));
+learn.command("finalize").description("Analyze session events and update CALIBER_LEARNINGS.md (called on SessionEnd)").option("--force", "Skip the running-process check (for manual invocation)").option("--auto", "Silent mode for hooks (lower threshold, no interactive output)").option("--incremental", "Extract learnings mid-session without clearing events").action(tracked("learn:finalize", (opts) => learnFinalizeCommand(opts)));
 learn.command("install").description("Install learning hooks into .claude/settings.json").action(tracked("learn:install", learnInstallCommand));
 learn.command("remove").description("Remove learning hooks from .claude/settings.json").action(tracked("learn:remove", learnRemoveCommand));
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 
 // src/utils/version-check.ts
-import fs36 from "fs";
-import path29 from "path";
+import fs39 from "fs";
+import path31 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync15 } from "child_process";
-import chalk20 from "chalk";
+import chalk22 from "chalk";
 import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path29.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path31.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs36.readFileSync(path29.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs39.readFileSync(path31.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
@@ -9968,8 +10479,8 @@ function isNewer(registry, current) {
 function getInstalledVersion() {
   try {
     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;
+    const pkgPath = path31.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs39.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -9994,17 +10505,17 @@ async function checkForUpdates() {
     if (!isInteractive) {
       const installTag = channel === "latest" ? "" : `@${channel}`;
       console.log(
-        chalk20.yellow(
+        chalk22.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk20.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
+Run ${chalk22.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk20.yellow(`
+      chalk22.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
@@ -10023,13 +10534,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk20.yellow(`Run ${chalk20.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
+        console.log(chalk22.yellow(`Run ${chalk22.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk20.green(`Updated to ${latest}`));
+      spinner.succeed(chalk22.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk20.dim(`
+      console.log(chalk22.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync15(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -10042,11 +10553,11 @@ Restarting: caliber ${args.join(" ")}
       if (err instanceof Error) {
         const stderr = err.stderr;
         const errMsg = stderr ? String(stderr).trim().split("\n").pop() : err.message.split("\n")[0];
-        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk20.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk22.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk20.yellow(
-          `Run ${chalk20.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
+        chalk22.yellow(
+          `Run ${chalk22.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
 `
         )
       );