@rely-ai/caliber 1.18.8 → 1.19.0

package/README.md

@@ -14,45 +14,24 @@
 
 ---
 
-Caliber scans your project — languages, frameworks, dependencies, file structure — and generates tailored config files for **Claude Code**, **Cursor**, and **OpenAI Codex**. If configs already exist, it audits them against your actual codebase and suggests targeted improvements.
-
-🔑 **API Key Optional** — use your existing Claude Code or Cursor subscription. Or bring your own key (Anthropic, OpenAI, Vertex AI, any OpenAI-compatible endpoint).
-
-🧠 **BYOAI** — Caliber works where you do. All LLM processing runs through your own models — no data is sent to third parties.
-
-### Why Caliber?
-
-Caliber **generates, audits, and maintains** your agentic development sessions.
-
-- 🏗️ **Generates, not just score** — builds your CLAUDE.md, Cursor rules, AGENTS.md, skills, and MCP configs from scratch
-- 🔀 **Multi-agent** — one command sets up Claude Code, Cursor, and Codex together
-- 🌍 **Any codebase** — TypeScript, Python, Go, Rust, Terraform, Java, Ruby — detection is fully LLM-driven, not hardcoded
-- 🧩 **Finds and installs skills** — searches community registries and installs relevant skills for your stack
-- 🔗 **Discovers MCP servers** — auto-detects tools your project uses and installs matching MCP servers
-- 🔄 **Keeps configs fresh** — git hooks and session hooks auto-update your docs as your code changes
-- ↩️ **Fully reversible** — automatic backups, score regression guard, and one-command undo
-
-## 🚀 Quick Start
-
-```bash
-npx @rely-ai/caliber init
-```
-
-That's it. On first run, Caliber walks you through provider setup interactively.
-
-Or install globally:
+Caliber analyzes your codebase — languages, frameworks, dependencies, architecture — and generates tailored, high-quality configs for **Claude Code**, **Cursor**, and **OpenAI Codex**. If configs already exist, it scores them, fixes what's stale, and keeps everything in sync as your code evolves.
 
 ```bash
 npm install -g @rely-ai/caliber
 caliber init
 ```
 
-> **Already have an API key?** Skip the interactive setup:
->
-> ```bash
-> export ANTHROPIC_API_KEY=sk-ant-...
-> npx @rely-ai/caliber init
-> ```
+No API key required — works with your existing **Claude Code** or **Cursor** subscription. Or bring your own key (Anthropic, OpenAI, Vertex AI, any OpenAI-compatible endpoint).
+
+## 💡 What Caliber Does
+
+| Without Caliber | With Caliber |
+|---|---|
+| Hand-write CLAUDE.md, Cursor rules, AGENTS.md separately | One command generates all three, tuned to your actual codebase |
+| Configs reference files that no longer exist | Deterministic scoring catches stale references and drift |
+| New team members start with no AI context | `caliber init` gives any contributor a complete setup in seconds |
+| Configs diverge across AI tools | Cross-platform parity — Claude, Cursor, and Codex stay consistent |
+| No idea if your config is actually helping | Score your setup (A–F grade) and see exactly what to improve |
 
 ## ⚙️ How It Works
 
@@ -62,93 +41,63 @@ caliber init
 ├─ 1. 🔌 Connect      Choose your LLM provider — Claude Code seat, Cursor seat,
 │                      or an API key (Anthropic, OpenAI, Vertex AI)
 │
-├─ 2. 🔍 Discover     Analyze languages, frameworks, dependencies, file structure,
-│                      and existing agent configs via LLM
+├─ 2. 🔍 Discover     Fingerprint your project: languages, frameworks, dependencies,
+│                      file structure, and existing agent configs
 │
-├─ 3. 🛠️  Generate     Create CLAUDE.md + skills in parallel (core docs via smart
-│                      model, skills via fast model). Auto-polishes for max score
+├─ 3. 🛠️  Generate     Build optimized configs with parallel LLM calls
+│                      (heavy model for docs, fast model for skills)
 │
