@rely-ai/caliber 1.25.0-dev.1773915517 → 1.25.0-dev.1773925407

package/dist/bin.js

@@ -271,20 +271,20 @@ var init_resolve_caliber = __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 execSync12, spawn as spawn3 } from "child_process";
+import fs25 from "fs";
+import path21 from "path";
 import os5 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, "");
+  fs25.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path21.join(DIFF_TEMP_DIR, path21.basename(proposedPath));
+  fs25.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync13(check, { stdio: "ignore" });
+    execSync12(check, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -318,7 +318,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path22.join(os5.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path21.join(os5.tmpdir(), "caliber-diff");
   }
 });
 
@@ -330,7 +330,7 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs27 from "fs";
+import fs26 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
@@ -367,8 +367,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 = fs26.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs26.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -543,13 +543,13 @@ __export(lock_exports, {
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
 });
-import fs36 from "fs";
-import path28 from "path";
+import fs35 from "fs";
+import path27 from "path";
 import os7 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs36.existsSync(LOCK_FILE)) return false;
-    const raw = fs36.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs35.existsSync(LOCK_FILE)) return false;
+    const raw = fs35.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -564,13 +564,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs36.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs35.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs36.existsSync(LOCK_FILE)) fs36.unlinkSync(LOCK_FILE);
+    if (fs35.existsSync(LOCK_FILE)) fs35.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -578,7 +578,7 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path28.join(os7.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path27.join(os7.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
@@ -590,9 +590,9 @@ import path35 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path24 from "path";
+import path23 from "path";
 import chalk14 from "chalk";
-import fs31 from "fs";
+import fs30 from "fs";
 
 // src/fingerprint/index.ts
 import fs7 from "fs";
@@ -4012,9 +4012,45 @@ import fs15 from "fs";
 // src/writers/claude/index.ts
 import fs9 from "fs";
 import path9 from "path";
+
+// src/writers/pre-commit-block.ts
+var BLOCK_START = "<!-- caliber:managed:pre-commit -->";
+var BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
+var MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .github/copilot-instructions.md AGENTS.md CALIBER_LEARNINGS.md";
+var PRE_COMMIT_BLOCK = `${BLOCK_START}
+## Before Committing
+
+Run \`caliber refresh\` before creating git commits to keep docs in sync with code changes.
+After it completes, stage any modified doc files before committing:
+
+\`\`\`bash
+caliber refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null
+\`\`\`
+${BLOCK_END}`;
+var CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
+var CURSOR_RULE_CONTENT = `---
+description: Run caliber refresh before git commits to keep docs in sync
+alwaysApply: true
+---
+Before creating git commits, run \`caliber refresh\` to update docs based on code changes,
+then stage modified doc files (${MANAGED_DOC_PATHS}).
+`;
+function hasPreCommitBlock(content) {
+  return content.includes(BLOCK_START);
+}
+function appendPreCommitBlock(content) {
+  if (hasPreCommitBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + PRE_COMMIT_BLOCK + "\n";
+}
+function getCursorPreCommitRule() {
+  return { filename: CURSOR_RULE_FILENAME, content: CURSOR_RULE_CONTENT };
+}
+
+// src/writers/claude/index.ts
 function writeClaudeConfig(config) {
   const written = [];
-  fs9.writeFileSync("CLAUDE.md", config.claudeMd);
+  fs9.writeFileSync("CLAUDE.md", appendPreCommitBlock(config.claudeMd));
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
@@ -4057,14 +4093,14 @@ function writeCursorConfig(config) {
     fs10.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
-  if (config.rules?.length) {
-    const rulesDir = path10.join(".cursor", "rules");
-    if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
-    for (const rule of config.rules) {
-      const rulePath = path10.join(rulesDir, rule.filename);
-      fs10.writeFileSync(rulePath, rule.content);
-      written.push(rulePath);
-    }
+  const preCommitRule = getCursorPreCommitRule();
+  const allRules = [...config.rules || [], preCommitRule];
+  const rulesDir = path10.join(".cursor", "rules");
+  if (!fs10.existsSync(rulesDir)) fs10.mkdirSync(rulesDir, { recursive: true });
+  for (const rule of allRules) {
+    const rulePath = path10.join(rulesDir, rule.filename);
+    fs10.writeFileSync(rulePath, rule.content);
+    written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
@@ -4106,7 +4142,7 @@ import fs11 from "fs";
 import path11 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs11.writeFileSync("AGENTS.md", config.agentsMd);
+  fs11.writeFileSync("AGENTS.md", appendPreCommitBlock(config.agentsMd));
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
@@ -4134,7 +4170,7 @@ function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
     fs12.mkdirSync(".github", { recursive: true });
-    fs12.writeFileSync(path12.join(".github", "copilot-instructions.md"), config.instructions);
+    fs12.writeFileSync(path12.join(".github", "copilot-instructions.md"), appendPreCommitBlock(config.instructions));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
@@ -4438,150 +4474,11 @@ ${agentRefs.join(" ")}
   return files;
 }
 
-// src/lib/hooks.ts
+// src/lib/learning-hooks.ts
 init_resolve_caliber();
 import fs19 from "fs";
 import path15 from "path";
-import { execSync as execSync7 } from "child_process";
 var SETTINGS_PATH = path15.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 (!fs19.existsSync(SETTINGS_PATH)) return {};
-  try {
-    return JSON.parse(fs19.readFileSync(SETTINGS_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeSettings(settings) {
-  const dir = path15.dirname(SETTINGS_PATH);
-  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
-  fs19.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();
-  return `${PRECOMMIT_START}
-if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
-  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  "${bin}" refresh 2>/dev/null || true
-  "${bin}" 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 = execSync7("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path15.join(gitDir, "hooks");
-  } catch {
-    return null;
-  }
-}
-function getPreCommitPath() {
-  const hooksDir = getGitHooksDir();
-  return hooksDir ? path15.join(hooksDir, "pre-commit") : null;
-}
-function isPreCommitHookInstalled() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs19.existsSync(hookPath)) return false;
-  const content = fs19.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 = path15.dirname(hookPath);
-  if (!fs19.existsSync(hooksDir)) fs19.mkdirSync(hooksDir, { recursive: true });
-  let content = "";
-  if (fs19.existsSync(hookPath)) {
-    content = fs19.readFileSync(hookPath, "utf-8");
-    if (!content.endsWith("\n")) content += "\n";
-    content += "\n" + getPrecommitBlock() + "\n";
-  } else {
-    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
-  }
-  fs19.writeFileSync(hookPath, content);
-  fs19.chmodSync(hookPath, 493);
-  return { installed: true, alreadyInstalled: false };
-}
-function removePreCommitHook() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs19.existsSync(hookPath)) {
-    return { removed: false, notFound: true };
-  }
-  let content = fs19.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() === "") {
-    fs19.unlinkSync(hookPath);
-  } else {
-    fs19.writeFileSync(hookPath, content);
-  }
-  return { removed: true, notFound: false };
-}
-
-// src/lib/learning-hooks.ts
-init_resolve_caliber();
-import fs20 from "fs";
-import path16 from "path";
-var SETTINGS_PATH2 = path16.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" },
@@ -4597,24 +4494,24 @@ function getHookConfigs() {
     description
   }));
 }
-function readSettings2() {
-  if (!fs20.existsSync(SETTINGS_PATH2)) return {};
+function readSettings() {
+  if (!fs19.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs20.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs19.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
-function writeSettings2(settings) {
-  const dir = path16.dirname(SETTINGS_PATH2);
-  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-  fs20.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+function writeSettings(settings) {
+  const dir = path15.dirname(SETTINGS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SETTINGS_PATH, 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 = readSettings2();
+  const settings = readSettings();
   if (!settings.hooks) return false;
   return HOOK_TAILS.every((cfg) => {
     const matchers = settings.hooks[cfg.event];
@@ -4625,7 +4522,7 @@ function installLearningHooks() {
   if (areLearningHooksInstalled()) {
     return { installed: false, alreadyInstalled: true };
   }
-  const settings = readSettings2();
+  const settings = readSettings();
   if (!settings.hooks) settings.hooks = {};
   const configs = getHookConfigs();
   for (const cfg of configs) {
@@ -4639,10 +4536,10 @@ function installLearningHooks() {
       });
     }
   }
-  writeSettings2(settings);
+  writeSettings(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path16.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path15.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -4650,17 +4547,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs20.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs19.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs20.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs19.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path16.dirname(CURSOR_HOOKS_PATH);
-  if (!fs20.existsSync(dir)) fs20.mkdirSync(dir, { recursive: true });
-  fs20.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path15.dirname(CURSOR_HOOKS_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -4707,7 +4604,7 @@ function removeCursorLearningHooks() {
   return { removed: true, notFound: false };
 }
 function removeLearningHooks() {
-  const settings = readSettings2();
+  const settings = readSettings();
   if (!settings.hooks) return { removed: false, notFound: true };
   let removedAny = false;
   for (const cfg of HOOK_TAILS) {
@@ -4724,16 +4621,16 @@ function removeLearningHooks() {
     delete settings.hooks;
   }
   if (!removedAny) return { removed: false, notFound: true };
-  writeSettings2(settings);
+  writeSettings(settings);
   return { removed: true, notFound: false };
 }
 
 // src/lib/state.ts
 init_constants();
-import fs21 from "fs";
-import path17 from "path";
-import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path17.join(CALIBER_DIR, ".caliber-state.json");
+import fs20 from "fs";
+import path16 from "path";
+import { execSync as execSync7 } from "child_process";
+var STATE_FILE = path16.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -4744,8 +4641,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs21.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs21.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs20.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs20.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -4753,14 +4650,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs21.existsSync(CALIBER_DIR)) {
-    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs20.existsSync(CALIBER_DIR)) {
+    fs20.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs21.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs20.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync8("git rev-parse HEAD", {
+    return execSync7("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -5369,7 +5266,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 execSync8 } from "child_process";
 import { join as join5 } from "path";
 function validateReferences(dir) {
   const configContent = collectPrimaryConfigContent(dir);
@@ -5378,13 +5275,13 @@ function validateReferences(dir) {
 }
 function detectGitDrift(dir) {
   try {
-    execSync9("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync8("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 = execSync8(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5405,7 +5302,7 @@ function detectGitDrift(dir) {
   let latestConfigCommitHash = null;
   for (const file of configFiles) {
     try {
-      const hash = execSync9(
+      const hash = execSync8(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -5414,7 +5311,7 @@ function detectGitDrift(dir) {
         latestConfigCommitHash = hash;
       } else {
         try {
-          execSync9(
+          execSync8(
             `git merge-base --is-ancestor ${latestConfigCommitHash} ${hash}`,
             { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }
           );
@@ -5429,12 +5326,12 @@ function detectGitDrift(dir) {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: true };
   }
   try {
-    const countStr = execSync9(
+    const countStr = execSync8(
       `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 = execSync8(
       `git log -1 --format=%ci ${latestConfigCommitHash}`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5506,12 +5403,12 @@ function checkAccuracy(dir) {
 
 // src/scoring/checks/freshness.ts
 import { existsSync as existsSync5, statSync as statSync3 } from "fs";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync9 } 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 = execSync9(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5531,12 +5428,12 @@ function getCommitsSinceConfigUpdate(dir) {
   }
   for (const file of configFiles) {
     try {
-      const hash = execSync10(
+      const hash = execSync9(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
       if (hash) {
-        const countStr = execSync10(
+        const countStr = execSync9(
           `git rev-list --count ${hash}..HEAD`,
           { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -5654,11 +5551,11 @@ 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 execSync10 } from "child_process";
 import { join as join7 } from "path";
 function hasPreCommitHook(dir) {
   try {
-    const gitDir = execSync11("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync10("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;
@@ -5687,7 +5584,12 @@ function checkBonus(dir) {
   if (hasPrecommit) {
     hookSources.push("git pre-commit");
   }
-  const hasHooks = hasClaudeHooks || hasPrecommit;
+  const claudeMd = readFileOrNull(join7(dir, "CLAUDE.md"));
+  const hasPreCommitBlock2 = claudeMd ? hasPreCommitBlock(claudeMd) : false;
+  if (hasPreCommitBlock2) {
+    hookSources.push("config pre-commit instruction");
+  }
+  const hasHooks = hasClaudeHooks || hasPrecommit || hasPreCommitBlock2;
   checks.push({
     id: "hooks_configured",
     name: "Hooks configured",
@@ -5696,11 +5598,11 @@ function checkBonus(dir) {
     earnedPoints: hasHooks ? POINTS_HOOKS : 0,
     passed: hasHooks,
     detail: hasHooks ? hookSources.join(", ") : "No hooks configured",
-    suggestion: hasHooks ? void 0 : "Run `caliber hooks --install` for auto-refresh",
+    suggestion: hasHooks ? void 0 : "Run `caliber init` to add pre-commit instructions",
     fix: hasHooks ? void 0 : {
       action: "install_hooks",
       data: {},
-      instruction: "Install caliber hooks for automatic config refresh on commits."
+      instruction: "Run caliber init to add pre-commit refresh instructions to config files."
     }
   });
   const agentsMdExists = existsSync6(join7(dir, "AGENTS.md"));
@@ -5810,22 +5712,22 @@ function checkSources(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs22 from "fs";
-import path18 from "path";
-var DISMISSED_FILE = path18.join(CALIBER_DIR, "dismissed-checks.json");
+import fs21 from "fs";
+import path17 from "path";
+var DISMISSED_FILE = path17.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs22.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs22.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs21.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs21.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs22.existsSync(CALIBER_DIR)) {
-    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs21.existsSync(CALIBER_DIR)) {
+    fs21.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs22.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs21.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -6073,13 +5975,13 @@ import { mkdirSync, readFileSync as readFileSync4, readdirSync as readdirSync4,
 import { join as join10, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs23 from "fs";
-import path19 from "path";
+import fs22 from "fs";
+import path18 from "path";
 import crypto3 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path19.join(dir, "CLAUDE.md");
-  if (fs23.existsSync(claudeMdPath)) {
+  const claudeMdPath = path18.join(dir, "CLAUDE.md");
+  if (fs22.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -6088,10 +5990,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path19.join(dir, ".claude", "skills");
-  if (fs23.existsSync(skillsDir)) {
-    for (const file of fs23.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path19.join(skillsDir, file);
+  const skillsDir = path18.join(dir, ".claude", "skills");
+  if (fs22.existsSync(skillsDir)) {
+    for (const file of fs22.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path18.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -6101,10 +6003,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path19.join(dir, ".mcp.json");
-  if (fs23.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path18.join(dir, ".mcp.json");
+  if (fs22.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs23.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -6119,8 +6021,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const agentsMdPath = path19.join(dir, "AGENTS.md");
-  if (fs23.existsSync(agentsMdPath)) {
+  const agentsMdPath = path18.join(dir, "AGENTS.md");
+  if (fs22.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -6129,12 +6031,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path19.join(dir, ".agents", "skills");
-  if (fs23.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path18.join(dir, ".agents", "skills");
+  if (fs22.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs23.readdirSync(codexSkillsDir)) {
-        const skillFile = path19.join(codexSkillsDir, name, "SKILL.md");
-        if (fs23.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(codexSkillsDir)) {
+        const skillFile = path18.join(codexSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -6147,8 +6049,8 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path19.join(dir, ".cursorrules");
-  if (fs23.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path18.join(dir, ".cursorrules");
+  if (fs22.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -6157,10 +6059,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path19.join(dir, ".cursor", "rules");
-  if (fs23.existsSync(cursorRulesDir)) {
-    for (const file of fs23.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path19.join(cursorRulesDir, file);
+  const cursorRulesDir = path18.join(dir, ".cursor", "rules");
+  if (fs22.existsSync(cursorRulesDir)) {
+    for (const file of fs22.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path18.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -6170,12 +6072,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path19.join(dir, ".cursor", "skills");
-  if (fs23.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path18.join(dir, ".cursor", "skills");
+  if (fs22.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs23.readdirSync(cursorSkillsDir)) {
-        const skillFile = path19.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs23.existsSync(skillFile)) {
+      for (const name of fs22.readdirSync(cursorSkillsDir)) {
+        const skillFile = path18.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs22.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -6188,10 +6090,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path19.join(dir, ".cursor", "mcp.json");
-  if (fs23.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path18.join(dir, ".cursor", "mcp.json");
+  if (fs22.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs23.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs22.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -6209,7 +6111,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs23.readFileSync(filePath, "utf-8");
+  const text = fs22.readFileSync(filePath, "utf-8");
   return crypto3.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -6224,27 +6126,27 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs24 from "fs";
-import path20 from "path";
+import fs23 from "fs";
+import path19 from "path";
 import os4 from "os";
 import crypto4 from "crypto";
-import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path20.join(os4.homedir(), ".caliber");
-var CONFIG_FILE2 = path20.join(CONFIG_DIR2, "config.json");
+import { execSync as execSync11 } from "child_process";
+var CONFIG_DIR2 = path19.join(os4.homedir(), ".caliber");
+var CONFIG_FILE2 = path19.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 (!fs23.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs23.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs24.existsSync(CONFIG_DIR2)) {
-    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs23.existsSync(CONFIG_DIR2)) {
+    fs23.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs23.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6255,7 +6157,7 @@ function getMachineId() {
 }
 function getGitEmailHash() {
   try {
-    const email = execSync12("git config user.email", { encoding: "utf-8" }).trim();
+    const email = execSync11("git config user.email", { encoding: "utf-8" }).trim();
     if (!email) return void 0;
     return crypto4.createHash("sha256").update(email).digest("hex");
   } catch {
@@ -7346,8 +7248,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 
 // src/lib/debug-report.ts
-import fs25 from "fs";
-import path21 from "path";
+import fs24 from "fs";
+import path20 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -7416,11 +7318,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 = path20.dirname(outputPath);
+    if (!fs24.existsSync(dir)) {
+      fs24.mkdirSync(dir, { recursive: true });
     }
-    fs25.writeFileSync(outputPath, lines.join("\n"));
+    fs24.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -7821,7 +7723,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs28 from "fs";
+import fs27 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -7962,10 +7864,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 (fs27.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs27.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs27.existsSync(`${dir}/.agents`) || fs27.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs27.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
@@ -7987,20 +7889,6 @@ async function promptAgent(detected) {
   });
   return selected;
 }
-async function promptHookType(targetAgent) {
-  const choices = [];
-  const hasClaude = targetAgent.includes("claude");
-  choices.push({ name: "Git pre-commit hook \u2014 refresh before each commit (recommended)", value: "precommit" });
-  if (hasClaude) {
-    choices.push({ name: "Claude Code hook \u2014 auto-refresh on session end", value: "claude" });
-    choices.push({ name: "Both (pre-commit + Claude Code)", value: "both" });
-  }
-  choices.push({ name: "Skip for now", value: "skip" });
-  return select5({
-    message: "Keep your AI docs & skills in sync as your code evolves?",
-    choices
-  });
-}
 async function promptLearnInstall(targetAgent) {
   const hasClaude = targetAgent.includes("claude");
   const hasCursor = targetAgent.includes("cursor");
@@ -8101,18 +7989,18 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs29 from "fs";
+import fs28 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 = fs28.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   if (codex?.agentsMd) {
-    const action = fs29.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs28.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -8149,7 +8037,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs29.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs28.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}`));
@@ -8159,7 +8047,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 = fs28.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}`));
@@ -8170,7 +8058,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 = fs28.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}`));
@@ -8180,7 +8068,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 = fs28.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}`));
@@ -8190,7 +8078,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs29.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs28.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8200,7 +8088,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 = fs28.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}`));
@@ -8211,7 +8099,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 = fs28.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -8258,12 +8146,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs30 from "fs";
-import path23 from "path";
+import fs29 from "fs";
+import path22 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path23.join(dir, ".caliber");
+  const caliberDir = path22.join(dir, ".caliber");
   try {
-    const stat = fs30.statSync(caliberDir);
+    const stat = fs29.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -8316,8 +8204,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 (fs29.existsSync(settingsPath)) {
+      settings = JSON.parse(fs29.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -8326,12 +8214,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 (!fs29.existsSync(".claude")) fs29.mkdirSync(".claude", { recursive: true });
+  fs29.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 = path22.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -8344,8 +8232,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"));
+    fs29.mkdirSync(path22.join(process.cwd(), ".caliber"), { recursive: true });
+    fs29.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8783,7 +8671,7 @@ async function initCommand(options) {
   const { default: ora9 } = await import("ora");
   const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs31.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs30.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
@@ -8873,66 +8761,8 @@ ${agentRefs.join(" ")}
     }
   }
   console.log("");
-  let hookChoice;
-  if (options.autoApprove) {
-    hookChoice = "skip";
-    log(options.verbose, "Auto-approve: skipping hook installation");
-  } else if (firstRun) {
-    const precommitResult = installPreCommitHook();
-    if (precommitResult.installed) {
-      console.log(`  ${chalk14.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-      console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")("caliber hooks --remove") + chalk14.dim(" to disable"));
-      hookChoice = "precommit";
-    } else if (precommitResult.alreadyInstalled) {
-      console.log(chalk14.dim("  Pre-commit hook already installed"));
-      hookChoice = "precommit";
-    } else {
-      hookChoice = "skip";
-    }
-    if (targetAgent.includes("claude")) {
-      const { default: select7 } = await import("@inquirer/select");
-      const wantsClaude = await select7({
-        message: "Also install Claude Code session hook? (auto-refresh on session end)",
-        choices: [
-          { name: "Yes", value: true },
-          { name: "No", value: false }
-        ]
-      });
-      if (wantsClaude) {
-        const hookResult = installHook();
-        if (hookResult.installed) {
-          console.log(`  ${chalk14.green("\u2713")} Claude Code hook installed`);
-        }
-        hookChoice = hookChoice === "precommit" ? "both" : "claude";
-      }
-    }
-  } else {
-    hookChoice = await promptHookType(targetAgent);
-    if (hookChoice === "claude" || hookChoice === "both") {
-      const hookResult = installHook();
-      if (hookResult.installed) {
-        console.log(`  ${chalk14.green("\u2713")} Claude Code hook installed \u2014 docs update on session end`);
-        console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")("caliber hooks --remove") + chalk14.dim(" to disable"));
-      } else if (hookResult.alreadyInstalled) {
-        console.log(chalk14.dim("  Claude Code hook already installed"));
-      }
-    }
-    if (hookChoice === "precommit" || hookChoice === "both") {
-      const precommitResult = installPreCommitHook();
-      if (precommitResult.installed) {
-        console.log(`  ${chalk14.green("\u2713")} Pre-commit hook installed \u2014 docs refresh before each commit`);
-        console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")("caliber hooks --remove") + chalk14.dim(" to disable"));
-      } else if (precommitResult.alreadyInstalled) {
-        console.log(chalk14.dim("  Pre-commit hook already installed"));
-      } else {
-        console.log(chalk14.yellow("  Could not install pre-commit hook (not a git repository?)"));
-      }
-    }
-    if (hookChoice === "skip") {
-      console.log(chalk14.dim("  Skipped auto-sync hooks. Run ") + chalk14.hex("#83D1EB")("caliber hooks --install") + chalk14.dim(" later to enable."));
-    }
-  }
-  trackInitHookSelected(hookChoice);
+  console.log(`  ${chalk14.green("\u2713")} Docs auto-refresh          ${chalk14.dim("agents run caliber refresh before commits")}`);
+  trackInitHookSelected("config-instructions");
   const hasLearnableAgent = targetAgent.includes("claude") || targetAgent.includes("cursor");
   let enableLearn = false;
   if (hasLearnableAgent) {
@@ -8967,13 +8797,7 @@ ${agentRefs.join(" ")}
   const skip = chalk14.dim("\u2013");
   console.log(chalk14.bold("  What was set up:\n"));
   console.log(`    ${done}  Config generated          ${title("caliber score")} ${chalk14.dim("for full breakdown")}`);
-  const hooksInstalled = hookChoice !== "skip";
-  if (hooksInstalled) {
-    const hookLabel = hookChoice === "both" ? "pre-commit + Claude Code" : hookChoice === "precommit" ? "pre-commit" : "Claude Code";
-    console.log(`    ${done}  Auto-sync hooks           ${chalk14.dim(hookLabel + " \u2014 docs stay fresh automatically")}`);
-  } else {
-    console.log(`    ${skip}  Auto-sync hooks           ${title("caliber hooks --install")} to enable later`);
-  }
+  console.log(`    ${done}  Docs auto-refresh        ${chalk14.dim("agents run caliber refresh before commits")}`);
   if (hasLearnableAgent) {
     if (enableLearn) {
       console.log(`    ${done}  Session learning          ${chalk14.dim("agent learns from your feedback")}`);
@@ -8996,9 +8820,9 @@ ${agentRefs.join(" ")}
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path24.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path23.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(chalk14.dim(`  Debug report written to ${path24.relative(process.cwd(), reportPath)}
+    console.log(chalk14.dim(`  Debug report written to ${path23.relative(process.cwd(), reportPath)}
 `));
   }
 }
@@ -9037,7 +8861,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs32 from "fs";
+import fs31 from "fs";
 init_config();
 async function statusCommand(options) {
   const config = loadConfig();
@@ -9064,7 +8888,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs32.existsSync(entry.path);
+    const exists = fs31.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -9219,21 +9043,21 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs33 from "fs";
+import fs32 from "fs";
 import os6 from "os";
-import path25 from "path";
+import path24 from "path";
 import { execFileSync } from "child_process";
 import chalk18 from "chalk";
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs33.mkdtempSync(path25.join(os6.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs32.mkdtempSync(path24.join(os6.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
         const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        fs33.writeFileSync(path25.join(tmpDir, file), content);
+        fs32.writeFileSync(path24.join(tmpDir, file), content);
       } catch {
       }
     }
@@ -9241,10 +9065,10 @@ function scoreBaseRef(ref, target) {
       try {
         const files = execFileSync("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 = path25.join(tmpDir, file);
-          fs33.mkdirSync(path25.dirname(filePath), { recursive: true });
+          const filePath = path24.join(tmpDir, file);
+          fs32.mkdirSync(path24.dirname(filePath), { recursive: true });
           const content = execFileSync("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-          fs33.writeFileSync(filePath, content);
+          fs32.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -9254,7 +9078,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs33.rmSync(tmpDir, { recursive: true, force: true });
+    fs32.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -9314,13 +9138,13 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs37 from "fs";
-import path29 from "path";
+import fs36 from "fs";
+import path28 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 execSync13 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -9335,7 +9159,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync14(cmd, {
+    return execSync13(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -9393,48 +9217,48 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs34 from "fs";
-import path26 from "path";
+import fs33 from "fs";
+import path25 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs34.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs33.writeFileSync("CLAUDE.md", appendPreCommitBlock(docs.claudeMd));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs34.writeFileSync("README.md", docs.readmeMd);
+    fs33.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs34.writeFileSync(".cursorrules", docs.cursorrules);
+    fs33.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path26.join(".cursor", "rules");
-    if (!fs34.existsSync(rulesDir)) fs34.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path25.join(".cursor", "rules");
+    if (!fs33.existsSync(rulesDir)) fs33.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      fs34.writeFileSync(path26.join(rulesDir, rule.filename), rule.content);
+      fs33.writeFileSync(path25.join(rulesDir, rule.filename), rule.content);
       written.push(`.cursor/rules/${rule.filename}`);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path26.join(".claude", "skills");
-    if (!fs34.existsSync(skillsDir)) fs34.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path25.join(".claude", "skills");
+    if (!fs33.existsSync(skillsDir)) fs33.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      fs34.writeFileSync(path26.join(skillsDir, skill.filename), skill.content);
+      fs33.writeFileSync(path25.join(skillsDir, skill.filename), skill.content);
       written.push(`.claude/skills/${skill.filename}`);
     }
   }
   if (docs.copilotInstructions) {
-    fs34.mkdirSync(".github", { recursive: true });
-    fs34.writeFileSync(path26.join(".github", "copilot-instructions.md"), docs.copilotInstructions);
+    fs33.mkdirSync(".github", { recursive: true });
+    fs33.writeFileSync(path25.join(".github", "copilot-instructions.md"), appendPreCommitBlock(docs.copilotInstructions));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
-    const instructionsDir = path26.join(".github", "instructions");
-    fs34.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path25.join(".github", "instructions");
+    fs33.mkdirSync(instructionsDir, { recursive: true });
     for (const file of docs.copilotInstructionFiles) {
-      fs34.writeFileSync(path26.join(instructionsDir, file.filename), file.content);
+      fs33.writeFileSync(path25.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -9514,8 +9338,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs35 from "fs";
-import path27 from "path";
+import fs34 from "fs";
+import path26 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -9633,20 +9457,20 @@ function deduplicateLearnedItems(existing, incoming) {
 }
 function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
   const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
-  fs35.writeFileSync(filePath, header + merged + "\n");
-  if (mode) fs35.chmodSync(filePath, mode);
+  fs34.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs34.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
 function writeLearnedSection(content) {
   return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path27.join(".claude", "skills", skill.name);
-  if (!fs35.existsSync(skillDir)) fs35.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path27.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs35.existsSync(skillPath)) {
-    const existing = fs35.readFileSync(skillPath, "utf-8");
-    fs35.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path26.join(".claude", "skills", skill.name);
+  if (!fs34.existsSync(skillDir)) fs34.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path26.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs34.existsSync(skillPath)) {
+    const existing = fs34.readFileSync(skillPath, "utf-8");
+    fs34.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -9655,47 +9479,47 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs35.writeFileSync(skillPath, frontmatter + skill.content);
+    fs34.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function writePersonalLearnedSection(content) {
-  if (!fs35.existsSync(AUTH_DIR)) fs35.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs34.existsSync(AUTH_DIR)) fs34.mkdirSync(AUTH_DIR, { recursive: true });
   return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
 }
 function readPersonalLearnings() {
-  if (!fs35.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
-  const content = fs35.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  if (!fs34.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs34.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
   const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
   return bullets || null;
 }
 function readLearnedSection() {
-  if (fs35.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs35.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs34.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs34.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs35.existsSync(claudeMdPath)) return null;
-  const content = fs35.readFileSync(claudeMdPath, "utf-8");
+  if (!fs34.existsSync(claudeMdPath)) return null;
+  const content = fs34.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 (fs35.existsSync(LEARNINGS_FILE)) return false;
+  if (fs34.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs35.existsSync(claudeMdPath)) return false;
-  const content = fs35.readFileSync(claudeMdPath, "utf-8");
+  if (!fs34.existsSync(claudeMdPath)) return false;
+  const content = fs34.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;
-  fs35.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs34.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs35.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs34.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
@@ -9707,11 +9531,11 @@ function log2(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs37.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs36.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path29.join(parentDir, entry.name);
-      if (fs37.existsSync(path29.join(childPath, ".git"))) {
+      const childPath = path28.join(parentDir, entry.name);
+      if (fs36.existsSync(path28.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -9817,7 +9641,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path29.basename(repo);
+      const repoName = path28.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -9839,6 +9663,147 @@ async function refreshCommand(options) {
 // src/commands/hooks.ts
 import chalk20 from "chalk";
 import fs38 from "fs";
+
+// src/lib/hooks.ts
+init_resolve_caliber();
+import fs37 from "fs";
+import path29 from "path";
+import { execSync as execSync14 } from "child_process";
+var SETTINGS_PATH2 = path29.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 (!fs37.existsSync(SETTINGS_PATH2)) return {};
+  try {
+    return JSON.parse(fs37.readFileSync(SETTINGS_PATH2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings2(settings) {
+  const dir = path29.dirname(SETTINGS_PATH2);
+  if (!fs37.existsSync(dir)) fs37.mkdirSync(dir, { recursive: true });
+  fs37.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();
+  return `${PRECOMMIT_START}
+if [ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1; then
+  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
+  "${bin}" refresh 2>/dev/null || true
+  "${bin}" 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 = execSync14("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return path29.join(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+function getPreCommitPath() {
+  const hooksDir = getGitHooksDir();
+  return hooksDir ? path29.join(hooksDir, "pre-commit") : null;
+}
+function isPreCommitHookInstalled() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs37.existsSync(hookPath)) return false;
+  const content = fs37.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 = path29.dirname(hookPath);
+  if (!fs37.existsSync(hooksDir)) fs37.mkdirSync(hooksDir, { recursive: true });
+  let content = "";
+  if (fs37.existsSync(hookPath)) {
+    content = fs37.readFileSync(hookPath, "utf-8");
+    if (!content.endsWith("\n")) content += "\n";
+    content += "\n" + getPrecommitBlock() + "\n";
+  } else {
+    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
+  }
+  fs37.writeFileSync(hookPath, content);
+  fs37.chmodSync(hookPath, 493);
+  return { installed: true, alreadyInstalled: false };
+}
+function removePreCommitHook() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs37.existsSync(hookPath)) {
+    return { removed: false, notFound: true };
+  }
+  let content = fs37.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() === "") {
+    fs37.unlinkSync(hookPath);
+  } else {
+    fs37.writeFileSync(hookPath, content);
+  }
+  return { removed: true, notFound: false };
+}
+
+// src/commands/hooks.ts
 var HOOKS = [
   {
     id: "session-end",
@@ -9869,6 +9834,10 @@ function printStatus() {
   console.log("");
 }
 async function hooksCommand(options) {
+  if (!options.install && !options.remove) {
+    console.log(chalk20.dim("\n  Note: caliber now adds refresh instructions directly to config files."));
+    console.log(chalk20.dim("  These hooks are available for non-agent workflows (manual commits).\n"));
+  }
   if (options.install) {
     for (const hook of HOOKS) {
       const result = hook.install();