@rely-ai/caliber 1.7.4 → 1.7.6

package/dist/bin.js

@@ -165,17 +165,18 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs28 from "fs";
-import path22 from "path";
+import fs30 from "fs";
+import path24 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
+import path19 from "path";
 import chalk8 from "chalk";
 import ora2 from "ora";
 import readline3 from "readline";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs22 from "fs";
+import fs24 from "fs";
 
 // src/fingerprint/index.ts
 import fs6 from "fs";
@@ -2670,28 +2671,64 @@ ${agentRefs.join(" ")}
 }
 
 // src/lib/hooks.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import path12 from "path";
+import { execSync as execSync6 } from "child_process";
+
+// src/lib/resolve-caliber.ts
+import fs16 from "fs";
 import { execSync as execSync5 } from "child_process";
+var _resolved = null;
+function resolveCaliber() {
+  if (_resolved) return _resolved;
+  try {
+    const found = execSync5("which caliber", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (found) {
+      _resolved = found;
+      return _resolved;
+    }
+  } catch {
+  }
+  const binPath = process.argv[1];
+  if (binPath && fs16.existsSync(binPath)) {
+    _resolved = binPath;
+    return _resolved;
+  }
+  _resolved = "caliber";
+  return _resolved;
+}
+function isCaliberCommand(command, subcommandTail) {
+  if (command === `caliber ${subcommandTail}`) return true;
+  if (command.endsWith(`/caliber ${subcommandTail}`)) return true;
+  return false;
+}
+
+// src/lib/hooks.ts
 var SETTINGS_PATH = path12.join(".claude", "settings.json");
-var HOOK_COMMAND = "caliber refresh --quiet";
+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 (!fs16.existsSync(SETTINGS_PATH)) return {};
+  if (!fs17.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs16.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs17.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
   const dir = path12.dirname(SETTINGS_PATH);
-  if (!fs16.existsSync(dir)) fs16.mkdirSync(dir, { recursive: true });
-  fs16.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
+  fs17.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
-    (entry) => entry.hooks?.some((h) => h.command === HOOK_COMMAND)
+    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
   );
 }
 function isHookInstalled() {
@@ -2709,7 +2746,7 @@ function installHook() {
   }
   settings.hooks.SessionEnd.push({
     matcher: "",
-    hooks: [{ type: "command", command: HOOK_COMMAND, description: HOOK_DESCRIPTION }]
+    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
   });
   writeSettings(settings);
   return { installed: true, alreadyInstalled: false };
@@ -2736,16 +2773,19 @@ function removeHook() {
 }
 var PRECOMMIT_START = "# caliber:pre-commit:start";
 var PRECOMMIT_END = "# caliber:pre-commit:end";
-var PRECOMMIT_BLOCK = `${PRECOMMIT_START}
-if command -v caliber >/dev/null 2>&1; then
+function getPrecommitBlock() {
+  const bin = resolveCaliber();
+  return `${PRECOMMIT_START}
+if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
   echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  caliber refresh 2>/dev/null || true
+  "${bin}" refresh 2>/dev/null || true
   git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md 2>/dev/null | xargs git add 2>/dev/null || true
 fi
 ${PRECOMMIT_END}`;
+}
 function getGitHooksDir() {
   try {
-    const gitDir = execSync5("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync6("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     return path12.join(gitDir, "hooks");
   } catch {
     return null;
@@ -2757,8 +2797,8 @@ function getPreCommitPath() {
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs16.existsSync(hookPath)) return false;
-  const content = fs16.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs17.existsSync(hookPath)) return false;
+  const content = fs17.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -2768,81 +2808,78 @@ function installPreCommitHook() {
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
   const hooksDir = path12.dirname(hookPath);
-  if (!fs16.existsSync(hooksDir)) fs16.mkdirSync(hooksDir, { recursive: true });
+  if (!fs17.existsSync(hooksDir)) fs17.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs16.existsSync(hookPath)) {
-    content = fs16.readFileSync(hookPath, "utf-8");
+  if (fs17.existsSync(hookPath)) {
+    content = fs17.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
-    content += "\n" + PRECOMMIT_BLOCK + "\n";
+    content += "\n" + getPrecommitBlock() + "\n";
   } else {
-    content = "#!/bin/sh\n\n" + PRECOMMIT_BLOCK + "\n";
+    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs16.writeFileSync(hookPath, content);
-  fs16.chmodSync(hookPath, 493);
+  fs17.writeFileSync(hookPath, content);
+  fs17.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs16.existsSync(hookPath)) {
+  if (!hookPath || !fs17.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs16.readFileSync(hookPath, "utf-8");
+  let content = fs17.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs16.unlinkSync(hookPath);
+    fs17.unlinkSync(hookPath);
   } else {
-    fs16.writeFileSync(hookPath, content);
+    fs17.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import path13 from "path";
 var SETTINGS_PATH2 = path13.join(".claude", "settings.json");
-var HOOK_CONFIGS = [
-  {
-    event: "PostToolUse",
-    command: "caliber learn observe",
-    description: "Caliber: recording tool usage for session learning"
-  },
-  {
-    event: "PostToolUseFailure",
-    command: "caliber learn observe --failure",
-    description: "Caliber: recording tool failure for session learning"
-  },
-  {
-    event: "SessionEnd",
-    command: "caliber learn finalize",
-    description: "Caliber: finalizing session learnings"
-  }
+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" },
+  { event: "SessionEnd", tail: "learn finalize", description: "Caliber: finalizing session learnings" }
 ];
+function getHookConfigs() {
+  const bin = resolveCaliber();
+  return HOOK_TAILS.map(({ event, tail, description }) => ({
+    event,
+    command: `${bin} ${tail}`,
+    tail,
+    description
+  }));
+}
 function readSettings2() {
-  if (!fs17.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs18.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs17.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs18.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
   const dir = path13.dirname(SETTINGS_PATH2);
-  if (!fs17.existsSync(dir)) fs17.mkdirSync(dir, { recursive: true });
-  fs17.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
+  fs18.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
-function hasLearningHook(matchers, command) {
-  return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
+function hasLearningHook(matchers, tail) {
+  return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
 }
 function areLearningHooksInstalled() {
   const settings = readSettings2();
   if (!settings.hooks) return false;
-  return HOOK_CONFIGS.every((cfg) => {
+  return HOOK_TAILS.every((cfg) => {
     const matchers = settings.hooks[cfg.event];
-    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.command);
+    return Array.isArray(matchers) && hasLearningHook(matchers, cfg.tail);
   });
 }
 function installLearningHooks() {
@@ -2851,11 +2888,12 @@ function installLearningHooks() {
   }
   const settings = readSettings2();
   if (!settings.hooks) settings.hooks = {};
-  for (const cfg of HOOK_CONFIGS) {
+  const configs = getHookConfigs();
+  for (const cfg of configs) {
     if (!Array.isArray(settings.hooks[cfg.event])) {
       settings.hooks[cfg.event] = [];
     }
-    if (!hasLearningHook(settings.hooks[cfg.event], cfg.command)) {
+    if (!hasLearningHook(settings.hooks[cfg.event], cfg.tail)) {
       settings.hooks[cfg.event].push({
         matcher: "",
         hooks: [{ type: "command", command: cfg.command, description: cfg.description }]
@@ -2869,10 +2907,10 @@ function removeLearningHooks() {
   const settings = readSettings2();
   if (!settings.hooks) return { removed: false, notFound: true };
   let removedAny = false;
-  for (const cfg of HOOK_CONFIGS) {
+  for (const cfg of HOOK_TAILS) {
     const matchers = settings.hooks[cfg.event];
     if (!Array.isArray(matchers)) continue;
-    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => h.command === cfg.command));
+    const idx = matchers.findIndex((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, cfg.tail)));
     if (idx !== -1) {
       matchers.splice(idx, 1);
       removedAny = true;
@@ -2889,9 +2927,9 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs18 from "fs";
+import fs19 from "fs";
 import path14 from "path";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
@@ -2903,8 +2941,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs18.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs18.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs19.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs19.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -2912,14 +2950,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs18.existsSync(CALIBER_DIR)) {
-    fs18.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs19.existsSync(CALIBER_DIR)) {
+    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs18.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs19.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync6("git rev-parse HEAD", {
+    return execSync7("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -3205,15 +3243,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path24) {
+function readFileOrNull(path26) {
   try {
-    return readFileSync(path24, "utf-8");
+    return readFileSync(path26, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path24) {
-  const content = readFileOrNull(path24);
+function readJsonOrNull(path26) {
+  const content = readFileOrNull(path26);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3581,9 +3619,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path24) {
+function readFileOrNull2(path26) {
   try {
-    return readFileSync3(path24, "utf-8");
+    return readFileSync3(path26, "utf-8");
   } catch {
     return null;
   }
@@ -3736,15 +3774,15 @@ function checkQuality(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import { join as join4 } from "path";
-function readFileOrNull3(path24) {
+function readFileOrNull3(path26) {
   try {
-    return readFileSync4(path24, "utf-8");
+    return readFileSync4(path26, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path24) {
-  const content = readFileOrNull3(path24);
+function readJsonOrNull2(path26) {
+  const content = readFileOrNull3(path26);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3927,9 +3965,9 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-function readFileOrNull4(path24) {
+function readFileOrNull4(path26) {
   try {
-    return readFileSync5(path24, "utf-8");
+    return readFileSync5(path26, "utf-8");
   } catch {
     return null;
   }
@@ -4041,18 +4079,18 @@ function checkFreshness(dir) {
 
 // src/scoring/checks/bonus.ts
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import { join as join6 } from "path";
-function readFileOrNull5(path24) {
+function readFileOrNull5(path26) {
   try {
-    return readFileSync6(path24, "utf-8");
+    return readFileSync6(path26, "utf-8");
   } catch {
     return null;
   }
 }
 function hasPreCommitHook(dir) {
   try {
-    const gitDir = execSync7("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync8("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join6(gitDir, "hooks", "pre-commit");
     const content = readFileOrNull5(hookPath);
     return content ? content.includes("caliber") : false;
@@ -4140,22 +4178,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs19 from "fs";
+import fs20 from "fs";
 import path15 from "path";
 var DISMISSED_FILE = path15.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs19.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs19.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs20.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs20.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs19.existsSync(CALIBER_DIR)) {
-    fs19.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs19.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs20.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -4350,13 +4388,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs20 from "fs";
+import fs21 from "fs";
 import path16 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
   const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs20.existsSync(claudeMdPath)) {
+  if (fs21.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -4366,8 +4404,8 @@ function scanLocalState(dir) {
     });
   }
   const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs20.existsSync(skillsDir)) {
-    for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+  if (fs21.existsSync(skillsDir)) {
+    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
       const filePath = path16.join(skillsDir, file);
       items.push({
         type: "skill",
@@ -4379,9 +4417,9 @@ function scanLocalState(dir) {
     }
   }
   const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs20.existsSync(mcpJsonPath)) {
+  if (fs21.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4397,7 +4435,7 @@ function scanLocalState(dir) {
     }
   }
   const agentsMdPath = path16.join(dir, "AGENTS.md");
-  if (fs20.existsSync(agentsMdPath)) {
+  if (fs21.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -4407,11 +4445,11 @@ function scanLocalState(dir) {
     });
   }
   const codexSkillsDir = path16.join(dir, ".agents", "skills");
-  if (fs20.existsSync(codexSkillsDir)) {
+  if (fs21.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs20.readdirSync(codexSkillsDir)) {
+      for (const name of fs21.readdirSync(codexSkillsDir)) {
         const skillFile = path16.join(codexSkillsDir, name, "SKILL.md");
-        if (fs20.existsSync(skillFile)) {
+        if (fs21.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -4425,7 +4463,7 @@ function scanLocalState(dir) {
     }
   }
   const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs20.existsSync(cursorrulesPath)) {
+  if (fs21.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -4435,8 +4473,8 @@ function scanLocalState(dir) {
     });
   }
   const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs20.existsSync(cursorRulesDir)) {
-    for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+  if (fs21.existsSync(cursorRulesDir)) {
+    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
       const filePath = path16.join(cursorRulesDir, file);
       items.push({
         type: "rule",
@@ -4448,11 +4486,11 @@ function scanLocalState(dir) {
     }
   }
   const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs20.existsSync(cursorSkillsDir)) {
+  if (fs21.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs20.readdirSync(cursorSkillsDir)) {
+      for (const name of fs21.readdirSync(cursorSkillsDir)) {
         const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs20.existsSync(skillFile)) {
+        if (fs21.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -4466,9 +4504,9 @@ function scanLocalState(dir) {
     }
   }
   const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs20.existsSync(cursorMcpPath)) {
+  if (fs21.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -4486,7 +4524,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs20.readFileSync(filePath, "utf-8");
+  const text = fs21.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -4501,27 +4539,27 @@ import { PostHog } from "posthog-node";
 import chalk6 from "chalk";
 
 // src/telemetry/config.ts
-import fs21 from "fs";
+import fs22 from "fs";
 import path17 from "path";
 import os3 from "os";
 import crypto3 from "crypto";
-import { execSync as execSync8 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 var CONFIG_DIR2 = path17.join(os3.homedir(), ".caliber");
 var CONFIG_FILE2 = path17.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs21.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs21.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs22.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs22.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs21.existsSync(CONFIG_DIR2)) {
-    fs21.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs22.existsSync(CONFIG_DIR2)) {
+    fs22.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs21.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs22.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -4532,7 +4570,7 @@ function getMachineId() {
 }
 function getGitEmailHash() {
   try {
-    const email = execSync8("git config user.email", { encoding: "utf-8" }).trim();
+    const email = execSync9("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
     return crypto3.createHash("sha256").update(email).digest("hex");
   } catch {
@@ -5229,6 +5267,93 @@ function printSkills(recs) {
   console.log("");
 }
 
+// src/lib/debug-report.ts
+import fs23 from "fs";
+import path18 from "path";
+var DebugReport = class {
+  sections = [];
+  startTime;
+  stepTimings = [];
+  lastStepStart;
+  lastStepName = null;
+  constructor() {
+    this.startTime = Date.now();
+    this.lastStepStart = this.startTime;
+  }
+  markStep(name) {
+    if (this.lastStepName) {
+      this.stepTimings.push({
+        step: this.lastStepName,
+        durationMs: Date.now() - this.lastStepStart
+      });
+    }
+    this.lastStepName = name;
+    this.lastStepStart = Date.now();
+  }
+  addSection(title, content) {
+    this.sections.push({ title, content });
+  }
+  addJson(title, data) {
+    this.sections.push({
+      title,
+      content: "```json\n" + JSON.stringify(data, null, 2) + "\n```"
+    });
+  }
+  addCodeBlock(title, code, lang = "text") {
+    this.sections.push({
+      title,
+      content: "```" + lang + "\n" + code + "\n```"
+    });
+  }
+  write(outputPath) {
+    if (this.lastStepName) {
+      this.stepTimings.push({
+        step: this.lastStepName,
+        durationMs: Date.now() - this.lastStepStart
+      });
+    }
+    const totalMs = Date.now() - this.startTime;
+    const lines = [];
+    lines.push("# Caliber Debug Report");
+    lines.push("");
+    lines.push(`- **Generated**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+    lines.push(`- **CWD**: ${process.cwd()}`);
+    lines.push(`- **Node**: ${process.version}`);
+    lines.push(`- **Total elapsed**: ${formatMs(totalMs)}`);
+    lines.push("");
+    for (const section of this.sections) {
+      lines.push(`## ${section.title}`);
+      lines.push("");
+      lines.push(section.content);
+      lines.push("");
+    }
+    if (this.stepTimings.length > 0) {
+      lines.push("## Timing");
+      lines.push("");
+      lines.push("| Step | Duration |");
+      lines.push("|------|----------|");
+      for (const t of this.stepTimings) {
+        lines.push(`| ${t.step} | ${formatMs(t.durationMs)} |`);
+      }
+      lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
+      lines.push("");
+    }
+    const dir = path18.dirname(outputPath);
+    if (!fs23.existsSync(dir)) {
+      fs23.mkdirSync(dir, { recursive: true });
+    }
+    fs23.writeFileSync(outputPath, lines.join("\n"));
+  }
+};
+function formatMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const secs = Math.floor(ms / 1e3);
+  const mins = Math.floor(secs / 60);
+  const remSecs = secs % 60;
+  if (mins > 0) return `${mins}m ${remSecs}s`;
+  return `${secs}s`;
+}
+
 // src/commands/onboard.ts
 async function initCommand(options) {
   const brand = chalk8.hex("#EB9D83");
@@ -5245,6 +5370,7 @@ async function initCommand(options) {
   console.log(title.bold("  Welcome to Caliber\n"));
   console.log(chalk8.dim("  Caliber analyzes your codebase and creates tailored config files"));
   console.log(chalk8.dim("  so your AI coding agents understand your project from day one.\n"));
+  const report = options.debugReport ? new DebugReport() : null;
   console.log(title.bold("  How onboarding works:\n"));
   console.log(chalk8.dim("  1. Connect    Set up your LLM provider"));
   console.log(chalk8.dim("  2. Discover   Analyze your code, dependencies, and structure"));
@@ -5276,6 +5402,12 @@ async function initCommand(options) {
   const fastModel = getFastModel();
   const modelLine = fastModel ? `  Provider: ${config.provider} | Model: ${displayModel} | Scan: ${fastModel}` : `  Provider: ${config.provider} | Model: ${displayModel}`;
   console.log(chalk8.dim(modelLine + "\n"));
+  if (report) {
+    report.markStep("Provider setup");
+    report.addSection("LLM Provider", `- **Provider**: ${config.provider}
+- **Model**: ${displayModel}
+- **Fast model**: ${fastModel || "none"}`);
+  }
   await validateModel({ fast: true });
   console.log(title.bold("  Step 2/6 \u2014 Discover your project\n"));
   console.log(chalk8.dim("  Learning about your languages, dependencies, structure, and existing configs.\n"));
@@ -5286,6 +5418,16 @@ async function initCommand(options) {
   console.log(chalk8.dim(`  Languages: ${fingerprint.languages.join(", ") || "none detected"}`));
   console.log(chalk8.dim(`  Files: ${fingerprint.fileTree.length} found
 `));
+  if (report) {
+    report.markStep("Fingerprint");
+    report.addJson("Fingerprint: Git", { remote: fingerprint.remote, 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 targetAgent = options.agent || await promptAgent();
   trackInitAgentSelected(targetAgent);
   const preScore = computeLocalScore(process.cwd(), targetAgent);
@@ -5303,6 +5445,15 @@ async function initCommand(options) {
   displayScoreSummary(baselineScore);
   const passingCount = baselineScore.checks.filter((c) => c.passed).length;
   const failingCount = baselineScore.checks.filter((c) => !c.passed).length;
+  if (report) {
+    report.markStep("Baseline scoring");
+    report.addSection("Scoring: Baseline", `**Score**: ${baselineScore.score}/100
+
+| Check | Passed | Points | Max |
+|-------|--------|--------|-----|
+` + baselineScore.checks.map((c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.points} | ${c.maxPoints} |`).join("\n"));
+    report.addSection("Generation: Target Agents", targetAgent.join(", "));
+  }
   const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length || fingerprint.existingConfigs.agentsMd);
   const NON_LLM_CHECKS = /* @__PURE__ */ new Set(["hooks_configured", "agents_md_exists", "permissions_configured", "mcp_servers"]);
   if (hasExistingConfig && baselineScore.score === 100) {
@@ -5356,6 +5507,11 @@ async function initCommand(options) {
     console.log(chalk8.dim("  Creating config files tailored to your project.\n"));
   }
   console.log(chalk8.dim("  This can take a couple of minutes depending on your model and provider.\n"));
+  if (report) {
+    report.markStep("Generation");
+    const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
+    report.addCodeBlock("Generation: Full LLM Prompt", fullPrompt);
+  }
   trackInitGenerationStarted(!!failingChecks);
   const genStartTime = Date.now();
   const genSpinner = ora2("Generating setup...").start();
@@ -5403,6 +5559,10 @@ async function initCommand(options) {
     }
     throw new Error("__exit__");
   }
+  if (report) {
+    if (rawOutput) report.addCodeBlock("Generation: Raw LLM Response", rawOutput);
+    report.addJson("Generation: Parsed Setup", generatedSetup);
+  }
   const elapsedMs = Date.now() - genStartTime;
   trackInitGenerationCompleted(elapsedMs, 0);
   const mins = Math.floor(elapsedMs / 6e4);
@@ -5550,6 +5710,14 @@ async function initCommand(options) {
     console.log(chalk8.dim("  Run ") + chalk8.hex("#83D1EB")("caliber onboard --force") + chalk8.dim(" to override.\n"));
     return;
   }
+  if (report) {
+    report.markStep("Post-write scoring");
+    report.addSection("Scoring: Post-Write", `**Score**: ${afterScore.score}/100 (delta: ${afterScore.score - baselineScore.score >= 0 ? "+" : ""}${afterScore.score - baselineScore.score})
+
+| Check | Passed | Points | Max |
+|-------|--------|--------|-----|
+` + afterScore.checks.map((c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.points} | ${c.maxPoints} |`).join("\n"));
+  }
   displayScoreDelta(baselineScore, afterScore);
   console.log(title.bold("\n  Step 6/6 \u2014 Community skills\n"));
   console.log(chalk8.dim("  Search public skill registries for skills that match your tech stack.\n"));
@@ -5581,6 +5749,13 @@ async function initCommand(options) {
   console.log(`    ${title("caliber skills")}         Discover community skills for your stack`);
   console.log(`    ${title("caliber undo")}         Revert all changes from this run`);
   console.log("");
+  if (report) {
+    report.markStep("Finished");
+    const reportPath = path19.join(process.cwd(), ".caliber", "debug-report.md");
+    report.write(reportPath);
+    console.log(chalk8.dim(`  Debug report written to ${path19.relative(process.cwd(), reportPath)}
+`));
+  }
 }
 async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
   while (true) {
@@ -5625,7 +5800,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path24, desc]) => `  ${path24}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path26, desc]) => `  ${path26}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -5738,7 +5913,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs22.existsSync("CLAUDE.md") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs24.existsSync("CLAUDE.md") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk8.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5748,7 +5923,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 = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs24.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5759,7 +5934,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs22.existsSync("AGENTS.md") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs24.existsSync("AGENTS.md") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk8.bold("AGENTS.md")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5769,7 +5944,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 = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs24.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5779,7 +5954,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs22.existsSync(".cursorrules") ? chalk8.yellow("~") : chalk8.green("+");
+      const icon = fs24.existsSync(".cursorrules") ? chalk8.yellow("~") : chalk8.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk8.bold(".cursorrules")}`);
       if (desc) console.log(chalk8.dim(`    ${desc}`));
@@ -5789,7 +5964,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 = fs22.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs24.existsSync(skillPath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk8.bold(skillPath)}`);
         console.log(chalk8.dim(`    ${desc || skill.description || skill.name}`));
@@ -5800,7 +5975,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs22.existsSync(rulePath) ? chalk8.yellow("~") : chalk8.green("+");
+        const icon = fs24.existsSync(rulePath) ? chalk8.yellow("~") : chalk8.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk8.bold(rulePath)}`);
         if (desc) {
@@ -5813,7 +5988,7 @@ function printSetupSummary(setup) {
       }
     }
   }
-  if (!codex && !fs22.existsSync("AGENTS.md")) {
+  if (!codex && !fs24.existsSync("AGENTS.md")) {
     console.log(`  ${chalk8.green("+")} ${chalk8.bold("AGENTS.md")}`);
     console.log(chalk8.dim("    Cross-agent coordination file"));
     console.log("");
@@ -5832,8 +6007,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs22.existsSync(settingsPath)) {
-      settings = JSON.parse(fs22.readFileSync(settingsPath, "utf-8"));
+    if (fs24.existsSync(settingsPath)) {
+      settings = JSON.parse(fs24.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -5847,8 +6022,8 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs22.existsSync(".claude")) fs22.mkdirSync(".claude", { recursive: true });
-  fs22.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs24.existsSync(".claude")) fs24.mkdirSync(".claude", { recursive: true });
+  fs24.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 
 // src/commands/undo.ts
@@ -5885,7 +6060,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk10 from "chalk";
-import fs23 from "fs";
+import fs25 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -5912,7 +6087,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk10.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs23.existsSync(entry.path);
+    const exists = fs25.existsSync(entry.path);
     const icon = exists ? chalk10.green("\u2713") : chalk10.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -6093,13 +6268,13 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs25 from "fs";
-import path19 from "path";
+import fs27 from "fs";
+import path21 from "path";
 import chalk13 from "chalk";
 import ora5 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -6113,7 +6288,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync9(cmd, {
+    return execSync10(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -6171,37 +6346,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs24 from "fs";
-import path18 from "path";
+import fs26 from "fs";
+import path20 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs24.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs26.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs24.writeFileSync("README.md", docs.readmeMd);
+    fs26.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs24.writeFileSync(".cursorrules", docs.cursorrules);
+    fs26.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path18.join(".cursor", "rules");
-    if (!fs24.existsSync(rulesDir)) fs24.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path20.join(".cursor", "rules");
+    if (!fs26.existsSync(rulesDir)) fs26.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path18.join(rulesDir, rule.filename);
-      fs24.writeFileSync(filePath, rule.content);
+      const filePath = path20.join(rulesDir, rule.filename);
+      fs26.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path18.join(".claude", "skills");
-    if (!fs24.existsSync(skillsDir)) fs24.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path20.join(".claude", "skills");
+    if (!fs26.existsSync(skillsDir)) fs26.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path18.join(skillsDir, skill.filename);
-      fs24.writeFileSync(filePath, skill.content);
+      const filePath = path20.join(skillsDir, skill.filename);
+      fs26.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -6280,11 +6455,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs25.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs27.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path19.join(parentDir, entry.name);
-      if (fs25.existsSync(path19.join(childPath, ".git"))) {
+      const childPath = path21.join(parentDir, entry.name);
+      if (fs27.existsSync(path21.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -6381,7 +6556,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path19.basename(repo);
+      const repoName = path21.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -6636,8 +6811,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs26 from "fs";
-import path20 from "path";
+import fs28 from "fs";
+import path22 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -6645,15 +6820,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs26.existsSync(LEARNING_DIR)) {
-    fs26.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs28.existsSync(LEARNING_DIR)) {
+    fs28.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path22.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path22.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -6664,50 +6839,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs26.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs28.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs26.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs28.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs26.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs28.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs26.existsSync(filePath)) return [];
-  const lines = fs26.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs28.existsSync(filePath)) return [];
+  const lines = fs28.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs26.existsSync(filePath)) return 0;
-  const content = fs26.readFileSync(filePath, "utf-8");
+  if (!fs28.existsSync(filePath)) return 0;
+  const content = fs28.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs26.existsSync(filePath)) fs26.unlinkSync(filePath);
+  if (fs28.existsSync(filePath)) fs28.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs26.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs28.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs28.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs26.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs28.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs27 from "fs";
-import path21 from "path";
+import fs29 from "fs";
+import path23 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6727,8 +6902,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs27.existsSync(claudeMdPath)) {
-    existing = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (fs29.existsSync(claudeMdPath)) {
+    existing = fs29.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6742,15 +6917,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs27.writeFileSync(claudeMdPath, updated);
+  fs29.writeFileSync(claudeMdPath, updated);
 }
 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 = path23.join(".claude", "skills", skill.name);
+  if (!fs29.existsSync(skillDir)) fs29.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path23.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs29.existsSync(skillPath)) {
+    const existing = fs29.readFileSync(skillPath, "utf-8");
+    fs29.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -6759,14 +6934,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs27.writeFileSync(skillPath, frontmatter + skill.content);
+    fs29.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs27.existsSync(claudeMdPath)) return null;
-  const content = fs27.readFileSync(claudeMdPath, "utf-8");
+  if (!fs29.existsSync(claudeMdPath)) return null;
+  const content = fs29.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6955,9 +7130,9 @@ Learned items in CLAUDE.md: ${chalk16.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path22.dirname(fileURLToPath(import.meta.url));
+var __dirname = path24.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs28.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs30.readFileSync(path24.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -7014,7 +7189,7 @@ function parseAgentOption(value) {
   }
   return agents;
 }
-program.command("onboard").alias("init").description("Onboard your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").action(tracked("onboard", initCommand));
+program.command("onboard").alias("init").description("Onboard your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").option("--debug-report", void 0, false).action(tracked("onboard", initCommand));
 program.command("undo").description("Revert all config changes made by Caliber").action(tracked("undo", undoCommand));
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(tracked("status", statusCommand));
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));
@@ -7031,22 +7206,22 @@ 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 fs29 from "fs";
-import path23 from "path";
+import fs31 from "fs";
+import path25 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import chalk17 from "chalk";
 import ora6 from "ora";
 import confirm from "@inquirer/confirm";
-var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path25.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs29.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs31.readFileSync(path25.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync10("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs29.readFileSync(pkgPath, "utf-8")).version;
+    const globalRoot = execSync11("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const pkgPath = path25.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs31.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -7089,7 +7264,7 @@ Update available: ${current} -> ${latest}`)
     }
     const spinner = ora6("Updating caliber...").start();
     try {
-      execSync10(`npm install -g @rely-ai/caliber@${latest}`, {
+      execSync11(`npm install -g @rely-ai/caliber@${latest}`, {
         stdio: "pipe",
         timeout: 12e4,
         env: { ...process.env, npm_config_fund: "false", npm_config_audit: "false" }
@@ -7106,7 +7281,7 @@ Update available: ${current} -> ${latest}`)
       console.log(chalk17.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
-      execSync10(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
+      execSync11(`caliber ${args.map((a) => JSON.stringify(a)).join(" ")}`, {
         stdio: "inherit",
         env: { ...process.env, CALIBER_SKIP_UPDATE_CHECK: "1" }
       });

package/package.json

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