-├─ 4. 👀 Review       See a diff of proposed changes — accept, refine via
-│                      chat, or decline. All changes are backed up automatically
+├─ 4. 👀 Review       See a diff of every proposed change — accept, refine
+│                      via chat, or decline. All originals are backed up
 │
-└─ 5. 🧩 Skills       Search community skill registries and install relevant
+└─ 5. 🧩 Skills       Search community registries and install relevant
                        skills for your tech stack
 ```
 
-Caliber works on **any codebase** — TypeScript, Python, Go, Rust, Terraform, Java, Ruby, and more. Language and framework detection is fully LLM-driven, not hardcoded.
+Already have a setup? If your existing config scores **95+**, Caliber skips full regeneration and applies targeted fixes to the specific checks that are failing.
 
 ### 📦 What It Generates
 
-| File                        | Platform    | Purpose                                                             |
-| --------------------------- | ----------- | ------------------------------------------------------------------- |
-| `CLAUDE.md`                 | Claude Code | Project context — build/test commands, architecture, conventions    |
-| `.cursor/rules/*.mdc`       | Cursor      | Modern rules with frontmatter (description, globs, alwaysApply)     |
-| `.cursorrules`              | Cursor      | Legacy rules file (if no `.cursor/rules/` exists)                   |
-| `AGENTS.md`                 | Codex       | Project context for OpenAI Codex                                    |
-| `.claude/skills/*/SKILL.md` | Claude Code | Reusable skill files following [OpenSkills](https://agentskills.io) |
-| `.cursor/skills/*/SKILL.md` | Cursor      | Skills for Cursor                                                   |
-| `.agents/skills/*/SKILL.md` | Codex       | Skills for Codex                                                    |
-| `.mcp.json`                 | Claude Code | MCP server configurations                                           |
-| `.cursor/mcp.json`          | Cursor      | MCP server configurations                                           |
-| `.claude/settings.json`     | Claude Code | Permissions and hooks                                               |
+**Claude Code**
+- `CLAUDE.md` — Project context, build/test commands, architecture, conventions
+- `.claude/skills/*/SKILL.md` — Reusable skills ([OpenSkills](https://agentskills.io) format)
+- `.mcp.json` — Auto-discovered MCP server configurations
+- `.claude/settings.json` — Permissions and hooks
 
-If these files already exist, Caliber audits them and suggests improvements — keeping what works, fixing what's stale, adding what's missing.
+**Cursor**
+- `.cursor/rules/*.mdc` — Modern rules with frontmatter (description, globs, alwaysApply)
+- `.cursor/skills/*/SKILL.md` — Skills for Cursor
+- `.cursor/mcp.json` — MCP server configurations
 
-### 🛡️ Safety
+**OpenAI Codex**
+- `AGENTS.md` — Project context for Codex
+- `.agents/skills/*/SKILL.md` — Skills for Codex
 
-Every change Caliber makes is reversible:
-
-- 💾 **Automatic backups** — previous versions saved to `.caliber/backups/{timestamp}/` before every write
-- 📊 **Score regression guard** — if a regeneration produces a lower score, changes are auto-reverted
-- ↩️ **Full undo** — `caliber undo` reverts all changes made by Caliber
-- 🔍 **Dry run** — preview any command's changes with `--dry-run`
-
-## 📋 Commands
+If these files already exist, Caliber audits them and suggests improvements — keeping what works, fixing what's stale, adding what's missing.
 
-| Command              | Description                                          |
-| -------------------- | ---------------------------------------------------- |
-| `caliber init`       | 🏁 Initialize your project — full 5-step wizard      |
-| `caliber score`      | 📊 Score your config quality (deterministic, no LLM) |
-| `caliber skills`     | 🧩 Discover and install community skills             |
-| `caliber regenerate` | 🔄 Re-analyze and regenerate your setup              |
-| `caliber refresh`    | 🔃 Update docs based on recent code changes          |
-| `caliber hooks`      | 🪝 Manage auto-refresh hooks                         |
-| `caliber config`     | ⚙️ Configure LLM provider, API key, and model        |
-| `caliber status`     | 📌 Show current setup status                         |
-| `caliber undo`       | ↩️ Revert all changes made by Caliber                |
+## ✨ Key Features
 
-### Examples
+### 🌍 Any Codebase
+TypeScript, Python, Go, Rust, Java, Ruby, Terraform, and more. Language and framework detection is fully LLM-driven — no hardcoded mappings. Caliber works on any project.
 
+### 🔀 Any AI Tool
+Target a single platform or all three at once:
 ```bash
-# Initialize
-caliber init                      # Interactive — picks agent, walks through setup
-caliber init --agent claude       # Target Claude Code only
-caliber init --agent cursor       # Target Cursor only
-caliber init --agent codex        # Target OpenAI Codex only
-caliber init --agent all          # Target all three
+caliber init --agent claude        # Claude Code only
+caliber init --agent cursor        # Cursor only
+caliber init --agent codex         # Codex only
+caliber init --agent all           # All three
 caliber init --agent claude,cursor # Comma-separated
-caliber init --dry-run            # Preview without writing files
-caliber init --force              # Overwrite existing setup without prompting
-
-# Scoring
-caliber score                        # Full breakdown with grade (A-F)
-caliber score --json                 # Machine-readable output
-caliber score --agent claude         # Score for a specific agent
-
-# Day-to-day
-caliber regenerate                   # Re-analyze and regenerate (alias: regen, re)
-caliber refresh                      # Update docs from recent git changes
-caliber refresh --dry-run            # Preview what would change
-caliber skills                       # Browse and install community skills
-caliber hooks                        # Toggle auto-refresh hooks
-caliber hooks --install              # Enable all hooks non-interactively
-caliber status                       # Show what Caliber has set up
-caliber undo                         # Revert everything
 ```
 
-## 📊 Scoring
+### 💬 Chat-Based Refinement
+Not happy with the generated output? During review, refine via natural language — describe what you want changed and Caliber iterates until you're satisfied.
 
-`caliber score` gives you a deterministic, tech-stack-agnostic quality score. No LLM needed — it cross-references your config files against the actual project filesystem.
+### 🔗 MCP Server Discovery
+Caliber detects the tools your project uses (databases, APIs, services) and auto-configures matching MCP servers for Claude Code and Cursor.
+
+### 📊 Deterministic Scoring
+`caliber score` evaluates your config quality without any LLM calls — purely by cross-referencing config files against your actual project filesystem.
 
 ```
   Agent Config Score    88 / 100    Grade A
@@ -161,59 +110,76 @@ caliber undo                         # Revert everything
   BONUS                                         5 / 5
 ```
 
-| Category               | Points | What it checks                                                     |
-| ---------------------- | ------ | ------------------------------------------------------------------ |
-| **Files & Setup**      | 25     | Config files exist, skills present, MCP servers, cross-platform parity |
-| **Quality**            | 25     | Has code blocks, concise token budget, concrete instructions, structured headings |
-| **Grounding**          | 20     | Config references actual project directories and files             |
-| **Accuracy**           | 15     | Referenced paths exist on disk, config is in sync with code (git-based) |
-| **Freshness & Safety** | 10     | Recently updated, no leaked secrets, permissions configured        |
-| **Bonus**              | 5      | Auto-refresh hooks, AGENTS.md, OpenSkills format                   |
-
-Every failing check includes structured fix data — when `caliber init` runs, the LLM receives exactly what's wrong and how to fix it.
-
-## 🧩 Skills
-
-Caliber searches three community registries and scores results against your project
-
-```bash
-caliber skills
-```
+<details>
+<summary>Scoring breakdown</summary>
 
-Skills are scored by LLM relevance (0–100) based on your project's actual tech stack and development patterns, then you pick which ones to install via an interactive selector. Installed skills follow the [OpenSkills](https://agentskills.io) standard with YAML frontmatter.
+| Category | Points | What it checks |
+|---|---|---|
+| **Files & Setup** | 25 | Config files exist, skills present, MCP servers, cross-platform parity |
+| **Quality** | 25 | Code blocks, concise token budget, concrete instructions, structured headings |
+| **Grounding** | 20 | Config references actual project directories and files |
+| **Accuracy** | 15 | Referenced paths exist on disk, config freshness vs. git history |
+| **Freshness & Safety** | 10 | Recently updated, no leaked secrets, permissions configured |
+| **Bonus** | 5 | Auto-refresh hooks, AGENTS.md, OpenSkills format |
 
-## 🔄 Auto-Refresh
+Every failing check includes structured fix data — when `caliber init` runs, the LLM receives exactly what's wrong and how to fix it.
 
-Keep your agent configs in sync with your codebase automatically:
+</details>
 
-| Hook                  | Trigger             | What it does                            |
-| --------------------- | ------------------- | --------------------------------------- |
-| 🤖 **Claude Code**    | End of each session | Runs `caliber refresh` and updates docs |
-| 📝 **Git pre-commit** | Before each commit  | Refreshes docs and stages updated files |
+### 🔄 Auto-Refresh
+Keep configs in sync with your codebase automatically:
 
-Set up hooks interactively with `caliber hooks`, or non-interactively:
+| Hook | Trigger | What it does |
+|---|---|---|
+| **Claude Code** | End of each session | Runs `caliber refresh` and updates docs |
+| **Git pre-commit** | Before each commit | Refreshes docs and stages updated files |
 
 ```bash
 caliber hooks --install    # Enable all hooks
 caliber hooks --remove     # Disable all hooks
 ```
 
-The refresh command analyzes your git diff (committed, staged, and unstaged changes) and updates your config files to reflect what changed. It works across multiple repos if run from a parent directory.
+The `refresh` command analyzes your git diff (committed, staged, and unstaged changes) and updates config files to reflect what changed. Works across multiple repos when run from a parent directory.
+
+### 🛡️ Fully Reversible
+Every change Caliber makes can be undone:
+- **Automatic backups** — originals saved to `.caliber/backups/` before every write
+- **Score regression guard** — if a regeneration produces a lower score, changes are auto-reverted
+- **Full undo** — `caliber undo` restores everything to its previous state
+- **Dry run** — preview changes with `--dry-run` before applying
+
+## 📋 Commands
+
+| Command | Description |
+|---|---|
+| `caliber init` | Full setup wizard — analyze, generate, review, install skills |
+| `caliber score` | Score config quality (deterministic, no LLM) |
+| `caliber regenerate` | Re-analyze and regenerate configs (aliases: `regen`, `re`) |
+| `caliber refresh` | Update docs based on recent code changes |
+| `caliber skills` | Discover and install community skills |
+| `caliber hooks` | Manage auto-refresh hooks |
+| `caliber config` | Configure LLM provider, API key, and model |
+| `caliber status` | Show current setup status |
+| `caliber undo` | Revert all changes made by Caliber |
 
 ## 🔌 LLM Providers
 
-| Provider                       | Setup                                 | Default Model              |
-| ------------------------------ | ------------------------------------- | -------------------------- |
-| 🟣 **Claude Code** (your seat) | `caliber config` → Claude Code        | Inherited from Claude Code |
-| 🔵 **Cursor** (your seat)      | `caliber config` → Cursor             | Inherited from Cursor      |
-| 🟠 **Anthropic**               | `export ANTHROPIC_API_KEY=sk-ant-...` | `claude-sonnet-4-6`        |
-| 🟢 **OpenAI**                  | `export OPENAI_API_KEY=sk-...`        | `gpt-4.1`                  |
-| 🔴 **Vertex AI**               | `export VERTEX_PROJECT_ID=my-project` | `claude-sonnet-4-6`        |
-| ⚪ **Custom endpoint**         | `OPENAI_API_KEY` + `OPENAI_BASE_URL`  | `gpt-4.1`                  |
+No API key? No problem. Caliber works with your existing AI tool subscription:
+
+| Provider | Setup | Default Model |
+|---|---|---|
+| **Claude Code** (your seat) | `caliber config` → Claude Code | Inherited from Claude Code |
+| **Cursor** (your seat) | `caliber config` → Cursor | Inherited from Cursor |
+| **Anthropic** | `export ANTHROPIC_API_KEY=sk-ant-...` | `claude-sonnet-4-6` |
+| **OpenAI** | `export OPENAI_API_KEY=sk-...` | `gpt-4.1` |
+| **Vertex AI** | `export VERTEX_PROJECT_ID=my-project` | `claude-sonnet-4-6` |
+| **Custom endpoint** | `OPENAI_API_KEY` + `OPENAI_BASE_URL` | `gpt-4.1` |
 
 Override the model for any provider: `export CALIBER_MODEL=<model-name>` or use `caliber config`.
 
-Configuration is stored in `~/.caliber/config.json` with restricted permissions (`0600`). 🔒 API keys are never written to project files.
+Caliber uses a **two-tier model system** — lightweight tasks (classification, scoring) auto-use a faster model, while heavy tasks (generation, refinement) use the default. This keeps costs low and speed high.
+
+Configuration is stored in `~/.caliber/config.json` with restricted permissions (`0600`). API keys are never written to project files.
 
 <details>
 <summary>Vertex AI advanced setup</summary>
@@ -237,18 +203,19 @@ export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
 <details>
 <summary>Environment variables reference</summary>
 
-| Variable                         | Purpose                                 |
-| -------------------------------- | --------------------------------------- |
-| `ANTHROPIC_API_KEY`              | Anthropic API key                       |
-| `OPENAI_API_KEY`                 | OpenAI API key                          |
-| `OPENAI_BASE_URL`                | Custom OpenAI-compatible endpoint       |
-| `VERTEX_PROJECT_ID`              | GCP project ID for Vertex AI            |
-| `VERTEX_REGION`                  | Vertex AI region (default: `us-east5`)  |
-| `VERTEX_SA_CREDENTIALS`          | Service account JSON (inline)           |
-| `GOOGLE_APPLICATION_CREDENTIALS` | Service account JSON file path          |
-| `CALIBER_USE_CLAUDE_CLI`         | Use Claude Code CLI (`1` to enable)     |
-| `CALIBER_USE_CURSOR_SEAT`        | Use Cursor subscription (`1` to enable) |
-| `CALIBER_MODEL`                  | Override model for any provider         |
+| Variable | Purpose |
+|---|---|
+| `ANTHROPIC_API_KEY` | Anthropic API key |
+| `OPENAI_API_KEY` | OpenAI API key |
+| `OPENAI_BASE_URL` | Custom OpenAI-compatible endpoint |
+| `VERTEX_PROJECT_ID` | GCP project ID for Vertex AI |
+| `VERTEX_REGION` | Vertex AI region (default: `us-east5`) |
+| `VERTEX_SA_CREDENTIALS` | Service account JSON (inline) |
+| `GOOGLE_APPLICATION_CREDENTIALS` | Service account JSON file path |
+| `CALIBER_USE_CLAUDE_CLI` | Use Claude Code CLI (`1` to enable) |
+| `CALIBER_USE_CURSOR_SEAT` | Use Cursor subscription (`1` to enable) |
+| `CALIBER_MODEL` | Override model for any provider |
+| `CALIBER_FAST_MODEL` | Override fast model for any provider |
 
 </details>
 

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";
 
@@ -2030,6 +2030,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 +2063,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
@@ -3593,7 +3600,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 +3725,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 +4069,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 +5178,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 +7398,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 +7411,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 +7516,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 +7527,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 +7575,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 +7721,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 +7749,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 +7765,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 +7828,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 +8052,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
+import fs31 from "fs";
 import chalk17 from "chalk";
 
 // src/learner/stdin.ts
@@ -7861,8 +8084,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 +8093,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 +8112,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 +8268,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 +8276,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 +8295,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 +8305,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 +8317,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 +8417,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 +8498,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 +8507,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;
   }

package/package.json

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