@rely-ai/caliber 1.25.1 → 1.26.0-dev.1773939160

package/dist/bin.js

@@ -230,7 +230,7 @@ __export(resolve_caliber_exports, {
   isCaliberCommand: () => isCaliberCommand,
   resolveCaliber: () => resolveCaliber
 });
-import fs18 from "fs";
+import fs19 from "fs";
 import { execSync as execSync6 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
@@ -252,7 +252,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs18.existsSync(binPath)) {
+  if (binPath && fs19.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -276,13 +276,13 @@ var init_resolve_caliber = __esm({
 
 // src/utils/editor.ts
 import { execSync as execSync12, spawn as spawn3 } from "child_process";
-import fs25 from "fs";
-import path21 from "path";
+import fs26 from "fs";
+import path22 from "path";
 import os5 from "os";
 function getEmptyFilePath(proposedPath) {
-  fs25.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path21.join(DIFF_TEMP_DIR, path21.basename(proposedPath));
-  fs25.writeFileSync(tempPath, "");
+  fs26.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path22.join(DIFF_TEMP_DIR, path22.basename(proposedPath));
+  fs26.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
@@ -322,7 +322,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path21.join(os5.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path22.join(os5.tmpdir(), "caliber-diff");
   }
 });
 
@@ -334,7 +334,7 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs26 from "fs";
+import fs27 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
@@ -371,8 +371,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs26.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs26.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs27.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs27.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -547,13 +547,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs35 from "fs";
-import path27 from "path";
+import fs36 from "fs";
+import path28 from "path";
 import os7 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs35.existsSync(LOCK_FILE)) return false;
-    const raw = fs35.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs36.existsSync(LOCK_FILE)) return false;
+    const raw = fs36.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -568,13 +568,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs35.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs36.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs35.existsSync(LOCK_FILE)) fs35.unlinkSync(LOCK_FILE);
+    if (fs36.existsSync(LOCK_FILE)) fs36.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -582,21 +582,21 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path27.join(os7.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path28.join(os7.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs45 from "fs";
-import path36 from "path";
+import fs46 from "fs";
+import path37 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path23 from "path";
+import path24 from "path";
 import chalk14 from "chalk";
-import fs30 from "fs";
+import fs31 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
@@ -3424,15 +3424,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
-function readFileOrNull2(path38) {
+function readFileOrNull2(path39) {
   try {
-    return readFileSync2(path38, "utf-8");
+    return readFileSync2(path39, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path38) {
-  const content = readFileOrNull2(path38);
+function readJsonOrNull(path39) {
+  const content = readFileOrNull2(path39);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -4019,7 +4019,7 @@ ${f.content}
 }
 
 // src/writers/index.ts
-import fs15 from "fs";
+import fs16 from "fs";
 
 // src/writers/claude/index.ts
 import fs9 from "fs";
@@ -4253,35 +4253,182 @@ function restoreBackup(backupDir, file) {
   return true;
 }
 
+// src/lib/builtin-skills.ts
+import fs14 from "fs";
+import path14 from "path";
+function buildSkillContent(skill) {
+  const frontmatter = `---
+name: ${skill.name}
+description: ${skill.description}
+---
+
+`;
+  return frontmatter + skill.content;
+}
+var FIND_SKILLS_SKILL = {
+  name: "find-skills",
+  description: "Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.",
+  content: `# Find Skills
+
+Search the public skill registry for community-contributed skills
+relevant to the user's current task and install them into this project.
+
+## Instructions
+
+1. Identify the key technologies, frameworks, or task types from the
+   user's request that might have community skills available
+2. Ask the user: "Would you like me to search for community skills
+   for [identified technologies]?"
+3. If the user agrees, run:
+   \`\`\`bash
+   caliber skills --query "<relevant terms>"
+   \`\`\`
+   This outputs the top 5 matching skills with scores and descriptions.
+4. Present the results to the user and ask which ones to install
+5. Install the selected skills:
+   \`\`\`bash
+   caliber skills --install <slug1>,<slug2>
+   \`\`\`
+6. Read the installed SKILL.md files to load them into your current
+   context so you can use them immediately in this session
+7. Summarize what was installed and continue with the user's task
+
+## Examples
+
+User: "let's build a web app using React"
+-> "I notice you want to work with React. Would you like me to search
+   for community skills that could help with React development?"
+-> If yes: run \`caliber skills --query "react frontend"\`
+-> Show the user the results, ask which to install
+-> Run \`caliber skills --install <selected-slugs>\`
+-> Read the installed files and continue
+
+User: "help me set up Docker for this project"
+-> "Would you like me to search for Docker-related skills?"
+-> If yes: run \`caliber skills --query "docker deployment"\`
+
+User: "I need to write tests for this Python ML pipeline"
+-> "Would you like me to find skills for Python ML testing?"
+-> If yes: run \`caliber skills --query "python machine-learning testing"\`
+
+## When NOT to trigger
+
+- The user is working within an already well-configured area
+- You already suggested skills for this technology in this session
+- The user is in the middle of urgent debugging or time-sensitive work
+- The technology is too generic (e.g. just "code" or "programming")
+`
+};
+var SAVE_LEARNING_SKILL = {
+  name: "save-learning",
+  description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
+  content: `# Save Learning
+
+Save a user's instruction or preference as a persistent learning that
+will be applied in all future sessions on this project.
+
+## Instructions
+
+1. Detect when the user gives an instruction to remember, such as:
+   - "remember this", "save this", "always do X", "never do Y"
+   - "from now on", "going forward", "in this project we..."
+   - Any stated convention, preference, or rule
+2. Refine the instruction into a clean, actionable learning bullet with
+   an appropriate type prefix:
+   - \`**[convention]**\` \u2014 coding style, workflow, git conventions
+   - \`**[pattern]**\` \u2014 reusable code patterns
+   - \`**[anti-pattern]**\` \u2014 things to avoid
+   - \`**[preference]**\` \u2014 personal/team preferences
+   - \`**[context]**\` \u2014 project-specific context
+3. Show the refined learning to the user and ask for confirmation
+4. If confirmed, run:
+   \`\`\`bash
+   caliber learn add "<refined learning>"
+   \`\`\`
+   For personal preferences (not project-level), add \`--personal\`:
+   \`\`\`bash
+   caliber learn add --personal "<refined learning>"
+   \`\`\`
+5. Stage the learnings file for the next commit:
+   \`\`\`bash
+   git add CALIBER_LEARNINGS.md
+   \`\`\`
+
+## Examples
+
+User: "when developing features, push to next branch not master, remember it"
+-> Refine: \`**[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`\`
+-> "I'll save this as a project learning:
+    **[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`
+    Save for future sessions?"
+-> If yes: run \`caliber learn add "**[convention]** Push feature commits to the next branch, not master"\`
+-> Run \`git add CALIBER_LEARNINGS.md\`
+
+User: "always use bun instead of npm"
+-> Refine: \`**[preference]** Use \\\`bun\\\` instead of \\\`npm\\\` for package management\`
+-> Confirm and save
+
+User: "never use any in TypeScript, use unknown instead"
+-> Refine: \`**[convention]** Use \\\`unknown\\\` instead of \\\`any\\\` in TypeScript\`
+-> Confirm and save
+
+## When NOT to trigger
+
+- The user is giving a one-time instruction for the current task only
+- The instruction is too vague to be actionable
+- The user explicitly says "just for now" or "only this time"
+`
+};
+var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL];
+var PLATFORM_CONFIGS = [
+  { platformDir: ".claude", skillsDir: path14.join(".claude", "skills") },
+  { platformDir: ".cursor", skillsDir: path14.join(".cursor", "skills") },
+  { platformDir: ".agents", skillsDir: path14.join(".agents", "skills") }
+];
+function ensureBuiltinSkills() {
+  const written = [];
+  for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
+    if (!fs14.existsSync(platformDir)) continue;
+    for (const skill of BUILTIN_SKILLS) {
+      const skillPath = path14.join(skillsDir, skill.name, "SKILL.md");
+      if (fs14.existsSync(skillPath)) continue;
+      fs14.mkdirSync(path14.dirname(skillPath), { recursive: true });
+      fs14.writeFileSync(skillPath, buildSkillContent(skill));
+      written.push(skillPath);
+    }
+  }
+  return written;
+}
+
 // src/writers/manifest.ts
 init_constants();
-import fs14 from "fs";
+import fs15 from "fs";
 import crypto2 from "crypto";
 function readManifest() {
   try {
-    if (!fs14.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs14.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs15.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs15.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs14.existsSync(CALIBER_DIR)) {
-    fs14.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs15.existsSync(CALIBER_DIR)) {
+    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs14.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs15.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs14.readFileSync(filePath);
+  const content = fs15.readFileSync(filePath);
   return crypto2.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs15.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs16.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs15.existsSync(f)),
+    ...filesToWrite.filter((f) => fs16.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -4300,9 +4447,10 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs15.unlinkSync(filePath);
+    fs16.unlinkSync(filePath);
     deleted.push(filePath);
   }
+  written.push(...ensureBuiltinSkills());
   ensureGitignore();
   const entries = [
     ...written.map((file) => ({
@@ -4330,8 +4478,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs15.existsSync(entry.path)) {
-        fs15.unlinkSync(entry.path);
+      if (fs16.existsSync(entry.path)) {
+        fs16.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -4341,8 +4489,8 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs15.existsSync(MANIFEST_FILE2)) {
-    fs15.unlinkSync(MANIFEST_FILE2);
+  if (fs16.existsSync(MANIFEST_FILE2)) {
+    fs16.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
@@ -4383,23 +4531,23 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs15.existsSync(gitignorePath)) {
-    const content = fs15.readFileSync(gitignorePath, "utf-8");
+  if (fs16.existsSync(gitignorePath)) {
+    const content = fs16.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs15.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs16.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs15.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs16.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
 init_constants();
-import fs16 from "fs";
-import path14 from "path";
-var STAGED_DIR = path14.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path14.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path14.join(STAGED_DIR, "current");
+import fs17 from "fs";
+import path15 from "path";
+var STAGED_DIR = path15.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path15.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path15.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4409,20 +4557,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path14.join(projectDir, file.path);
-    if (fs16.existsSync(originalPath)) {
-      const existing = fs16.readFileSync(originalPath, "utf-8");
+    const originalPath = path15.join(projectDir, file.path);
+    if (fs17.existsSync(originalPath)) {
+      const existing = fs17.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path14.join(PROPOSED_DIR, file.path);
-    fs16.mkdirSync(path14.dirname(proposedPath), { recursive: true });
-    fs16.writeFileSync(proposedPath, file.content);
-    if (fs16.existsSync(originalPath)) {
-      const currentPath = path14.join(CURRENT_DIR, file.path);
-      fs16.mkdirSync(path14.dirname(currentPath), { recursive: true });
-      fs16.copyFileSync(originalPath, currentPath);
+    const proposedPath = path15.join(PROPOSED_DIR, file.path);
+    fs17.mkdirSync(path15.dirname(proposedPath), { recursive: true });
+    fs17.writeFileSync(proposedPath, file.content);
+    if (fs17.existsSync(originalPath)) {
+      const currentPath = path15.join(CURRENT_DIR, file.path);
+      fs17.mkdirSync(path15.dirname(currentPath), { recursive: true });
+      fs17.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -4433,22 +4581,13 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs16.existsSync(STAGED_DIR)) {
-    fs16.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs17.existsSync(STAGED_DIR)) {
+    fs17.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs17 from "fs";
-function buildSkillContent(skill) {
-  const frontmatter = `---
-name: ${skill.name}
-description: ${skill.description}
----
-
-`;
-  return frontmatter + skill.content;
-}
+import fs18 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -4462,6 +4601,9 @@ function collectSetupFiles(setup, targetAgent) {
         files.push({ path: `.claude/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
       }
     }
+    for (const builtin of BUILTIN_SKILLS) {
+      files.push({ path: `.claude/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+    }
   }
   if (codex) {
     if (codex.agentsMd) files.push({ path: "AGENTS.md", content: codex.agentsMd });
@@ -4471,6 +4613,9 @@ function collectSetupFiles(setup, targetAgent) {
         files.push({ path: `.agents/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
       }
     }
+    for (const builtin of BUILTIN_SKILLS) {
+      files.push({ path: `.agents/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+    }
   }
   if (cursor) {
     if (cursor.cursorrules) files.push({ path: ".cursorrules", content: cursor.cursorrules });
@@ -4480,6 +4625,9 @@ function collectSetupFiles(setup, targetAgent) {
         files.push({ path: `.cursor/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
       }
     }
+    for (const builtin of BUILTIN_SKILLS) {
+      files.push({ path: `.cursor/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+    }
     const rules = cursor.rules;
     if (Array.isArray(rules)) {
       for (const rule of rules) {
@@ -4498,7 +4646,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs17.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs18.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -4516,9 +4664,9 @@ ${agentRefs.join(" ")}
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs19 from "fs";
-import path15 from "path";
-var SETTINGS_PATH = path15.join(".claude", "settings.json");
+import fs20 from "fs";
+import path16 from "path";
+var SETTINGS_PATH = path16.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -4535,17 +4683,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings() {
-  if (!fs19.existsSync(SETTINGS_PATH)) return {};
+  if (!fs20.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs19.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs20.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path15.dirname(SETTINGS_PATH);
-  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
-  fs19.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path16.dirname(SETTINGS_PATH);
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -4579,7 +4727,7 @@ function installLearningHooks() {
   writeSettings(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path15.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path16.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -4587,17 +4735,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs19.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs19.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs20.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path15.dirname(CURSOR_HOOKS_PATH);
-  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
-  fs19.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path16.dirname(CURSOR_HOOKS_PATH);
+  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
+  fs20.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -4667,10 +4815,10 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs20 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path17 from "path";
 import { execSync as execSync7 } from "child_process";
-var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path17.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -4681,8 +4829,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs20.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs20.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs21.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs21.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -4690,10 +4838,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs20.existsSync(CALIBER_DIR)) {
-    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs20.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs21.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -5752,22 +5900,22 @@ function checkSources(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs21 from "fs";
-import path17 from "path";
-var DISMISSED_FILE = path17.join(CALIBER_DIR, "dismissed-checks.json");
+import fs22 from "fs";
+import path18 from "path";
+var DISMISSED_FILE = path18.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs21.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs21.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs22.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs22.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs21.existsSync(CALIBER_DIR)) {
-    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs22.existsSync(CALIBER_DIR)) {
+    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs21.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs22.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -6015,13 +6163,13 @@ import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4,
 import { join as join10, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs22 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path19 from "path";
 import crypto3 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path18.join(dir, "CLAUDE.md");
-  if (fs22.existsSync(claudeMdPath)) {
+  const claudeMdPath = path19.join(dir, "CLAUDE.md");
+  if (fs23.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -6030,10 +6178,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path18.join(dir, ".claude", "skills");
-  if (fs22.existsSync(skillsDir)) {
-    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path18.join(skillsDir, file);
+  const skillsDir = path19.join(dir, ".claude", "skills");
+  if (fs23.existsSync(skillsDir)) {
+    for (const file of fs23.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path19.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -6043,10 +6191,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path18.join(dir, ".mcp.json");
-  if (fs22.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path19.join(dir, ".mcp.json");
+  if (fs23.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -6061,8 +6209,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path18.join(dir, "AGENTS.md");
-  if (fs22.existsSync(agentsMdPath)) {
+  const agentsMdPath = path19.join(dir, "AGENTS.md");
+  if (fs23.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -6071,12 +6219,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path18.join(dir, ".agents", "skills");
-  if (fs22.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path19.join(dir, ".agents", "skills");
+  if (fs23.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs22.readdirSync(codexSkillsDir)) {
-        const skillFile = path18.join(codexSkillsDir, name, "SKILL.md");
-        if (fs22.existsSync(skillFile)) {
+      for (const name of fs23.readdirSync(codexSkillsDir)) {
+        const skillFile = path19.join(codexSkillsDir, name, "SKILL.md");
+        if (fs23.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -6089,8 +6237,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path18.join(dir, ".cursorrules");
-  if (fs22.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path19.join(dir, ".cursorrules");
+  if (fs23.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -6099,10 +6247,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path18.join(dir, ".cursor", "rules");
-  if (fs22.existsSync(cursorRulesDir)) {
-    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path18.join(cursorRulesDir, file);
+  const cursorRulesDir = path19.join(dir, ".cursor", "rules");
+  if (fs23.existsSync(cursorRulesDir)) {
+    for (const file of fs23.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path19.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -6112,12 +6260,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path18.join(dir, ".cursor", "skills");
-  if (fs22.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
+  if (fs23.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs22.readdirSync(cursorSkillsDir)) {
-        const skillFile = path18.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs22.existsSync(skillFile)) {
+      for (const name of fs23.readdirSync(cursorSkillsDir)) {
+        const skillFile = path19.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs23.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -6130,10 +6278,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path18.join(dir, ".cursor", "mcp.json");
-  if (fs22.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
+  if (fs23.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs23.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -6151,7 +6299,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs22.readFileSync(filePath, "utf-8");
+  const text = fs23.readFileSync(filePath, "utf-8");
   return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -6166,27 +6314,27 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs23 from "fs";
-import path19 from "path";
+import fs24 from "fs";
+import path20 from "path";
 import os4 from "os";
 import crypto4 from "crypto";
 import { execSync as execSync11 } from "child_process";
-var CONFIG_DIR2 = path19.join(os4.homedir(), ".caliber");
-var CONFIG_FILE2 = path19.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = path20.join(os4.homedir(), ".caliber");
+var CONFIG_FILE2 = path20.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs23.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs23.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs24.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs24.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs23.existsSync(CONFIG_DIR2)) {
-    fs23.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs24.existsSync(CONFIG_DIR2)) {
+    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs23.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6671,7 +6819,109 @@ async function searchSkills(fingerprint, targetPlatforms, onStatus) {
   const available = results.filter((r) => contentMap.has(r.slug));
   return { results: available, contentMap };
 }
-async function recommendCommand() {
+async function querySkills(query) {
+  const terms = query.split(/[\s,]+/).filter(Boolean);
+  if (terms.length === 0) {
+    console.log(chalk6.yellow("Please provide search terms."));
+    throw new Error("__exit__");
+  }
+  const platforms = detectLocalPlatforms();
+  const installedSkills = getInstalledSkills(platforms);
+  const primaryPlatform = platforms.includes("claude") ? "claude" : platforms[0];
+  const searchSpinner = ora("Searching skill registries...").start();
+  const allCandidates = await searchAllProviders(terms, primaryPlatform);
+  if (!allCandidates.length) {
+    searchSpinner.succeed("No skills found matching your query.");
+    return;
+  }
+  const newCandidates = allCandidates.filter((c) => !installedSkills.has(c.slug.toLowerCase()));
+  if (!newCandidates.length) {
+    searchSpinner.succeed("All matching skills are already installed.");
+    return;
+  }
+  searchSpinner.succeed(`Found ${newCandidates.length} candidates`);
+  let results;
+  const config = loadConfig();
+  if (config) {
+    const scoreSpinner = ora("Scoring relevance...").start();
+    try {
+      const queryContext = `User is looking for skills related to: ${query}`;
+      results = await scoreWithLLM(newCandidates, queryContext, terms);
+      if (results.length === 0) {
+        scoreSpinner.succeed("No highly relevant skills found.");
+        return;
+      }
+      scoreSpinner.succeed(`${results.length} relevant`);
+    } catch {
+      results = newCandidates.slice(0, 5);
+    }
+  } else {
+    results = newCandidates.slice(0, 5);
+  }
+  const top = results.slice(0, 5);
+  const fetchSpinner = ora("Verifying availability...").start();
+  const contentMap = /* @__PURE__ */ new Map();
+  await Promise.all(top.map(async (rec) => {
+    const content = await fetchSkillContent(rec);
+    if (content) contentMap.set(rec.slug, content);
+  }));
+  const available = top.filter((r) => contentMap.has(r.slug));
+  fetchSpinner.succeed(`${available.length} available`);
+  if (!available.length) {
+    console.log(chalk6.dim("  No installable skills found.\n"));
+    return;
+  }
+  console.log("");
+  for (let i = 0; i < available.length; i++) {
+    const r = available[i];
+    const scoreStr = r.score > 0 ? ` (score: ${r.score})` : "";
+    console.log(`  ${i + 1}. ${r.slug}${scoreStr}`);
+    console.log(`     ${r.reason || r.name}`);
+  }
+  console.log("");
+  console.log(chalk6.dim(`  Install with: caliber skills --install ${available.map((r) => r.slug).join(",")}`));
+  console.log("");
+}
+async function installBySlug(slugStr) {
+  const slugs = slugStr.split(",").map((s) => s.trim()).filter(Boolean);
+  if (slugs.length === 0) {
+    console.log(chalk6.yellow("Please provide skill slugs to install."));
+    throw new Error("__exit__");
+  }
+  const platforms = detectLocalPlatforms();
+  const spinner = ora(`Fetching ${slugs.length} skill${slugs.length > 1 ? "s" : ""}...`).start();
+  const allResults = await searchAllProviders(slugs);
+  const matched = [];
+  for (const slug of slugs) {
+    const match = allResults.find((r) => r.slug.toLowerCase() === slug.toLowerCase());
+    if (match) matched.push(match);
+  }
+  if (!matched.length) {
+    spinner.fail("No matching skills found in the registry.");
+    return;
+  }
+  const contentMap = /* @__PURE__ */ new Map();
+  await Promise.all(matched.map(async (rec) => {
+    const content = await fetchSkillContent(rec);
+    if (content) contentMap.set(rec.slug, content);
+  }));
+  const installable = matched.filter((r) => contentMap.has(r.slug));
+  if (!installable.length) {
+    spinner.fail("Could not fetch skill content.");
+    return;
+  }
+  spinner.succeed(`Fetched ${installable.length} skill${installable.length > 1 ? "s" : ""}`);
+  await installSkills(installable, platforms, contentMap);
+}
+async function recommendCommand(options) {
+  if (options.install) {
+    await installBySlug(options.install);
+    return;
+  }
+  if (options.query) {
+    await querySkills(options.query);
+    return;
+  }
   const proceed = await select3({
     message: "Search public repos for relevant skills to add to this project?",
     choices: [
@@ -7145,11 +7395,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path38) => {
-    const cached = existsCache.get(path38);
+  const cachedExists = (path39) => {
+    const cached = existsCache.get(path39);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path38);
-    existsCache.set(path38, result);
+    const result = existsSync9(path39);
+    existsCache.set(path39, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -7288,8 +7538,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 
 // src/lib/debug-report.ts
-import fs24 from "fs";
-import path20 from "path";
+import fs25 from "fs";
+import path21 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -7358,11 +7608,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path20.dirname(outputPath);
-    if (!fs24.existsSync(dir)) {
-      fs24.mkdirSync(dir, { recursive: true });
+    const dir = path21.dirname(outputPath);
+    if (!fs25.existsSync(dir)) {
+      fs25.mkdirSync(dir, { recursive: true });
     }
-    fs24.writeFileSync(outputPath, lines.join("\n"));
+    fs25.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -7763,7 +8013,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs27 from "fs";
+import fs28 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -7904,10 +8154,10 @@ init_config();
 init_review();
 function detectAgents(dir) {
   const agents = [];
-  if (fs27.existsSync(`${dir}/.claude`)) agents.push("claude");
-  if (fs27.existsSync(`${dir}/.cursor`)) agents.push("cursor");
-  if (fs27.existsSync(`${dir}/.agents`) || fs27.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
-  if (fs27.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
+  if (fs28.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs28.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs28.existsSync(`${dir}/.agents`) || fs28.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs28.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
@@ -8029,18 +8279,18 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs28 from "fs";
+import fs29 from "fs";
 function formatWhatChanged(setup) {
   const lines = [];
   const claude = setup.claude;
   const codex = setup.codex;
   const cursor = setup.cursor;
   if (claude?.claudeMd) {
-    const action = fs28.existsSync("CLAUDE.md") ? "Updated" : "Created";
+    const action = fs29.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   if (codex?.agentsMd) {
-    const action = fs28.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs29.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -8077,7 +8327,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs28.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk12.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8087,7 +8337,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 = fs28.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8098,7 +8348,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs28.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8108,7 +8358,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs28.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8118,7 +8368,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs28.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs29.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8128,7 +8378,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 = fs28.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8139,7 +8389,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rulesArr) && rulesArr.length > 0) {
       for (const rule of rulesArr) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs28.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs29.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -8186,12 +8436,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs29 from "fs";
-import path22 from "path";
+import fs30 from "fs";
+import path23 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path22.join(dir, ".caliber");
+  const caliberDir = path23.join(dir, ".caliber");
   try {
-    const stat = fs29.statSync(caliberDir);
+    const stat = fs30.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -8244,8 +8494,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs29.existsSync(settingsPath)) {
-      settings = JSON.parse(fs29.readFileSync(settingsPath, "utf-8"));
+    if (fs30.existsSync(settingsPath)) {
+      settings = JSON.parse(fs30.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -8254,12 +8504,12 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs29.existsSync(".claude")) fs29.mkdirSync(".claude", { recursive: true });
-  fs29.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs30.existsSync(".claude")) fs30.mkdirSync(".claude", { recursive: true });
+  fs30.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path22.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path23.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -8272,8 +8522,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs29.mkdirSync(path22.join(process.cwd(), ".caliber"), { recursive: true });
-    fs29.writeFileSync(logPath, lines.join("\n"));
+    fs30.mkdirSync(path23.join(process.cwd(), ".caliber"), { recursive: true });
+    fs30.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8711,7 +8961,7 @@ async function initCommand(options) {
   const { default: ora9 } = await import("ora");
   const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs30.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs31.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -8860,9 +9110,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path23.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path24.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk14.dim(`  Debug report written to ${path23.relative(process.cwd(), reportPath)}
+    console.log(chalk14.dim(`  Debug report written to ${path24.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -8901,7 +9151,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs31 from "fs";
+import fs32 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -8928,7 +9178,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs31.existsSync(entry.path);
+    const exists = fs32.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -9083,21 +9333,21 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs32 from "fs";
+import fs33 from "fs";
 import os6 from "os";
-import path24 from "path";
+import path25 from "path";
 import { execFileSync } from "child_process";
 import chalk18 from "chalk";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs32.mkdtempSync(path24.join(os6.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs33.mkdtempSync(path25.join(os6.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
         const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        fs32.writeFileSync(path24.join(tmpDir, file), content);
+        fs33.writeFileSync(path25.join(tmpDir, file), content);
       } catch {
       }
     }
@@ -9105,10 +9355,10 @@ function scoreBaseRef(ref, target) {
       try {
         const files = execFileSync("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean);
         for (const file of files) {
-          const filePath = path24.join(tmpDir, file);
-          fs32.mkdirSync(path24.dirname(filePath), { recursive: true });
+          const filePath = path25.join(tmpDir, file);
+          fs33.mkdirSync(path25.dirname(filePath), { recursive: true });
           const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-          fs32.writeFileSync(filePath, content);
+          fs33.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -9118,7 +9368,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs32.rmSync(tmpDir, { recursive: true, force: true });
+    fs33.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -9178,8 +9428,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs36 from "fs";
-import path28 from "path";
+import fs37 from "fs";
+import path29 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
 
@@ -9257,48 +9507,48 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs33 from "fs";
-import path25 from "path";
+import fs34 from "fs";
+import path26 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs33.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
+    fs34.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs33.writeFileSync("README.md", docs.readmeMd);
+    fs34.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs33.writeFileSync(".cursorrules", docs.cursorrules);
+    fs34.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path25.join(".cursor", "rules");
-    if (!fs33.existsSync(rulesDir)) fs33.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path26.join(".cursor", "rules");
+    if (!fs34.existsSync(rulesDir)) fs34.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      fs33.writeFileSync(path25.join(rulesDir, rule.filename), rule.content);
+      fs34.writeFileSync(path26.join(rulesDir, rule.filename), rule.content);
       written.push(`.cursor/rules/${rule.filename}`);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path25.join(".claude", "skills");
-    if (!fs33.existsSync(skillsDir)) fs33.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path26.join(".claude", "skills");
+    if (!fs34.existsSync(skillsDir)) fs34.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      fs33.writeFileSync(path25.join(skillsDir, skill.filename), skill.content);
+      fs34.writeFileSync(path26.join(skillsDir, skill.filename), skill.content);
       written.push(`.claude/skills/${skill.filename}`);
     }
   }
   if (docs.copilotInstructions) {
-    fs33.mkdirSync(".github", { recursive: true });
-    fs33.writeFileSync(path25.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions)));
+    fs34.mkdirSync(".github", { recursive: true });
+    fs34.writeFileSync(path26.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions)));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
-    const instructionsDir = path25.join(".github", "instructions");
-    fs33.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path26.join(".github", "instructions");
+    fs34.mkdirSync(instructionsDir, { recursive: true });
     for (const file of docs.copilotInstructionFiles) {
-      fs33.writeFileSync(path25.join(instructionsDir, file.filename), file.content);
+      fs34.writeFileSync(path26.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -9378,8 +9628,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs34 from "fs";
-import path26 from "path";
+import fs35 from "fs";
+import path27 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -9497,20 +9747,20 @@ function deduplicateLearnedItems(existing, incoming) {
 }
 function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
   const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
-  fs34.writeFileSync(filePath, header + merged + "\n");
-  if (mode) fs34.chmodSync(filePath, mode);
+  fs35.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs35.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
 function writeLearnedSection(content) {
   return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path26.join(".claude", "skills", skill.name);
-  if (!fs34.existsSync(skillDir)) fs34.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path26.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs34.existsSync(skillPath)) {
-    const existing = fs34.readFileSync(skillPath, "utf-8");
-    fs34.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path27.join(".claude", "skills", skill.name);
+  if (!fs35.existsSync(skillDir)) fs35.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path27.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs35.existsSync(skillPath)) {
+    const existing = fs35.readFileSync(skillPath, "utf-8");
+    fs35.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -9519,47 +9769,56 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs34.writeFileSync(skillPath, frontmatter + skill.content);
+    fs35.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function writePersonalLearnedSection(content) {
-  if (!fs34.existsSync(AUTH_DIR)) fs34.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs35.existsSync(AUTH_DIR)) fs35.mkdirSync(AUTH_DIR, { recursive: true });
   return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
 }
+function addLearning(bullet, scope = "project") {
+  const formatted = bullet.startsWith("- ") ? bullet : `- ${bullet}`;
+  if (scope === "personal") {
+    const result2 = writePersonalLearnedSection(formatted);
+    return { file: PERSONAL_LEARNINGS_FILE, added: result2.newCount > 0 };
+  }
+  const result = writeLearnedSection(formatted);
+  return { file: LEARNINGS_FILE, added: result.newCount > 0 };
+}
 function readPersonalLearnings() {
-  if (!fs34.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
-  const content = fs34.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  if (!fs35.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs35.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
   const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
   return bullets || null;
 }
 function readLearnedSection() {
-  if (fs34.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs34.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs35.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs35.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs34.existsSync(claudeMdPath)) return null;
-  const content = fs34.readFileSync(claudeMdPath, "utf-8");
+  if (!fs35.existsSync(claudeMdPath)) return null;
+  const content = fs35.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 (fs34.existsSync(LEARNINGS_FILE)) return false;
+  if (fs35.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs34.existsSync(claudeMdPath)) return false;
-  const content = fs34.readFileSync(claudeMdPath, "utf-8");
+  if (!fs35.existsSync(claudeMdPath)) return false;
+  const content = fs35.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;
-  fs34.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs35.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs34.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs35.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -9571,11 +9830,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs36.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs37.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path28.join(parentDir, entry.name);
-      if (fs36.existsSync(path28.join(childPath, ".git"))) {
+      const childPath = path29.join(parentDir, entry.name);
+      if (fs37.existsSync(path29.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -9649,6 +9908,10 @@ async function refreshSingleRepo(repoDir, options) {
     log2(quiet, chalk19.dim(`
   ${response.changesSummary}`));
   }
+  const builtinWritten = ensureBuiltinSkills();
+  for (const file of builtinWritten) {
+    log2(quiet, `  ${chalk19.green("\u2713")} ${file} ${chalk19.dim("(built-in)")}`);
+  }
   if (currentSha) {
     writeState({ lastRefreshSha: currentSha, lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString() });
   }
@@ -9681,7 +9944,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path28.basename(repo);
+      const repoName = path29.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -9702,31 +9965,31 @@ async function refreshCommand(options) {
 
 // src/commands/hooks.ts
 import chalk20 from "chalk";
-import fs38 from "fs";
+import fs39 from "fs";
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs37 from "fs";
-import path29 from "path";
+import fs38 from "fs";
+import path30 from "path";
 import { execSync as execSync14 } from "child_process";
-var SETTINGS_PATH2 = path29.join(".claude", "settings.json");
+var SETTINGS_PATH2 = path30.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings2() {
-  if (!fs37.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs38.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs37.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs38.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path29.dirname(SETTINGS_PATH2);
-  if (!fs37.existsSync(dir)) fs37.mkdirSync(dir, { recursive: true });
-  fs37.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path30.dirname(SETTINGS_PATH2);
+  if (!fs38.existsSync(dir)) fs38.mkdirSync(dir, { recursive: true });
+  fs38.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -9789,19 +10052,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync14("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path29.join(gitDir, "hooks");
+    return path30.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path29.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path30.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs37.existsSync(hookPath)) return false;
-  const content = fs37.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs38.existsSync(hookPath)) return false;
+  const content = fs38.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -9810,35 +10073,35 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path29.dirname(hookPath);
-  if (!fs37.existsSync(hooksDir)) fs37.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path30.dirname(hookPath);
+  if (!fs38.existsSync(hooksDir)) fs38.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs37.existsSync(hookPath)) {
-    content = fs37.readFileSync(hookPath, "utf-8");
+  if (fs38.existsSync(hookPath)) {
+    content = fs38.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs37.writeFileSync(hookPath, content);
-  fs37.chmodSync(hookPath, 493);
+  fs38.writeFileSync(hookPath, content);
+  fs38.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs37.existsSync(hookPath)) {
+  if (!hookPath || !fs38.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs37.readFileSync(hookPath, "utf-8");
+  let content = fs38.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs37.unlinkSync(hookPath);
+    fs38.unlinkSync(hookPath);
   } else {
-    fs37.writeFileSync(hookPath, content);
+    fs38.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
@@ -9887,11 +10150,11 @@ async function hooksCommand(options) {
         console.log(chalk20.green("  \u2713") + ` ${hook.label} enabled`);
       }
     }
-    if (fs38.existsSync(".claude")) {
+    if (fs39.existsSync(".claude")) {
       const r = installLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Claude Code learning hooks enabled");
     }
-    if (fs38.existsSync(".cursor")) {
+    if (fs39.existsSync(".cursor")) {
       const r = installCursorLearningHooks();
       if (r.installed) console.log(chalk20.green("  \u2713") + " Cursor learning hooks enabled");
     }
@@ -10059,8 +10322,8 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs42 from "fs";
-import path33 from "path";
+import fs43 from "fs";
+import path34 from "path";
 import chalk23 from "chalk";
 
 // src/learner/stdin.ts
@@ -10092,8 +10355,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs39 from "fs";
-import path30 from "path";
+import fs40 from "fs";
+import path31 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -10102,15 +10365,15 @@ var DEFAULT_STATE = {
   lastAnalysisEventCount: 0
 };
 function ensureLearningDir() {
-  if (!fs39.existsSync(LEARNING_DIR)) {
-    fs39.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs40.existsSync(LEARNING_DIR)) {
+    fs40.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path30.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path31.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path30.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path31.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -10120,10 +10383,10 @@ function truncateResponse(response) {
 function trimSessionFileIfNeeded(filePath) {
   const state = readState2();
   if (state.eventCount + 1 > LEARNING_MAX_EVENTS) {
-    const lines = fs39.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs40.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     if (lines.length > LEARNING_MAX_EVENTS) {
       const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-      fs39.writeFileSync(filePath, kept.join("\n") + "\n");
+      fs40.writeFileSync(filePath, kept.join("\n") + "\n");
     }
   }
 }
@@ -10131,19 +10394,19 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs39.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs40.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   trimSessionFileIfNeeded(filePath);
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs39.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  fs40.appendFileSync(filePath, JSON.stringify(event) + "\n");
   trimSessionFileIfNeeded(filePath);
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs39.existsSync(filePath)) return [];
-  const lines = fs39.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs40.existsSync(filePath)) return [];
+  const lines = fs40.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -10155,26 +10418,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs39.existsSync(filePath)) return 0;
-  const content = fs39.readFileSync(filePath, "utf-8");
+  if (!fs40.existsSync(filePath)) return 0;
+  const content = fs40.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs39.existsSync(filePath)) fs39.unlinkSync(filePath);
+  if (fs40.existsSync(filePath)) fs40.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs39.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs40.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs39.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs40.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs39.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs40.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -10182,16 +10445,16 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path30.join(LEARNING_DIR, LOCK_FILE2);
+  return path31.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs39.existsSync(lockPath)) {
+  if (fs40.existsSync(lockPath)) {
     try {
-      const stat = fs39.statSync(lockPath);
+      const stat = fs40.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
-        const pid = parseInt(fs39.readFileSync(lockPath, "utf-8").trim(), 10);
+        const pid = parseInt(fs40.readFileSync(lockPath, "utf-8").trim(), 10);
         if (!isNaN(pid) && isProcessAlive(pid)) {
           return false;
         }
@@ -10199,12 +10462,12 @@ function acquireFinalizeLock() {
     } catch {
     }
     try {
-      fs39.unlinkSync(lockPath);
+      fs40.unlinkSync(lockPath);
     } catch {
     }
   }
   try {
-    fs39.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs40.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -10221,7 +10484,7 @@ function isProcessAlive(pid) {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs39.existsSync(lockPath)) fs39.unlinkSync(lockPath);
+    if (fs40.existsSync(lockPath)) fs40.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -10267,22 +10530,22 @@ function sanitizeSecrets(text) {
 
 // src/lib/notifications.ts
 init_constants();
-import fs40 from "fs";
-import path31 from "path";
+import fs41 from "fs";
+import path32 from "path";
 import chalk22 from "chalk";
-var NOTIFICATION_FILE = path31.join(LEARNING_DIR, "last-finalize-summary.json");
+var NOTIFICATION_FILE = path32.join(LEARNING_DIR, "last-finalize-summary.json");
 function writeFinalizeSummary(summary) {
   try {
     ensureLearningDir();
-    fs40.writeFileSync(NOTIFICATION_FILE, JSON.stringify(summary, null, 2));
+    fs41.writeFileSync(NOTIFICATION_FILE, JSON.stringify(summary, null, 2));
   } catch {
   }
 }
 function checkPendingNotifications() {
   try {
-    if (!fs40.existsSync(NOTIFICATION_FILE)) return;
-    const raw = fs40.readFileSync(NOTIFICATION_FILE, "utf-8");
-    fs40.unlinkSync(NOTIFICATION_FILE);
+    if (!fs41.existsSync(NOTIFICATION_FILE)) return;
+    const raw = fs41.readFileSync(NOTIFICATION_FILE, "utf-8");
+    fs41.unlinkSync(NOTIFICATION_FILE);
     const summary = JSON.parse(raw);
     if (!summary.newItemCount || summary.newItemCount === 0) return;
     const wasteLabel = summary.wasteTokens > 0 ? ` (~${summary.wasteTokens.toLocaleString()} wasted tokens captured)` : "";
@@ -10298,7 +10561,7 @@ function checkPendingNotifications() {
     console.log("");
   } catch {
     try {
-      fs40.unlinkSync(NOTIFICATION_FILE);
+      fs41.unlinkSync(NOTIFICATION_FILE);
     } catch {
     }
   }
@@ -10436,8 +10699,8 @@ init_config();
 
 // src/learner/roi.ts
 init_constants();
-import fs41 from "fs";
-import path32 from "path";
+import fs42 from "fs";
+import path33 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
   totalWasteSeconds: 0,
@@ -10451,19 +10714,19 @@ var DEFAULT_TOTALS = {
   lastSessionTimestamp: ""
 };
 function roiFilePath() {
-  return path32.join(LEARNING_DIR, LEARNING_ROI_FILE);
+  return path33.join(LEARNING_DIR, LEARNING_ROI_FILE);
 }
 function readROIStats() {
   const filePath = roiFilePath();
-  if (!fs41.existsSync(filePath)) {
+  if (!fs42.existsSync(filePath)) {
     return { learnings: [], sessions: [], totals: { ...DEFAULT_TOTALS } };
   }
   try {
-    return JSON.parse(fs41.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs42.readFileSync(filePath, "utf-8"));
   } catch {
     try {
       const corruptPath = filePath + ".corrupt";
-      fs41.renameSync(filePath, corruptPath);
+      fs42.renameSync(filePath, corruptPath);
       console.error(`caliber: roi-stats.json was corrupt \u2014 renamed to ${corruptPath}`);
     } catch {
     }
@@ -10472,7 +10735,7 @@ function readROIStats() {
 }
 function writeROIStats(stats) {
   ensureLearningDir();
-  fs41.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
+  fs42.writeFileSync(roiFilePath(), JSON.stringify(stats, null, 2));
 }
 function recalculateTotals(stats) {
   const totals = stats.totals;
@@ -10679,9 +10942,9 @@ var AUTO_SETTLE_MS = 200;
 var INCREMENTAL_INTERVAL = 50;
 function writeFinalizeError(message) {
   try {
-    const errorPath = path33.join(LEARNING_DIR, LEARNING_LAST_ERROR_FILE);
-    if (!fs42.existsSync(LEARNING_DIR)) fs42.mkdirSync(LEARNING_DIR, { recursive: true });
-    fs42.writeFileSync(errorPath, JSON.stringify({
+    const errorPath = path34.join(LEARNING_DIR, LEARNING_LAST_ERROR_FILE);
+    if (!fs43.existsSync(LEARNING_DIR)) fs43.mkdirSync(LEARNING_DIR, { recursive: true });
+    fs43.writeFileSync(errorPath, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       error: message,
       pid: process.pid
@@ -10691,9 +10954,9 @@ function writeFinalizeError(message) {
 }
 function readFinalizeError() {
   try {
-    const errorPath = path33.join(LEARNING_DIR, LEARNING_LAST_ERROR_FILE);
-    if (!fs42.existsSync(errorPath)) return null;
-    return JSON.parse(fs42.readFileSync(errorPath, "utf-8"));
+    const errorPath = path34.join(LEARNING_DIR, LEARNING_LAST_ERROR_FILE);
+    if (!fs43.existsSync(errorPath)) return null;
+    return JSON.parse(fs43.readFileSync(errorPath, "utf-8"));
   } catch {
     return null;
   }
@@ -10740,14 +11003,14 @@ async function learnObserveCommand(options) {
         const { resolveCaliber: resolveCaliber2 } = await Promise.resolve().then(() => (init_resolve_caliber(), resolve_caliber_exports));
         const bin = resolveCaliber2();
         const { spawn: spawn4 } = await import("child_process");
-        const logPath = path33.join(LEARNING_DIR, LEARNING_FINALIZE_LOG);
-        if (!fs42.existsSync(LEARNING_DIR)) fs42.mkdirSync(LEARNING_DIR, { recursive: true });
-        const logFd = fs42.openSync(logPath, "a");
+        const logPath = path34.join(LEARNING_DIR, LEARNING_FINALIZE_LOG);
+        if (!fs43.existsSync(LEARNING_DIR)) fs43.mkdirSync(LEARNING_DIR, { recursive: true });
+        const logFd = fs43.openSync(logPath, "a");
         spawn4(bin, ["learn", "finalize", "--auto", "--incremental"], {
           detached: true,
           stdio: ["ignore", logFd, logFd]
         }).unref();
-        fs42.closeSync(logFd);
+        fs43.closeSync(logFd);
       } catch {
       }
     }
@@ -10954,7 +11217,7 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs42.existsSync(".claude")) {
+  if (fs43.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Claude Code learning hooks installed");
@@ -10963,7 +11226,7 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs42.existsSync(".cursor")) {
+  if (fs43.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
       console.log(chalk23.green("\u2713") + " Cursor learning hooks installed");
@@ -10972,7 +11235,7 @@ async function learnInstallCommand() {
       console.log(chalk23.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs42.existsSync(".claude") && !fs42.existsSync(".cursor")) {
+  if (!fs43.existsSync(".claude") && !fs43.existsSync(".cursor")) {
     console.log(chalk23.yellow("No .claude/ or .cursor/ directory found."));
     console.log(chalk23.dim("  Run `caliber init` first, or create the directory manually."));
     return;
@@ -11030,8 +11293,8 @@ async function learnStatusCommand() {
   if (lastError) {
     console.log(`Last error: ${chalk23.red(lastError.error)}`);
     console.log(chalk23.dim(`  at ${lastError.timestamp}`));
-    const logPath = path33.join(LEARNING_DIR, LEARNING_FINALIZE_LOG);
-    if (fs42.existsSync(logPath)) {
+    const logPath = path34.join(LEARNING_DIR, LEARNING_FINALIZE_LOG);
+    if (fs43.existsSync(logPath)) {
       console.log(chalk23.dim(`  Full log: ${logPath}`));
     }
   }
@@ -11111,11 +11374,11 @@ async function learnDeleteCommand(indexStr) {
   }
   const item = items[targetIdx];
   const filePath = item.source === "personal" ? PERSONAL_LEARNINGS_FILE : "CALIBER_LEARNINGS.md";
-  if (!fs42.existsSync(filePath)) {
+  if (!fs43.existsSync(filePath)) {
     console.log(chalk23.red("Learnings file not found."));
     return;
   }
-  const content = fs42.readFileSync(filePath, "utf-8");
+  const content = fs43.readFileSync(filePath, "utf-8");
   const lines = content.split("\n");
   const bulletsOfSource = items.filter((i) => i.source === item.source);
   const posInFile = bulletsOfSource.indexOf(item);
@@ -11136,9 +11399,9 @@ async function learnDeleteCommand(indexStr) {
   }
   const bulletToRemove = lines[lineToRemove];
   const newLines = lines.filter((_, i) => i !== lineToRemove);
-  fs42.writeFileSync(filePath, newLines.join("\n"));
+  fs43.writeFileSync(filePath, newLines.join("\n"));
   if (item.source === "personal") {
-    fs42.chmodSync(filePath, 384);
+    fs43.chmodSync(filePath, 384);
   }
   const roiStats = readROIStats();
   const cleanText = bulletToRemove.replace(/^- /, "").replace(/^\*\*\[[^\]]+\]\*\*\s*/, "").trim();
@@ -11149,6 +11412,19 @@ async function learnDeleteCommand(indexStr) {
   }
   console.log(chalk23.green("\u2713") + ` Removed: ${bulletToRemove.replace(/^- /, "").slice(0, 80)}`);
 }
+async function learnAddCommand(content, options) {
+  if (!content.trim()) {
+    console.log(chalk23.yellow("Please provide learning content."));
+    throw new Error("__exit__");
+  }
+  const scope = options.personal ? "personal" : "project";
+  const result = addLearning(content.trim(), scope);
+  if (result.added) {
+    console.log(chalk23.green("\u2713") + ` Learning saved to ${result.file}`);
+  } else {
+    console.log(chalk23.dim("  Similar learning already exists \u2014 skipped."));
+  }
+}
 
 // src/commands/insights.ts
 import chalk24 from "chalk";
@@ -11285,8 +11561,8 @@ async function insightsCommand(options) {
 }
 
 // src/commands/sources.ts
-import fs43 from "fs";
-import path34 from "path";
+import fs44 from "fs";
+import path35 from "path";
 import chalk25 from "chalk";
 async function sourcesListCommand() {
   const dir = process.cwd();
@@ -11302,9 +11578,9 @@ async function sourcesListCommand() {
   if (configSources.length > 0) {
     for (const source of configSources) {
       const sourcePath = source.path || source.url || "";
-      const exists = source.path ? fs43.existsSync(path34.resolve(dir, source.path)) : false;
+      const exists = source.path ? fs44.existsSync(path35.resolve(dir, source.path)) : false;
       const status = exists ? chalk25.green("reachable") : chalk25.red("not found");
-      const hasSummary = source.path && fs43.existsSync(path34.join(path34.resolve(dir, source.path), ".caliber", "summary.json"));
+      const hasSummary = source.path && fs44.existsSync(path35.join(path35.resolve(dir, source.path), ".caliber", "summary.json"));
       console.log(`  ${chalk25.bold(source.role || source.type)}  ${chalk25.dim(sourcePath)}`);
       console.log(`    Type: ${source.type}  Status: ${status}${hasSummary ? "  " + chalk25.cyan("has summary.json") : ""}`);
       if (source.description) console.log(`    ${chalk25.dim(source.description)}`);
@@ -11314,7 +11590,7 @@ async function sourcesListCommand() {
   if (workspaces.length > 0) {
     console.log(chalk25.dim("  Auto-detected workspaces:"));
     for (const ws of workspaces) {
-      const exists = fs43.existsSync(path34.resolve(dir, ws));
+      const exists = fs44.existsSync(path35.resolve(dir, ws));
       console.log(`    ${exists ? chalk25.green("\u25CF") : chalk25.red("\u25CF")} ${ws}`);
     }
     console.log("");
@@ -11322,8 +11598,8 @@ async function sourcesListCommand() {
 }
 async function sourcesAddCommand(sourcePath) {
   const dir = process.cwd();
-  const absPath = path34.resolve(dir, sourcePath);
-  if (!fs43.existsSync(absPath)) {
+  const absPath = path35.resolve(dir, sourcePath);
+  if (!fs44.existsSync(absPath)) {
     console.log(chalk25.red(`
   Path not found: ${sourcePath}
 `));
@@ -11338,7 +11614,7 @@ async function sourcesAddCommand(sourcePath) {
   }
   const existing = loadSourcesConfig(dir);
   const alreadyConfigured = existing.some(
-    (s) => s.path && path34.resolve(dir, s.path) === absPath
+    (s) => s.path && path35.resolve(dir, s.path) === absPath
   );
   if (alreadyConfigured) {
     console.log(chalk25.yellow(`
@@ -11386,8 +11662,8 @@ async function sourcesRemoveCommand(name) {
 }
 
 // src/commands/publish.ts
-import fs44 from "fs";
-import path35 from "path";
+import fs45 from "fs";
+import path36 from "path";
 import chalk26 from "chalk";
 import ora7 from "ora";
 init_config();
@@ -11401,10 +11677,10 @@ async function publishCommand() {
   const spinner = ora7("Generating project summary...").start();
   try {
     const fingerprint = await collectFingerprint(dir);
-    const claudeMd = readFileOrNull(path35.join(dir, "CLAUDE.md"));
+    const claudeMd = readFileOrNull(path36.join(dir, "CLAUDE.md"));
     const topLevelDirs = fingerprint.fileTree.filter((f) => f.endsWith("/") && !f.includes("/")).map((f) => f.replace(/\/$/, ""));
     const summary = {
-      name: fingerprint.packageName || path35.basename(dir),
+      name: fingerprint.packageName || path36.basename(dir),
       version: "1.0.0",
       description: fingerprint.description || "",
       languages: fingerprint.languages,
@@ -11416,7 +11692,7 @@ async function publishCommand() {
       summary.conventions = claudeMd.slice(0, 2e3);
     }
     try {
-      const pkgContent = readFileOrNull(path35.join(dir, "package.json"));
+      const pkgContent = readFileOrNull(path36.join(dir, "package.json"));
       if (pkgContent) {
         const pkg3 = JSON.parse(pkgContent);
         if (pkg3.scripts) {
@@ -11429,14 +11705,14 @@ async function publishCommand() {
       }
     } catch {
     }
-    const outputDir = path35.join(dir, ".caliber");
-    if (!fs44.existsSync(outputDir)) {
-      fs44.mkdirSync(outputDir, { recursive: true });
+    const outputDir = path36.join(dir, ".caliber");
+    if (!fs45.existsSync(outputDir)) {
+      fs45.mkdirSync(outputDir, { recursive: true });
     }
-    const outputPath = path35.join(outputDir, "summary.json");
-    fs44.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+    const outputPath = path36.join(outputDir, "summary.json");
+    fs45.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
     spinner.succeed("Project summary published");
-    console.log(`  ${chalk26.green("\u2713")} ${path35.relative(dir, outputPath)}`);
+    console.log(`  ${chalk26.green("\u2713")} ${path36.relative(dir, outputPath)}`);
     console.log(chalk26.dim("\n  Other projects can now reference this repo as a source."));
     console.log(chalk26.dim("  When they run `caliber init`, they'll read this summary automatically.\n"));
   } catch (err) {
@@ -11448,9 +11724,9 @@ async function publishCommand() {
 }
 
 // src/cli.ts
-var __dirname = path36.dirname(fileURLToPath(import.meta.url));
+var __dirname = path37.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs45.readFileSync(path36.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs46.readFileSync(path37.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -11516,7 +11792,7 @@ program.command("undo").description("Revert all config changes made by Caliber")
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(tracked("status", statusCommand));
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));
 program.command("config").description("Configure LLM provider, API key, and model").action(tracked("config", configCommand));
-program.command("skills").description("Discover and install community skills for your project").action(tracked("skills", recommendCommand));
+program.command("skills").description("Discover and install community skills for your project").option("--query <terms>", 'Search for skills by topic (e.g. "react frontend")').option("--install <slugs>", "Install specific skills by slug (comma-separated)").action(tracked("skills", recommendCommand));
 program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex, github-copilot", parseAgentOption).option("--compare <ref>", "Compare score against a git ref (branch, tag, or SHA)").action(tracked("score", scoreCommand));
 program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(tracked("refresh", refreshCommand));
 program.command("hooks").description("Manage auto-refresh hooks (toggle interactively)").option("--install", "Enable all hooks non-interactively").option("--remove", "Disable all hooks non-interactively").action(tracked("hooks", hooksCommand));
@@ -11534,18 +11810,19 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(tracked("learn:status", learnStatusCommand));
 learn.command("list").description("List all learnings with their source and activation data").option("--verbose", "Show explanations and activation counts").action(tracked("learn:list", (opts) => learnListCommand(opts)));
 learn.command("delete <index>").description("Delete a learning by its index number (from `caliber learn list`)").action(tracked("learn:delete", (index) => learnDeleteCommand(index)));
+learn.command("add <content>").description("Add a learning directly (used by agent skills)").option("--personal", "Save as a personal learning instead of project-level").action(tracked("learn:add", learnAddCommand));
 
 // src/utils/version-check.ts
-import fs46 from "fs";
-import path37 from "path";
+import fs47 from "fs";
+import path38 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync15 } from "child_process";
 import chalk27 from "chalk";
 import ora8 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path37.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path38.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs46.readFileSync(path37.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs47.readFileSync(path38.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
@@ -11570,8 +11847,8 @@ function isNewer(registry, current) {
 function getInstalledVersion() {
   try {
     const globalRoot = execSync15("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path37.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs46.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path38.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs47.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }