@caliber-ai/cli 0.22.0 → 0.24.0

package/dist/bin.js

@@ -30,11 +30,15 @@ __export(constants_exports, {
   CALIBER_DIR: () => CALIBER_DIR,
   CLI_CALLBACK_PORT: () => CLI_CALLBACK_PORT,
   FRONTEND_URL: () => FRONTEND_URL,
+  LEARNING_DIR: () => LEARNING_DIR,
+  LEARNING_MAX_EVENTS: () => LEARNING_MAX_EVENTS,
+  LEARNING_SESSION_FILE: () => LEARNING_SESSION_FILE,
+  LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
 import path2 from "path";
 import os2 from "os";
-var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR;
+var API_URL, FRONTEND_URL, CLI_CALLBACK_PORT, AUTH_DIR, AUTH_FILE, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -46,6 +50,10 @@ var init_constants = __esm({
     CALIBER_DIR = ".caliber";
     MANIFEST_FILE = path2.join(CALIBER_DIR, "manifest.json");
     BACKUPS_DIR = path2.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path2.join(CALIBER_DIR, "learning");
+    LEARNING_SESSION_FILE = "current-session.jsonl";
+    LEARNING_STATE_FILE = "state.json";
+    LEARNING_MAX_EVENTS = 500;
   }
 });
 
@@ -75,8 +83,8 @@ if (dsn) {
 
 // src/cli.ts
 import { Command } from "commander";
-import fs22 from "fs";
-import path19 from "path";
+import fs25 from "fs";
+import path22 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
@@ -84,7 +92,7 @@ import chalk3 from "chalk";
 import ora2 from "ora";
 import readline from "readline";
 import select from "@inquirer/select";
-import fs17 from "fs";
+import fs18 from "fs";
 
 // src/auth/token-store.ts
 init_constants();
@@ -957,9 +965,9 @@ async function getValidToken() {
   }
   return refreshed;
 }
-async function apiRequest(path21, options = {}) {
+async function apiRequest(path24, options = {}) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path21}`, {
+  let resp = await fetch(`${API_URL}${path24}`, {
     method: options.method || "GET",
     headers: {
       "Content-Type": "application/json",
@@ -973,7 +981,7 @@ async function apiRequest(path21, options = {}) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path21}`, {
+    resp = await fetch(`${API_URL}${path24}`, {
       method: options.method || "GET",
       headers: {
         "Content-Type": "application/json",
@@ -989,9 +997,9 @@ async function apiRequest(path21, options = {}) {
   const json = await resp.json();
   return json.data;
 }
-async function apiStream(path21, body, onChunk, onComplete, onError, onStatus) {
+async function apiStream(path24, body, onChunk, onComplete, onError, onStatus) {
   let token = await getValidToken();
-  let resp = await fetch(`${API_URL}${path21}`, {
+  let resp = await fetch(`${API_URL}${path24}`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -1005,7 +1013,7 @@ async function apiStream(path21, body, onChunk, onComplete, onError, onStatus) {
       throw new Error("Session expired. Run `caliber login` to re-authenticate.");
     }
     token = refreshed;
-    resp = await fetch(`${API_URL}${path21}`, {
+    resp = await fetch(`${API_URL}${path24}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -1510,25 +1518,112 @@ function removeHook() {
   return { removed: true, notFound: false };
 }
 
-// src/lib/state.ts
-init_constants();
+// src/lib/learning-hooks.ts
 import fs16 from "fs";
 import path15 from "path";
+var SETTINGS_PATH2 = path15.join(".claude", "settings.json");
+var HOOK_CONFIGS = [
+  {
+    event: "PostToolUse",
+    command: "caliber learn observe",
+    description: "Caliber: recording tool usage for session learning"
+  },
+  {
+    event: "PostToolUseFailure",
+    command: "caliber learn observe --failure",
+    description: "Caliber: recording tool failure for session learning"
+  },
+  {
+    event: "SessionEnd",
+    command: "caliber learn finalize",
+    description: "Caliber: finalizing session learnings"
+  }
+];
+function readSettings2() {
+  if (!fs16.existsSync(SETTINGS_PATH2)) return {};
+  try {
+    return JSON.parse(fs16.readFileSync(SETTINGS_PATH2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings2(settings) {
+  const dir = path15.dirname(SETTINGS_PATH2);
+  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
+  fs16.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+}
+function hasLearningHook(matchers, command) {
+  return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
+}
+function areLearningHooksInstalled() {
+  const settings = readSettings2();
+  if (!settings.hooks) return false;
+  return HOOK_CONFIGS.every((cfg) => {
+    const matchers = settings.hooks[cfg.event];
+    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.command);
+  });
+}
+function installLearningHooks() {
+  if (areLearningHooksInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const settings = readSettings2();
+  if (!settings.hooks) settings.hooks = {};
+  for (const cfg of HOOK_CONFIGS) {
+    if (!Array.isArray(settings.hooks[cfg.event])) {
+      settings.hooks[cfg.event] = [];
+    }
+    if (!hasLearningHook(settings.hooks[cfg.event], cfg.command)) {
+      settings.hooks[cfg.event].push({
+        matcher: "",
+        hooks: [{ type: "command", command: cfg.command, description: cfg.description }]
+      });
+    }
+  }
+  writeSettings2(settings);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeLearningHooks() {
+  const settings = readSettings2();
+  if (!settings.hooks) return { removed: false, notFound: true };
+  let removedAny = false;
+  for (const cfg of HOOK_CONFIGS) {
+    const matchers = settings.hooks[cfg.event];
+    if (!Array.isArray(matchers)) continue;
+    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => h.command === cfg.command));
+    if (idx !== -1) {
+      matchers.splice(idx, 1);
+      removedAny = true;
+      if (matchers.length === 0) delete settings.hooks[cfg.event];
+    }
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  if (!removedAny) return { removed: false, notFound: true };
+  writeSettings2(settings);
+  return { removed: true, notFound: false };
+}
+
+// src/lib/state.ts
+init_constants();
+import fs17 from "fs";
+import path16 from "path";
 import { execSync as execSync3 } from "child_process";
-var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
 function readState() {
   try {
-    if (!fs16.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs16.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs17.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs17.readFileSync(STATE_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  if (!fs16.existsSync(CALIBER_DIR)) {
-    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs16.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs17.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -1885,6 +1980,13 @@ async function initCommand(options) {
     } else if (hookResult.alreadyInstalled) {
       console.log(chalk3.dim("  Auto-refresh hook already installed"));
     }
+    const learnResult = installLearningHooks();
+    if (learnResult.installed) {
+      console.log(`  ${chalk3.green("\u2713")} Learning hooks installed \u2014 session insights captured automatically`);
+      console.log(chalk3.dim("    Run `caliber learn remove` to disable"));
+    } else if (learnResult.alreadyInstalled) {
+      console.log(chalk3.dim("  Learning hooks already installed"));
+    }
   }
   try {
     let projectId = existingProjectId;
@@ -2016,8 +2118,8 @@ function openReview(method, stagedFiles) {
   } else {
     for (const file of stagedFiles) {
       if (file.currentPath) {
-        const currentLines = fs17.readFileSync(file.currentPath, "utf-8").split("\n");
-        const proposedLines = fs17.readFileSync(file.proposedPath, "utf-8").split("\n");
+        const currentLines = fs18.readFileSync(file.currentPath, "utf-8").split("\n");
+        const proposedLines = fs18.readFileSync(file.proposedPath, "utf-8").split("\n");
         const patch = createTwoFilesPatch(file.relativePath, file.relativePath, currentLines.join("\n"), proposedLines.join("\n"));
         let added = 0, removed = 0;
         for (const line of patch.split("\n")) {
@@ -2026,7 +2128,7 @@ function openReview(method, stagedFiles) {
         }
         console.log(`    ${chalk3.yellow("~")} ${file.relativePath}  ${chalk3.green(`+${added}`)} ${chalk3.red(`-${removed}`)}`);
       } else {
-        const lines = fs17.readFileSync(file.proposedPath, "utf-8").split("\n").length;
+        const lines = fs18.readFileSync(file.proposedPath, "utf-8").split("\n").length;
         console.log(`    ${chalk3.green("+")} ${file.relativePath}  ${chalk3.dim(`${lines} lines`)}`);
       }
     }
@@ -2057,7 +2159,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs17.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs18.existsSync("CLAUDE.md") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk3.bold("CLAUDE.md")}`);
       if (desc) {
@@ -2069,7 +2171,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 = fs17.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
         console.log(chalk3.dim(`    ${desc || skill.description || skill.name}`));
@@ -2079,7 +2181,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs17.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
+      const icon = fs18.existsSync(".cursorrules") ? chalk3.yellow("~") : chalk3.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk3.bold(".cursorrules")}`);
       if (desc) console.log(chalk3.dim(`    ${desc}`));
@@ -2089,7 +2191,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 = fs17.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs18.existsSync(skillPath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk3.bold(skillPath)}`);
         console.log(chalk3.dim(`    ${desc || skill.description || skill.name}`));
@@ -2100,7 +2202,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs17.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
+        const icon = fs18.existsSync(rulePath) ? chalk3.yellow("~") : chalk3.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk3.bold(rulePath)}`);
         if (desc) {
@@ -2197,16 +2299,16 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk5 from "chalk";
-import fs19 from "fs";
+import fs20 from "fs";
 
 // src/scanner/index.ts
-import fs18 from "fs";
-import path16 from "path";
+import fs19 from "fs";
+import path17 from "path";
 import crypto4 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs18.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs19.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -2215,10 +2317,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs18.existsSync(skillsDir)) {
-    for (const file of fs18.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs19.existsSync(skillsDir)) {
+    for (const file of fs19.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -2228,10 +2330,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs18.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs19.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs18.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs19.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -2246,8 +2348,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs18.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs19.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -2256,10 +2358,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs18.existsSync(cursorRulesDir)) {
-    for (const file of fs18.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs19.existsSync(cursorRulesDir)) {
+    for (const file of fs19.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -2269,12 +2371,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs18.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs19.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs18.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs18.existsSync(skillFile)) {
+      for (const name of fs19.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs19.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -2287,10 +2389,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs18.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs19.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs18.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs19.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -2334,7 +2436,7 @@ function compareState(serverItems, localItems) {
   return { installed, missing, outdated, extra };
 }
 function hashFile(filePath) {
-  const text = fs18.readFileSync(filePath, "utf-8");
+  const text = fs19.readFileSync(filePath, "utf-8");
   return crypto4.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -2366,7 +2468,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk5.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs19.existsSync(entry.path);
+    const exists = fs20.existsSync(entry.path);
     const icon = exists ? chalk5.green("\u2713") : chalk5.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -3001,8 +3103,8 @@ async function diffCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs21 from "fs";
-import path18 from "path";
+import fs22 from "fs";
+import path19 from "path";
 import chalk11 from "chalk";
 import ora8 from "ora";
 
@@ -3079,37 +3181,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs20 from "fs";
-import path17 from "path";
+import fs21 from "fs";
+import path18 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs20.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs21.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs20.writeFileSync("README.md", docs.readmeMd);
+    fs21.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs20.writeFileSync(".cursorrules", docs.cursorrules);
+    fs21.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path17.join(".cursor", "rules");
-    if (!fs20.existsSync(rulesDir)) fs20.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path18.join(".cursor", "rules");
+    if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path17.join(rulesDir, rule.filename);
-      fs20.writeFileSync(filePath, rule.content);
+      const filePath = path18.join(rulesDir, rule.filename);
+      fs21.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path17.join(".claude", "skills");
-    if (!fs20.existsSync(skillsDir)) fs20.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path18.join(".claude", "skills");
+    if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path17.join(skillsDir, skill.filename);
-      fs20.writeFileSync(filePath, skill.content);
+      const filePath = path18.join(skillsDir, skill.filename);
+      fs21.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -3123,11 +3225,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs21.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path18.join(parentDir, entry.name);
-      if (fs21.existsSync(path18.join(childPath, ".git"))) {
+      const childPath = path19.join(parentDir, entry.name);
+      if (fs22.existsSync(path19.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -3230,7 +3332,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path18.basename(repo);
+      const repoName = path19.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -3371,10 +3473,287 @@ async function reviewCommand(message, options) {
   await submitReview({ rating, bestPart, biggestGap, wouldRecommend });
 }
 
+// src/commands/learn.ts
+import chalk14 from "chalk";
+
+// src/learner/stdin.ts
+var STDIN_TIMEOUT_MS = 5e3;
+function readStdin() {
+  return new Promise((resolve2, reject) => {
+    if (process.stdin.isTTY) {
+      resolve2("");
+      return;
+    }
+    const chunks = [];
+    const timer = setTimeout(() => {
+      process.stdin.removeAllListeners();
+      process.stdin.destroy();
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve2(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    process.stdin.resume();
+  });
+}
+
+// src/learner/storage.ts
+init_constants();
+import fs23 from "fs";
+import path20 from "path";
+var MAX_RESPONSE_LENGTH = 2e3;
+var DEFAULT_STATE = {
+  sessionId: null,
+  eventCount: 0,
+  lastAnalysisTimestamp: null
+};
+function ensureLearningDir() {
+  if (!fs23.existsSync(LEARNING_DIR)) {
+    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
+  }
+}
+function sessionFilePath() {
+  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+}
+function stateFilePath() {
+  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
+}
+function truncateResponse(response) {
+  const str = JSON.stringify(response);
+  if (str.length <= MAX_RESPONSE_LENGTH) return response;
+  return { _truncated: str.slice(0, MAX_RESPONSE_LENGTH) };
+}
+function appendEvent(event) {
+  ensureLearningDir();
+  const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
+  const filePath = sessionFilePath();
+  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  const count = getEventCount();
+  if (count > LEARNING_MAX_EVENTS) {
+    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
+    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
+  }
+}
+function readAllEvents() {
+  const filePath = sessionFilePath();
+  if (!fs23.existsSync(filePath)) return [];
+  const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function getEventCount() {
+  const filePath = sessionFilePath();
+  if (!fs23.existsSync(filePath)) return 0;
+  const content = fs23.readFileSync(filePath, "utf-8");
+  return content.split("\n").filter(Boolean).length;
+}
+function clearSession() {
+  const filePath = sessionFilePath();
+  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
+}
+function readState2() {
+  const filePath = stateFilePath();
+  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
+  try {
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function writeState2(state) {
+  ensureLearningDir();
+  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+}
+function resetState() {
+  writeState2({ ...DEFAULT_STATE });
+}
+
+// src/learner/writer.ts
+import fs24 from "fs";
+import path21 from "path";
+var LEARNED_START = "<!-- caliber:learned -->";
+var LEARNED_END = "<!-- /caliber:learned -->";
+function writeLearnedContent(update) {
+  const written = [];
+  if (update.claudeMdLearnedSection) {
+    writeLearnedSection(update.claudeMdLearnedSection);
+    written.push("CLAUDE.md");
+  }
+  if (update.skills?.length) {
+    for (const skill of update.skills) {
+      const skillPath = writeLearnedSkill(skill);
+      written.push(skillPath);
+    }
+  }
+  return written;
+}
+function writeLearnedSection(content) {
+  const claudeMdPath = "CLAUDE.md";
+  let existing = "";
+  if (fs24.existsSync(claudeMdPath)) {
+    existing = fs24.readFileSync(claudeMdPath, "utf-8");
+  }
+  const section = `${LEARNED_START}
+${content}
+${LEARNED_END}`;
+  const startIdx = existing.indexOf(LEARNED_START);
+  const endIdx = existing.indexOf(LEARNED_END);
+  let updated;
+  if (startIdx !== -1 && endIdx !== -1) {
+    updated = existing.slice(0, startIdx) + section + existing.slice(endIdx + LEARNED_END.length);
+  } else {
+    const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
+    updated = existing + separator + "\n" + section + "\n";
+  }
+  fs24.writeFileSync(claudeMdPath, updated);
+}
+function writeLearnedSkill(skill) {
+  const skillDir = path21.join(".claude", "skills", skill.name);
+  if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs24.existsSync(skillPath)) {
+    const existing = fs24.readFileSync(skillPath, "utf-8");
+    fs24.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  } else {
+    const frontmatter = [
+      "---",
+      `name: ${skill.name}`,
+      `description: ${skill.description}`,
+      "---",
+      ""
+    ].join("\n");
+    fs24.writeFileSync(skillPath, frontmatter + skill.content);
+  }
+  return skillPath;
+}
+function readLearnedSection() {
+  const claudeMdPath = "CLAUDE.md";
+  if (!fs24.existsSync(claudeMdPath)) return null;
+  const content = fs24.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();
+}
+
+// src/commands/learn.ts
+async function learnObserveCommand(options) {
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) return;
+    const hookData = JSON.parse(raw);
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      session_id: hookData.session_id || "unknown",
+      hook_event_name: options.failure ? "PostToolUseFailure" : "PostToolUse",
+      tool_name: hookData.tool_name || "unknown",
+      tool_input: hookData.tool_input || {},
+      tool_response: hookData.tool_response || {},
+      tool_use_id: hookData.tool_use_id || "",
+      cwd: hookData.cwd || process.cwd()
+    };
+    appendEvent(event);
+    const state = readState2();
+    state.eventCount++;
+    if (!state.sessionId) state.sessionId = event.session_id;
+    writeState2(state);
+  } catch {
+  }
+}
+async function learnFinalizeCommand() {
+  try {
+    const auth2 = getStoredAuth();
+    if (!auth2) {
+      clearSession();
+      resetState();
+      return;
+    }
+    const events = readAllEvents();
+    if (!events.length) {
+      clearSession();
+      resetState();
+      return;
+    }
+    const existingConfigs = readExistingConfigs(process.cwd());
+    const existingLearnedSection = readLearnedSection();
+    const existingSkills = existingConfigs.claudeSkills || [];
+    const response = await apiRequest("/api/learn/analyze", {
+      method: "POST",
+      body: {
+        events,
+        existingClaudeMd: existingConfigs.claudeMd || "",
+        existingLearnedSection,
+        existingSkills
+      }
+    });
+    if (response.claudeMdLearnedSection || response.skills?.length) {
+      writeLearnedContent({
+        claudeMdLearnedSection: response.claudeMdLearnedSection,
+        skills: response.skills
+      });
+    }
+  } catch {
+  } finally {
+    clearSession();
+    resetState();
+  }
+}
+async function learnInstallCommand() {
+  const result = installLearningHooks();
+  if (result.alreadyInstalled) {
+    console.log(chalk14.dim("Learning hooks already installed."));
+    return;
+  }
+  console.log(chalk14.green("\u2713") + " Learning hooks installed in .claude/settings.json");
+  console.log(chalk14.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
+  console.log(chalk14.dim("  Session learnings will be written to CLAUDE.md and skills."));
+}
+async function learnRemoveCommand() {
+  const result = removeLearningHooks();
+  if (result.notFound) {
+    console.log(chalk14.dim("Learning hooks not found."));
+    return;
+  }
+  console.log(chalk14.green("\u2713") + " Learning hooks removed from .claude/settings.json");
+}
+async function learnStatusCommand() {
+  const installed = areLearningHooksInstalled();
+  const state = readState2();
+  const eventCount = getEventCount();
+  console.log(chalk14.bold("Session Learning Status"));
+  console.log();
+  if (installed) {
+    console.log(chalk14.green("\u2713") + " Learning hooks are " + chalk14.green("installed"));
+  } else {
+    console.log(chalk14.dim("\u2717") + " Learning hooks are " + chalk14.yellow("not installed"));
+    console.log(chalk14.dim("  Run `caliber learn install` to enable session learning."));
+  }
+  console.log();
+  console.log(`Events recorded: ${chalk14.cyan(String(eventCount))}`);
+  console.log(`Total this session: ${chalk14.cyan(String(state.eventCount))}`);
+  if (state.lastAnalysisTimestamp) {
+    console.log(`Last analysis: ${chalk14.cyan(state.lastAnalysisTimestamp)}`);
+  } else {
+    console.log(`Last analysis: ${chalk14.dim("none")}`);
+  }
+  const learnedSection = readLearnedSection();
+  if (learnedSection) {
+    const lineCount = learnedSection.split("\n").filter(Boolean).length;
+    console.log(`
+Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
+  }
+}
+
 // src/cli.ts
-var __dirname2 = path19.dirname(fileURLToPath3(import.meta.url));
+var __dirname2 = path22.dirname(fileURLToPath3(import.meta.url));
 var pkg3 = JSON.parse(
-  fs22.readFileSync(path19.resolve(__dirname2, "..", "package.json"), "utf-8")
+  fs25.readFileSync(path22.resolve(__dirname2, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg3.version}-local` : pkg3.version;
@@ -3394,24 +3773,30 @@ var hooks = program.command("hooks").description("Manage Claude Code session hoo
 hooks.command("install").description("Install auto-refresh SessionEnd hook").action(hooksInstallCommand);
 hooks.command("remove").description("Remove auto-refresh SessionEnd hook").action(hooksRemoveCommand);
 hooks.command("status").description("Check if auto-refresh hook is installed").action(hooksStatusCommand);
+var learn = program.command("learn").description("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").action(learnObserveCommand);
+learn.command("finalize").description("Analyze session events and update CLAUDE.md (called on SessionEnd)").action(learnFinalizeCommand);
+learn.command("install").description("Install learning hooks into .claude/settings.json").action(learnInstallCommand);
+learn.command("remove").description("Remove learning hooks from .claude/settings.json").action(learnRemoveCommand);
+learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs26 from "fs";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { execSync as execSync5 } from "child_process";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import ora10 from "ora";
 import confirm3 from "@inquirer/confirm";
-var __dirname_vc = path20.dirname(fileURLToPath4(import.meta.url));
+var __dirname_vc = path23.dirname(fileURLToPath4(import.meta.url));
 var pkg4 = JSON.parse(
-  fs23.readFileSync(path20.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync5("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path20.join(globalRoot, "@caliber-ai", "cli", "package.json");
-    return JSON.parse(fs23.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path23.join(globalRoot, "@caliber-ai", "cli", "package.json");
+    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -3434,17 +3819,17 @@ async function checkForUpdates() {
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
       console.log(
-        chalk14.yellow(
+        chalk15.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk14.bold("npm install -g @caliber-ai/cli")} to upgrade.
+Run ${chalk15.bold("npm install -g @caliber-ai/cli")} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk14.yellow(`
+      chalk15.yellow(`
 Update available: ${current} -> ${latest}`)
     );
     const shouldUpdate = await confirm3({ message: "Would you like to update now? (Y/n)", default: true });
@@ -3458,13 +3843,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk14.yellow(`Run ${chalk14.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually.
+        console.log(chalk15.yellow(`Run ${chalk15.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk14.green(`Updated to ${latest}`));
+      spinner.succeed(chalk15.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk14.dim(`
+      console.log(chalk15.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execSync5(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
@@ -3475,10 +3860,10 @@ Restarting: caliber ${args.join(" ")}
     } catch (err) {
       spinner.fail("Update failed");
       const msg = err instanceof Error ? err.message : "";
-      if (msg && !msg.includes("SIGTERM")) console.log(chalk14.dim(`  ${msg.split("\n")[0]}`));
+      if (msg && !msg.includes("SIGTERM")) console.log(chalk15.dim(`  ${msg.split("\n")[0]}`));
       console.log(
-        chalk14.yellow(
-          `Run ${chalk14.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually to upgrade.
+        chalk15.yellow(
+          `Run ${chalk15.bold(`npm install -g @caliber-ai/cli@${latest}`)} manually to upgrade.
 `
         )
       );