@caliber-ai/cli 0.23.0 → 0.24.0

package/dist/bin.js

@@ -92,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();
@@ -1518,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 {
@@ -1893,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;
@@ -2024,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")) {
@@ -2034,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`)}`);
       }
     }
@@ -2065,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) {
@@ -2077,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}`));
@@ -2087,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}`));
@@ -2097,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}`));
@@ -2108,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) {
@@ -2205,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",
@@ -2223,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",
@@ -2236,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({
@@ -2254,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",
@@ -2264,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",
@@ -2277,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",
@@ -2295,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({
@@ -2342,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) {
@@ -2374,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})`);
   }
@@ -3009,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";
 
@@ -3087,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);
     }
   }
@@ -3131,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);
       }
     }
@@ -3238,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 });
@@ -3411,8 +3505,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs22 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path20 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -3420,15 +3514,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs22.existsSync(LEARNING_DIR)) {
-    fs22.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs23.existsSync(LEARNING_DIR)) {
+    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -3439,50 +3533,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs22.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs22.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs22.existsSync(filePath)) return [];
-  const lines = fs22.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  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 (!fs22.existsSync(filePath)) return 0;
-  const content = fs22.readFileSync(filePath, "utf-8");
+  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 (fs22.existsSync(filePath)) fs22.unlinkSync(filePath);
+  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs22.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs22.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs22.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs23 from "fs";
-import path20 from "path";
+import fs24 from "fs";
+import path21 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -3502,8 +3596,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs23.existsSync(claudeMdPath)) {
-    existing = fs23.readFileSync(claudeMdPath, "utf-8");
+  if (fs24.existsSync(claudeMdPath)) {
+    existing = fs24.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -3517,15 +3611,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs23.writeFileSync(claudeMdPath, updated);
+  fs24.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path20.join(".claude", "skills", skill.name);
-  if (!fs23.existsSync(skillDir)) fs23.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path20.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs23.existsSync(skillPath)) {
-    const existing = fs23.readFileSync(skillPath, "utf-8");
-    fs23.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  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 = [
       "---",
@@ -3534,107 +3628,20 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs23.writeFileSync(skillPath, frontmatter + skill.content);
+    fs24.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs23.existsSync(claudeMdPath)) return null;
-  const content = fs23.readFileSync(claudeMdPath, "utf-8");
+  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/lib/learning-hooks.ts
-import fs24 from "fs";
-import path21 from "path";
-var SETTINGS_PATH2 = path21.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 (!fs24.existsSync(SETTINGS_PATH2)) return {};
-  try {
-    return JSON.parse(fs24.readFileSync(SETTINGS_PATH2, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeSettings2(settings) {
-  const dir = path21.dirname(SETTINGS_PATH2);
-  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
-  fs24.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/commands/learn.ts
 async function learnObserveCommand(options) {
   try {