@rely-ai/caliber 1.20.0-dev.1773685636 → 1.20.0-dev.1773686430

package/dist/bin.js

@@ -177,13 +177,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs28 from "fs";
-import path22 from "path";
-import os4 from "os";
+import fs29 from "fs";
+import path23 from "path";
+import os5 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs28.existsSync(LOCK_FILE)) return false;
-    const raw = fs28.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs29.existsSync(LOCK_FILE)) return false;
+    const raw = fs29.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 {
-    fs28.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs29.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs28.existsSync(LOCK_FILE)) fs28.unlinkSync(LOCK_FILE);
+    if (fs29.existsSync(LOCK_FILE)) fs29.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -212,24 +212,24 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path22.join(os4.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path23.join(os5.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs32 from "fs";
-import path25 from "path";
+import fs33 from "fs";
+import path26 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path19 from "path";
+import path20 from "path";
 import chalk10 from "chalk";
 import ora2 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs24 from "fs";
+import fs25 from "fs";
 
 // src/fingerprint/index.ts
 import fs6 from "fs";
@@ -2262,15 +2262,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path27) {
+function readFileOrNull(path28) {
   try {
-    return readFileSync(path27, "utf-8");
+    return readFileSync(path28, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path27) {
-  const content = readFileOrNull(path27);
+function readJsonOrNull(path28) {
+  const content = readFileOrNull(path28);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3236,13 +3236,23 @@ function cleanupStaging() {
 
 // src/utils/review.ts
 import chalk2 from "chalk";
-import fs14 from "fs";
+import fs15 from "fs";
 import select2 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 
 // src/utils/editor.ts
 import { execSync as execSync5, spawn as spawn3 } from "child_process";
+import fs14 from "fs";
+import path12 from "path";
+import os3 from "os";
 var IS_WINDOWS3 = process.platform === "win32";
+var DIFF_TEMP_DIR = path12.join(os3.tmpdir(), "caliber-diff");
+function getEmptyFilePath(proposedPath) {
+  fs14.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path12.join(DIFF_TEMP_DIR, path12.basename(proposedPath));
+  fs14.writeFileSync(tempPath, "");
+  return tempPath;
+}
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
@@ -3263,13 +3273,12 @@ function openDiffsInEditor(editor, files) {
   const cmd = editor === "cursor" ? "cursor" : "code";
   for (const file of files) {
     try {
+      const leftPath = file.originalPath ?? getEmptyFilePath(file.proposedPath);
       if (IS_WINDOWS3) {
         const quote = (s) => `"${s}"`;
-        const parts = file.originalPath ? [cmd, "--diff", quote(file.originalPath), quote(file.proposedPath)] : [cmd, quote(file.proposedPath)];
-        spawn3(parts.join(" "), { shell: true, stdio: "ignore", detached: true }).unref();
+        spawn3([cmd, "--diff", quote(leftPath), quote(file.proposedPath)].join(" "), { shell: true, stdio: "ignore", detached: true }).unref();
       } else {
-        const args = file.originalPath ? ["--diff", file.originalPath, file.proposedPath] : [file.proposedPath];
-        spawn3(cmd, args, { stdio: "ignore", detached: true }).unref();
+        spawn3(cmd, ["--diff", leftPath, file.proposedPath], { stdio: "ignore", detached: true }).unref();
       }
     } catch {
       continue;
@@ -3312,8 +3321,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs14.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs14.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs15.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs15.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -3476,7 +3485,7 @@ async function interactiveDiffExplorer(files) {
 }
 
 // src/commands/setup-files.ts
-import fs15 from "fs";
+import fs16 from "fs";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -3525,7 +3534,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs15.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs16.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.");
@@ -3542,12 +3551,12 @@ ${agentRefs.join(" ")}
 }
 
 // src/lib/hooks.ts
-import fs17 from "fs";
-import path12 from "path";
+import fs18 from "fs";
+import path13 from "path";
 import { execSync as execSync7 } from "child_process";
 
 // src/lib/resolve-caliber.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import { execSync as execSync6 } from "child_process";
 var _resolved = null;
 function resolveCaliber() {
@@ -3570,7 +3579,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs16.existsSync(binPath)) {
+  if (binPath && fs17.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -3586,24 +3595,24 @@ function isCaliberCommand(command, subcommandTail) {
 }
 
 // src/lib/hooks.ts
-var SETTINGS_PATH = path12.join(".claude", "settings.json");
+var SETTINGS_PATH = path13.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 readSettings() {
-  if (!fs17.existsSync(SETTINGS_PATH)) return {};
+  if (!fs18.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs18.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path12.dirname(SETTINGS_PATH);
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path13.dirname(SETTINGS_PATH);
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3666,19 +3675,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync7("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path12.join(gitDir, "hooks");
+    return path13.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path12.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path13.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) return false;
-  const content = fs17.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs18.existsSync(hookPath)) return false;
+  const content = fs18.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3687,43 +3696,43 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path12.dirname(hookPath);
-  if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path13.dirname(hookPath);
+  if (!fs18.existsSync(hooksDir)) fs18.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs17.existsSync(hookPath)) {
-    content = fs17.readFileSync(hookPath, "utf-8");
+  if (fs18.existsSync(hookPath)) {
+    content = fs18.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs17.writeFileSync(hookPath, content);
-  fs17.chmodSync(hookPath, 493);
+  fs18.writeFileSync(hookPath, content);
+  fs18.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs17.existsSync(hookPath)) {
+  if (!hookPath || !fs18.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs17.readFileSync(hookPath, "utf-8");
+  let content = fs18.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex2 = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex2, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs17.unlinkSync(hookPath);
+    fs18.unlinkSync(hookPath);
   } else {
-    fs17.writeFileSync(hookPath, content);
+    fs18.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs18 from "fs";
-import path13 from "path";
-var SETTINGS_PATH2 = path13.join(".claude", "settings.json");
+import fs19 from "fs";
+import path14 from "path";
+var SETTINGS_PATH2 = path14.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" },
@@ -3740,17 +3749,17 @@ function getHookConfigs() {
   }));
 }
 function readSettings2() {
-  if (!fs18.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs19.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs18.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs19.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path13.dirname(SETTINGS_PATH2);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path14.dirname(SETTINGS_PATH2);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
@@ -3784,7 +3793,7 @@ function installLearningHooks() {
   writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path13.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path14.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -3792,17 +3801,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize" }
 ];
 function readCursorHooks() {
-  if (!fs18.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs19.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs18.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs19.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));
+  const dir = path14.dirname(CURSOR_HOOKS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -3872,10 +3881,10 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs19 from "fs";
-import path14 from "path";
+import fs20 from "fs";
+import path15 from "path";
 import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path15.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -3886,8 +3895,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs19.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs19.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs20.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs20.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -3895,10 +3904,10 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs20.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -5255,22 +5264,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs20 from "fs";
-import path15 from "path";
-var DISMISSED_FILE = path15.join(CALIBER_DIR, "dismissed-checks.json");
+import fs21 from "fs";
+import path16 from "path";
+var DISMISSED_FILE = path16.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs20.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs20.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs21.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs21.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs20.existsSync(CALIBER_DIR)) {
-    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs20.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs21.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -5466,13 +5475,13 @@ import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4,
 import { join as join9, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs21 from "fs";
-import path16 from "path";
+import fs22 from "fs";
+import path17 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs21.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs22.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5481,10 +5490,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs21.existsSync(skillsDir)) {
-    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs22.existsSync(skillsDir)) {
+    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -5494,10 +5503,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs21.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs22.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5512,8 +5521,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path16.join(dir, "AGENTS.md");
-  if (fs21.existsSync(agentsMdPath)) {
+  const agentsMdPath = path17.join(dir, "AGENTS.md");
+  if (fs22.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -5522,12 +5531,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path16.join(dir, ".agents", "skills");
-  if (fs21.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path17.join(dir, ".agents", "skills");
+  if (fs22.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(codexSkillsDir)) {
-        const skillFile = path16.join(codexSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(codexSkillsDir)) {
+        const skillFile = path17.join(codexSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -5540,8 +5549,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs21.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs22.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5550,10 +5559,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs21.existsSync(cursorRulesDir)) {
-    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs22.existsSync(cursorRulesDir)) {
+    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -5563,12 +5572,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs21.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs22.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs21.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs21.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -5581,10 +5590,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs21.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs22.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs21.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5602,7 +5611,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs21.readFileSync(filePath, "utf-8");
+  const text = fs22.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5617,27 +5626,27 @@ import { PostHog } from "posthog-node";
 import chalk7 from "chalk";
 
 // src/telemetry/config.ts
-import fs22 from "fs";
-import path17 from "path";
-import os3 from "os";
+import fs23 from "fs";
+import path18 from "path";
+import os4 from "os";
 import crypto3 from "crypto";
 import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path17.join(os3.homedir(), ".caliber");
-var CONFIG_FILE2 = path17.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = path18.join(os4.homedir(), ".caliber");
+var CONFIG_FILE2 = path18.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs22.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs22.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs23.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs23.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs22.existsSync(CONFIG_DIR2)) {
-    fs22.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs23.existsSync(CONFIG_DIR2)) {
+    fs23.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs22.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs23.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6361,8 +6370,8 @@ function printSkills(recs) {
 }
 
 // src/lib/debug-report.ts
-import fs23 from "fs";
-import path18 from "path";
+import fs24 from "fs";
+import path19 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -6431,11 +6440,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path18.dirname(outputPath);
-    if (!fs23.existsSync(dir)) {
-      fs23.mkdirSync(dir, { recursive: true });
+    const dir = path19.dirname(outputPath);
+    if (!fs24.existsSync(dir)) {
+      fs24.mkdirSync(dir, { recursive: true });
     }
-    fs23.writeFileSync(outputPath, lines.join("\n"));
+    fs24.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -6921,7 +6930,7 @@ async function initCommand(options) {
   }
   const writeSpinner = ora2("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs24.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs25.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -7062,9 +7071,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path19.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path20.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk10.dim(`  Debug report written to ${path19.relative(process.cwd(), reportPath)}
+    console.log(chalk10.dim(`  Debug report written to ${path20.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -7111,7 +7120,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path27, desc]) => `  ${path27}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path28, desc]) => `  ${path28}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -7227,7 +7236,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs24.existsSync("CLAUDE.md") ? chalk10.yellow("~") : chalk10.green("+");
+      const icon = fs25.existsSync("CLAUDE.md") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk10.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk10.dim(`    ${desc}`));
@@ -7237,7 +7246,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 = fs24.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
         console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
@@ -7248,7 +7257,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs24.existsSync("AGENTS.md") ? chalk10.yellow("~") : chalk10.green("+");
+      const icon = fs25.existsSync("AGENTS.md") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk10.bold("AGENTS.md")}`);
       if (desc) console.log(chalk10.dim(`    ${desc}`));
@@ -7258,7 +7267,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 = fs24.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
         console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
@@ -7268,7 +7277,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs24.existsSync(".cursorrules") ? chalk10.yellow("~") : chalk10.green("+");
+      const icon = fs25.existsSync(".cursorrules") ? chalk10.yellow("~") : chalk10.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk10.bold(".cursorrules")}`);
       if (desc) console.log(chalk10.dim(`    ${desc}`));
@@ -7278,7 +7287,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 = fs24.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
+        const icon = fs25.existsSync(skillPath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk10.bold(skillPath)}`);
         console.log(chalk10.dim(`    ${desc || skill.description || skill.name}`));
@@ -7289,7 +7298,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs24.existsSync(rulePath) ? chalk10.yellow("~") : chalk10.green("+");
+        const icon = fs25.existsSync(rulePath) ? chalk10.yellow("~") : chalk10.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk10.bold(rulePath)}`);
         if (desc) {
@@ -7353,8 +7362,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs24.existsSync(settingsPath)) {
-      settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
+    if (fs25.existsSync(settingsPath)) {
+      settings = JSON.parse(fs25.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -7363,8 +7372,8 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs24.existsSync(".claude")) fs24.mkdirSync(".claude", { recursive: true });
-  fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs25.existsSync(".claude")) fs25.mkdirSync(".claude", { recursive: true });
+  fs25.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function displayTokenUsage() {
   const summary = getUsageSummary();
@@ -7388,7 +7397,7 @@ function displayTokenUsage() {
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path19.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path20.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -7401,8 +7410,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs24.mkdirSync(path19.join(process.cwd(), ".caliber"), { recursive: true });
-    fs24.writeFileSync(logPath, lines.join("\n"));
+    fs25.mkdirSync(path20.join(process.cwd(), ".caliber"), { recursive: true });
+    fs25.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk10.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -7443,7 +7452,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk12 from "chalk";
-import fs25 from "fs";
+import fs26 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -7470,7 +7479,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk12.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs25.existsSync(entry.path);
+    const exists = fs26.existsSync(entry.path);
     const icon = exists ? chalk12.green("\u2713") : chalk12.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -7651,8 +7660,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs29 from "fs";
-import path23 from "path";
+import fs30 from "fs";
+import path24 from "path";
 import chalk15 from "chalk";
 import ora5 from "ora";
 
@@ -7730,37 +7739,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs26 from "fs";
-import path20 from "path";
+import fs27 from "fs";
+import path21 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs26.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs27.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs26.writeFileSync("README.md", docs.readmeMd);
+    fs27.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs26.writeFileSync(".cursorrules", docs.cursorrules);
+    fs27.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path20.join(".cursor", "rules");
-    if (!fs26.existsSync(rulesDir)) fs26.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path21.join(".cursor", "rules");
+    if (!fs27.existsSync(rulesDir)) fs27.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path20.join(rulesDir, rule.filename);
-      fs26.writeFileSync(filePath, rule.content);
+      const filePath = path21.join(rulesDir, rule.filename);
+      fs27.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path20.join(".claude", "skills");
-    if (!fs26.existsSync(skillsDir)) fs26.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path21.join(".claude", "skills");
+    if (!fs27.existsSync(skillsDir)) fs27.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path20.join(skillsDir, skill.filename);
-      fs26.writeFileSync(filePath, skill.content);
+      const filePath = path21.join(skillsDir, skill.filename);
+      fs27.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -7837,8 +7846,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs27 from "fs";
-import path21 from "path";
+import fs28 from "fs";
+import path22 from "path";
 var LEARNINGS_FILE = "CALIBER_LEARNINGS.md";
 var LEARNINGS_HEADER = `# Caliber Learnings
 
@@ -7922,16 +7931,16 @@ function deduplicateLearnedItems(existing, incoming) {
 function writeLearnedSection(content) {
   const existingSection = readLearnedSection();
   const { merged, newCount, newItems } = deduplicateLearnedItems(existingSection, content);
-  fs27.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + merged + "\n");
+  fs28.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);
+  const skillDir = path22.join(".claude", "skills", skill.name);
+  if (!fs28.existsSync(skillDir)) fs28.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path22.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs28.existsSync(skillPath)) {
+    const existing = fs28.readFileSync(skillPath, "utf-8");
+    fs28.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -7940,37 +7949,37 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs27.writeFileSync(skillPath, frontmatter + skill.content);
+    fs28.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
-  if (fs27.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs27.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs28.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs28.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");
+  if (!fs28.existsSync(claudeMdPath)) return null;
+  const content = fs28.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;
+  if (fs28.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs27.existsSync(claudeMdPath)) return false;
-  const content = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (!fs28.existsSync(claudeMdPath)) return false;
+  const content = fs28.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");
+  fs28.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");
+  fs28.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -7982,11 +7991,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs29.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs30.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path23.join(parentDir, entry.name);
-      if (fs29.existsSync(path23.join(childPath, ".git"))) {
+      const childPath = path24.join(parentDir, entry.name);
+      if (fs30.existsSync(path24.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -8089,7 +8098,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path23.basename(repo);
+      const repoName = path24.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -8313,7 +8322,7 @@ async function configCommand() {
 }
 
 // src/commands/learn.ts
-import fs31 from "fs";
+import fs32 from "fs";
 import chalk18 from "chalk";
 
 // src/learner/stdin.ts
@@ -8345,8 +8354,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs30 from "fs";
-import path24 from "path";
+import fs31 from "fs";
+import path25 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -8354,15 +8363,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs30.existsSync(LEARNING_DIR)) {
-    fs30.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs31.existsSync(LEARNING_DIR)) {
+    fs31.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path24.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path25.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path24.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path25.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -8373,29 +8382,29 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs30.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs31.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs30.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function appendPromptEvent(event) {
   ensureLearningDir();
   const filePath = sessionFilePath();
-  fs30.appendFileSync(filePath, JSON.stringify(event) + "\n");
+  fs31.appendFileSync(filePath, JSON.stringify(event) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs30.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs31.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs30.existsSync(filePath)) return [];
-  const lines = fs30.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs31.existsSync(filePath)) return [];
+  const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   const events = [];
   for (const line of lines) {
     try {
@@ -8407,26 +8416,26 @@ function readAllEvents() {
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs30.existsSync(filePath)) return 0;
-  const content = fs30.readFileSync(filePath, "utf-8");
+  if (!fs31.existsSync(filePath)) return 0;
+  const content = fs31.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs30.existsSync(filePath)) fs30.unlinkSync(filePath);
+  if (fs31.existsSync(filePath)) fs31.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs30.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs31.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs31.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs30.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs31.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
@@ -8434,14 +8443,14 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path24.join(LEARNING_DIR, LOCK_FILE2);
+  return path25.join(LEARNING_DIR, LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
   const lockPath = lockFilePath();
-  if (fs30.existsSync(lockPath)) {
+  if (fs31.existsSync(lockPath)) {
     try {
-      const stat = fs30.statSync(lockPath);
+      const stat = fs31.statSync(lockPath);
       if (Date.now() - stat.mtimeMs < LOCK_STALE_MS) {
         return false;
       }
@@ -8449,7 +8458,7 @@ function acquireFinalizeLock() {
     }
   }
   try {
-    fs30.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs31.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
     return true;
   } catch {
     return false;
@@ -8458,7 +8467,7 @@ function acquireFinalizeLock() {
 function releaseFinalizeLock() {
   const lockPath = lockFilePath();
   try {
-    if (fs30.existsSync(lockPath)) fs30.unlinkSync(lockPath);
+    if (fs31.existsSync(lockPath)) fs31.unlinkSync(lockPath);
   } catch {
   }
 }
@@ -8690,7 +8699,7 @@ async function learnFinalizeCommand(options) {
 }
 async function learnInstallCommand() {
   let anyInstalled = false;
-  if (fs31.existsSync(".claude")) {
+  if (fs32.existsSync(".claude")) {
     const r = installLearningHooks();
     if (r.installed) {
       console.log(chalk18.green("\u2713") + " Claude Code learning hooks installed");
@@ -8699,7 +8708,7 @@ async function learnInstallCommand() {
       console.log(chalk18.dim("  Claude Code hooks already installed"));
     }
   }
-  if (fs31.existsSync(".cursor")) {
+  if (fs32.existsSync(".cursor")) {
     const r = installCursorLearningHooks();
     if (r.installed) {
       console.log(chalk18.green("\u2713") + " Cursor learning hooks installed");
@@ -8708,7 +8717,7 @@ async function learnInstallCommand() {
       console.log(chalk18.dim("  Cursor hooks already installed"));
     }
   }
-  if (!fs31.existsSync(".claude") && !fs31.existsSync(".cursor")) {
+  if (!fs32.existsSync(".claude") && !fs32.existsSync(".cursor")) {
     console.log(chalk18.yellow("No .claude/ or .cursor/ directory found."));
     console.log(chalk18.dim("  Run `caliber init` first, or create the directory manually."));
     return;
@@ -8771,9 +8780,9 @@ Learned items in CALIBER_LEARNINGS.md: ${chalk18.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path25.dirname(fileURLToPath(import.meta.url));
+var __dirname = path26.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs32.readFileSync(path25.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs33.readFileSync(path26.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -8847,22 +8856,42 @@ 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 fs33 from "fs";
-import path26 from "path";
+import fs34 from "fs";
+import path27 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync14 } from "child_process";
 import chalk19 from "chalk";
 import ora6 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path26.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path27.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs33.readFileSync(path26.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs34.readFileSync(path27.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
+function getChannel(version) {
+  const match = version.match(/-(dev|next)\./);
+  return match ? match[1] : "latest";
+}
+function isNewer(registry, current) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-");
+    const parts = core.split(".").map(Number);
+    return { major: parts[0], minor: parts[1], patch: parts[2], pre };
+  };
+  const r = parse(registry);
+  const c = parse(current);
+  if (r.major !== c.major) return r.major > c.major;
+  if (r.minor !== c.minor) return r.minor > c.minor;
+  if (r.patch !== c.patch) return r.patch > c.patch;
+  if (!r.pre && c.pre) return true;
+  if (r.pre && !c.pre) return false;
+  if (r.pre && c.pre) return r.pre > c.pre;
+  return false;
+}
 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(fs33.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path27.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs34.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -8870,9 +8899,11 @@ function getInstalledVersion() {
 async function checkForUpdates() {
   if (process.env.CALIBER_SKIP_UPDATE_CHECK) return;
   try {
+    const current = pkg2.version;
+    const channel = getChannel(current);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 2e3);
-    const res = await fetch("https://registry.npmjs.org/@rely-ai/caliber/latest", {
+    const res = await fetch(`https://registry.npmjs.org/@rely-ai/caliber/${channel}`, {
       signal: controller.signal
     });
     clearTimeout(timeout);
@@ -8880,15 +8911,15 @@ async function checkForUpdates() {
     const data = await res.json();
     const latest = data.version;
     if (!latest) return;
-    const current = pkg2.version;
-    if (current === latest) return;
+    if (!isNewer(latest, current)) return;
     const isInteractive = process.stdin.isTTY === true;
     if (!isInteractive) {
+      const installTag = channel === "latest" ? "" : `@${channel}`;
       console.log(
         chalk19.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk19.bold("npm install -g @rely-ai/caliber")} to upgrade.
+Run ${chalk19.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
 `
         )
       );
@@ -8903,9 +8934,10 @@ Update available: ${current} -> ${latest}`)
       console.log();
       return;
     }
+    const tag = channel === "latest" ? latest : channel;
     const spinner = ora6("Updating caliber...").start();
     try {
-      execSync14(`npm install -g @rely-ai/caliber@${latest}`, {
+      execSync14(`npm install -g @rely-ai/caliber@${tag}`, {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -8913,7 +8945,7 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk19.yellow(`Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually.
+        console.log(chalk19.yellow(`Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
 `));
         return;
       }
@@ -8936,7 +8968,7 @@ Restarting: caliber ${args.join(" ")}
       }
       console.log(
         chalk19.yellow(
-          `Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${latest}`)} manually to upgrade.
+          `Run ${chalk19.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
 `
         )
       );

package/package.json

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