@rely-ai/caliber 1.30.0 → 1.30.2

package/dist/bin.js

@@ -158,30 +158,16 @@ var init_config = __esm({
   }
 });
 
-// src/llm/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isSeatBased: () => isSeatBased
-});
-function isSeatBased(provider) {
-  return SEAT_BASED_PROVIDERS.has(provider);
-}
-var SEAT_BASED_PROVIDERS;
-var init_types = __esm({
-  "src/llm/types.ts"() {
-    "use strict";
-    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
-  }
-});
-
 // src/lib/resolve-caliber.ts
 var resolve_caliber_exports = {};
 __export(resolve_caliber_exports, {
   isCaliberCommand: () => isCaliberCommand,
+  isNpxResolution: () => isNpxResolution,
+  resetResolvedCaliber: () => resetResolvedCaliber,
   resolveCaliber: () => resolveCaliber
 });
-import fs20 from "fs";
-import { execSync as execSync7 } from "child_process";
+import fs6 from "fs";
+import { execSync as execSync4 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
   const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
@@ -191,7 +177,7 @@ function resolveCaliber() {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    execSync7(whichCmd, {
+    execSync4(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -200,13 +186,19 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && fs20.existsSync(binPath)) {
+  if (binPath && /caliber/.test(binPath) && fs6.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
   _resolved = "caliber";
   return _resolved;
 }
+function isNpxResolution() {
+  return resolveCaliber().startsWith("npx ");
+}
+function resetResolvedCaliber() {
+  _resolved = null;
+}
 function isCaliberCommand(command, subcommandTail) {
   if (command === `caliber ${subcommandTail}`) return true;
   if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
@@ -222,6 +214,22 @@ var init_resolve_caliber = __esm({
   }
 });
 
+// src/llm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isSeatBased: () => isSeatBased
+});
+function isSeatBased(provider) {
+  return SEAT_BASED_PROVIDERS.has(provider);
+}
+var SEAT_BASED_PROVIDERS;
+var init_types = __esm({
+  "src/llm/types.ts"() {
+    "use strict";
+    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
+  }
+});
+
 // src/utils/editor.ts
 import { execSync as execSync13, spawn as spawn3 } from "child_process";
 import fs26 from "fs";
@@ -415,7 +423,7 @@ async function interactiveDiffExplorer(files) {
     stdout.write(output + "\n");
     lineCount = output.split("\n").length;
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     console.log("");
     draw(true);
     stdin.setRawMode(true);
@@ -450,7 +458,7 @@ async function interactiveDiffExplorer(files) {
           case "":
             cleanup();
             console.log("");
-            resolve2();
+            resolve3();
             break;
         }
       } else {
@@ -473,7 +481,7 @@ async function interactiveDiffExplorer(files) {
           case "":
             cleanup();
             console.log("");
-            resolve2();
+            resolve3();
             break;
         }
       }
@@ -547,7 +555,7 @@ import chalk14 from "chalk";
 import fs32 from "fs";
 
 // src/fingerprint/index.ts
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 
 // src/fingerprint/git.ts
@@ -1590,19 +1598,20 @@ var OpenAICompatProvider = class {
 };
 
 // src/llm/cursor-acp.ts
-import { spawn, execSync as execSync4 } from "child_process";
+import { spawn, execSync as execSync5 } from "child_process";
 import os3 from "os";
 
 // src/llm/seat-based-errors.ts
+init_resolve_caliber();
 var ERROR_PATTERNS = [
   { pattern: /not logged in|not authenticated|login required|unauthorized/i, message: "Authentication required. Run the login command for your provider to re-authenticate." },
   { pattern: /rate limit|too many requests|429/i, message: "Rate limit exceeded. Retrying..." },
-  { pattern: /model.*not found|invalid model|model.*unavailable/i, message: "The requested model is not available. Run `caliber config` to select a different model." }
+  { pattern: /model.*not found|invalid model|model.*unavailable/i, message: () => `The requested model is not available. Run \`${resolveCaliber()} config\` to select a different model.` }
 ];
 function parseSeatBasedError(stderr, exitCode) {
   if (!stderr && exitCode === 0) return null;
   for (const { pattern, message } of ERROR_PATTERNS) {
-    if (pattern.test(stderr)) return message;
+    if (pattern.test(stderr)) return typeof message === "function" ? message() : message;
   }
   return null;
 }
@@ -1722,7 +1731,7 @@ var CursorAcpProvider = class {
     return stderr ? `${base}: ${stderr.slice(0, 200)}` : base;
   }
   runPrint(model, prompt) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const { child, stderrChunks } = this.spawnAgent(model, false);
       let settled = false;
       const chunks = [];
@@ -1750,7 +1759,7 @@ var CursorAcpProvider = class {
         if (code !== 0 && !output) {
           reject(new Error(this.buildErrorMessage(code, stderrChunks)));
         } else {
-          resolve2(output);
+          resolve3(output);
         }
       });
       child.stdin.write(prompt);
@@ -1758,7 +1767,7 @@ var CursorAcpProvider = class {
     });
   }
   runPrintStream(model, prompt, callbacks) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const { child, stderrChunks } = this.spawnAgent(model, true);
       let buffer = "";
       let endCalled = false;
@@ -1840,7 +1849,7 @@ var CursorAcpProvider = class {
             reject(err);
           }
         } else {
-          resolve2();
+          resolve3();
         }
       });
       child.stdin.write(prompt);
