@rely-ai/caliber 1.18.9 → 1.19.1

package/dist/bin.js

@@ -177,13 +177,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs27 from "fs";
-import path21 from "path";
+import fs28 from "fs";
+import path22 from "path";
 import os4 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs27.existsSync(LOCK_FILE)) return false;
-    const raw = fs27.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs28.existsSync(LOCK_FILE)) return false;
+    const raw = fs28.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -198,13 +198,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs27.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs28.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs27.existsSync(LOCK_FILE)) fs27.unlinkSync(LOCK_FILE);
+    if (fs28.existsSync(LOCK_FILE)) fs28.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -212,14 +212,14 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path21.join(os4.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path22.join(os4.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs31 from "fs";
+import fs32 from "fs";
 import path25 from "path";
 import { fileURLToPath } from "url";
 
@@ -1382,11 +1382,15 @@ var ClaudeCliProvider = class {
     const combined = this.buildCombinedPrompt(options);
     const args = ["-p"];
     if (options.model) args.push("--model", options.model);
-    const child = spawn2(CLAUDE_CLI_BIN, args, {
+    const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
       cwd: process.cwd(),
       stdio: ["pipe", "pipe", "inherit"],
       env: process.env,
-      ...IS_WINDOWS2 && { shell: true }
+      shell: true
+    }) : spawn2(CLAUDE_CLI_BIN, args, {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "inherit"],
+      env: process.env
     });
     child.stdin.end(combined);
     let settled = false;
@@ -1446,11 +1450,15 @@ ${msg.content}
     return new Promise((resolve2, reject) => {
       const args = ["-p"];
       if (model) args.push("--model", model);
-      const child = spawn2(CLAUDE_CLI_BIN, args, {
+      const child = IS_WINDOWS2 ? spawn2([CLAUDE_CLI_BIN, ...args].join(" "), {
         cwd: process.cwd(),
         stdio: ["pipe", "pipe", "inherit"],
         env: process.env,
-        ...IS_WINDOWS2 && { shell: true }
+        shell: true
+      }) : spawn2(CLAUDE_CLI_BIN, args, {
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "inherit"],
+        env: process.env
       });
       child.stdin.end(combinedPrompt);
       const chunks = [];
@@ -2030,6 +2038,8 @@ Rules:
 - Be conservative \u2014 don't rewrite sections that aren't affected by the changes
 - Don't add speculative or aspirational content
 - Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
+- Do NOT modify CALIBER_LEARNINGS.md \u2014 it is managed separately by the learning system
+- Preserve any references to CALIBER_LEARNINGS.md in CLAUDE.md
 - If a doc doesn't need updating, return null for it
 - For CLAUDE.md: update commands, architecture notes, conventions, key files if the diffs affect them. Keep under 150 lines.
 - For README.md: update setup instructions, API docs, or feature descriptions if affected
@@ -2061,20 +2071,25 @@ Your job is to reason deeply about these events and identify:
 3. **Workarounds**: When the agent had to abandon one approach entirely and use a different strategy
 4. **Repeated struggles**: The same tool being called many times against the same target, indicating confusion or trial-and-error
 5. **Project-specific conventions**: Commands, paths, patterns, or configurations that are specific to this project and would help future sessions
+6. **Anti-patterns**: Commands, approaches, or configurations that consistently fail or cause problems \u2014 things future sessions should explicitly avoid
 
 From these observations, produce:
 
 ### claudeMdLearnedSection
-A markdown section with concise, actionable bullet points that should be added to the project's primary instructions file (CLAUDE.md for Claude Code, AGENTS.md for Codex). Each bullet should be a concrete instruction that prevents a past mistake or encodes a discovered convention. Examples:
+A markdown section with concise, actionable bullet points. Your output will be written to CALIBER_LEARNINGS.md \u2014 a standalone file that all AI coding agents (Claude Code, Cursor, Codex) reference for project-specific patterns and anti-patterns. Each bullet should be a concrete instruction that prevents a past mistake or encodes a discovered convention. Examples:
 - "Always run \`npm install\` before \`npm run build\` in this project"
 - "The test database requires \`DATABASE_URL\` to be set \u2014 use \`source .env.test\` first"
 - "TypeScript strict mode is enabled \u2014 never use \`any\`, use \`unknown\` with type guards"
 - "Use \`pnpm\` not \`npm\` \u2014 the lockfile is pnpm-lock.yaml"
+- "Never use \`npm\` in this project \u2014 pnpm-lock.yaml is the lockfile"
+- "Do NOT run \`jest\` directly \u2014 always use \`npm run test\` which sets the correct env"
+- "Avoid modifying files in \`src/generated/\` \u2014 they are auto-generated by the build step"
 
 Rules for the learned section:
 - Be additive: keep all existing learned items, add new ones, remove duplicates
 - Never repeat instructions already present in the main CLAUDE.md
 - Each bullet must be specific and actionable \u2014 no vague advice
+- Include both positive directives ('Always do X') and negative rules ('Never do Y because Z') when the session evidence supports them
 - Maximum ~30 bullet items total
 - Group related items under subheadings if there are many
 - If there's nothing meaningful to learn, return null
@@ -3193,18 +3208,13 @@ function openDiffsInEditor(editor, files) {
   const cmd = editor === "cursor" ? "cursor" : "code";
   for (const file of files) {
     try {
-      if (file.originalPath) {
-        spawn3(cmd, ["--diff", file.originalPath, file.proposedPath], {
-          stdio: "ignore",
-          detached: true,
-          ...IS_WINDOWS3 && { shell: true }
-        }).unref();
+      if (IS_WINDOWS3) {
+        const quote = (s) => `"${s}"`;
+        const parts = file.originalPath ? [cmd, "--diff", quote(file.originalPath), quote(file.proposedPath)] : [cmd, quote(file.proposedPath)];
+        spawn3(parts.join(" "), { shell: true, stdio: "ignore", detached: true }).unref();
       } else {
-        spawn3(cmd, [file.proposedPath], {
-          stdio: "ignore",
-          detached: true,
-          ...IS_WINDOWS3 && { shell: true }
-        }).unref();
+        const args = file.originalPath ? ["--diff", file.originalPath, file.proposedPath] : [file.proposedPath];
+        spawn3(cmd, args, { stdio: "ignore", detached: true }).unref();
       }
     } catch {
       continue;
@@ -3593,7 +3603,8 @@ function getPrecommitBlock() {
 if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
   echo "\\033[2mcaliber: refreshing docs...\\033[0m"
   "${bin}" refresh 2>/dev/null || true
-  git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md 2>/dev/null | xargs git add 2>/dev/null || true
+  "${bin}" learn finalize 2>/dev/null || true
+  git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md CALIBER_LEARNINGS.md 2>/dev/null | xargs git add 2>/dev/null || true
 fi
 ${PRECOMMIT_END}`;
 }
@@ -3717,6 +3728,69 @@ function installLearningHooks() {
   writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
+var CURSOR_HOOKS_PATH = path13.join(".cursor", "hooks.json");
+var CURSOR_HOOK_EVENTS = [
+  { event: "postToolUse", tail: "learn observe" },
+  { event: "postToolUseFailure", tail: "learn observe --failure" },
+  { event: "sessionEnd", tail: "learn finalize" }
+];
+function readCursorHooks() {
+  if (!fs18.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  try {
+    return JSON.parse(fs18.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+  } catch {
+    return { version: 1, hooks: {} };
+  }
+}
+function writeCursorHooks(config) {
+  const dir = path13.dirname(CURSOR_HOOKS_PATH);
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+}
+function hasCursorHook(entries, tail) {
+  return entries.some((e) => isCaliberCommand(e.command, tail));
+}
+function areCursorLearningHooksInstalled() {
+  const config = readCursorHooks();
+  return CURSOR_HOOK_EVENTS.every((cfg) => {
+    const entries = config.hooks[cfg.event];
+    return Array.isArray(entries) && hasCursorHook(entries, cfg.tail);
+  });
+}
+function installCursorLearningHooks() {
+  if (areCursorLearningHooksInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const config = readCursorHooks();
+  const bin = resolveCaliber();
+  for (const cfg of CURSOR_HOOK_EVENTS) {
+    if (!Array.isArray(config.hooks[cfg.event])) {
+      config.hooks[cfg.event] = [];
+    }
+    if (!hasCursorHook(config.hooks[cfg.event], cfg.tail)) {
+      config.hooks[cfg.event].push({ command: `${bin} ${cfg.tail}` });
+    }
+  }
+  writeCursorHooks(config);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeCursorLearningHooks() {
+  const config = readCursorHooks();
+  let removedAny = false;
+  for (const cfg of CURSOR_HOOK_EVENTS) {
+    const entries = config.hooks[cfg.event];
+    if (!Array.isArray(entries)) continue;
+    const idx = entries.findIndex((e) => isCaliberCommand(e.command, cfg.tail));
+    if (idx !== -1) {
+      entries.splice(idx, 1);
+      removedAny = true;
+      if (entries.length === 0) delete config.hooks[cfg.event];
+    }
+  }
+  if (!removedAny) return { removed: false, notFound: true };
+  writeCursorHooks(config);
+  return { removed: true, notFound: false };
+}
 function removeLearningHooks() {
   const settings = readSettings2();
   if (!settings.hooks) return { removed: false, notFound: true };
@@ -3998,6 +4072,7 @@ var POINTS_PERMISSIONS = 2;
 var POINTS_HOOKS = 2;
 var POINTS_AGENTS_MD = 1;
 var POINTS_OPEN_SKILLS_FORMAT = 2;
+var POINTS_LEARNED_CONTENT = 2;
 var TOKEN_BUDGET_THRESHOLDS = [
   { maxTokens: 2e3, points: 6 },
   { maxTokens: 3500, points: 5 },
@@ -5106,6 +5181,18 @@ function checkBonus(dir) {
       instruction: "Migrate flat skill files to .claude/skills/{name}/SKILL.md with YAML frontmatter."
     } : void 0
   });
+  const learningsContent = readFileOrNull2(join7(dir, "CALIBER_LEARNINGS.md"));
+  const hasLearned = learningsContent ? learningsContent.split("\n").filter((l) => l.startsWith("- ")).length > 0 : false;
+  checks.push({
+    id: "learned_content",
+    name: "Learned content present",
+    category: "bonus",
+    maxPoints: POINTS_LEARNED_CONTENT,
+    earnedPoints: hasLearned ? POINTS_LEARNED_CONTENT : 0,
+    passed: hasLearned,
+    detail: hasLearned ? "Session learnings found in CALIBER_LEARNINGS.md" : "No learned content",
+    suggestion: hasLearned ? void 0 : "Install learning hooks: `caliber learn install`"
+  });
   return checks;
 }
 
@@ -7314,8 +7401,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs28 from "fs";
-import path22 from "path";
+import fs29 from "fs";
+import path23 from "path";
 import chalk14 from "chalk";
 import ora5 from "ora";
 
@@ -7327,7 +7414,8 @@ var DOC_PATTERNS = [
   "README.md",
   ".cursorrules",
   ".cursor/rules/",
-  ".claude/skills/"
+  ".claude/skills/",
+  "CALIBER_LEARNINGS.md"
 ];
 function excludeArgs() {
   return DOC_PATTERNS.flatMap((p) => ["--", `:!${p}`]);
@@ -7431,8 +7519,8 @@ function writeRefreshDocs(docs) {
 
 // src/ai/refresh.ts
 init_config();
-async function refreshDocs(diff, existingDocs, projectContext) {
-  const prompt = buildRefreshPrompt(diff, existingDocs, projectContext);
+async function refreshDocs(diff, existingDocs, projectContext, learnedSection) {
+  const prompt = buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection);
   const fastModel = getFastModel();
   const raw = await llmCall({
     system: REFRESH_SYSTEM_PROMPT,
@@ -7442,7 +7530,7 @@ async function refreshDocs(diff, existingDocs, projectContext) {
   });
   return parseJsonResponse(raw);
 }
-function buildRefreshPrompt(diff, existingDocs, projectContext) {
+function buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection) {
   const parts = [];
   parts.push("Update documentation based on the following code changes.\n");
   if (projectContext.packageName) parts.push(`Project: ${projectContext.packageName}`);
@@ -7490,9 +7578,144 @@ Changed files: ${diff.changedFiles.join(", ")}`);
       parts.push(rule.content);
     }
   }
+  if (learnedSection) {
+    parts.push("\n--- Learned Patterns (from session learning) ---");
+    parts.push("Consider these accumulated learnings when deciding what to update:");
+    parts.push(learnedSection);
+  }
   return parts.join("\n");
 }
 
+// src/learner/writer.ts
+import fs27 from "fs";
+import path21 from "path";
+var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
+var LEARNINGS_HEADER = `# Caliber Learnings
+
+Accumulated patterns and anti-patterns from development sessions.
+Auto-managed by [caliber](https://github.com/rely-ai-org/caliber) \u2014 do not edit manually.
+
+`;
+var LEARNED_START = "<!-- caliber:learned -->";
+var LEARNED_END = "<!-- /caliber:learned -->";
+var MAX_LEARNED_ITEMS = 30;
+function writeLearnedContent(update) {
+  const written = [];
+  let newItemCount = 0;
+  let newItems = [];
+  if (update.claudeMdLearnedSection) {
+    const result = writeLearnedSection(update.claudeMdLearnedSection);
+    newItemCount = result.newCount;
+    newItems = result.newItems;
+    written.push(LEARNINGS_FILE);
+  }
+  if (update.skills?.length) {
+    for (const skill of update.skills) {
+      const skillPath = writeLearnedSkill(skill);
+      written.push(skillPath);
+    }
+  }
+  return { written, newItemCount, newItems };
+}
+function parseBullets(content) {
+  const lines = content.split("\n");
+  const bullets = [];
+  let current = "";
+  for (const line of lines) {
+    if (line.startsWith("- ")) {
+      if (current) bullets.push(current);
+      current = line;
+    } else if (current && line.trim() && !line.startsWith("#")) {
+      current += "\n" + line;
+    } else {
+      if (current) bullets.push(current);
+      current = "";
+    }
+  }
+  if (current) bullets.push(current);
+  return bullets;
+}
+function normalizeBullet(bullet) {
+  return bullet.replace(/^- /, "").replace(/`[^`]*`/g, "").replace(/\s+/g, " ").toLowerCase().trim();
+}
+function deduplicateLearnedItems(existing, incoming) {
+  const existingBullets = existing ? parseBullets(existing) : [];
+  const incomingBullets = parseBullets(incoming);
+  const merged = [...existingBullets];
+  const newItems = [];
+  for (const bullet of incomingBullets) {
+    const norm = normalizeBullet(bullet);
+    if (!norm) continue;
+    const isDup = merged.some((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;
+    });
+    if (!isDup) {
+      merged.push(bullet);
+      newItems.push(bullet);
+    }
+  }
+  const capped = merged.length > MAX_LEARNED_ITEMS ? merged.slice(-MAX_LEARNED_ITEMS) : merged;
+  return { merged: capped.join("\n"), newCount: newItems.length, newItems };
+}
+function writeLearnedSection(content) {
+  const existingSection = readLearnedSection();
+  const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
+  fs27.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+  return { newCount, newItems };
+}
+function writeLearnedSkill(skill) {
+  const skillDir = path21.join(".claude", "skills", skill.name);
+  if (!fs27.existsSync(skillDir)) fs27.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs27.existsSync(skillPath)) {
+    const existing = fs27.readFileSync(skillPath, "utf-8");
+    fs27.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  } else {
+    const frontmatter = [
+      "---",
+      `name: ${skill.name}`,
+      `description: ${skill.description}`,
+      "---",
+      ""
+    ].join("\n");
+    fs27.writeFileSync(skillPath, frontmatter + skill.content);
+  }
+  return skillPath;
+}
+function readLearnedSection() {
+  if (fs27.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs27.readFileSync(LEARNINGS_FILE, "utf-8");
+    const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
+    return bullets || null;
+  }
+  const claudeMdPath = "CLAUDE.md";
+  if (!fs27.existsSync(claudeMdPath)) return null;
+  const content = fs27.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 (fs27.existsSync(LEARNINGS_FILE)) return false;
+  const claudeMdPath = "CLAUDE.md";
+  if (!fs27.existsSync(claudeMdPath)) return false;
+  const content = fs27.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;
+  fs27.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
+  fs27.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  return true;
+}
+
 // src/commands/refresh.ts
 init_config();
 function log2(quiet, ...args) {
@@ -7501,11 +7724,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs28.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs29.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path22.join(parentDir, entry.name);
-      if (fs28.existsSync(path22.join(childPath, ".git"))) {
+      const childPath = path23.join(parentDir, entry.name);
+      if (fs29.existsSync(path23.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -7529,6 +7752,7 @@ async function refreshSingleRepo(repoDir, options) {
   }
   const spinner = quiet ? null : ora5(`${prefix}Analyzing changes...`).start();
   const existingDocs = readExistingConfigs(repoDir);
+  const learnedSection = readLearnedSection();
   const fingerprint = await collectFingerprint(repoDir);
   const projectContext = {
     languages: fingerprint.languages,
@@ -7544,7 +7768,8 @@ async function refreshSingleRepo(repoDir, options) {
       summary: diff.summary
     },
     existingDocs,
-    projectContext
+    projectContext,
+    learnedSection
   );
   if (!response.docsUpdated || response.docsUpdated.length === 0) {
     spinner?.succeed(`${prefix}No doc updates needed`);
@@ -7606,7 +7831,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path22.basename(repo);
+      const repoName = path23.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -7830,6 +8055,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
+import fs31 from "fs";
 import chalk17 from "chalk";
 
 // src/learner/stdin.ts
@@ -7861,8 +8087,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs29 from "fs";
-import path23 from "path";
+import fs30 from "fs";
+import path24 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -7870,15 +8096,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs29.existsSync(LEARNING_DIR)) {
-    fs29.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs30.existsSync(LEARNING_DIR)) {
+    fs30.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path23.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path24.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path23.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path24.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -7889,113 +8115,84 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs29.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs30.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs29.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs29.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs30.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs29.existsSync(filePath)) return [];
-  const lines = fs29.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs30.existsSync(filePath)) return [];
+  const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs29.existsSync(filePath)) return 0;
-  const content = fs29.readFileSync(filePath, "utf-8");
+  if (!fs30.existsSync(filePath)) return 0;
+  const content = fs30.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs29.existsSync(filePath)) fs29.unlinkSync(filePath);
+  if (fs30.existsSync(filePath)) fs30.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs29.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs30.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs29.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs29.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs30.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
-
-// src/learner/writer.ts
-import fs30 from "fs";
-import path24 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);
+var LOCK_FILE2 = "finalize.lock";
+var LOCK_STALE_MS = 5 * 60 * 1e3;
+function lockFilePath() {
+  return path24.join(LEARNING_DIR, LOCK_FILE2);
+}
+function acquireFinalizeLock() {
+  ensureLearningDir();
+  const lockPath = lockFilePath();
+  if (fs30.existsSync(lockPath)) {
+    try {
+      const stat = fs30.statSync(lockPath);
+      if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
+        return false;
+      }
+    } catch {
     }
   }
-  return written;
-}
-function writeLearnedSection(content) {
-  const claudeMdPath = "CLAUDE.md";
-  let existing = "";
-  if (fs30.existsSync(claudeMdPath)) {
-    existing = fs30.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";
+  try {
+    fs30.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    try {
+      const stat = fs30.statSync(lockPath);
+      if (Date.now() - stat.mtimeMs >= LOCK_STALE_MS) {
+        fs30.writeFileSync(lockPath, String(process.pid));
+        return true;
+      }
+    } catch {
+    }
+    return false;
   }
-  fs30.writeFileSync(claudeMdPath, updated);
 }
-function writeLearnedSkill(skill) {
-  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 = [
-      "---",
-      `name: ${skill.name}`,
-      `description: ${skill.description}`,
-      "---",
-      ""
-    ].join("\n");
-    fs30.writeFileSync(skillPath, frontmatter + skill.content);
+function releaseFinalizeLock() {
+  const lockPath = lockFilePath();
+  try {
+    if (fs30.existsSync(lockPath)) fs30.unlinkSync(lockPath);
+  } catch {
   }
-  return skillPath;
-}
-function readLearnedSection() {
-  const claudeMdPath = "CLAUDE.md";
-  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();
 }
 
 // src/ai/learn.ts
@@ -8074,6 +8271,7 @@ ${eventsText}`;
 
 // src/commands/learn.ts
 init_config();
+var MIN_EVENTS_FOR_ANALYSIS = 50;
 async function learnObserveCommand(options) {
   try {
     const raw = await readStdin();
@@ -8081,11 +8279,11 @@ async function learnObserveCommand(options) {
     const hookData = JSON.parse(raw);
     const event = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      session_id: hookData.session_id || "unknown",
+      session_id: hookData.session_id || hookData.conversation_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_response: hookData.tool_response || hookData.tool_output || {},
       tool_use_id: hookData.tool_use_id || "",
       cwd: hookData.cwd || process.cwd()
     };
@@ -8100,6 +8298,8 @@ async function learnObserveCommand(options) {
 async function learnFinalizeCommand() {
   const { isCaliberRunning: isCaliberRunning2 } = await Promise.resolve().then(() => (init_lock(), lock_exports));
   if (isCaliberRunning2()) return;
+  if (!acquireFinalizeLock()) return;
+  let analyzed = false;
   try {
     const config = loadConfig();
     if (!config) {
@@ -8108,12 +8308,9 @@ async function learnFinalizeCommand() {
       return;
     }
     const events = readAllEvents();
-    if (!events.length) {
-      clearSession();
-      resetState();
-      return;
-    }
-    await validateModel();
+    if (events.length < MIN_EVENTS_FOR_ANALYSIS) return;
+    await validateModel({ fast: true });
+    migrateInlineLearnings();
     const existingConfigs = readExistingConfigs(process.cwd());
     const existingLearnedSection = readLearnedSection();
     const existingSkills = existingConfigs.claudeSkills || [];
@@ -8123,51 +8320,97 @@ async function learnFinalizeCommand() {
       existingLearnedSection,
       existingSkills
     );
+    analyzed = true;
     if (response.claudeMdLearnedSection || response.skills?.length) {
-      writeLearnedContent({
+      const result = writeLearnedContent({
         claudeMdLearnedSection: response.claudeMdLearnedSection,
         skills: response.skills
       });
+      if (result.newItemCount > 0) {
+        console.log(chalk17.dim(`caliber: learned ${result.newItemCount} new pattern${result.newItemCount === 1 ? "" : "s"}`));
+        for (const item of result.newItems) {
+          console.log(chalk17.dim(`  + ${item.replace(/^- /, "").slice(0, 80)}`));
+        }
+      }
     }
   } catch {
   } finally {
-    clearSession();
-    resetState();
+    if (analyzed) {
+      clearSession();
+      resetState();
+    }
+    releaseFinalizeLock();
   }
 }
 async function learnInstallCommand() {
-  const result = installLearningHooks();
-  if (result.alreadyInstalled) {
-    console.log(chalk17.dim("Learning hooks already installed."));
+  let anyInstalled = false;
+  if (fs31.existsSync(".claude")) {
+    const r = installLearningHooks();
+    if (r.installed) {
+      console.log(chalk17.green("\u2713") + " Claude Code learning hooks installed");
+      anyInstalled = true;
+    } else if (r.alreadyInstalled) {
+      console.log(chalk17.dim("  Claude Code hooks already installed"));
+    }
+  }
+  if (fs31.existsSync(".cursor")) {
+    const r = installCursorLearningHooks();
+    if (r.installed) {
+      console.log(chalk17.green("\u2713") + " Cursor learning hooks installed");
+      anyInstalled = true;
+    } else if (r.alreadyInstalled) {
+      console.log(chalk17.dim("  Cursor hooks already installed"));
+    }
+  }
+  if (!fs31.existsSync(".claude") && !fs31.existsSync(".cursor")) {
+    console.log(chalk17.yellow("No .claude/ or .cursor/ directory found."));
+    console.log(chalk17.dim("  Run `caliber init` first, or create the directory manually."));
     return;
   }
-  console.log(chalk17.green("\u2713") + " Learning hooks installed in .claude/settings.json");
-  console.log(chalk17.dim("  PostToolUse, PostToolUseFailure, and SessionEnd hooks active."));
-  console.log(chalk17.dim("  Session learnings will be written to CLAUDE.md and skills."));
+  if (anyInstalled) {
+    console.log(chalk17.dim(`  Tool usage will be recorded and learnings extracted after \u2265${MIN_EVENTS_FOR_ANALYSIS} events.`));
+    console.log(chalk17.dim("  Learnings written to CALIBER_LEARNINGS.md."));
+  }
 }
 async function learnRemoveCommand() {
-  const result = removeLearningHooks();
-  if (result.notFound) {
-    console.log(chalk17.dim("Learning hooks not found."));
-    return;
+  let anyRemoved = false;
+  const r1 = removeLearningHooks();
+  if (r1.removed) {
+    console.log(chalk17.green("\u2713") + " Claude Code learning hooks removed");
+    anyRemoved = true;
+  }
+  const r2 = removeCursorLearningHooks();
+  if (r2.removed) {
+    console.log(chalk17.green("\u2713") + " Cursor learning hooks removed");
+    anyRemoved = true;
+  }
+  if (!anyRemoved) {
+    console.log(chalk17.dim("No learning hooks found."));
   }
-  console.log(chalk17.green("\u2713") + " Learning hooks removed from .claude/settings.json");
 }
 async function learnStatusCommand() {
-  const installed = areLearningHooksInstalled();
+  const claudeInstalled = areLearningHooksInstalled();
+  const cursorInstalled = areCursorLearningHooksInstalled();
   const state = readState2();
   const eventCount = getEventCount();
   console.log(chalk17.bold("Session Learning Status"));
   console.log();
-  if (installed) {
-    console.log(chalk17.green("\u2713") + " Learning hooks are " + chalk17.green("installed"));
+  if (claudeInstalled) {
+    console.log(chalk17.green("\u2713") + " Claude Code hooks " + chalk17.green("installed"));
+  } else {
+    console.log(chalk17.dim("\u2717") + " Claude Code hooks " + chalk17.dim("not installed"));
+  }
+  if (cursorInstalled) {
+    console.log(chalk17.green("\u2713") + " Cursor hooks " + chalk17.green("installed"));
   } else {
-    console.log(chalk17.dim("\u2717") + " Learning hooks are " + chalk17.yellow("not installed"));
+    console.log(chalk17.dim("\u2717") + " Cursor hooks " + chalk17.dim("not installed"));
+  }
+  if (!claudeInstalled && !cursorInstalled) {
     console.log(chalk17.dim("  Run `caliber learn install` to enable session learning."));
   }
   console.log();
   console.log(`Events recorded: ${chalk17.cyan(String(eventCount))}`);
-  console.log(`Total this session: ${chalk17.cyan(String(state.eventCount))}`);
+  console.log(`Threshold for analysis: ${chalk17.cyan(String(MIN_EVENTS_FOR_ANALYSIS))}`);
   if (state.lastAnalysisTimestamp) {
     console.log(`Last analysis: ${chalk17.cyan(state.lastAnalysisTimestamp)}`);
   } else {
@@ -8177,14 +8420,14 @@ async function learnStatusCommand() {
   if (learnedSection) {
     const lineCount = learnedSection.split("\n").filter(Boolean).length;
     console.log(`
-Learned items in CLAUDE.md: ${chalk17.cyan(String(lineCount))}`);
+Learned items in CALIBER_LEARNINGS.md: ${chalk17.cyan(String(lineCount))}`);
   }
 }
 
 // src/cli.ts
 var __dirname = path25.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs31.readFileSync(path25.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs32.readFileSync(path25.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -8258,7 +8501,7 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 
 // src/utils/version-check.ts
-import fs32 from "fs";
+import fs33 from "fs";
 import path26 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync14 } from "child_process";
@@ -8267,13 +8510,13 @@ import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
 var __dirname_vc = path26.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs32.readFileSync(path26.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs33.readFileSync(path26.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync14("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const pkgPath = path26.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs32.readFileSync(pkgPath, "utf-8")).version;
+    return JSON.parse(fs33.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -8362,7 +8605,9 @@ acquireLock();
 if (process.env.CALIBER_LOCAL) {
   process.env.CALIBER_SKIP_UPDATE_CHECK = "1";
 }
-var isQuickExit = ["--version", "-V", "--help", "-h"].some((f) => process.argv.includes(f));
+var userArgs = process.argv.slice(2);
+var hasCommand = userArgs.some((a) => !a.startsWith("-"));
+var isQuickExit = !hasCommand || ["--version", "-V", "--help", "-h"].some((f) => userArgs.includes(f));
 if (!isQuickExit) {
   await checkForUpdates();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rely-ai/caliber",
-  "version": "1.18.9",
+  "version": "1.19.1",
   "description": "Analyze your codebase and generate optimized AI agent configs (CLAUDE.md, .cursorrules, skills) — no API key needed",
   "type": "module",
   "bin": {