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

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");
+  const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
+  content = content.replace(regex, "\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) {
@@ -6449,31 +6458,10 @@ function formatMs(ms) {
 
 // src/utils/parallel-tasks.ts
 import chalk9 from "chalk";
-
-// node_modules/ansi-regex/index.js
-function ansiRegex({ onlyFirst = false } = {}) {
-  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-  const pattern = `${osc}|${csi}`;
-  return new RegExp(pattern, onlyFirst ? void 0 : "g");
-}
-
-// node_modules/strip-ansi/index.js
-var regex = ansiRegex();
-function stripAnsi(string) {
-  if (typeof string !== "string") {
-    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
-  }
-  if (!string.includes("\x1B") && !string.includes("\x9B")) {
-    return string;
-  }
-  return string.replace(regex, "");
-}
-
-// src/utils/parallel-tasks.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var SPINNER_INTERVAL_MS = 80;
+var NAME_COL_WIDTH = 26;
+var PREFIX = "    ";
 var ParallelTaskDisplay = class {
   tasks = [];
   lineCount = 0;
@@ -6518,48 +6506,48 @@ var ParallelTaskDisplay = class {
     if (secs < 60) return `${secs}s`;
     return `${Math.floor(secs / 60)}m ${secs % 60}s`;
   }
-  truncate(text, maxVisible) {
-    const plain = stripAnsi(text);
-    if (plain.length <= maxVisible) return text;
-    let visible = 0;
-    let i = 0;
-    while (i < text.length && visible < maxVisible - 3) {
-      if (text[i] === "\x1B") {
-        const end = text.indexOf("m", i);
-        if (end !== -1) {
-          i = end + 1;
-          continue;
-        }
-      }
-      visible++;
-      i++;
-    }
-    return text.slice(0, i) + "...";
+  smartTruncate(text, max) {
+    if (text.length <= max) return text;
+    const cut = text.slice(0, max - 1);
+    const lastSpace = cut.lastIndexOf(" ");
+    const boundary = lastSpace > max * 0.5 ? lastSpace : max - 1;
+    return text.slice(0, boundary) + "\u2026";
   }
   renderLine(task) {
-    const maxWidth = process.stdout.columns || 80;
+    const cols = process.stdout.columns || 80;
     const elapsed = task.startTime ? this.formatTime((task.endTime ?? Date.now()) - task.startTime) : "";
-    let line;
+    const timeStr = elapsed ? ` ${chalk9.dim(elapsed)}` : "";
+    const timePlain = elapsed ? ` ${elapsed}` : "";
+    let icon;
+    let nameStyle;
+    let msgStyle;
     switch (task.status) {
       case "pending":
-        line = `  ${chalk9.dim("\u25CB")} ${chalk9.dim(task.name)}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}`;
+        icon = chalk9.dim("\u25CB");
+        nameStyle = chalk9.dim;
+        msgStyle = chalk9.dim;
         break;
-      case "running": {
-        const spinner = chalk9.cyan(SPINNER_FRAMES[this.spinnerFrame]);
-        const time = elapsed ? chalk9.dim(` (${elapsed})`) : "";
-        line = `  ${spinner} ${task.name}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}${time}`;
+      case "running":
+        icon = chalk9.cyan(SPINNER_FRAMES[this.spinnerFrame]);
+        nameStyle = chalk9.white;
+        msgStyle = chalk9.dim;
         break;
-      }
-      case "done": {
-        const time = elapsed ? chalk9.dim(` (${elapsed})`) : "";
-        line = `  ${chalk9.green("\u2713")} ${task.name}${task.message ? chalk9.dim(` \u2014 ${task.message}`) : ""}${time}`;
+      case "done":
+        icon = chalk9.green("\u2713");
+        nameStyle = chalk9.white;
+        msgStyle = chalk9.dim;
         break;
-      }
       case "failed":
-        line = `  ${chalk9.red("\u2717")} ${task.name}${task.message ? chalk9.red(` \u2014 ${task.message}`) : ""}`;
+        icon = chalk9.red("\u2717");
+        nameStyle = chalk9.white;
+        msgStyle = chalk9.red;
         break;
     }
-    return this.truncate(line, maxWidth - 1);
+    const paddedName = task.name.padEnd(NAME_COL_WIDTH);
+    const usedByFixed = PREFIX.length + 2 + NAME_COL_WIDTH + timePlain.length;
+    const msgMax = Math.max(cols - usedByFixed - 2, 10);
+    const msg = task.message ? this.smartTruncate(task.message, msgMax) : "";
+    return `${PREFIX}${icon} ${nameStyle(paddedName)}${msg ? msgStyle(msg) : ""}${timeStr}`;
   }
   draw(initial) {
     const { stdout } = process;
@@ -6568,9 +6556,6 @@ var ParallelTaskDisplay = class {
     }
     stdout.write("\x1B[0J");
     const lines = this.tasks.map((t) => this.renderLine(t));
-    const totalElapsed = this.formatTime(Date.now() - this.startTime);
-    lines.push(chalk9.dim(`
-  Total: ${totalElapsed}`));
     const output = lines.join("\n");
     stdout.write(output + "\n");
     this.lineCount = output.split("\n").length;
@@ -6710,57 +6695,59 @@ async function initCommand(options) {
   let genStopReason;
   let skillSearchResult = { results: [], contentMap: /* @__PURE__ */ new Map() };
   let fingerprint;
-  const fpSpinner = ora2("Scanning project...").start();
-  try {
-    fingerprint = await collectFingerprint(process.cwd());
-    fpSpinner.succeed(`Stack detected \u2014 ${fingerprint.languages.join(", ") || "no languages"}${fingerprint.frameworks.length > 0 ? `, ${fingerprint.frameworks.join(", ")}` : ""}`);
-  } catch (err) {
-    fpSpinner.fail("Failed to scan project");
-    throw new Error("__exit__");
-  }
-  trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
-  log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
-  if (report) {
-    report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
-    report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
-    report.addJson("Fingerprint: Detected Stack", { languages: fingerprint.languages, frameworks: fingerprint.frameworks, tools: fingerprint.tools });
-    report.addJson("Fingerprint: Existing Configs", fingerprint.existingConfigs);
-    if (fingerprint.codeAnalysis) report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
-  }
-  const isEmpty = fingerprint.fileTree.length < 3;
-  if (isEmpty) {
-    fingerprint.description = await promptInput("What will you build in this project?");
-  }
-  const failingForDismissal = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
-  if (failingForDismissal.length > 0) {
-    const newDismissals = await evaluateDismissals(failingForDismissal, fingerprint);
-    if (newDismissals.length > 0) {
-      const existing = readDismissedChecks();
-      const existingIds = new Set(existing.map((d) => d.id));
-      const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
-      writeDismissedChecks(merged);
-      baselineScore = computeLocalScore(process.cwd(), targetAgent);
-    }
-  }
-  let failingChecks;
-  let passingChecks;
-  let currentScore;
-  if (hasExistingConfig && baselineScore.score >= 95 && !options.force) {
-    const currentLlmFixable = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
-    failingChecks = currentLlmFixable.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
-    passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
-    currentScore = baselineScore.score;
-  }
-  if (report) {
-    const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
-    report.addCodeBlock("Generation: Full LLM Prompt", fullPrompt);
-  }
   const display = new ParallelTaskDisplay();
+  const TASK_STACK = display.add("Detecting project stack");
   const TASK_CONFIG = display.add("Generating configs");
   const TASK_SKILLS_GEN = display.add("Generating skills");
   const TASK_SKILLS_SEARCH = wantsSkills ? display.add("Searching community skills") : -1;
   display.start();
   try {
+    display.update(TASK_STACK, "running");
+    fingerprint = await collectFingerprint(process.cwd());
+    const stackSummary = [
+      ...fingerprint.languages,
+      ...fingerprint.frameworks
+    ].join(", ") || "no languages";
+    display.update(TASK_STACK, "done", stackSummary);
+    trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
+    log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
+    if (report) {
+      report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
+      report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
+      report.addJson("Fingerprint: Detected Stack", { languages: fingerprint.languages, frameworks: fingerprint.frameworks, tools: fingerprint.tools });
+      report.addJson("Fingerprint: Existing Configs", fingerprint.existingConfigs);
+      if (fingerprint.codeAnalysis) report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
+    }
+    const isEmpty = fingerprint.fileTree.length < 3;
+    if (isEmpty) {
+      display.stop();
+      fingerprint.description = await promptInput("What will you build in this project?");
+      display.start();
+    }
+    const failingForDismissal = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
+    if (failingForDismissal.length > 0) {
+      const newDismissals = await evaluateDismissals(failingForDismissal, fingerprint);
+      if (newDismissals.length > 0) {
+        const existing = readDismissedChecks();
+        const existingIds = new Set(existing.map((d) => d.id));
+        const merged = [...existing, ...newDismissals.filter((d) => !existingIds.has(d.id))];
+        writeDismissedChecks(merged);
+        baselineScore = computeLocalScore(process.cwd(), targetAgent);
+      }
+    }
+    let failingChecks;
+    let passingChecks;
+    let currentScore;
+    if (hasExistingConfig && baselineScore.score >= 95 && !options.force) {
+      const currentLlmFixable = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
+      failingChecks = currentLlmFixable.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
+      passingChecks = baselineScore.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
+      currentScore = baselineScore.score;
+    }
+    if (report) {
+      const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
+      report.addCodeBlock("Generation: Full LLM Prompt", fullPrompt);
+    }
     display.update(TASK_CONFIG, "running");
     const generatePromise = (async () => {
       const result = await generateSetup(
@@ -6813,7 +6800,7 @@ async function initCommand(options) {
         ]);
         skillSearchResult = await searchWithTimeout;
         const count = skillSearchResult.results.length;
-        display.update(TASK_SKILLS_SEARCH, "done", count > 0 ? `${count} skills found` : "No matches");
+        display.update(TASK_SKILLS_SEARCH, "done", count > 0 ? `${count} found` : "No matches");
       } catch (err) {
         const reason = err instanceof Error && err.message === "timeout" ? "Timed out" : "Search failed";
         display.update(TASK_SKILLS_SEARCH, "failed", reason);
@@ -6836,7 +6823,7 @@ async function initCommand(options) {
   const secs = Math.floor(elapsedMs % 6e4 / 1e3);
   const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
   console.log(chalk10.dim(`
-  Completed in ${timeStr}
+  Done in ${timeStr}
 `));
   if (!generatedSetup) {
     console.log(chalk10.red("  Failed to generate setup."));
@@ -6869,8 +6856,9 @@ async function initCommand(options) {
   } else {
     console.log("");
   }
+  const hasSkillResults = skillSearchResult.results.length > 0;
   let action;
-  if (totalChanges === 0 && skillSearchResult.results.length === 0) {
+  if (totalChanges === 0 && !hasSkillResults) {
     console.log(chalk10.dim("  No changes needed \u2014 your configs are already up to date.\n"));
     cleanupStaging();
     action = "accept";
@@ -6880,13 +6868,20 @@ async function initCommand(options) {
     trackInitReviewAction(action, "auto-approved");
   } else {
     if (totalChanges > 0) {
-      const wantsReview = await promptWantsReview();
-      if (wantsReview) {
+      const reviewChoice = await select5({
+        message: "Review your tailored setup?",
+        choices: [
+          { name: "Yes, show me the diffs", value: "review" },
+          ...hasSkillResults ? [{ name: `No, continue to community skills (${skillSearchResult.results.length} found)`, value: "skip" }] : [],
+          { name: "No, continue", value: "skip" }
+        ]
+      });
+      if (reviewChoice === "review") {
         const reviewMethod = await promptReviewMethod();
         await openReview(reviewMethod, staged.stagedFiles);
       }
     }
-    action = await promptReviewAction();
+    action = await promptReviewAction(hasSkillResults);
     trackInitReviewAction(action, totalChanges > 0 ? "reviewed" : "skipped");
   }
   let refinementRound = 0;
@@ -6905,7 +6900,7 @@ async function initCommand(options) {
 `));
     printSetupSummary(generatedSetup);
     await openReview("terminal", restaged.stagedFiles);
-    action = await promptReviewAction();
+    action = await promptReviewAction(hasSkillResults);
     trackInitReviewAction(action, "terminal");
   }
   cleanupStaging();
@@ -6921,7 +6916,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 +7057,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 +7106,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}`;
 }
@@ -7205,13 +7200,14 @@ async function promptHookType(targetAgent) {
     choices
   });
 }
-async function promptReviewAction() {
+async function promptReviewAction(hasSkillResults = false) {
+  const acceptLabel = hasSkillResults ? "Accept and continue to community skills" : "Accept and apply";
   return select5({
     message: "What would you like to do?",
     choices: [
-      { name: "Accept and apply", value: "accept" },
+      { name: acceptLabel, value: "accept" },
       { name: "Refine via chat", value: "refine" },
-      { name: "Decline", value: "decline" }
+      { name: "Decline all changes", value: "decline" }
     ]
   });
 }
@@ -7221,13 +7217,13 @@ function printSetupSummary(setup) {
   const fileDescriptions = setup.fileDescriptions;
   const deletions = setup.deletions;
   console.log("");
-  console.log(chalk10.bold("  Proposed changes:\n"));
+  console.log(chalk10.bold("  Your tailored setup:\n"));
   const getDescription = (filePath) => {
     return fileDescriptions?.[filePath];
   };
   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 +7233,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 +7244,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 +7254,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 +7264,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 +7274,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 +7285,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 +7349,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 +7359,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 +7384,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 +7397,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 +7439,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 +7466,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 +7647,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 +7726,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 +7833,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 +7918,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 +7936,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 +7978,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 +8085,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 +8309,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 +8341,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 +8350,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 +8369,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 +8403,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 +8430,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 +8445,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 +8454,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 +8686,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 +8695,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 +8704,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 +8767,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 +8843,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 +8886,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 +8898,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 +8921,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 +8932,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 +8955,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.
 `
         )
       );