@@ -1866,7 +1875,7 @@ var CursorAcpProvider = class {
 function isCursorAgentAvailable() {
   try {
     const cmd = IS_WINDOWS ? `where ${AGENT_BIN}` : `which ${AGENT_BIN}`;
-    execSync4(cmd, { stdio: "ignore" });
+    execSync5(cmd, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -1874,7 +1883,7 @@ function isCursorAgentAvailable() {
 }
 function isCursorLoggedIn() {
   try {
-    const result = execSync4(`${AGENT_BIN} status`, { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
+    const result = execSync5(`${AGENT_BIN} status`, { stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 });
     return !result.toString().includes("not logged in");
   } catch {
     return false;
@@ -1882,7 +1891,7 @@ function isCursorLoggedIn() {
 }
 
 // src/llm/claude-cli.ts
-import { spawn as spawn2, execSync as execSync5 } from "child_process";
+import { spawn as spawn2, execSync as execSync6 } from "child_process";
 var CLAUDE_CLI_BIN = "claude";
 var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
 var IS_WINDOWS2 = process.platform === "win32";
@@ -1977,7 +1986,7 @@ var ClaudeCliProvider = class {
     return combined;
   }
   runClaudePrint(combinedPrompt, model) {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const args = ["-p"];
       if (model) args.push("--model", model);
       const child = spawnClaude(args);
@@ -1994,7 +2003,7 @@ var ClaudeCliProvider = class {
         clearTimeout(timer);
         const stdout = Buffer.concat(chunks).toString("utf-8").trim();
         if (code === 0) {
-          resolve2(stdout);
+          resolve3(stdout);
         } else {
           const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
           const friendly = parseSeatBasedError(stderr, code);
@@ -2017,7 +2026,7 @@ var ClaudeCliProvider = class {
 function isClaudeCliAvailable() {
   try {
     const cmd = process.platform === "win32" ? `where ${CLAUDE_CLI_BIN}` : `which ${CLAUDE_CLI_BIN}`;
-    execSync5(cmd, { stdio: "ignore" });
+    execSync6(cmd, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -2075,6 +2084,7 @@ function estimateTokens(text) {
 
 // src/llm/model-recovery.ts
 init_config();
+init_resolve_caliber();
 import chalk from "chalk";
 import select from "@inquirer/select";
 var KNOWN_MODELS = {
@@ -2128,7 +2138,7 @@ function filterRelevantModels(models, provider) {
 async function handleModelNotAvailable(failedModel, provider, config) {
   if (!process.stdin.isTTY) {
     console.error(
-      chalk.red(`Model "${failedModel}" is not available. Run \`caliber config\` to select a different model.`)
+      chalk.red(`Model "${failedModel}" is not available. Run \`${resolveCaliber()} config\` to select a different model.`)
     );
     return null;
   }
@@ -2147,7 +2157,7 @@ async function handleModelNotAvailable(failedModel, provider, config) {
   }
   models = models.filter((m) => m !== failedModel);
   if (models.length === 0) {
-    console.log(chalk.red("  No alternative models found. Run `caliber config` to configure manually."));
+    console.log(chalk.red(`  No alternative models found. Run \`${resolveCaliber()} config\` to configure manually.`));
     return null;
   }
   console.log("");
@@ -2174,6 +2184,7 @@ async function handleModelNotAvailable(failedModel, provider, config) {
 }
 
 // src/llm/index.ts
+init_resolve_caliber();
 init_types();
 init_config();
 var cachedProvider = null;
@@ -2211,7 +2222,7 @@ function getProvider() {
   const config = loadConfig();
   if (!config) {
     throw new Error(
-      "No LLM provider configured. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or VERTEX_PROJECT_ID; or run `caliber config` and choose Cursor or Claude Code; or set CALIBER_USE_CURSOR_SEAT=1 / CALIBER_USE_CLAUDE_CLI=1."
+      `No LLM provider configured. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or VERTEX_PROJECT_ID; or run \`${resolveCaliber()} config\` and choose Cursor or Claude Code; or set CALIBER_USE_CURSOR_SEAT=1 / CALIBER_USE_CLAUDE_CLI=1.`
     );
   }
   cachedConfig = config;
@@ -2774,10 +2785,10 @@ async function detectProjectStack(fileTree, suffixCounts) {
 init_config();
 
 // src/fingerprint/cache.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import path6 from "path";
 import crypto from "crypto";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 var CACHE_VERSION = 1;
 var CACHE_DIR = ".caliber/cache";
 var CACHE_FILE = "fingerprint.json";
@@ -2786,7 +2797,7 @@ function getCachePath(dir) {
 }
 function getGitHead(dir) {
   try {
-    return execSync6("git rev-parse HEAD", {
+    return execSync7("git rev-parse HEAD", {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -2798,7 +2809,7 @@ function getGitHead(dir) {
 }
 function getDirtySignature(dir) {
   try {
-    const output = execSync6("git diff --name-only HEAD", {
+    const output = execSync7("git diff --name-only HEAD", {
       cwd: dir,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -2819,8 +2830,8 @@ function computeTreeSignature(fileTree, dir) {
 function loadFingerprintCache(dir, fileTree) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs6.existsSync(cachePath)) return null;
-    const raw = fs6.readFileSync(cachePath, "utf-8");
+    if (!fs7.existsSync(cachePath)) return null;
+    const raw = fs7.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (cache.version !== CACHE_VERSION) return null;
     const currentHead = getGitHead(dir);
@@ -2842,8 +2853,8 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
   const cachePath = getCachePath(dir);
   try {
     const cacheDir = path6.dirname(cachePath);
-    if (!fs6.existsSync(cacheDir)) {
-      fs6.mkdirSync(cacheDir, { recursive: true });
+    if (!fs7.existsSync(cacheDir)) {
+      fs7.mkdirSync(cacheDir, { recursive: true });
     }
     const cache = {
       version: CACHE_VERSION,
@@ -2855,15 +2866,15 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       tools,
       workspaces
     };
-    fs6.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 function getDetectedWorkspaces(dir) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs6.existsSync(cachePath)) return [];
-    const raw = fs6.readFileSync(cachePath, "utf-8");
+    if (!fs7.existsSync(cachePath)) return [];
+    const raw = fs7.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     return cache.workspaces ?? [];
   } catch {
@@ -2916,8 +2927,8 @@ async function collectFingerprint(dir) {
 function readPackageName(dir) {
   try {
     const pkgPath = path7.join(dir, "package.json");
-    if (!fs7.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+    if (!fs8.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -2947,22 +2958,22 @@ async function enrichWithLLM(fingerprint) {
 }
 
 // src/scanner/index.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path8 from "path";
 import crypto2 from "crypto";
 import os4 from "os";
 function detectPlatforms() {
   const home = os4.homedir();
   return {
-    claude: fs8.existsSync(path8.join(home, ".claude")),
-    cursor: fs8.existsSync(getCursorConfigDir()),
-    codex: fs8.existsSync(path8.join(home, ".codex"))
+    claude: fs9.existsSync(path8.join(home, ".claude")),
+    cursor: fs9.existsSync(getCursorConfigDir()),
+    codex: fs9.existsSync(path8.join(home, ".codex"))
   };
 }
 function scanLocalState(dir) {
   const items = [];
   const claudeMdPath = path8.join(dir, "CLAUDE.md");
-  if (fs8.existsSync(claudeMdPath)) {
+  if (fs9.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -2972,8 +2983,8 @@ function scanLocalState(dir) {
     });
   }
   const skillsDir = path8.join(dir, ".claude", "skills");
-  if (fs8.existsSync(skillsDir)) {
-    for (const file of fs8.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+  if (fs9.existsSync(skillsDir)) {
+    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
       const filePath = path8.join(skillsDir, file);
       items.push({
         type: "skill",
@@ -2985,9 +2996,9 @@ function scanLocalState(dir) {
     }
   }
   const mcpJsonPath = path8.join(dir, ".mcp.json");
-  if (fs8.existsSync(mcpJsonPath)) {
+  if (fs9.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs8.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3004,7 +3015,7 @@ function scanLocalState(dir) {
     }
   }
   const agentsMdPath = path8.join(dir, "AGENTS.md");
-  if (fs8.existsSync(agentsMdPath)) {
+  if (fs9.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -3014,11 +3025,11 @@ function scanLocalState(dir) {
     });
   }
   const codexSkillsDir = path8.join(dir, ".agents", "skills");
-  if (fs8.existsSync(codexSkillsDir)) {
+  if (fs9.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs8.readdirSync(codexSkillsDir)) {
+      for (const name of fs9.readdirSync(codexSkillsDir)) {
         const skillFile = path8.join(codexSkillsDir, name, "SKILL.md");
-        if (fs8.existsSync(skillFile)) {
+        if (fs9.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -3033,7 +3044,7 @@ function scanLocalState(dir) {
     }
   }
   const cursorrulesPath = path8.join(dir, ".cursorrules");
-  if (fs8.existsSync(cursorrulesPath)) {
+  if (fs9.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -3043,8 +3054,8 @@ function scanLocalState(dir) {
     });
   }
   const cursorRulesDir = path8.join(dir, ".cursor", "rules");
-  if (fs8.existsSync(cursorRulesDir)) {
-    for (const file of fs8.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+  if (fs9.existsSync(cursorRulesDir)) {
+    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
       const filePath = path8.join(cursorRulesDir, file);
       items.push({
         type: "rule",
@@ -3056,11 +3067,11 @@ function scanLocalState(dir) {
     }
   }
   const cursorSkillsDir = path8.join(dir, ".cursor", "skills");
-  if (fs8.existsSync(cursorSkillsDir)) {
+  if (fs9.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs8.readdirSync(cursorSkillsDir)) {
+      for (const name of fs9.readdirSync(cursorSkillsDir)) {
         const skillFile = path8.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs8.existsSync(skillFile)) {
+        if (fs9.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -3075,9 +3086,9 @@ function scanLocalState(dir) {
     }
   }
   const cursorMcpPath = path8.join(dir, ".cursor", "mcp.json");
-  if (fs8.existsSync(cursorMcpPath)) {
+  if (fs9.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs8.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3096,7 +3107,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs8.readFileSync(filePath, "utf-8");
+  const text = fs9.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -3118,7 +3129,7 @@ function getCursorConfigDir() {
 }
 
 // src/fingerprint/sources.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import path9 from "path";
 
 // src/scoring/utils.ts
@@ -3457,15 +3468,15 @@ function loadSourcesConfig(dir) {
 }
 function writeSourcesConfig(dir, sources2) {
   const configDir = path9.join(dir, ".caliber");
-  if (!fs9.existsSync(configDir)) {
-    fs9.mkdirSync(configDir, { recursive: true });
+  if (!fs10.existsSync(configDir)) {
+    fs10.mkdirSync(configDir, { recursive: true });
   }
   const configPath = path9.join(configDir, "sources.json");
-  fs9.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  fs10.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs9.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs10.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
@@ -3509,7 +3520,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs9.statSync(absPath);
+      stat = fs10.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -3564,7 +3575,7 @@ function collectRepoSummary(resolved, projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs9.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs10.readdirSync(absPath, { withFileTypes: true });
     topLevelDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, 20);
     keyFiles = entries.filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => e.name).slice(0, 15);
   } catch {
@@ -3891,7 +3902,7 @@ async function streamGeneration(config) {
       config.baseMaxTokens + attempt * config.tokenIncrement,
       config.maxTokensCap
     );
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       let preJsonBuffer = "";
       let jsonContent = "";
       let inJson = false;
@@ -3946,7 +3957,7 @@ async function streamGeneration(config) {
             }
             if (!setup && stopReason === "max_tokens" && attempt < MAX_RETRIES2) {
               if (config.callbacks) config.callbacks.onStatus("Output was truncated, retrying with higher token limit...");
-              setTimeout(() => attemptGeneration().then(resolve2), 1e3);
+              setTimeout(() => attemptGeneration().then(resolve3), 1e3);
               return;
             }
             let explanation;
@@ -3956,24 +3967,24 @@ async function streamGeneration(config) {
             }
             if (setup) {
               if (config.callbacks) config.callbacks.onComplete(setup, explanation);
-              resolve2({ setup, explanation, stopReason: stopReason ?? void 0 });
+              resolve3({ setup, explanation, stopReason: stopReason ?? void 0 });
             } else {
-              resolve2({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
+              resolve3({ setup: null, explanation, raw: preJsonBuffer, stopReason: stopReason ?? void 0 });
             }
           },
           onError: (error) => {
             if (isTransientError2(error) && attempt < MAX_RETRIES2) {
               if (config.callbacks) config.callbacks.onStatus("Connection interrupted, retrying...");
-              setTimeout(() => attemptGeneration().then(resolve2), 2e3);
+              setTimeout(() => attemptGeneration().then(resolve3), 2e3);
               return;
             }
             if (config.callbacks) config.callbacks.onError(error.message);
-            resolve2({ setup: null, raw: error.message, stopReason: "error" });
+            resolve3({ setup: null, raw: error.message, stopReason: "error" });
           }
         }
       ).catch((error) => {
         if (config.callbacks) config.callbacks.onError(error.message);
-        resolve2({ setup: null, raw: error.message, stopReason: "error" });
+        resolve3({ setup: null, raw: error.message, stopReason: "error" });
       });
     });
   };
@@ -4231,44 +4242,51 @@ ${f.content}
 }
 
 // src/writers/index.ts
-import fs17 from "fs";
+import fs18 from "fs";
 
 // src/writers/claude/index.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import path10 from "path";
 
 // src/writers/pre-commit-block.ts
+init_resolve_caliber();
 var BLOCK_START = "<!-- caliber:managed:pre-commit -->";
 var BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
 var MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .github/copilot-instructions.md AGENTS.md CALIBER_LEARNINGS.md";
-var PRE_COMMIT_BLOCK = `${BLOCK_START}
+function getPreCommitBlock() {
+  const bin = resolveCaliber();
+  return `${BLOCK_START}
 ## Before Committing
 
-Run \`caliber refresh\` before creating git commits to keep docs in sync with code changes.
+Run \`${bin} refresh\` before creating git commits to keep docs in sync with code changes.
 After it completes, stage any modified doc files before committing:
 
 \`\`\`bash
-caliber refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null
+${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null
 \`\`\`
 ${BLOCK_END}`;
+}
 var CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
-var CURSOR_RULE_CONTENT = `---
+function getCursorRuleContent() {
+  const bin = resolveCaliber();
+  return `---
 description: Run caliber refresh before git commits to keep docs in sync
 alwaysApply: true
 ---
-Before creating git commits, run \`caliber refresh\` to update docs based on code changes,
+Before creating git commits, run \`${bin} refresh\` to update docs based on code changes,
 then stage modified doc files (${MANAGED_DOC_PATHS}).
 `;
+}
 function hasPreCommitBlock(content) {
   return content.includes(BLOCK_START);
 }
 function appendPreCommitBlock(content) {
   if (hasPreCommitBlock(content)) return content;
   const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + PRE_COMMIT_BLOCK + "\n";
+  return trimmed + "\n\n" + getPreCommitBlock() + "\n";
 }
 function getCursorPreCommitRule() {
-  return { filename: CURSOR_RULE_FILENAME, content: CURSOR_RULE_CONTENT };
+  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
 }
 var LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
 var LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
@@ -4301,12 +4319,12 @@ function getCursorLearningsRule() {
 // src/writers/claude/index.ts
 function writeClaudeConfig(config) {
   const written = [];
-  fs10.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
+  fs11.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path10.join(".claude", "skills", skill.name);
-      if (!fs10.existsSync(skillDir)) fs10.mkdirSync(skillDir, { recursive: true });
+      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
       const skillPath = path10.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -4315,49 +4333,49 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs10.writeFileSync(skillPath, frontmatter + skill.content);
+      fs11.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs10.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs10.readFileSync(".mcp.json", "utf-8"));
+      if (fs11.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs11.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs10.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs11.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path11 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs11.writeFileSync(".cursorrules", config.cursorrules);
+    fs12.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
   const learningsRule = getCursorLearningsRule();
   const allRules = [...config.rules || [], preCommitRule, learningsRule];
   const rulesDir = path11.join(".cursor", "rules");
-  if (!fs11.existsSync(rulesDir)) fs11.mkdirSync(rulesDir, { recursive: true });
+  if (!fs12.existsSync(rulesDir)) fs12.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
     const rulePath = path11.join(rulesDir, rule.filename);
-    fs11.writeFileSync(rulePath, rule.content);
+    fs12.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path11.join(".cursor", "skills", skill.name);
-      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
+      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
       const skillPath = path11.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -4366,40 +4384,40 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs11.writeFileSync(skillPath, frontmatter + skill.content);
+      fs12.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs11.existsSync(cursorDir)) fs11.mkdirSync(cursorDir, { recursive: true });
+    if (!fs12.existsSync(cursorDir)) fs12.mkdirSync(cursorDir, { recursive: true });
     const mcpPath = path11.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs11.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs11.readFileSync(mcpPath, "utf-8"));
+      if (fs12.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs12.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs11.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs12.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
 }
 
 // src/writers/codex/index.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path12 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs12.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  fs13.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path12.join(".agents", "skills", skill.name);
-      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
       const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -4408,7 +4426,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs12.writeFileSync(skillPath, frontmatter + skill.content);
+      fs13.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -4416,20 +4434,20 @@ function writeCodexConfig(config) {
 }
 
 // src/writers/github-copilot/index.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path13 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs13.mkdirSync(".github", { recursive: true });
-    fs13.writeFileSync(path13.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
+    fs14.mkdirSync(".github", { recursive: true });
+    fs14.writeFileSync(path13.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
     const instructionsDir = path13.join(".github", "instructions");
-    fs13.mkdirSync(instructionsDir, { recursive: true });
+    fs14.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs13.writeFileSync(path13.join(instructionsDir, file.filename), file.content);
+      fs14.writeFileSync(path13.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -4437,35 +4455,36 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs14 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupDir = path14.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs14.existsSync(file)) continue;
+    if (!fs15.existsSync(file)) continue;
     const dest = path14.join(backupDir, file);
     const destDir = path14.dirname(dest);
-    if (!fs14.existsSync(destDir)) {
-      fs14.mkdirSync(destDir, { recursive: true });
+    if (!fs15.existsSync(destDir)) {
+      fs15.mkdirSync(destDir, { recursive: true });
     }
-    fs14.copyFileSync(file, dest);
+    fs15.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
   const backupFile = path14.join(backupDir, file);
-  if (!fs14.existsSync(backupFile)) return false;
+  if (!fs15.existsSync(backupFile)) return false;
   const destDir = path14.dirname(file);
-  if (!fs14.existsSync(destDir)) {
-    fs14.mkdirSync(destDir, { recursive: true });
+  if (!fs15.existsSync(destDir)) {
+    fs15.mkdirSync(destDir, { recursive: true });
   }
-  fs14.copyFileSync(backupFile, file);
+  fs15.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/lib/builtin-skills.ts
-import fs15 from "fs";
+init_resolve_caliber();
+import fs16 from "fs";
 import path15 from "path";
 function buildSkillContent(skill) {
   const frontmatter = `---
@@ -4476,10 +4495,9 @@ description: ${skill.description}
 `;
   return frontmatter + skill.content;
 }
-var FIND_SKILLS_SKILL = {
-  name: "find-skills",
-  description: "Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.",
-  content: `# Find Skills
+function getFindSkillsContent() {
+  const bin = resolveCaliber();
+  return `# Find Skills
 
 Search the public skill registry for community-contributed skills
 relevant to the user's current task and install them into this project.
@@ -4492,13 +4510,13 @@ relevant to the user's current task and install them into this project.
    for [identified technologies]?"
 3. If the user agrees, run:
    \`\`\`bash
-   caliber skills --query "<relevant terms>"
+   ${bin} skills --query "<relevant terms>"
    \`\`\`
    This outputs the top 5 matching skills with scores and descriptions.
 4. Present the results to the user and ask which ones to install
 5. Install the selected skills:
    \`\`\`bash
-   caliber skills --install <slug1>,<slug2>
+   ${bin} skills --install <slug1>,<slug2>
    \`\`\`
 6. Read the installed SKILL.md files to load them into your current
    context so you can use them immediately in this session
@@ -4509,18 +4527,18 @@ relevant to the user's current task and install them into this project.
 User: "let's build a web app using React"
 -> "I notice you want to work with React. Would you like me to search
    for community skills that could help with React development?"
--> If yes: run \`caliber skills --query "react frontend"\`
+-> If yes: run \`${bin} skills --query "react frontend"\`
 -> Show the user the results, ask which to install
--> Run \`caliber skills --install <selected-slugs>\`
+-> Run \`${bin} skills --install <selected-slugs>\`
 -> Read the installed files and continue
 
 User: "help me set up Docker for this project"
 -> "Would you like me to search for Docker-related skills?"
--> If yes: run \`caliber skills --query "docker deployment"\`
+-> If yes: run \`${bin} skills --query "docker deployment"\`
 
 User: "I need to write tests for this Python ML pipeline"
 -> "Would you like me to find skills for Python ML testing?"
--> If yes: run \`caliber skills --query "python machine-learning testing"\`
+-> If yes: run \`${bin} skills --query "python machine-learning testing"\`
 
 ## When NOT to trigger
 
@@ -4528,12 +4546,11 @@ User: "I need to write tests for this Python ML pipeline"
 - You already suggested skills for this technology in this session
 - The user is in the middle of urgent debugging or time-sensitive work
 - The technology is too generic (e.g. just "code" or "programming")
-`
-};
-var SAVE_LEARNING_SKILL = {
-  name: "save-learning",
-  description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
-  content: `# Save Learning
+`;
+}
+function getSaveLearningContent() {
+  const bin = resolveCaliber();
+  return `# Save Learning
 
 Save a user's instruction or preference as a persistent learning that
 will be applied in all future sessions on this project.
@@ -4554,11 +4571,11 @@ will be applied in all future sessions on this project.
 3. Show the refined learning to the user and ask for confirmation
 4. If confirmed, run:
    \`\`\`bash
-   caliber learn add "<refined learning>"
+   ${bin} learn add "<refined learning>"
    \`\`\`
    For personal preferences (not project-level), add \`--personal\`:
    \`\`\`bash
-   caliber learn add --personal "<refined learning>"
+   ${bin} learn add --personal "<refined learning>"
    \`\`\`
 5. Stage the learnings file for the next commit:
    \`\`\`bash
@@ -4572,7 +4589,7 @@ User: "when developing features, push to next branch not master, remember it"
 -> "I'll save this as a project learning:
     **[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`
     Save for future sessions?"
--> If yes: run \`caliber learn add "**[convention]** Push feature commits to the next branch, not master"\`
+-> If yes: run \`${bin} learn add "**[convention]** Push feature commits to the next branch, not master"\`
 -> Run \`git add CALIBER_LEARNINGS.md\`
 
 User: "always use bun instead of npm"
@@ -4588,7 +4605,21 @@ User: "never use any in TypeScript, use unknown instead"
 - The user is giving a one-time instruction for the current task only
 - The instruction is too vague to be actionable
 - The user explicitly says "just for now" or "only this time"
-`
+`;
+}
+var FIND_SKILLS_SKILL = {
+  name: "find-skills",
+  description: "Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.",
+  get content() {
+    return getFindSkillsContent();
+  }
+};
+var SAVE_LEARNING_SKILL = {
+  name: "save-learning",
+  description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
+  get content() {
+    return getSaveLearningContent();
+  }
 };
 var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL];
 var PLATFORM_CONFIGS = [
@@ -4599,12 +4630,12 @@ var PLATFORM_CONFIGS = [
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs15.existsSync(platformDir)) continue;
+    if (!fs16.existsSync(platformDir)) continue;
     for (const skill of BUILTIN_SKILLS) {
       const skillPath = path15.join(skillsDir, skill.name, "SKILL.md");
-      if (fs15.existsSync(skillPath)) continue;
-      fs15.mkdirSync(path15.dirname(skillPath), { recursive: true });
-      fs15.writeFileSync(skillPath, buildSkillContent(skill));
+      if (fs16.existsSync(skillPath)) continue;
+      fs16.mkdirSync(path15.dirname(skillPath), { recursive: true });
+      fs16.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -4612,33 +4643,33 @@ function ensureBuiltinSkills() {
 }
 
 // src/writers/manifest.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs16.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs16.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs17.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs17.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs16.existsSync(CALIBER_DIR)) {
-    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs16.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs17.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs16.readFileSync(filePath);
+  const content = fs17.readFileSync(filePath);
   return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs17.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs18.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs17.existsSync(f)),
+    ...filesToWrite.filter((f) => fs18.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -4657,7 +4688,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs17.unlinkSync(filePath);
+    fs18.unlinkSync(filePath);
     deleted.push(filePath);
   }
   written.push(...ensureBuiltinSkills());
@@ -4688,8 +4719,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs17.existsSync(entry.path)) {
-        fs17.unlinkSync(entry.path);
+      if (fs18.existsSync(entry.path)) {
+        fs18.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -4698,8 +4729,8 @@ function undoSetup() {
       }
     }
   }
-  if (fs17.existsSync(MANIFEST_FILE)) {
-    fs17.unlinkSync(MANIFEST_FILE);
+  if (fs18.existsSync(MANIFEST_FILE)) {
+    fs18.unlinkSync(MANIFEST_FILE);
   }
   return { restored, removed };
 }
@@ -4740,18 +4771,18 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs17.existsSync(gitignorePath)) {
-    const content = fs17.readFileSync(gitignorePath, "utf-8");
+  if (fs18.existsSync(gitignorePath)) {
+    const content = fs18.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs17.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs18.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs17.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs18.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
-import fs18 from "fs";
+import fs19 from "fs";
 import path16 from "path";
 var STAGED_DIR = path16.join(CALIBER_DIR, "staged");
 var PROPOSED_DIR = path16.join(STAGED_DIR, "proposed");
@@ -4766,19 +4797,19 @@ function stageFiles(files, projectDir) {
   const stagedFiles = [];
   for (const file of files) {
     const originalPath = path16.join(projectDir, file.path);
-    if (fs18.existsSync(originalPath)) {
-      const existing = fs18.readFileSync(originalPath, "utf-8");
+    if (fs19.existsSync(originalPath)) {
+      const existing = fs19.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
     const proposedPath = path16.join(PROPOSED_DIR, file.path);
-    fs18.mkdirSync(path16.dirname(proposedPath), { recursive: true });
-    fs18.writeFileSync(proposedPath, file.content);
-    if (fs18.existsSync(originalPath)) {
+    fs19.mkdirSync(path16.dirname(proposedPath), { recursive: true });
+    fs19.writeFileSync(proposedPath, file.content);
+    if (fs19.existsSync(originalPath)) {
       const currentPath = path16.join(CURRENT_DIR, file.path);
-      fs18.mkdirSync(path16.dirname(currentPath), { recursive: true });
-      fs18.copyFileSync(originalPath, currentPath);
+      fs19.mkdirSync(path16.dirname(currentPath), { recursive: true });
+      fs19.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -4789,13 +4820,13 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs18.existsSync(STAGED_DIR)) {
-    fs18.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs19.existsSync(STAGED_DIR)) {
+    fs19.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs19 from "fs";
+import fs20 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -4854,7 +4885,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs19.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs20.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.");
@@ -5021,6 +5052,9 @@ function removeLearningHooks() {
   return { removed: true, notFound: false };
 }
 
+// src/commands/init.ts
+init_resolve_caliber();
+
 // src/lib/state.ts
 import fs22 from "fs";
 import path18 from "path";
@@ -5066,10 +5100,10 @@ import chalk2 from "chalk";
 import readline from "readline";
 function promptInput(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     rl.question(chalk2.cyan(`${question} `), (answer) => {
       rl.close();
-      resolve2(answer.trim());
+      resolve3(answer.trim());
     });
   });
 }
@@ -5667,6 +5701,7 @@ function checkGrounding(dir) {
 import { existsSync as existsSync4, statSync as statSync2 } from "fs";
 import { execSync as execSync9 } from "child_process";
 import { join as join5 } from "path";
+init_resolve_caliber();
 function validateReferences(dir) {
   const configContent = collectPrimaryConfigContent(dir);
   if (!configContent) return { valid: [], invalid: [], total: 0 };
@@ -5790,7 +5825,7 @@ function checkAccuracy(dir) {
     earnedPoints: driftPoints,
     passed: drift.commitsSinceConfigUpdate <= 15 || !drift.isGitRepo,
     detail: !drift.isGitRepo ? "Not a git repository \u2014 skipping drift check" : !drift.lastConfigCommit ? "Config files not tracked in git" : drift.commitsSinceConfigUpdate === 0 ? "Config is up to date with latest commits" : `${drift.commitsSinceConfigUpdate} commit${drift.commitsSinceConfigUpdate === 1 ? "" : "s"} since last config update`,
-    suggestion: drift.commitsSinceConfigUpdate > 15 ? `Code has had ${drift.commitsSinceConfigUpdate} commits since last config update \u2014 run \`caliber refresh\` to sync` : void 0,
+    suggestion: drift.commitsSinceConfigUpdate > 15 ? `Code has had ${drift.commitsSinceConfigUpdate} commits since last config update \u2014 run \`${resolveCaliber()} refresh\` to sync` : void 0,
     fix: drift.commitsSinceConfigUpdate > 15 ? {
       action: "refresh_config",
       data: { commitsSince: drift.commitsSinceConfigUpdate, lastConfigCommit: drift.lastConfigCommit },
@@ -5801,6 +5836,7 @@ function checkAccuracy(dir) {
 }
 
 // src/scoring/checks/freshness.ts
+init_resolve_caliber();
 import { existsSync as existsSync5, statSync as statSync3 } from "fs";
 import { execSync as execSync10 } from "child_process";
 import { join as join6 } from "path";
@@ -5864,7 +5900,7 @@ function checkFreshness(dir) {
     earnedPoints: freshnessPoints,
     passed: freshnessPoints >= 3,
     detail: freshnessDetail,
-    suggestion: commitsSince !== null && freshnessPoints < 3 ? `Config is ${commitsSince} commits behind \u2014 run \`caliber refresh\` to update it` : void 0,
+    suggestion: commitsSince !== null && freshnessPoints < 3 ? `Config is ${commitsSince} commits behind \u2014 run \`${resolveCaliber()} refresh\` to update it` : void 0,
     fix: commitsSince !== null && freshnessPoints < 3 ? {
       action: "refresh_config",
       data: { commitsSince },
@@ -5952,6 +5988,7 @@ function checkFreshness(dir) {
 import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync11 } from "child_process";
 import { join as join7 } from "path";
+init_resolve_caliber();
 function hasPreCommitHook(dir) {
   try {
     const gitDir = execSync11("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
@@ -5997,11 +6034,11 @@ function checkBonus(dir) {
     earnedPoints: hasHooks ? POINTS_HOOKS : 0,
     passed: hasHooks,
     detail: hasHooks ? hookSources.join(", ") : "No hooks configured",
-    suggestion: hasHooks ? void 0 : "Run `caliber init` to add pre-commit instructions",
+    suggestion: hasHooks ? void 0 : `Run \`${resolveCaliber()} init\` to add pre-commit instructions`,
     fix: hasHooks ? void 0 : {
       action: "install_hooks",
       data: {},
-      instruction: "Run caliber init to add pre-commit refresh instructions to config files."
+      instruction: `Run ${resolveCaliber()} init to add pre-commit refresh instructions to config files.`
     }
   });
   const agentsMdExists = existsSync6(join7(dir, "AGENTS.md"));
@@ -6066,13 +6103,14 @@ function checkBonus(dir) {
     earnedPoints: hasLearned ? POINTS_LEARNED_CONTENT : 0,
     passed: hasLearned,
     detail: hasLearned ? "Session learnings found in CALIBER_LEARNINGS.md" : "No learned content",
-    suggestion: hasLearned ? void 0 : "Install learning hooks: `caliber learn install`"
+    suggestion: hasLearned ? void 0 : `Install learning hooks: \`${resolveCaliber()} learn install\``
   });
   return checks;
 }
 
 // src/scoring/checks/sources.ts
 import { join as join8 } from "path";
+init_resolve_caliber();
 function checkSources(dir) {
   const checks = [];
   const configSources = loadSourcesConfig(dir);
@@ -6085,7 +6123,7 @@ function checkSources(dir) {
     earnedPoints: hasSources ? POINTS_SOURCES_CONFIGURED : 0,
     passed: hasSources,
     detail: hasSources ? `${configSources.length} source${configSources.length === 1 ? "" : "s"} configured` : "No external sources configured",
-    suggestion: hasSources ? void 0 : "Run `caliber sources add <path>` to add related repos or docs"
+    suggestion: hasSources ? void 0 : `Run \`${resolveCaliber()} sources add <path>\` to add related repos or docs`
   });
   if (hasSources) {
     const claudeMd = readFileOrNull(join8(dir, "CLAUDE.md"));
@@ -6103,7 +6141,7 @@ function checkSources(dir) {
       earnedPoints: referenced ? POINTS_SOURCES_REFERENCED : 0,
       passed: referenced,
       detail: referenced ? "At least one source is referenced in CLAUDE.md" : "No configured sources are mentioned in CLAUDE.md",
-      suggestion: referenced ? void 0 : "Regenerate with `caliber init` to include source context in your config"
+      suggestion: referenced ? void 0 : `Regenerate with \`${resolveCaliber()} init\` to include source context in your config`
     });
   }
   return checks;
@@ -6194,6 +6232,7 @@ function computeLocalScore(dir, targetAgent) {
 }
 
 // src/scoring/display.ts
+init_resolve_caliber();
 import chalk4 from "chalk";
 var AGENT_DISPLAY_NAMES = {
   claude: "Claude Code",
@@ -6329,7 +6368,7 @@ function displayScoreSummary(result) {
     const remaining = failing.length - shown.length;
     const moreText = remaining > 0 ? ` (+${remaining} more)` : "";
     console.log(chalk4.dim(`
-  Run ${chalk4.hex("#83D1EB")("caliber score")} for details.${moreText}`));
+  Run ${chalk4.hex("#83D1EB")(`${resolveCaliber()} score`)} for details.${moreText}`));
   }
   console.log("");
 }
@@ -6371,7 +6410,7 @@ import chalk6 from "chalk";
 import ora from "ora";
 import select3 from "@inquirer/select";
 import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4, existsSync as existsSync8, writeFileSync } from "fs";
-import { join as join10, dirname as dirname2 } from "path";
+import { join as join10, dirname as dirname2, resolve as resolve2 } from "path";
 init_config();
 
 // src/telemetry/index.ts
@@ -6408,11 +6447,12 @@ function getMachineId() {
   writeConfig({ ...config, machineId });
   return machineId;
 }
+var EMAIL_HASH_KEY = "caliber-telemetry-v1";
 function getGitEmailHash() {
   try {
     const email = execSync12("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
-    return crypto4.createHash("sha256").update(email).digest("hex");
+    return crypto4.createHmac("sha256", EMAIL_HASH_KEY).update(email).digest("hex");
   } catch {
     return void 0;
   }
@@ -6573,6 +6613,7 @@ function trackInsightsViewed(totalSessions, learningCount) {
 }
 
 // src/commands/recommend.ts
+init_resolve_caliber();
 function detectLocalPlatforms() {
   const items = scanLocalState(process.cwd());
   const platforms = /* @__PURE__ */ new Set();
@@ -6581,14 +6622,19 @@ function detectLocalPlatforms() {
   }
   return platforms.size > 0 ? Array.from(platforms) : ["claude"];
 }
+function sanitizeSlug(slug) {
+  return slug.replace(/[^a-zA-Z0-9_\-]/g, "-").replace(/^-+|-+$/g, "");
+}
 function getSkillPath(platform, slug) {
-  if (platform === "cursor") {
-    return join10(".cursor", "skills", slug, "SKILL.md");
+  const safe = sanitizeSlug(slug);
+  if (!safe) throw new Error(`Invalid skill slug: "${slug}"`);
+  const baseDir = platform === "cursor" ? join10(".cursor", "skills") : platform === "codex" ? join10(".agents", "skills") : join10(".claude", "skills");
+  const cwd = process.cwd();
+  const fullPath = resolve2(cwd, baseDir, safe, "SKILL.md");
+  if (!fullPath.startsWith(resolve2(cwd, baseDir) + "/")) {
+    throw new Error(`Skill path escapes base directory: "${slug}"`);
   }
-  if (platform === "codex") {
-    return join10(".agents", "skills", slug, "SKILL.md");
-  }
-  return join10(".claude", "skills", slug, "SKILL.md");
+  return join10(baseDir, safe, "SKILL.md");
 }
 function getSkillDir(platform) {
   if (platform === "cursor") return join10(process.cwd(), ".cursor", "skills");
@@ -6944,7 +6990,7 @@ async function querySkills(query) {
     console.log(`     ${r.reason || r.name}`);
   }
   console.log("");
-  console.log(chalk6.dim(`  Install with: caliber skills --install ${available.map((r) => r.slug).join(",")}`));
+  console.log(chalk6.dim(`  Install with: ${resolveCaliber()} skills --install ${available.map((r) => r.slug).join(",")}`));
   console.log("");
 }
 async function installBySlug(slugStr) {
@@ -7121,7 +7167,7 @@ async function interactiveSelect(recs) {
     stdout.write(output + "\n");
     lineCount = output.split("\n").length;
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     console.log("");
     draw(true);
     stdin.setRawMode(true);
@@ -7159,9 +7205,9 @@ async function interactiveSelect(recs) {
           cleanup();
           if (selected.size === 0) {
             console.log(chalk6.dim("\n  No skills selected.\n"));
-            resolve2(null);
+            resolve3(null);
           } else {
-            resolve2(Array.from(selected).sort().map((i) => recs[i]));
+            resolve3(Array.from(selected).sort().map((i) => recs[i]));
           }
           break;
         case "q":
@@ -7169,7 +7215,7 @@ async function interactiveSelect(recs) {
         case "":
           cleanup();
           console.log(chalk6.dim("\n  Cancelled.\n"));
-          resolve2(null);
+          resolve3(null);
           break;
       }
     }
@@ -8089,7 +8135,7 @@ ${JSON.stringify(currentSetup, null, 2)}
 User request: ${message}
 
 Return the complete updated AgentSetup JSON incorporating the user's changes. Respond with ONLY the JSON.`;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let buffer = "";
     provider.stream(
       {
@@ -8109,20 +8155,20 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
           try {
             const setup = JSON.parse(jsonToParse);
             if (callbacks) callbacks.onComplete(setup);
-            resolve2(setup);
+            resolve3(setup);
           } catch {
             if (callbacks) callbacks.onError("Failed to parse AI response. Try rephrasing your request.");
-            resolve2(null);
+            resolve3(null);
           }
         },
         onError: (error) => {
           if (callbacks) callbacks.onError(error.message);
-          resolve2(null);
+          resolve3(null);
         }
       }
     ).catch((error) => {
       if (callbacks) callbacks.onError(error.message);
-      resolve2(null);
+      resolve3(null);
     });
   });
 }
@@ -8707,6 +8753,7 @@ function log(verbose, ...args) {
 async function initCommand(options) {
   const brand = chalk14.hex("#EB9D83");
   const title = chalk14.hex("#83D1EB");
+  const bin = resolveCaliber();
   const firstRun = isFirstRun(process.cwd());
   if (firstRun) {
     console.log(brand.bold(`
@@ -8804,7 +8851,7 @@ async function initCommand(options) {
   if (hasExistingConfig && baselineScore.score === 100) {
     trackInitScoreComputed(baselineScore.score, passingCount, failingCount, true);
     console.log(chalk14.bold.green("  Your config is already optimal \u2014 nothing to change.\n"));
-    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")("caliber init --force") + chalk14.dim(" to regenerate anyway.\n"));
+    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to regenerate anyway.\n"));
     if (!options.force) return;
   }
   const allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
@@ -8820,7 +8867,7 @@ async function initCommand(options) {
       }
     }
     console.log("");
-    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")("caliber init --force") + chalk14.dim(" to regenerate anyway.\n"));
+    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to regenerate anyway.\n"));
     return;
   }
   console.log(title.bold("  Step 2/4 \u2014 Engine\n"));
@@ -9155,7 +9202,7 @@ ${agentRefs.join(" ")}
       }
     } catch {
     }
-    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")("caliber init --force") + chalk14.dim(" to override.\n"));
+    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to override.\n"));
     return;
   }
   if (report) {
@@ -9185,7 +9232,7 @@ ${agentRefs.join(" ")}
     }
   }
   console.log("");
-  console.log(`  ${chalk14.green("\u2713")} Docs auto-refresh          ${chalk14.dim("agents run caliber refresh before commits")}`);
+  console.log(`  ${chalk14.green("\u2713")} Docs auto-refresh          ${chalk14.dim(`agents run ${resolveCaliber()} refresh before commits`)}`);
   trackInitHookSelected("config-instructions");
   const hasLearnableAgent = targetAgent.includes("claude") || targetAgent.includes("cursor");
   let enableLearn = false;
@@ -9204,9 +9251,9 @@ ${agentRefs.join(" ")}
           if (r.installed) console.log(`  ${chalk14.green("\u2713")} Learning hooks installed for Cursor`);
           else if (r.alreadyInstalled) console.log(chalk14.dim("  Cursor learning hooks already installed"));
         }
-        console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")("caliber learn status") + chalk14.dim(" to see insights"));
+        console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")(`${bin} learn status`) + chalk14.dim(" to see insights"));
       } else {
-        console.log(chalk14.dim("  Skipped. Run ") + chalk14.hex("#83D1EB")("caliber learn install") + chalk14.dim(" later to enable."));
+        console.log(chalk14.dim("  Skipped. Run ") + chalk14.hex("#83D1EB")(`${bin} learn install`) + chalk14.dim(" later to enable."));
       }
     } else {
       enableLearn = true;
@@ -9220,13 +9267,13 @@ ${agentRefs.join(" ")}
   const done = chalk14.green("\u2713");
   const skip = chalk14.dim("\u2013");
   console.log(chalk14.bold("  What was configured:\n"));
-  console.log(`    ${done}  Config generated          ${title("caliber score")} ${chalk14.dim("for full breakdown")}`);
-  console.log(`    ${done}  Docs auto-refresh        ${chalk14.dim("agents run caliber refresh before commits")}`);
+  console.log(`    ${done}  Config generated          ${title(`${bin} score`)} ${chalk14.dim("for full breakdown")}`);
+  console.log(`    ${done}  Docs auto-refresh        ${chalk14.dim(`agents run ${bin} refresh before commits`)}`);
   if (hasLearnableAgent) {
     if (enableLearn) {
       console.log(`    ${done}  Session learning          ${chalk14.dim("agent learns from your feedback")}`);
     } else {
-      console.log(`    ${skip}  Session learning          ${title("caliber learn install")} to enable later`);
+      console.log(`    ${skip}  Session learning          ${title(`${bin} learn install`)} to enable later`);
     }
   }
   if (communitySkillsInstalled > 0) {
@@ -9235,9 +9282,9 @@ ${agentRefs.join(" ")}
     console.log(`    ${skip}  Community skills          ${chalk14.dim("available but skipped")}`);
   }
   console.log(chalk14.bold("\n  Explore next:\n"));
-  console.log(`    ${title("caliber skills")}       Find more community skills as your codebase evolves`);
-  console.log(`    ${title("caliber score")}        See the full scoring breakdown with improvement tips`);
-  console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
+  console.log(`    ${title(`${bin} skills`)}       Find more community skills as your codebase evolves`);
+  console.log(`    ${title(`${bin} score`)}        See the full scoring breakdown with improvement tips`);
+  console.log(`    ${title(`${bin} undo`)}         Revert all changes from this run`);
   console.log("");
   if (options.showTokens) {
     displayTokenUsage();
@@ -9287,6 +9334,7 @@ function undoCommand() {
 import chalk16 from "chalk";
 import fs33 from "fs";
 init_config();
+init_resolve_caliber();
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -9303,11 +9351,12 @@ async function statusCommand(options) {
   if (config) {
     console.log(`  LLM: ${chalk16.green(config.provider)} (${config.model})`);
   } else {
-    console.log(`  LLM: ${chalk16.yellow("Not configured")} \u2014 run ${chalk16.hex("#83D1EB")("caliber config")}`);
+    const bin = resolveCaliber();
+    console.log(`  LLM: ${chalk16.yellow("Not configured")} \u2014 run ${chalk16.hex("#83D1EB")(`${bin} config`)}`);
   }
   if (!manifest) {
     console.log(`  Config: ${chalk16.dim("No config applied")}`);
-    console.log(chalk16.dim("\n  Run ") + chalk16.hex("#83D1EB")("caliber init") + chalk16.dim(" to get started.\n"));
+    console.log(chalk16.dim("\n  Run ") + chalk16.hex("#83D1EB")(`${resolveCaliber()} init`) + chalk16.dim(" to get started.\n"));
     return;
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
@@ -9325,15 +9374,17 @@ import ora5 from "ora";
 import select6 from "@inquirer/select";
 init_review();
 init_config();
+init_resolve_caliber();
 async function regenerateCommand(options) {
+  const bin = resolveCaliber();
   const config = loadConfig();
   if (!config) {
-    console.log(chalk17.red("No LLM provider configured. Run ") + chalk17.hex("#83D1EB")("caliber config") + chalk17.red(" first."));
+    console.log(chalk17.red("No LLM provider configured. Run ") + chalk17.hex("#83D1EB")(`${bin} config`) + chalk17.red(" first."));
     throw new Error("__exit__");
   }
   const manifest = readManifest();
   if (!manifest) {
-    console.log(chalk17.yellow("No existing config found. Run ") + chalk17.hex("#83D1EB")("caliber init") + chalk17.yellow(" first."));
+    console.log(chalk17.yellow("No existing config found. Run ") + chalk17.hex("#83D1EB")(`${bin} init`) + chalk17.yellow(" first."));
     throw new Error("__exit__");
   }
   const targetAgent = readState()?.targetAgent ?? ["claude", "cursor"];
@@ -9457,13 +9508,13 @@ async function regenerateCommand(options) {
       }
     } catch {
     }
-    console.log(chalk17.dim("  Run ") + chalk17.hex("#83D1EB")("caliber init --force") + chalk17.dim(" to override.\n"));
+    console.log(chalk17.dim("  Run ") + chalk17.hex("#83D1EB")(`${bin} init --force`) + chalk17.dim(" to override.\n"));
     return;
   }
   displayScoreDelta(baselineScore, afterScore);
   trackRegenerateCompleted(action, Date.now());
   console.log(chalk17.bold.green("  Regeneration complete!"));
-  console.log(chalk17.dim("  Run ") + chalk17.hex("#83D1EB")("caliber undo") + chalk17.dim(" to revert changes.\n"));
+  console.log(chalk17.dim("  Run ") + chalk17.hex("#83D1EB")(`${bin} undo`) + chalk17.dim(" to revert changes.\n"));
 }
 
 // src/commands/score.ts
@@ -9472,6 +9523,7 @@ import os7 from "os";
 import path26 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import chalk18 from "chalk";
+init_resolve_caliber();
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
@@ -9552,12 +9604,13 @@ async function scoreCommand(options) {
   displayScore(result);
   const separator = chalk18.gray("  " + "\u2500".repeat(53));
   console.log(separator);
+  const bin = resolveCaliber();
   if (result.score < 40) {
-    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")("caliber init") + chalk18.gray(" to generate a complete, optimized config."));
+    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to generate a complete, optimized config."));
   } else if (result.score < 70) {
-    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")("caliber init") + chalk18.gray(" to improve your config."));
+    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to improve your config."));
   } else {
-    console.log(chalk18.green("  Looking good!") + chalk18.gray(" Run ") + chalk18.hex("#83D1EB")("caliber regenerate") + chalk18.gray(" to rebuild from scratch."));
+    console.log(chalk18.green("  Looking good!") + chalk18.gray(" Run ") + chalk18.hex("#83D1EB")(`${bin} regenerate`) + chalk18.gray(" to rebuild from scratch."));
   }
   console.log("");
 }
@@ -9964,6 +10017,7 @@ function migrateInlineLearnings() {
 
 // src/commands/refresh.ts
 init_config();
+init_resolve_caliber();
 function log2(quiet, ...args) {
   if (!quiet) console.log(...args);
 }
@@ -10116,7 +10170,7 @@ async function refreshCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (quiet) return;
-      console.log(chalk19.red("No LLM provider configured. Run ") + chalk19.hex("#83D1EB")("caliber config") + chalk19.red(" (e.g. choose Cursor) or set an API key."));
+      console.log(chalk19.red("No LLM provider configured. Run ") + chalk19.hex("#83D1EB")(`${resolveCaliber()} config`) + chalk19.red(" (e.g. choose Cursor) or set an API key."));
       throw new Error("__exit__");
     }
     await validateModel({ fast: true });
@@ -10230,11 +10284,14 @@ var PRECOMMIT_START = "# caliber:pre-commit:start";
 var PRECOMMIT_END = "# caliber:pre-commit:end";
 function getPrecommitBlock() {
   const bin = resolveCaliber();
+  const npx = isNpxResolution();
+  const guard = npx ? "command -v npx >/dev/null 2>&1" : `[ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1`;
+  const invoke = npx ? bin : `"${bin}"`;
   return `${PRECOMMIT_START}
-if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
+if ${guard}; then
   echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  "${bin}" refresh 2>/dev/null || true
-  "${bin}" learn finalize 2>/dev/null || true
+  ${invoke} refresh 2>/dev/null || true
+  ${invoke} learn finalize 2>/dev/null || true
   git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md CALIBER_LEARNINGS.md 2>/dev/null | xargs git add 2>/dev/null || true
 fi
 ${PRECOMMIT_END}`;
@@ -10394,7 +10451,7 @@ async function hooksCommand(options) {
     stdout.write(output + "\n");
     lineCount = output.split("\n").length;
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     console.log("");
     draw(true);
     stdin.setRawMode(true);
@@ -10452,14 +10509,14 @@ async function hooksCommand(options) {
         case "\n":
           cleanup();
           apply();
-          resolve2();
+          resolve3();
           break;
         case "q":
         case "\x1B":
         case "":
           cleanup();
           console.log(chalk20.dim("\n  Cancelled.\n"));
-          resolve2();
+          resolve3();
           break;
       }
     }
@@ -10519,21 +10576,21 @@ import chalk23 from "chalk";
 // src/learner/stdin.ts
 var STDIN_TIMEOUT_MS = 5e3;
 function readStdin() {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     if (process.stdin.isTTY) {
-      resolve2("");
+      resolve3("");
       return;
     }
     const chunks = [];
     const timer = setTimeout(() => {
       process.stdin.removeAllListeners();
       process.stdin.destroy();
-      resolve2(Buffer.concat(chunks).toString("utf-8"));
+      resolve3(Buffer.concat(chunks).toString("utf-8"));
     }, STDIN_TIMEOUT_MS);
     process.stdin.on("data", (chunk) => chunks.push(chunk));
     process.stdin.on("end", () => {
       clearTimeout(timer);
-      resolve2(Buffer.concat(chunks).toString("utf-8"));
+      resolve3(Buffer.concat(chunks).toString("utf-8"));
     });
     process.stdin.on("error", (err) => {
       clearTimeout(timer);
@@ -11139,6 +11196,7 @@ function findStaleLearnings(stats, minSessions = DEFAULT_MIN_SESSIONS) {
 }
 
 // src/commands/learn.ts
+init_resolve_caliber();
 var MIN_EVENTS_FOR_ANALYSIS = 25;
 var MIN_EVENTS_AUTO = 10;
 var AUTO_SETTLE_MS = 200;
@@ -11242,7 +11300,7 @@ async function learnFinalizeCommand(options) {
     const config = loadConfig();
     if (!config) {
       if (isAuto) return;
-      console.log(chalk23.yellow("caliber: no LLM provider configured \u2014 run `caliber config` first"));
+      console.log(chalk23.yellow(`caliber: no LLM provider configured \u2014 run \`${resolveCaliber()} config\` first`));
       clearSession();
       resetState();
       return;
@@ -11390,7 +11448,7 @@ async function learnFinalizeCommand(options) {
     if (!isIncremental) {
       const staleLearnings = findStaleLearnings(roiStats);
       if (staleLearnings.length > 0 && !isAuto) {
-        console.log(chalk23.yellow(`caliber: ${staleLearnings.length} learning${staleLearnings.length === 1 ? "" : "s"} never activated \u2014 run \`caliber learn list --verbose\` to review`));
+        console.log(chalk23.yellow(`caliber: ${staleLearnings.length} learning${staleLearnings.length === 1 ? "" : "s"} never activated \u2014 run \`${resolveCaliber()} learn list --verbose\` to review`));
       }
     }
     if (!isAuto && t.estimatedSavingsTokens > 0) {
@@ -11440,7 +11498,7 @@ async function learnInstallCommand() {
   }
   if (!fs44.existsSync(".claude") && !fs44.existsSync(".cursor")) {
     console.log(chalk23.yellow("No .claude/ or .cursor/ directory found."));
-    console.log(chalk23.dim("  Run `caliber init` first, or create the directory manually."));
+    console.log(chalk23.dim(`  Run \`${resolveCaliber()} init\` first, or create the directory manually.`));
     return;
   }
   if (anyInstalled) {
@@ -11482,7 +11540,7 @@ async function learnStatusCommand() {
     console.log(chalk23.dim("\u2717") + " Cursor hooks " + chalk23.dim("not installed"));
   }
   if (!claudeInstalled && !cursorInstalled) {
-    console.log(chalk23.dim("  Run `caliber learn install` to enable session learning."));
+    console.log(chalk23.dim(`  Run \`${resolveCaliber()} learn install\` to enable session learning.`));
   }
   console.log();
   console.log(`Events recorded: ${chalk23.cyan(String(eventCount))}`);
@@ -11537,7 +11595,7 @@ function getAllLearnings() {
 async function learnListCommand(options) {
   const items = getAllLearnings();
   if (items.length === 0) {
-    console.log(chalk23.dim("No learnings yet. Run `caliber learn install` to start."));
+    console.log(chalk23.dim(`No learnings yet. Run \`${resolveCaliber()} learn install\` to start.`));
     return;
   }
   const roiStats = options?.verbose ? readROIStats() : null;
@@ -11566,7 +11624,7 @@ async function learnListCommand(options) {
 async function learnDeleteCommand(indexStr) {
   const index = parseInt(indexStr, 10);
   if (isNaN(index) || index < 1) {
-    console.log(chalk23.red(`Invalid index: "${indexStr}". Use a number from \`caliber learn list\`.`));
+    console.log(chalk23.red(`Invalid index: "${indexStr}". Use a number from \`${resolveCaliber()} learn list\`.`));
     return;
   }
   const items = getAllLearnings();
@@ -11631,6 +11689,7 @@ async function learnAddCommand(content, options) {
 
 // src/commands/insights.ts
 import chalk24 from "chalk";
+init_resolve_caliber();
 var MIN_SESSIONS_FULL = 20;
 function buildInsightsData(stats) {
   const t = stats.totals;
@@ -11676,7 +11735,7 @@ function displayColdStart(score) {
     console.log(chalk24.yellow("  Learning hooks not installed."));
     console.log(chalk24.dim("  Session learning captures patterns from your AI coding sessions \u2014 what"));
     console.log(chalk24.dim("  fails, what works, corrections you make \u2014 so your agents improve over time.\n"));
-    console.log(chalk24.dim("  Run ") + chalk24.cyan("caliber learn install") + chalk24.dim(" to enable."));
+    console.log(chalk24.dim("  Run ") + chalk24.cyan(`${resolveCaliber()} learn install`) + chalk24.dim(" to enable."));
   } else {
     console.log(chalk24.dim("  Learning hooks are active. Use your AI agent and insights"));
     console.log(chalk24.dim("  will appear automatically after each session.\n"));
@@ -11779,13 +11838,14 @@ async function insightsCommand(options) {
 import fs45 from "fs";
 import path36 from "path";
 import chalk25 from "chalk";
+init_resolve_caliber();
 async function sourcesListCommand() {
   const dir = process.cwd();
   const configSources = loadSourcesConfig(dir);
   const workspaces = getDetectedWorkspaces(dir);
   if (configSources.length === 0 && workspaces.length === 0) {
     console.log(chalk25.dim("\n  No sources configured.\n"));
-    console.log(chalk25.dim("  Add a source: ") + chalk25.hex("#83D1EB")("caliber sources add <path>"));
+    console.log(chalk25.dim("  Add a source: ") + chalk25.hex("#83D1EB")(`${resolveCaliber()} sources add <path>`));
     console.log(chalk25.dim("  Or add to .caliber/sources.json manually.\n"));
     return;
   }
@@ -11882,11 +11942,12 @@ import path37 from "path";
 import chalk26 from "chalk";
 import ora7 from "ora";
 init_config();
+init_resolve_caliber();
 async function publishCommand() {
   const dir = process.cwd();
   const config = loadConfig();
   if (!config) {
-    console.log(chalk26.red("No LLM provider configured. Run ") + chalk26.hex("#83D1EB")("caliber config") + chalk26.red(" first."));
+    console.log(chalk26.red("No LLM provider configured. Run ") + chalk26.hex("#83D1EB")(`${resolveCaliber()} config`) + chalk26.red(" first."));
     throw new Error("__exit__");
   }
   const spinner = ora7("Generating project summary...").start();
@@ -12031,7 +12092,7 @@ learn.command("add <content>").description("Add a learning directly (used by age
 import fs48 from "fs";
 import path39 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync16 } from "child_process";
+import { execSync as execSync16, execFileSync as execFileSync3 } from "child_process";
 import chalk27 from "chalk";
 import ora8 from "ora";
 import confirm2 from "@inquirer/confirm";
@@ -12107,9 +12168,10 @@ Update available: ${current} -> ${latest}`)
       return;
     }
     const tag = channel === "latest" ? latest : channel;
+    if (!/^[\w.\-]+$/.test(tag)) return;
     const spinner = ora8("Updating caliber...").start();
     try {
-      execSync16(`npm install -g @rely-ai/caliber@${tag}`, {
+      execFileSync3("npm", ["install", "-g", `@rely-ai/caliber@${tag}`], {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -12126,7 +12188,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk27.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync16(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execFileSync3("caliber", args, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });