@rely-ai/caliber 1.30.6 → 1.31.0-dev.1774710550

package/dist/bin.js

@@ -231,20 +231,20 @@ var init_types = __esm({
 });
 
 // src/utils/editor.ts
-import { execSync as execSync13, spawn as spawn3 } from "child_process";
-import fs26 from "fs";
-import path22 from "path";
+import { execSync as execSync14, spawn as spawn3 } from "child_process";
+import fs27 from "fs";
+import path23 from "path";
 import os6 from "os";
 function getEmptyFilePath(proposedPath) {
-  fs26.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path22.join(DIFF_TEMP_DIR, path22.basename(proposedPath));
-  fs26.writeFileSync(tempPath, "");
+  fs27.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path23.join(DIFF_TEMP_DIR, path23.basename(proposedPath));
+  fs27.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync13(check, { stdio: "ignore" });
+    execSync14(check, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -278,7 +278,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path22.join(os6.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path23.join(os6.tmpdir(), "caliber-diff");
   }
 });
 
@@ -290,7 +290,7 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs27 from "fs";
+import fs28 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
@@ -327,8 +327,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs27.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs27.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs28.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs28.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -503,13 +503,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs37 from "fs";
-import path29 from "path";
+import fs38 from "fs";
+import path30 from "path";
 import os8 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs37.existsSync(LOCK_FILE)) return false;
-    const raw = fs37.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs38.existsSync(LOCK_FILE)) return false;
+    const raw = fs38.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -524,13 +524,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs37.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs38.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs37.existsSync(LOCK_FILE)) fs37.unlinkSync(LOCK_FILE);
+    if (fs38.existsSync(LOCK_FILE)) fs38.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -538,7 +538,7 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path29.join(os8.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path30.join(os8.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
@@ -550,9 +550,9 @@ import path38 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path25 from "path";
+import path26 from "path";
 import chalk14 from "chalk";
-import fs32 from "fs";
+import fs33 from "fs";
 
 // src/fingerprint/index.ts
 import fs8 from "fs";
@@ -2450,7 +2450,7 @@ PRIORITY WHEN CONSTRAINTS CONFLICT: Grounding and reference density matter more
 Note: Permissions, hooks, freshness tracking, and OpenSkills frontmatter are scored automatically by caliber \u2014 do not optimize for them.
 README.md is provided for context only \u2014 do NOT include a readmeMd field in your output.`;
 var OUTPUT_SIZE_CONSTRAINTS = `OUTPUT SIZE CONSTRAINTS \u2014 these are critical:
-- CLAUDE.md / AGENTS.md: MUST be under 150 lines for maximum score. Aim for 100-140 lines. Be concise \u2014 commands, architecture overview, and key conventions. Use bullet points and tables, not prose.
+- CLAUDE.md / AGENTS.md: MUST be under 400 lines for maximum score. Aim for 200-350 lines. Be thorough \u2014 commands, architecture overview, key conventions, data flow, and important patterns. Use bullet points and tables, not prose.
 
 Pack project references densely in architecture sections \u2014 use inline paths, not prose paragraphs:
 GOOD: **Entry**: \`src/bin.ts\` \u2192 \`src/cli.ts\` \xB7 **LLM** (\`src/llm/\`): \`anthropic.ts\` \xB7 \`vertex.ts\` \xB7 \`openai-compat.ts\`
@@ -2578,7 +2578,7 @@ Structure:
 5. "## Common Issues" (required) \u2014 specific error messages and their fixes. Not "check your config" but "If you see 'Connection refused on port 5432': 1. Verify postgres is running: docker ps | grep postgres 2. Check .env has correct DATABASE_URL"
 
 Rules:
-- Max 150 lines. Focus on actionable instructions, not documentation prose.
+- Max 400 lines. Focus on actionable instructions, not documentation prose.
 - Study existing code in the project context to extract the real patterns being used. A skill for "create API route" should show the exact file structure, imports, error handling, and naming that existing routes use.
 - Be specific and actionable. GOOD: "Run \`pnpm test -- --filter=api\` to verify". BAD: "Validate the data before proceeding."
 - Never use ambiguous language. Instead of "handle errors properly", write "Wrap the DB call in try/catch. On failure, return { error: string, code: number } matching the ErrorResponse type in \`src/types.ts\`."
@@ -2632,7 +2632,7 @@ Rules:
 - Update the "fileDescriptions" to reflect any changes you make.
 
 Quality constraints \u2014 your changes are scored, so do not break these:
-- CLAUDE.md / AGENTS.md: MUST stay under 150 lines. If adding content, remove less important lines to stay within budget. Do not refuse the user's request \u2014 make the change and trim elsewhere.
+- CLAUDE.md / AGENTS.md: MUST stay under 400 lines. If adding content, remove less important lines to stay within budget. Do not refuse the user's request \u2014 make the change and trim elsewhere.
 - Avoid vague instructions ("follow best practices", "write clean code", "ensure quality").
 - Do NOT add directory tree listings in code blocks.
 - Do NOT remove existing code blocks \u2014 they contribute to the executable content score.
@@ -2656,7 +2656,7 @@ CONSERVATIVE UPDATE means:
 - NEVER replace specific paths/commands with generic prose
 
 Quality constraints (the output is scored deterministically):
-- CLAUDE.md / AGENTS.md: MUST stay under 150 lines. If the diff adds content, trim the least important lines elsewhere.
+- CLAUDE.md / AGENTS.md: MUST stay under 400 lines. If the diff adds content, trim the least important lines elsewhere.
 - Keep 3+ code blocks with executable commands \u2014 do not remove code blocks
 - Every file path, command, and identifier must be in backticks
 - ONLY reference file paths that exist in the provided file tree \u2014 do NOT invent paths
@@ -2664,6 +2664,7 @@ Quality constraints (the output is scored deterministically):
 
 Managed content:
 - Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
+- Keep context sync blocks (<!-- caliber:managed:sync --> ... <!-- /caliber:managed:sync -->) intact
 - Do NOT modify CALIBER_LEARNINGS.md \u2014 it is managed separately
 - Preserve any references to CALIBER_LEARNINGS.md in CLAUDE.md
 
@@ -2679,9 +2680,12 @@ Return a JSON object with this exact shape:
     "copilotInstructionFiles": [{"filename": "name.instructions.md", "content": "..."}] or null
   },
   "changesSummary": "<1-2 sentence summary of what was updated and why>",
+  "fileChanges": [{"file": "CLAUDE.md", "description": "added new API routes, updated build commands"}],
   "docsUpdated": ["CLAUDE.md", "README.md"]
 }
 
+The "fileChanges" array MUST include one entry per file that was updated (non-null in updatedDocs). Each entry describes what specifically changed in that file \u2014 be concrete (e.g. "added auth middleware section" not "updated docs").
+
 Respond with ONLY the JSON object, no markdown fences or extra text.`;
 var LEARN_SYSTEM_PROMPT = `You are an expert developer experience engineer. You analyze raw tool call events from AI coding sessions to extract reusable operational lessons that will help future LLM sessions work more effectively in this project.
 
@@ -3173,9 +3177,151 @@ function getCursorConfigDir() {
   return path8.join(home, ".config", "Cursor");
 }
 
-// src/fingerprint/sources.ts
+// src/lib/hooks.ts
+init_resolve_caliber();
 import fs10 from "fs";
 import path9 from "path";
+import { execSync as execSync8 } from "child_process";
+var SETTINGS_PATH = path9.join(".claude", "settings.json");
+var REFRESH_TAIL = "refresh --quiet";
+var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
+function getHookCommand() {
+  return `${resolveCaliber()} ${REFRESH_TAIL}`;
+}
+function readSettings() {
+  if (!fs10.existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  const dir = path9.dirname(SETTINGS_PATH);
+  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+function findHookIndex(sessionEnd) {
+  return sessionEnd.findIndex(
+    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
+  );
+}
+function isHookInstalled() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) return false;
+  return findHookIndex(sessionEnd) !== -1;
+}
+function installHook() {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionEnd)) settings.hooks.SessionEnd = [];
+  if (findHookIndex(settings.hooks.SessionEnd) !== -1) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  settings.hooks.SessionEnd.push({
+    matcher: "",
+    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
+  });
+  writeSettings(settings);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeHook() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) {
+    return { removed: false, notFound: true };
+  }
+  const idx = findHookIndex(sessionEnd);
+  if (idx === -1) {
+    return { removed: false, notFound: true };
+  }
+  sessionEnd.splice(idx, 1);
+  if (sessionEnd.length === 0) {
+    delete settings.hooks.SessionEnd;
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings);
+  return { removed: true, notFound: false };
+}
+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 ${guard}; then
+  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
+  ${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}`;
+}
+function getGitHooksDir() {
+  try {
+    const gitDir = execSync8("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return path9.join(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+function getPreCommitPath() {
+  const hooksDir = getGitHooksDir();
+  return hooksDir ? path9.join(hooksDir, "pre-commit") : null;
+}
+function isPreCommitHookInstalled() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs10.existsSync(hookPath)) return false;
+  const content = fs10.readFileSync(hookPath, "utf-8");
+  return content.includes(PRECOMMIT_START);
+}
+function installPreCommitHook() {
+  if (isPreCommitHookInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const hookPath = getPreCommitPath();
+  if (!hookPath) return { installed: false, alreadyInstalled: false };
+  const hooksDir = path9.dirname(hookPath);
+  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
+  let content = "";
+  if (fs10.existsSync(hookPath)) {
+    content = fs10.readFileSync(hookPath, "utf-8");
+    if (!content.endsWith("\n")) content += "\n";
+    content += "\n" + getPrecommitBlock() + "\n";
+  } else {
+    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
+  }
+  fs10.writeFileSync(hookPath, content);
+  fs10.chmodSync(hookPath, 493);
+  return { installed: true, alreadyInstalled: false };
+}
+function removePreCommitHook() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs10.existsSync(hookPath)) {
+    return { removed: false, notFound: true };
+  }
+  let content = fs10.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() === "") {
+    fs10.unlinkSync(hookPath);
+  } else {
+    fs10.writeFileSync(hookPath, content);
+  }
+  return { removed: true, notFound: false };
+}
+
+// src/fingerprint/sources.ts
+import fs11 from "fs";
+import path10 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
@@ -3494,7 +3640,7 @@ var SOURCE_CONTENT_LIMIT = 2e3;
 var README_CONTENT_LIMIT = 1e3;
 var ORIGIN_PRIORITY = { cli: 0, config: 1, workspace: 2 };
 function loadSourcesConfig(dir) {
-  const configPath = path9.join(dir, ".caliber", "sources.json");
+  const configPath = path10.join(dir, ".caliber", "sources.json");
   const content = readFileOrNull(configPath);
   if (!content) return [];
   try {
@@ -3512,29 +3658,29 @@ function loadSourcesConfig(dir) {
   }
 }
 function writeSourcesConfig(dir, sources2) {
-  const configDir = path9.join(dir, ".caliber");
-  if (!fs10.existsSync(configDir)) {
-    fs10.mkdirSync(configDir, { recursive: true });
+  const configDir = path10.join(dir, ".caliber");
+  if (!fs11.existsSync(configDir)) {
+    fs11.mkdirSync(configDir, { recursive: true });
   }
-  const configPath = path9.join(configDir, "sources.json");
-  fs10.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  const configPath = path10.join(configDir, "sources.json");
+  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs10.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
 }
 function isInsideDir(childPath, parentDir) {
-  const relative2 = path9.relative(parentDir, childPath);
-  return !relative2.startsWith("..") && !path9.isAbsolute(relative2);
+  const relative2 = path10.relative(parentDir, childPath);
+  return !relative2.startsWith("..") && !path10.isAbsolute(relative2);
 }
 function resolveAllSources(dir, cliSources, workspaces) {
   const seen = /* @__PURE__ */ new Map();
-  const projectRoot = path9.resolve(dir);
+  const projectRoot = path10.resolve(dir);
   for (const src of cliSources) {
-    const absPath = path9.resolve(dir, src);
+    const absPath = path10.resolve(dir, src);
     if (seen.has(absPath)) continue;
     const type = detectSourceType(absPath);
     seen.set(absPath, {
@@ -3547,12 +3693,12 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const cfg of configSources) {
     if (cfg.type === "url") continue;
     if (!cfg.path) continue;
-    const absPath = path9.resolve(dir, cfg.path);
+    const absPath = path10.resolve(dir, cfg.path);
     if (seen.has(absPath)) continue;
     seen.set(absPath, { absPath, config: cfg, origin: "config" });
   }
   for (const ws of workspaces) {
-    const absPath = path9.resolve(dir, ws);
+    const absPath = path10.resolve(dir, ws);
     if (seen.has(absPath)) continue;
     if (!isInsideDir(absPath, projectRoot)) continue;
     seen.set(absPath, {
@@ -3565,7 +3711,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs10.statSync(absPath);
+      stat = fs11.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -3594,13 +3740,13 @@ function collectSourceSummary(resolved, projectDir) {
   if (config.type === "file") {
     return collectFileSummary(resolved, projectDir);
   }
-  const summaryPath = path9.join(absPath, ".caliber", "summary.json");
+  const summaryPath = path10.join(absPath, ".caliber", "summary.json");
   const summaryContent = readFileOrNull(summaryPath);
   if (summaryContent) {
     try {
       const published = JSON.parse(summaryContent);
       return {
-        name: published.name || path9.basename(absPath),
+        name: published.name || path10.basename(absPath),
         type: "repo",
         role: config.role || published.role || "related-repo",
         description: config.description || published.description || "",
@@ -3620,18 +3766,18 @@ function collectRepoSummary(resolved, projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs10.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs11.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 {
   }
-  const claudeMdContent = readFileOrNull(path9.join(absPath, "CLAUDE.md"));
+  const claudeMdContent = readFileOrNull(path10.join(absPath, "CLAUDE.md"));
   const existingClaudeMd = claudeMdContent ? claudeMdContent.slice(0, SOURCE_CONTENT_LIMIT) : void 0;
-  const readmeContent = readFileOrNull(path9.join(absPath, "README.md"));
+  const readmeContent = readFileOrNull(path10.join(absPath, "README.md"));
   const readmeExcerpt = readmeContent ? readmeContent.slice(0, README_CONTENT_LIMIT) : void 0;
   const gitRemoteUrl = getGitRemoteUrl(absPath);
   return {
-    name: packageName || path9.basename(absPath),
+    name: packageName || path10.basename(absPath),
     type: "repo",
     role: config.role || "related-repo",
     description: config.description || "",
@@ -3648,7 +3794,7 @@ function collectFileSummary(resolved, projectDir) {
   const { config, origin, absPath } = resolved;
   const content = readFileOrNull(absPath);
   return {
-    name: path9.basename(absPath),
+    name: path10.basename(absPath),
     type: "file",
     role: config.role || "reference-doc",
     description: config.description || content?.slice(0, 100).split("\n")[0] || "",
@@ -4287,39 +4433,52 @@ ${f.content}
 }
 
 // src/writers/index.ts
-import fs18 from "fs";
+import fs19 from "fs";
 
 // src/writers/claude/index.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 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 MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
 function getPreCommitBlock() {
   const bin = resolveCaliber();
   return `${BLOCK_START}
 ## Before Committing
 
-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:
+**IMPORTANT:** Before every git commit, you MUST ensure Caliber syncs agent configs with the latest code changes.
 
+First, check if the pre-commit hook is already installed:
 \`\`\`bash
-${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null
+grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"
 \`\`\`
+
+- If **hook-active**: the hook handles sync automatically \u2014 just commit normally. Tell the user: "Caliber will sync your agent configs automatically via the pre-commit hook."
+- If **no-hook**: run Caliber manually before committing:
+  1. Tell the user: "Caliber: Syncing agent configs with your latest changes..."
+  2. Run: \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\`
+  3. After it completes, briefly tell the user what Caliber updated. Then proceed with the commit.
+
+If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Install it with: npm install -g @rely-ai/caliber"
 ${BLOCK_END}`;
 }
 var CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
 function getCursorRuleContent() {
   const bin = resolveCaliber();
   return `---
-description: Run caliber refresh before git commits to keep docs in sync
+description: Run Caliber sync before git commits to keep agent configs up to date
 alwaysApply: true
 ---
-Before creating git commits, run \`${bin} refresh\` to update docs based on code changes,
-then stage modified doc files (${MANAGED_DOC_PATHS}).
+Before every git commit, check if the Caliber pre-commit hook is installed:
+Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"\`
+
+If hook-active: just commit normally \u2014 Caliber syncs automatically via the hook. Tell the user: "Caliber will sync your agent configs automatically."
+If no-hook: run \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\` before committing, and tell the user what was updated.
+
+If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Install with: npm install -g @rely-ai/caliber"
 `;
 }
 function hasPreCommitBlock(content) {
@@ -4360,17 +4519,52 @@ function appendLearningsBlock(content) {
 function getCursorLearningsRule() {
   return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
 }
+var SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
+var SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
+function getSyncBlock() {
+  const bin = resolveCaliber();
+  return `${SYNC_BLOCK_START}
+## Context Sync
+
+This project uses [Caliber](https://github.com/rely-ai/caliber) to keep AI agent configs in sync across Claude Code, Cursor, Copilot, and Codex.
+Configs update automatically before each commit via \`${bin} refresh\`.
+If the pre-commit hook is not set up, run \`${bin} hooks --install\` to enable automatic sync.
+${SYNC_BLOCK_END}`;
+}
+function hasSyncBlock(content) {
+  return content.includes(SYNC_BLOCK_START);
+}
+function appendSyncBlock(content) {
+  if (hasSyncBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + getSyncBlock() + "\n";
+}
+var CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
+function getCursorSyncContent() {
+  const bin = resolveCaliber();
+  return `---
+description: This project uses Caliber for automatic AI agent context sync
+alwaysApply: true
+---
+This project uses Caliber to keep AI agent configs (CLAUDE.md, Cursor rules, Copilot instructions)
+in sync with the codebase automatically. Before each commit, run \`${bin} refresh\` to sync configs.
+If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Install with: npm install -g @rely-ai/caliber"
+`;
+}
+function getCursorSyncRule() {
+  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
+}
 
 // src/writers/claude/index.ts
 function writeClaudeConfig(config) {
   const written = [];
-  fs11.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
+  fs12.writeFileSync("CLAUDE.md", appendSyncBlock(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 (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path10.join(skillDir, "SKILL.md");
+      const skillDir = path11.join(".claude", "skills", skill.name);
+      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path11.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4378,50 +4572,51 @@ function writeClaudeConfig(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) {
     let existingServers = {};
     try {
-      if (fs11.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs11.readFileSync(".mcp.json", "utf-8"));
+      if (fs12.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs11.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
 }
 
 // src/writers/cursor/index.ts
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs12.writeFileSync(".cursorrules", config.cursorrules);
+    fs13.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 (!fs12.existsSync(rulesDir)) fs12.mkdirSync(rulesDir, { recursive: true });
+  const syncRule = getCursorSyncRule();
+  const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule];
+  const rulesDir = path12.join(".cursor", "rules");
+  if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
-    const rulePath = path11.join(rulesDir, rule.filename);
-    fs12.writeFileSync(rulePath, rule.content);
+    const rulePath = path12.join(rulesDir, rule.filename);
+    fs13.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 (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path11.join(skillDir, "SKILL.md");
+      const skillDir = path12.join(".cursor", "skills", skill.name);
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4429,41 +4624,41 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs12.writeFileSync(skillPath, frontmatter + skill.content);
+      fs13.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs12.existsSync(cursorDir)) fs12.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path11.join(cursorDir, "mcp.json");
+    if (!fs13.existsSync(cursorDir)) fs13.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path12.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs12.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs12.readFileSync(mcpPath, "utf-8"));
+      if (fs13.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs12.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
 }
 
 // src/writers/codex/index.ts
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs13.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  fs14.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 (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path12.join(skillDir, "SKILL.md");
+      const skillDir = path13.join(".agents", "skills", skill.name);
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path13.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4471,7 +4666,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -4479,20 +4674,20 @@ function writeCodexConfig(config) {
 }
 
 // src/writers/github-copilot/index.ts
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs14.mkdirSync(".github", { recursive: true });
-    fs14.writeFileSync(path13.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
+    fs15.mkdirSync(".github", { recursive: true });
+    fs15.writeFileSync(path14.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.instructions))));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
-    const instructionsDir = path13.join(".github", "instructions");
-    fs14.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path14.join(".github", "instructions");
+    fs15.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs14.writeFileSync(path13.join(instructionsDir, file.filename), file.content);
+      fs15.writeFileSync(path14.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -4500,37 +4695,37 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path15 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path14.join(BACKUPS_DIR, timestamp);
+  const backupDir = path15.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs15.existsSync(file)) continue;
-    const dest = path14.join(backupDir, file);
-    const destDir = path14.dirname(dest);
-    if (!fs15.existsSync(destDir)) {
-      fs15.mkdirSync(destDir, { recursive: true });
+    if (!fs16.existsSync(file)) continue;
+    const dest = path15.join(backupDir, file);
+    const destDir = path15.dirname(dest);
+    if (!fs16.existsSync(destDir)) {
+      fs16.mkdirSync(destDir, { recursive: true });
     }
-    fs15.copyFileSync(file, dest);
+    fs16.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path14.join(backupDir, file);
-  if (!fs15.existsSync(backupFile)) return false;
-  const destDir = path14.dirname(file);
-  if (!fs15.existsSync(destDir)) {
-    fs15.mkdirSync(destDir, { recursive: true });
+  const backupFile = path15.join(backupDir, file);
+  if (!fs16.existsSync(backupFile)) return false;
+  const destDir = path15.dirname(file);
+  if (!fs16.existsSync(destDir)) {
+    fs16.mkdirSync(destDir, { recursive: true });
   }
-  fs15.copyFileSync(backupFile, file);
+  fs16.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/lib/builtin-skills.ts
 init_resolve_caliber();
-import fs16 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path16 from "path";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -4666,21 +4861,128 @@ var SAVE_LEARNING_SKILL = {
     return getSaveLearningContent();
   }
 };
-var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL];
+function getSetupCaliberContent() {
+  const bin = resolveCaliber();
+  return `# Setup Caliber
+
+Set up Caliber for automatic AI agent context sync on this project.
+Caliber keeps your CLAUDE.md, Cursor rules, Copilot instructions, and Codex configs
+in sync with your codebase \u2014 automatically on every commit.
+
+## Instructions
+
+1. Check if Caliber is already set up locally:
+   \`\`\`bash
+   grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"
+   \`\`\`
+
+2. If **hook-active**, tell the user: "Caliber is already set up on this repo.
+   Your agent configs update automatically on every commit." Then stop.
+
+3. If **no-hook**, ask the user: "Are you setting up Caliber for yourself (solo)
+   or for your team?"
+
+### Solo Setup
+
+a. Tell the user: "I'll set up Caliber to sync your agent configs automatically
+   on every commit."
+b. Install the pre-commit hook:
+   \`\`\`bash
+   ${bin} hooks --install
+   \`\`\`
+c. Run a refresh to make sure configs are current:
+   \`\`\`bash
+   ${bin} refresh
+   \`\`\`
+d. Tell the user what happened and that configs will auto-sync on every commit.
+
+### Team Setup
+
+a. Tell the user: "I'll set up Caliber for your team \u2014 local hooks for you,
+   plus a GitHub Action for automatic sync across the team."
+b. Install the local pre-commit hook:
+   \`\`\`bash
+   ${bin} hooks --install
+   \`\`\`
+c. Run a refresh:
+   \`\`\`bash
+   ${bin} refresh
+   \`\`\`
+d. Create the GitHub Action workflow for nightly sync. Write this file to
+   \`.github/workflows/caliber-sync.yml\`:
+   \`\`\`yaml
+   name: Caliber Sync
+   on:
+     schedule:
+       - cron: '0 3 * * 1-5'
+     pull_request:
+       types: [opened, synchronize]
+     workflow_dispatch:
+   jobs:
+     sync:
+       runs-on: ubuntu-latest
+       steps:
+         - uses: actions/checkout@v4
+         - uses: caliber-ai-org/ai-setup@v1
+           with:
+             mode: sync
+             auto-refresh: true
+             comment: true
+             github-token: \${{ secrets.GITHUB_TOKEN }}
+           env:
+             ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+   \`\`\`
+e. Tell the user: "Created the GitHub Action workflow. Add your ANTHROPIC_API_KEY
+   to your repo secrets (Settings \u2192 Secrets \u2192 Actions), then commit and push this
+   workflow file. From now on, every PR gets a Caliber sync check and configs
+   refresh nightly."
+f. Offer to commit the workflow file and the updated configs.
+
+### If \`${bin}\` is not found
+
+Install it first:
+\`\`\`bash
+npm install -g @rely-ai/caliber
+\`\`\`
+Or use npx (no install needed):
+\`\`\`bash
+npx @rely-ai/caliber hooks --install
+\`\`\`
+
+## When to trigger
+
+- When a developer first opens this project and Caliber hooks are not installed
+- When the user asks about keeping agent configs up to date
+- When the user asks "how do I set up Caliber" or "what is Caliber"
+
+## When NOT to trigger
+
+- Hooks are already installed and working
+- The user is in the middle of time-sensitive work
+`;
+}
+var SETUP_CALIBER_SKILL = {
+  name: "setup-caliber",
+  description: "Sets up Caliber for automatic AI agent context sync. Installs pre-commit hooks so CLAUDE.md, Cursor rules, and Copilot instructions update automatically on every commit. Use when Caliber hooks are not yet installed or when the user asks about keeping agent configs in sync.",
+  get content() {
+    return getSetupCaliberContent();
+  }
+};
+var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL, SETUP_CALIBER_SKILL];
 var PLATFORM_CONFIGS = [
-  { platformDir: ".claude", skillsDir: path15.join(".claude", "skills") },
-  { platformDir: ".cursor", skillsDir: path15.join(".cursor", "skills") },
-  { platformDir: ".agents", skillsDir: path15.join(".agents", "skills") }
+  { platformDir: ".claude", skillsDir: path16.join(".claude", "skills") },
+  { platformDir: ".cursor", skillsDir: path16.join(".cursor", "skills") },
+  { platformDir: ".agents", skillsDir: path16.join(".agents", "skills") }
 ];
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs16.existsSync(platformDir)) continue;
+    if (!fs17.existsSync(platformDir)) continue;
     for (const skill of BUILTIN_SKILLS) {
-      const skillPath = path15.join(skillsDir, skill.name, "SKILL.md");
-      if (fs16.existsSync(skillPath)) continue;
-      fs16.mkdirSync(path15.dirname(skillPath), { recursive: true });
-      fs16.writeFileSync(skillPath, buildSkillContent(skill));
+      const skillPath = path16.join(skillsDir, skill.name, "SKILL.md");
+      if (fs17.existsSync(skillPath)) continue;
+      fs17.mkdirSync(path16.dirname(skillPath), { recursive: true });
+      fs17.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -4688,33 +4990,33 @@ function ensureBuiltinSkills() {
 }
 
 // src/writers/manifest.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs17.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs17.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs18.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs18.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs17.existsSync(CALIBER_DIR)) {
-    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs18.existsSync(CALIBER_DIR)) {
+    fs18.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs17.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs18.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs17.readFileSync(filePath);
+  const content = fs18.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) => fs18.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs19.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs18.existsSync(f)),
+    ...filesToWrite.filter((f) => fs19.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
@@ -4733,7 +5035,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs18.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
     deleted.push(filePath);
   }
   written.push(...ensureBuiltinSkills());
@@ -4764,8 +5066,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs18.existsSync(entry.path)) {
-        fs18.unlinkSync(entry.path);
+      if (fs19.existsSync(entry.path)) {
+        fs19.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -4774,8 +5076,8 @@ function undoSetup() {
       }
     }
   }
-  if (fs18.existsSync(MANIFEST_FILE)) {
-    fs18.unlinkSync(MANIFEST_FILE);
+  if (fs19.existsSync(MANIFEST_FILE)) {
+    fs19.unlinkSync(MANIFEST_FILE);
   }
   return { restored, removed };
 }
@@ -4816,22 +5118,22 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs18.existsSync(gitignorePath)) {
-    const content = fs18.readFileSync(gitignorePath, "utf-8");
+  if (fs19.existsSync(gitignorePath)) {
+    const content = fs19.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs18.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs19.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs18.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs19.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
-import fs19 from "fs";
-import path16 from "path";
-var STAGED_DIR = path16.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path16.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path16.join(STAGED_DIR, "current");
+import fs20 from "fs";
+import path17 from "path";
+var STAGED_DIR = path17.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path17.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path17.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4841,20 +5143,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path16.join(projectDir, file.path);
-    if (fs19.existsSync(originalPath)) {
-      const existing = fs19.readFileSync(originalPath, "utf-8");
+    const originalPath = path17.join(projectDir, file.path);
+    if (fs20.existsSync(originalPath)) {
+      const existing = fs20.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path16.join(PROPOSED_DIR, file.path);
-    fs19.mkdirSync(path16.dirname(proposedPath), { recursive: true });
-    fs19.writeFileSync(proposedPath, file.content);
-    if (fs19.existsSync(originalPath)) {
-      const currentPath = path16.join(CURRENT_DIR, file.path);
-      fs19.mkdirSync(path16.dirname(currentPath), { recursive: true });
-      fs19.copyFileSync(originalPath, currentPath);
+    const proposedPath = path17.join(PROPOSED_DIR, file.path);
+    fs20.mkdirSync(path17.dirname(proposedPath), { recursive: true });
+    fs20.writeFileSync(proposedPath, file.content);
+    if (fs20.existsSync(originalPath)) {
+      const currentPath = path17.join(CURRENT_DIR, file.path);
+      fs20.mkdirSync(path17.dirname(currentPath), { recursive: true });
+      fs20.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -4865,13 +5167,13 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs19.existsSync(STAGED_DIR)) {
-    fs19.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs20.existsSync(STAGED_DIR)) {
+    fs20.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs20 from "fs";
+import fs21 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -4930,7 +5232,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs20.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs21.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.");
@@ -4948,9 +5250,9 @@ ${agentRefs.join(" ")}
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs21 from "fs";
-import path17 from "path";
-var SETTINGS_PATH = path17.join(".claude", "settings.json");
+import fs22 from "fs";
+import path18 from "path";
+var SETTINGS_PATH2 = path18.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -4966,24 +5268,24 @@ function getHookConfigs() {
     description
   }));
 }
-function readSettings() {
-  if (!fs21.existsSync(SETTINGS_PATH)) return {};
+function readSettings2() {
+  if (!fs22.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs21.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs22.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
-function writeSettings(settings) {
-  const dir = path17.dirname(SETTINGS_PATH);
-  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
-  fs21.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+function writeSettings2(settings) {
+  const dir = path18.dirname(SETTINGS_PATH2);
+  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+  fs22.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
 }
 function areLearningHooksInstalled() {
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) return false;
   return HOOK_TAILS.every((cfg) => {
     const matchers = settings.hooks[cfg.event];
@@ -4994,7 +5296,7 @@ function installLearningHooks() {
   if (areLearningHooksInstalled()) {
     return { installed: false, alreadyInstalled: true };
   }
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) settings.hooks = {};
   const configs = getHookConfigs();
   for (const cfg of configs) {
@@ -5008,10 +5310,10 @@ function installLearningHooks() {
       });
     }
   }
-  writeSettings(settings);
+  writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path17.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path18.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -5019,17 +5321,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs21.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs22.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs21.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs22.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path17.dirname(CURSOR_HOOKS_PATH);
-  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
-  fs21.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path18.dirname(CURSOR_HOOKS_PATH);
+  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+  fs22.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -5076,7 +5378,7 @@ function removeCursorLearningHooks() {
   return { removed: true, notFound: false };
 }
 function removeLearningHooks() {
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) return { removed: false, notFound: true };
   let removedAny = false;
   for (const cfg of HOOK_TAILS) {
@@ -5093,7 +5395,7 @@ function removeLearningHooks() {
     delete settings.hooks;
   }
   if (!removedAny) return { removed: false, notFound: true };
-  writeSettings(settings);
+  writeSettings2(settings);
   return { removed: true, notFound: false };
 }
 
@@ -5101,10 +5403,10 @@ function removeLearningHooks() {
 init_resolve_caliber();
 
 // src/lib/state.ts
-import fs22 from "fs";
-import path18 from "path";
-import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path18.join(CALIBER_DIR, ".caliber-state.json");
+import fs23 from "fs";
+import path19 from "path";
+import { execSync as execSync9 } from "child_process";
+var STATE_FILE = path19.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -5115,8 +5417,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs22.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs22.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs23.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs23.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -5124,14 +5426,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs22.existsSync(CALIBER_DIR)) {
-    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs23.existsSync(CALIBER_DIR)) {
+    fs23.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs22.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs23.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync8("git rev-parse HEAD", {
+    return execSync9("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -5278,11 +5580,11 @@ var POINTS_LEARNED_CONTENT = 2;
 var POINTS_SOURCES_CONFIGURED = 3;
 var POINTS_SOURCES_REFERENCED = 3;
 var TOKEN_BUDGET_THRESHOLDS = [
-  { maxTokens: 2e3, points: 6 },
-  { maxTokens: 3500, points: 5 },
-  { maxTokens: 5e3, points: 4 },
-  { maxTokens: 8e3, points: 2 },
-  { maxTokens: 12e3, points: 1 }
+  { maxTokens: 5e3, points: 6 },
+  { maxTokens: 8e3, points: 5 },
+  { maxTokens: 12e3, points: 4 },
+  { maxTokens: 16e3, points: 2 },
+  { maxTokens: 24e3, points: 1 }
 ];
 var CODE_BLOCK_THRESHOLDS = [
   { minBlocks: 3, points: 8 },
@@ -5744,7 +6046,7 @@ function checkGrounding(dir) {
 
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync4, statSync as statSync2 } from "fs";
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import { join as join5 } from "path";
 init_resolve_caliber();
 function validateReferences(dir) {
@@ -5754,13 +6056,13 @@ function validateReferences(dir) {
 }
 function detectGitDrift(dir) {
   try {
-    execSync9("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync10("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
   } catch {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: false };
   }
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules", ".cursor/rules"];
   try {
-    const headTimestamp = execSync9(
+    const headTimestamp = execSync10(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5781,7 +6083,7 @@ function detectGitDrift(dir) {
   let latestConfigCommitHash = null;
   for (const file of configFiles) {
     try {
-      const hash = execSync9(
+      const hash = execSync10(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -5790,7 +6092,7 @@ function detectGitDrift(dir) {
         latestConfigCommitHash = hash;
       } else {
         try {
-          execSync9(
+          execSync10(
             `git merge-base --is-ancestor ${latestConfigCommitHash} ${hash}`,
             { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }
           );
@@ -5805,12 +6107,12 @@ function detectGitDrift(dir) {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: true };
   }
   try {
-    const countStr = execSync9(
+    const countStr = execSync10(
       `git rev-list --count ${latestConfigCommitHash}..HEAD`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     const commitsSince = parseInt(countStr, 10) || 0;
-    const lastDate = execSync9(
+    const lastDate = execSync10(
       `git log -1 --format=%ci ${latestConfigCommitHash}`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5883,12 +6185,12 @@ 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 { execSync as execSync11 } from "child_process";
 import { join as join6 } from "path";
 function getCommitsSinceConfigUpdate(dir) {
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules"];
   try {
-    const headTimestamp = execSync10(
+    const headTimestamp = execSync11(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5908,12 +6210,12 @@ function getCommitsSinceConfigUpdate(dir) {
   }
   for (const file of configFiles) {
     try {
-      const hash = execSync10(
+      const hash = execSync11(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
       if (hash) {
-        const countStr = execSync10(
+        const countStr = execSync11(
           `git rev-list --count ${hash}..HEAD`,
           { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -6031,12 +6333,12 @@ function checkFreshness(dir) {
 
 // src/scoring/checks/bonus.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
-import { execSync as execSync11 } from "child_process";
+import { execSync as execSync12 } 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();
+    const gitDir = execSync12("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join7(gitDir, "hooks", "pre-commit");
     const content = readFileOrNull(hookPath);
     return content ? content.includes("caliber") : false;
@@ -6193,22 +6495,22 @@ function checkSources(dir) {
 }
 
 // src/scoring/dismissed.ts
-import fs23 from "fs";
-import path19 from "path";
-var DISMISSED_FILE = path19.join(CALIBER_DIR, "dismissed-checks.json");
+import fs24 from "fs";
+import path20 from "path";
+var DISMISSED_FILE = path20.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs23.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs23.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs24.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs24.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs23.existsSync(CALIBER_DIR)) {
-    fs23.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs24.existsSync(CALIBER_DIR)) {
+    fs24.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs23.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs24.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -6463,27 +6765,27 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs24 from "fs";
-import path20 from "path";
+import fs25 from "fs";
+import path21 from "path";
 import os5 from "os";
 import crypto4 from "crypto";
-import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path20.join(os5.homedir(), ".caliber");
-var CONFIG_FILE2 = path20.join(CONFIG_DIR2, "config.json");
+import { execSync as execSync13 } from "child_process";
+var CONFIG_DIR2 = path21.join(os5.homedir(), ".caliber");
+var CONFIG_FILE2 = path21.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs24.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs24.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs25.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs25.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs24.existsSync(CONFIG_DIR2)) {
-    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs25.existsSync(CONFIG_DIR2)) {
+    fs25.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs25.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6495,7 +6797,7 @@ function getMachineId() {
 var EMAIL_HASH_KEY = "caliber-telemetry-v1";
 function getGitEmailHash() {
   try {
-    const email = execSync12("git config user.email", { encoding: "utf-8" }).trim();
+    const email = execSync13("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
     return crypto4.createHmac("sha256", EMAIL_HASH_KEY).update(email).digest("hex");
   } catch {
@@ -7694,8 +7996,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 
 // src/lib/debug-report.ts
-import fs25 from "fs";
-import path21 from "path";
+import fs26 from "fs";
+import path22 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -7764,11 +8066,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path21.dirname(outputPath);
-    if (!fs25.existsSync(dir)) {
-      fs25.mkdirSync(dir, { recursive: true });
+    const dir = path22.dirname(outputPath);
+    if (!fs26.existsSync(dir)) {
+      fs26.mkdirSync(dir, { recursive: true });
     }
-    fs25.writeFileSync(outputPath, lines.join("\n"));
+    fs26.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -8169,7 +8471,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs28 from "fs";
+import fs29 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -8310,10 +8612,10 @@ init_config();
 init_review();
 function detectAgents(dir) {
   const agents = [];
-  if (fs28.existsSync(`${dir}/.claude`)) agents.push("claude");
-  if (fs28.existsSync(`${dir}/.cursor`)) agents.push("cursor");
-  if (fs28.existsSync(`${dir}/.agents`) || fs28.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
-  if (fs28.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
+  if (fs29.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs29.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs29.existsSync(`${dir}/.agents`) || fs29.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs29.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
@@ -8435,18 +8737,18 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs29 from "fs";
+import fs30 from "fs";
 function formatWhatChanged(setup) {
   const lines = [];
   const claude = setup.claude;
   const codex = setup.codex;
   const cursor = setup.cursor;
   if (claude?.claudeMd) {
-    const action = fs29.existsSync("CLAUDE.md") ? "Updated" : "Created";
+    const action = fs30.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   if (codex?.agentsMd) {
-    const action = fs29.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs30.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -8483,7 +8785,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs29.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk12.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8493,7 +8795,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 = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8504,7 +8806,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs29.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8514,7 +8816,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 = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8524,7 +8826,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs29.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8534,7 +8836,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 = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8545,7 +8847,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rulesArr) && rulesArr.length > 0) {
       for (const rule of rulesArr) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs29.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -8592,12 +8894,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs30 from "fs";
-import path23 from "path";
+import fs31 from "fs";
+import path24 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path23.join(dir, ".caliber");
+  const caliberDir = path24.join(dir, ".caliber");
   try {
-    const stat = fs30.statSync(caliberDir);
+    const stat = fs31.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -8650,8 +8952,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs30.existsSync(settingsPath)) {
-      settings = JSON.parse(fs30.readFileSync(settingsPath, "utf-8"));
+    if (fs31.existsSync(settingsPath)) {
+      settings = JSON.parse(fs31.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -8660,12 +8962,12 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs30.existsSync(".claude")) fs30.mkdirSync(".claude", { recursive: true });
-  fs30.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs31.existsSync(".claude")) fs31.mkdirSync(".claude", { recursive: true });
+  fs31.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path23.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path24.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -8678,8 +8980,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs30.mkdirSync(path23.join(process.cwd(), ".caliber"), { recursive: true });
-    fs30.writeFileSync(logPath, lines.join("\n"));
+    fs31.mkdirSync(path24.join(process.cwd(), ".caliber"), { recursive: true });
+    fs31.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8730,13 +9032,13 @@ ${JSON.stringify(checkList, null, 2)}`,
 }
 
 // src/scoring/history.ts
-import fs31 from "fs";
-import path24 from "path";
+import fs32 from "fs";
+import path25 from "path";
 var HISTORY_FILE = "score-history.jsonl";
 var MAX_ENTRIES = 500;
 var TRIM_THRESHOLD = MAX_ENTRIES + 50;
 function historyFilePath() {
-  return path24.join(CALIBER_DIR, HISTORY_FILE);
+  return path25.join(CALIBER_DIR, HISTORY_FILE);
 }
 function recordScore(result, trigger) {
   const entry = {
@@ -8747,14 +9049,14 @@ function recordScore(result, trigger) {
     trigger
   };
   try {
-    fs31.mkdirSync(CALIBER_DIR, { recursive: true });
+    fs32.mkdirSync(CALIBER_DIR, { recursive: true });
     const filePath = historyFilePath();
-    fs31.appendFileSync(filePath, JSON.stringify(entry) + "\n");
-    const stat = fs31.statSync(filePath);
+    fs32.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+    const stat = fs32.statSync(filePath);
     if (stat.size > TRIM_THRESHOLD * 120) {
-      const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+      const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
       if (lines.length > MAX_ENTRIES) {
-        fs31.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
+        fs32.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
       }
     }
   } catch {
@@ -8763,7 +9065,7 @@ function recordScore(result, trigger) {
 function readScoreHistory() {
   const filePath = historyFilePath();
   try {
-    const content = fs31.readFileSync(filePath, "utf-8");
+    const content = fs32.readFileSync(filePath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       if (!line) continue;
@@ -8809,13 +9111,13 @@ async function initCommand(options) {
   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
   `));
-    console.log(chalk14.dim("  Scan your project and generate tailored config files for"));
-    console.log(chalk14.dim("  Claude Code, Cursor, Codex, and GitHub Copilot.\n"));
+    console.log(chalk14.dim("  Keep your AI agent configs in sync \u2014 automatically."));
+    console.log(chalk14.dim("  Works across Claude Code, Cursor, Codex, and GitHub Copilot.\n"));
     console.log(title.bold("  How it works:\n"));
     console.log(chalk14.dim("  1. Connect    Link your LLM provider and select your agents"));
     console.log(chalk14.dim("  2. Engine     Detect stack, generate configs & skills in parallel"));
     console.log(chalk14.dim("  3. Review     See all changes \u2014 accept, refine, or decline"));
-    console.log(chalk14.dim("  4. Finalize   Score check and auto-sync hooks\n"));
+    console.log(chalk14.dim("  4. Finalize   Install sync hooks and score your setup\n"));
   } else {
     console.log(brand.bold("\n  CALIBER") + chalk14.dim("  \u2014 regenerating config\n"));
   }
@@ -9186,7 +9488,7 @@ async function initCommand(options) {
   const { default: ora9 } = await import("ora");
   const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs32.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs33.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -9229,6 +9531,12 @@ ${agentRefs.join(" ")}
     throw new Error("__exit__");
   }
   if (fingerprint) ensurePermissions(fingerprint);
+  const hookResult = installPreCommitHook();
+  if (hookResult.installed) {
+    console.log(`  ${chalk14.green("\u2713")} Pre-commit hook installed \u2014 configs sync on every commit`);
+  } else if (hookResult.alreadyInstalled) {
+    console.log(chalk14.dim("  Pre-commit hook already installed"));
+  }
   const sha = getCurrentHeadSha();
   writeState({
     lastRefreshSha: sha ?? "",
@@ -9306,9 +9614,9 @@ ${agentRefs.join(" ")}
       if (targetAgent.includes("cursor")) installCursorLearningHooks();
     }
   }
-  console.log(chalk14.bold.green("\n  Configuration complete!"));
-  console.log(chalk14.dim("  Your AI agents now understand your project's architecture, build commands,"));
-  console.log(chalk14.dim("  testing patterns, and conventions. All changes are backed up automatically.\n"));
+  console.log(chalk14.bold.green("\n  Caliber is set up!"));
+  console.log(chalk14.dim("  Your AI agent configs will now stay in sync with your codebase automatically."));
+  console.log(chalk14.dim("  Every commit refreshes configs for all your agents. All changes are backed up.\n"));
   const done = chalk14.green("\u2713");
   const skip = chalk14.dim("\u2013");
   console.log(chalk14.bold("  What was configured:\n"));
@@ -9336,9 +9644,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path25.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path26.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk14.dim(`  Debug report written to ${path25.relative(process.cwd(), reportPath)}
+    console.log(chalk14.dim(`  Debug report written to ${path26.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -9377,7 +9685,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs33 from "fs";
+import fs34 from "fs";
 init_config();
 init_resolve_caliber();
 async function statusCommand(options) {
@@ -9406,7 +9714,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs33.existsSync(entry.path);
+    const exists = fs34.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -9563,9 +9871,9 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs34 from "fs";
+import fs35 from "fs";
 import os7 from "os";
-import path26 from "path";
+import path27 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import chalk18 from "chalk";
 init_resolve_caliber();
@@ -9573,12 +9881,12 @@ var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs34.mkdtempSync(path26.join(os7.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs35.mkdtempSync(path27.join(os7.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
         const content = execFileSync2("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        fs34.writeFileSync(path26.join(tmpDir, file), content);
+        fs35.writeFileSync(path27.join(tmpDir, file), content);
       } catch {
       }
     }
@@ -9586,10 +9894,10 @@ function scoreBaseRef(ref, target) {
       try {
         const files = execFileSync2("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean);
         for (const file of files) {
-          const filePath = path26.join(tmpDir, file);
-          fs34.mkdirSync(path26.dirname(filePath), { recursive: true });
+          const filePath = path27.join(tmpDir, file);
+          fs35.mkdirSync(path27.dirname(filePath), { recursive: true });
           const content = execFileSync2("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-          fs34.writeFileSync(filePath, content);
+          fs35.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -9599,7 +9907,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs34.rmSync(tmpDir, { recursive: true, force: true });
+    fs35.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -9661,13 +9969,13 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs38 from "fs";
-import path30 from "path";
+import fs39 from "fs";
+import path31 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -9682,7 +9990,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync14(cmd, {
+    return execSync15(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -9740,48 +10048,48 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs35 from "fs";
-import path27 from "path";
+import fs36 from "fs";
+import path28 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs35.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
+    fs36.writeFileSync("CLAUDE.md", appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.claudeMd))));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs35.writeFileSync("README.md", docs.readmeMd);
+    fs36.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs35.writeFileSync(".cursorrules", docs.cursorrules);
+    fs36.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path27.join(".cursor", "rules");
-    if (!fs35.existsSync(rulesDir)) fs35.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path28.join(".cursor", "rules");
+    if (!fs36.existsSync(rulesDir)) fs36.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      fs35.writeFileSync(path27.join(rulesDir, rule.filename), rule.content);
+      fs36.writeFileSync(path28.join(rulesDir, rule.filename), rule.content);
       written.push(`.cursor/rules/${rule.filename}`);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path27.join(".claude", "skills");
-    if (!fs35.existsSync(skillsDir)) fs35.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path28.join(".claude", "skills");
+    if (!fs36.existsSync(skillsDir)) fs36.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      fs35.writeFileSync(path27.join(skillsDir, skill.filename), skill.content);
+      fs36.writeFileSync(path28.join(skillsDir, skill.filename), skill.content);
       written.push(`.claude/skills/${skill.filename}`);
     }
   }
   if (docs.copilotInstructions) {
-    fs35.mkdirSync(".github", { recursive: true });
-    fs35.writeFileSync(path27.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions)));
+    fs36.mkdirSync(".github", { recursive: true });
+    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions))));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
-    const instructionsDir = path27.join(".github", "instructions");
-    fs35.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path28.join(".github", "instructions");
+    fs36.mkdirSync(instructionsDir, { recursive: true });
     for (const file of docs.copilotInstructionFiles) {
-      fs35.writeFileSync(path27.join(instructionsDir, file.filename), file.content);
+      fs36.writeFileSync(path28.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -9867,8 +10175,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs36 from "fs";
-import path28 from "path";
+import fs37 from "fs";
+import path29 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -9985,20 +10293,20 @@ function deduplicateLearnedItems(existing, incoming) {
 }
 function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
   const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
-  fs36.writeFileSync(filePath, header + merged + "\n");
-  if (mode) fs36.chmodSync(filePath, mode);
+  fs37.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs37.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
 function writeLearnedSection(content) {
   return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path28.join(".claude", "skills", skill.name);
-  if (!fs36.existsSync(skillDir)) fs36.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path28.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs36.existsSync(skillPath)) {
-    const existing = fs36.readFileSync(skillPath, "utf-8");
-    fs36.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path29.join(".claude", "skills", skill.name);
+  if (!fs37.existsSync(skillDir)) fs37.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path29.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs37.existsSync(skillPath)) {
+    const existing = fs37.readFileSync(skillPath, "utf-8");
+    fs37.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -10007,12 +10315,12 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs36.writeFileSync(skillPath, frontmatter + skill.content);
+    fs37.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function writePersonalLearnedSection(content) {
-  if (!fs36.existsSync(AUTH_DIR)) fs36.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs37.existsSync(AUTH_DIR)) fs37.mkdirSync(AUTH_DIR, { recursive: true });
   return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
 }
 function addLearning(bullet, scope = "project") {
@@ -10025,55 +10333,64 @@ function addLearning(bullet, scope = "project") {
   return { file: LEARNINGS_FILE, added: result.newCount > 0 };
 }
 function readPersonalLearnings() {
-  if (!fs36.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
-  const content = fs36.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  if (!fs37.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs37.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
   const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
   return bullets || null;
 }
 function readLearnedSection() {
-  if (fs36.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs36.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs37.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs37.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs36.existsSync(claudeMdPath)) return null;
-  const content = fs36.readFileSync(claudeMdPath, "utf-8");
+  if (!fs37.existsSync(claudeMdPath)) return null;
+  const content = fs37.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
   return content.slice(startIdx + LEARNED_START.length, endIdx).trim() || null;
 }
 function migrateInlineLearnings() {
-  if (fs36.existsSync(LEARNINGS_FILE)) return false;
+  if (fs37.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs36.existsSync(claudeMdPath)) return false;
-  const content = fs36.readFileSync(claudeMdPath, "utf-8");
+  if (!fs37.existsSync(claudeMdPath)) return false;
+  const content = fs37.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return false;
   const section = content.slice(startIdx + LEARNED_START.length, endIdx).trim();
   if (!section) return false;
-  fs36.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs37.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs36.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs37.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
 // src/commands/refresh.ts
 init_config();
 init_resolve_caliber();
+function detectSyncedAgents(writtenFiles) {
+  const agents = [];
+  const joined = writtenFiles.join(" ");
+  if (joined.includes("CLAUDE.md") || joined.includes(".claude/")) agents.push("Claude Code");
+  if (joined.includes(".cursor/") || joined.includes(".cursorrules")) agents.push("Cursor");
+  if (joined.includes("copilot-instructions") || joined.includes(".github/instructions/")) agents.push("Copilot");
+  if (joined.includes("AGENTS.md") || joined.includes(".agents/")) agents.push("Codex");
+  return agents;
+}
 function log2(quiet, ...args) {
   if (!quiet) console.log(...args);
 }
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs38.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs39.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path30.join(parentDir, entry.name);
-      if (fs38.existsSync(path30.join(childPath, ".git"))) {
+      const childPath = path31.join(parentDir, entry.name);
+      if (fs39.existsSync(path31.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -10159,9 +10476,9 @@ async function refreshSingleRepo(repoDir, options) {
   const filesToWrite = response.docsUpdated || [];
   const preRefreshContents = /* @__PURE__ */ new Map();
   for (const filePath of filesToWrite) {
-    const fullPath = path30.resolve(repoDir, filePath);
+    const fullPath = path31.resolve(repoDir, filePath);
     try {
-      preRefreshContents.set(filePath, fs38.readFileSync(fullPath, "utf-8"));
+      preRefreshContents.set(filePath, fs39.readFileSync(fullPath, "utf-8"));
     } catch {
       preRefreshContents.set(filePath, null);
     }
@@ -10171,14 +10488,14 @@ async function refreshSingleRepo(repoDir, options) {
   const postScore = computeLocalScore(repoDir, targetAgent);
   if (postScore.score < preScore.score) {
     for (const [filePath, content] of preRefreshContents) {
-      const fullPath = path30.resolve(repoDir, filePath);
+      const fullPath = path31.resolve(repoDir, filePath);
       if (content === null) {
         try {
-          fs38.unlinkSync(fullPath);
+          fs39.unlinkSync(fullPath);
         } catch {
         }
       } else {
-        fs38.writeFileSync(fullPath, content);
+        fs39.writeFileSync(fullPath, content);
       }
     }
     spinner?.warn(`${prefix}Refresh reverted \u2014 score would drop from ${preScore.score} to ${postScore.score}`);
@@ -10190,8 +10507,18 @@ async function refreshSingleRepo(repoDir, options) {
   }
   recordScore(postScore, "refresh");
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
+  const fileChangesMap = new Map(
+    (response.fileChanges || []).map((fc) => [fc.file, fc.description])
+  );
   for (const file of written) {
-    log2(quiet, `  ${chalk19.green("\u2713")} ${file}`);
+    const desc = fileChangesMap.get(file);
+    const suffix = desc ? chalk19.dim(` \u2014 ${desc}`) : "";
+    log2(quiet, `  ${chalk19.green("\u2713")} ${file}${suffix}`);
+  }
+  const agents = detectSyncedAgents(written);
+  if (agents.length > 1) {
+    log2(quiet, chalk19.cyan(`
+  ${agents.length} agent formats in sync (${agents.join(", ")})`));
   }
   if (response.changesSummary) {
     log2(quiet, chalk19.dim(`
@@ -10233,7 +10560,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path30.basename(repo);
+      const repoName = path31.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -10255,150 +10582,6 @@ async function refreshCommand(options) {
 // src/commands/hooks.ts
 import chalk20 from "chalk";
 import fs40 from "fs";
-
-// src/lib/hooks.ts
-init_resolve_caliber();
-import fs39 from "fs";
-import path31 from "path";
-import { execSync as execSync15 } from "child_process";
-var SETTINGS_PATH2 = path31.join(".claude", "settings.json");
-var REFRESH_TAIL = "refresh --quiet";
-var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
-function getHookCommand() {
-  return `${resolveCaliber()} ${REFRESH_TAIL}`;
-}
-function readSettings2() {
-  if (!fs39.existsSync(SETTINGS_PATH2)) return {};
-  try {
-    return JSON.parse(fs39.readFileSync(SETTINGS_PATH2, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeSettings2(settings) {
-  const dir = path31.dirname(SETTINGS_PATH2);
-  if (!fs39.existsSync(dir)) fs39.mkdirSync(dir, { recursive: true });
-  fs39.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
-}
-function findHookIndex(sessionEnd) {
-  return sessionEnd.findIndex(
-    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
-  );
-}
-function isHookInstalled() {
-  const settings = readSettings2();
-  const sessionEnd = settings.hooks?.SessionEnd;
-  if (!Array.isArray(sessionEnd)) return false;
-  return findHookIndex(sessionEnd) !== -1;
-}
-function installHook() {
-  const settings = readSettings2();
-  if (!settings.hooks) settings.hooks = {};
-  if (!Array.isArray(settings.hooks.SessionEnd)) settings.hooks.SessionEnd = [];
-  if (findHookIndex(settings.hooks.SessionEnd) !== -1) {
-    return { installed: false, alreadyInstalled: true };
-  }
-  settings.hooks.SessionEnd.push({
-    matcher: "",
-    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
-  });
-  writeSettings2(settings);
-  return { installed: true, alreadyInstalled: false };
-}
-function removeHook() {
-  const settings = readSettings2();
-  const sessionEnd = settings.hooks?.SessionEnd;
-  if (!Array.isArray(sessionEnd)) {
-    return { removed: false, notFound: true };
-  }
-  const idx = findHookIndex(sessionEnd);
-  if (idx === -1) {
-    return { removed: false, notFound: true };
-  }
-  sessionEnd.splice(idx, 1);
-  if (sessionEnd.length === 0) {
-    delete settings.hooks.SessionEnd;
-  }
-  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
-  }
-  writeSettings2(settings);
-  return { removed: true, notFound: false };
-}
-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 ${guard}; then
-  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  ${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}`;
-}
-function getGitHooksDir() {
-  try {
-    const gitDir = execSync15("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path31.join(gitDir, "hooks");
-  } catch {
-    return null;
-  }
-}
-function getPreCommitPath() {
-  const hooksDir = getGitHooksDir();
-  return hooksDir ? path31.join(hooksDir, "pre-commit") : null;
-}
-function isPreCommitHookInstalled() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs39.existsSync(hookPath)) return false;
-  const content = fs39.readFileSync(hookPath, "utf-8");
-  return content.includes(PRECOMMIT_START);
-}
-function installPreCommitHook() {
-  if (isPreCommitHookInstalled()) {
-    return { installed: false, alreadyInstalled: true };
-  }
-  const hookPath = getPreCommitPath();
-  if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path31.dirname(hookPath);
-  if (!fs39.existsSync(hooksDir)) fs39.mkdirSync(hooksDir, { recursive: true });
-  let content = "";
-  if (fs39.existsSync(hookPath)) {
-    content = fs39.readFileSync(hookPath, "utf-8");
-    if (!content.endsWith("\n")) content += "\n";
-    content += "\n" + getPrecommitBlock() + "\n";
-  } else {
-    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
-  }
-  fs39.writeFileSync(hookPath, content);
-  fs39.chmodSync(hookPath, 493);
-  return { installed: true, alreadyInstalled: false };
-}
-function removePreCommitHook() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs39.existsSync(hookPath)) {
-    return { removed: false, notFound: true };
-  }
-  let content = fs39.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() === "") {
-    fs39.unlinkSync(hookPath);
-  } else {
-    fs39.writeFileSync(hookPath, content);
-  }
-  return { removed: true, notFound: false };
-}
-
-// src/commands/hooks.ts
 var HOOKS = [
   {
     id: "session-end",