@rely-ai/caliber 1.31.0-dev.1774741028 → 1.31.0-dev.1774815271

package/dist/bin.js

@@ -9,155 +9,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/llm/config.ts
-var config_exports = {};
-__export(config_exports, {
-  DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
-  DEFAULT_MODELS: () => DEFAULT_MODELS,
-  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
-  getConfigFilePath: () => getConfigFilePath,
-  getDisplayModel: () => getDisplayModel,
-  getFastModel: () => getFastModel,
-  getMaxPromptTokens: () => getMaxPromptTokens,
-  loadConfig: () => loadConfig,
-  readConfigFile: () => readConfigFile,
-  resolveFromEnv: () => resolveFromEnv,
-  writeConfigFile: () => writeConfigFile
-});
-import fs4 from "fs";
-import path5 from "path";
-import os2 from "os";
-function getMaxPromptTokens() {
-  const config = loadConfig();
-  const model = process.env.CALIBER_MODEL || config?.model;
-  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
-  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
-  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
-}
-function loadConfig() {
-  const envConfig = resolveFromEnv();
-  if (envConfig) return envConfig;
-  return readConfigFile();
-}
-function resolveFromEnv() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return {
-      provider: "anthropic",
-      apiKey: process.env.ANTHROPIC_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.anthropic
-    };
-  }
-  if (process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID) {
-    return {
-      provider: "vertex",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.vertex,
-      vertexProjectId: process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID,
-      vertexRegion: process.env.VERTEX_REGION || process.env.GCP_REGION || "us-east5",
-      vertexCredentials: process.env.VERTEX_SA_CREDENTIALS || process.env.GOOGLE_APPLICATION_CREDENTIALS
-    };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return {
-      provider: "openai",
-      apiKey: process.env.OPENAI_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.openai,
-      baseUrl: process.env.OPENAI_BASE_URL
-    };
-  }
-  if (process.env.CALIBER_USE_CURSOR_SEAT === "1" || process.env.CALIBER_USE_CURSOR_SEAT === "true") {
-    return {
-      provider: "cursor",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.cursor
-    };
-  }
-  if (process.env.CALIBER_USE_CLAUDE_CLI === "1" || process.env.CALIBER_USE_CLAUDE_CLI === "true") {
-    return {
-      provider: "claude-cli",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS["claude-cli"]
-    };
-  }
-  return null;
-}
-function readConfigFile() {
-  try {
-    if (!fs4.existsSync(CONFIG_FILE)) return null;
-    const raw = fs4.readFileSync(CONFIG_FILE, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function writeConfigFile(config) {
-  if (!fs4.existsSync(CONFIG_DIR)) {
-    fs4.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  const sanitized = { ...config };
-  if (sanitized.apiKey) {
-    sanitized.apiKey = sanitized.apiKey.trim();
-  }
-  fs4.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
-}
-function getConfigFilePath() {
-  return CONFIG_FILE;
-}
-function getDisplayModel(config) {
-  if (config.model === "default" && config.provider === "claude-cli") {
-    return process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)";
-  }
-  return config.model;
-}
-function getFastModel() {
-  if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
-  const config = loadConfig();
-  const provider = config?.provider;
-  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex" || provider === "claude-cli")) {
-    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
-  }
-  if (config?.fastModel) return config.fastModel;
-  if (provider) return DEFAULT_FAST_MODELS[provider];
-  return void 0;
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
-var init_config = __esm({
-  "src/llm/config.ts"() {
-    "use strict";
-    CONFIG_DIR = path5.join(os2.homedir(), ".caliber");
-    CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
-    DEFAULT_MODELS = {
-      anthropic: "claude-sonnet-4-6",
-      vertex: "claude-sonnet-4-6",
-      openai: "gpt-4.1",
-      cursor: "sonnet-4.6",
-      "claude-cli": "default"
-    };
-    MODEL_CONTEXT_WINDOWS = {
-      "claude-sonnet-4-6": 2e5,
-      "claude-opus-4-6": 2e5,
-      "claude-haiku-4-5-20251001": 2e5,
-      "claude-sonnet-4-5-20250514": 2e5,
-      "gpt-4.1": 1e6,
-      "gpt-4.1-mini": 1e6,
-      "gpt-4o": 128e3,
-      "gpt-4o-mini": 128e3,
-      "sonnet-4.6": 2e5
-    };
-    DEFAULT_CONTEXT_WINDOW = 2e5;
-    INPUT_BUDGET_FRACTION = 0.6;
-    MAX_PROMPT_TOKENS_CAP = 3e5;
-    MIN_PROMPT_TOKENS = 3e4;
-    DEFAULT_FAST_MODELS = {
-      anthropic: "claude-haiku-4-5-20251001",
-      vertex: "claude-haiku-4-5-20251001",
-      openai: "gpt-4.1-mini",
-      cursor: "gpt-5.3-codex-fast"
-    };
-  }
-});
-
 // src/lib/resolve-caliber.ts
 var resolve_caliber_exports = {};
 __export(resolve_caliber_exports, {
@@ -166,8 +17,8 @@ __export(resolve_caliber_exports, {
   resetResolvedCaliber: () => resetResolvedCaliber,
   resolveCaliber: () => resolveCaliber
 });
-import fs6 from "fs";
-import { execSync as execSync4 } from "child_process";
+import fs2 from "fs";
+import { execSync as execSync3 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
   const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
@@ -177,7 +28,7 @@ function resolveCaliber() {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    execSync4(whichCmd, {
+    execSync3(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -186,7 +37,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && /caliber/.test(binPath) && fs6.existsSync(binPath)) {
+  if (binPath && /caliber/.test(binPath) && fs2.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -214,214 +65,65 @@ var init_resolve_caliber = __esm({
   }
 });
 
-// src/llm/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isSeatBased: () => isSeatBased
-});
-function isSeatBased(provider) {
-  return SEAT_BASED_PROVIDERS.has(provider);
-}
-var SEAT_BASED_PROVIDERS;
-var init_types = __esm({
-  "src/llm/types.ts"() {
-    "use strict";
-    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
-  }
+// src/lib/builtin-skills.ts
+var builtin_skills_exports = {};
+__export(builtin_skills_exports, {
+  BUILTIN_SKILLS: () => BUILTIN_SKILLS,
+  BUILTIN_SKILL_NAMES: () => BUILTIN_SKILL_NAMES,
+  FIND_SKILLS_SKILL: () => FIND_SKILLS_SKILL,
+  PLATFORM_CONFIGS: () => PLATFORM_CONFIGS,
+  SAVE_LEARNING_SKILL: () => SAVE_LEARNING_SKILL,
+  SETUP_CALIBER_SKILL: () => SETUP_CALIBER_SKILL,
+  buildSkillContent: () => buildSkillContent,
+  ensureBuiltinSkills: () => ensureBuiltinSkills
 });
+import fs3 from "fs";
+import path3 from "path";
+function buildSkillContent(skill) {
+  const frontmatter = `---
+name: ${skill.name}
+description: ${skill.description}
+---
 
-// src/writers/pre-commit-block.ts
-var pre_commit_block_exports = {};
-__export(pre_commit_block_exports, {
-  appendLearningsBlock: () => appendLearningsBlock,
-  appendPreCommitBlock: () => appendPreCommitBlock,
-  appendSyncBlock: () => appendSyncBlock,
-  getCursorLearningsRule: () => getCursorLearningsRule,
-  getCursorPreCommitRule: () => getCursorPreCommitRule,
-  getCursorSyncRule: () => getCursorSyncRule,
-  hasLearningsBlock: () => hasLearningsBlock,
-  hasPreCommitBlock: () => hasPreCommitBlock,
-  hasSyncBlock: () => hasSyncBlock
-});
-function getPreCommitBlock() {
+`;
+  return frontmatter + skill.content;
+}
+function getFindSkillsContent() {
   const bin = resolveCaliber();
-  return `${BLOCK_START}
-## Before Committing
+  return `# Find Skills
 
-**IMPORTANT:** Before every git commit, you MUST ensure Caliber syncs agent configs with the latest code changes.
+Search the public skill registry for community-contributed skills
+relevant to the user's current task and install them into this project.
 
-First, check if the pre-commit hook is already installed:
-\`\`\`bash
-grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"
-\`\`\`
+## Instructions
 
-- 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.
+1. Identify the key technologies, frameworks, or task types from the
+   user's request that might have community skills available
+2. Ask the user: "Would you like me to search for community skills
+   for [identified technologies]?"
+3. If the user agrees, run:
+   \`\`\`bash
+   ${bin} skills --query "<relevant terms>"
+   \`\`\`
+   This outputs the top 5 matching skills with scores and descriptions.
+4. Present the results to the user and ask which ones to install
+5. Install the selected skills:
+   \`\`\`bash
+   ${bin} skills --install <slug1>,<slug2>
+   \`\`\`
+6. Read the installed SKILL.md files to load them into your current
+   context so you can use them immediately in this session
+7. Summarize what was installed and continue with the user's task
 
-If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."
-${BLOCK_END}`;
-}
-function getCursorRuleContent() {
-  const bin = resolveCaliber();
-  return `---
-description: Run Caliber sync before git commits to keep agent configs up to date
-alwaysApply: true
----
-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"\`
+## Examples
 
-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, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
-`;
-}
-function hasPreCommitBlock(content) {
-  return content.includes(BLOCK_START);
-}
-function appendPreCommitBlock(content) {
-  if (hasPreCommitBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getPreCommitBlock() + "\n";
-}
-function getCursorPreCommitRule() {
-  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
-}
-function hasLearningsBlock(content) {
-  return content.includes(LEARNINGS_BLOCK_START);
-}
-function appendLearningsBlock(content) {
-  if (hasLearningsBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + LEARNINGS_BLOCK + "\n";
-}
-function getCursorLearningsRule() {
-  return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
-}
-function getSyncBlock() {
-  const bin = resolveCaliber();
-  return `${SYNC_BLOCK_START}
-## Context Sync
-
-This project uses [Caliber](https://github.com/caliber-ai-org/ai-setup) 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";
-}
-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, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
-`;
-}
-function getCursorSyncRule() {
-  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
-}
-var BLOCK_START, BLOCK_END, MANAGED_DOC_PATHS, CURSOR_RULE_FILENAME, LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END, LEARNINGS_BLOCK, CURSOR_LEARNINGS_FILENAME, CURSOR_LEARNINGS_CONTENT, SYNC_BLOCK_START, SYNC_BLOCK_END, CURSOR_SYNC_FILENAME;
-var init_pre_commit_block = __esm({
-  "src/writers/pre-commit-block.ts"() {
-    "use strict";
-    init_resolve_caliber();
-    BLOCK_START = "<!-- caliber:managed:pre-commit -->";
-    BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
-    MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
-    CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
-    LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
-    LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
-    LEARNINGS_BLOCK = `${LEARNINGS_BLOCK_START}
-## Session Learnings
-
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-${LEARNINGS_BLOCK_END}`;
-    CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
-    CURSOR_LEARNINGS_CONTENT = `---
-description: Reference session-learned patterns from CALIBER_LEARNINGS.md
-alwaysApply: true
----
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-`;
-    SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
-    SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
-    CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
-  }
-});
-
-// src/lib/builtin-skills.ts
-var builtin_skills_exports = {};
-__export(builtin_skills_exports, {
-  BUILTIN_SKILLS: () => BUILTIN_SKILLS,
-  BUILTIN_SKILL_NAMES: () => BUILTIN_SKILL_NAMES,
-  FIND_SKILLS_SKILL: () => FIND_SKILLS_SKILL,
-  SAVE_LEARNING_SKILL: () => SAVE_LEARNING_SKILL,
-  SETUP_CALIBER_SKILL: () => SETUP_CALIBER_SKILL,
-  buildSkillContent: () => buildSkillContent,
-  ensureBuiltinSkills: () => ensureBuiltinSkills
-});
-import fs17 from "fs";
-import path16 from "path";
-function buildSkillContent(skill) {
-  const frontmatter = `---
-name: ${skill.name}
-description: ${skill.description}
----
-
-`;
-  return frontmatter + skill.content;
-}
-function getFindSkillsContent() {
-  const bin = resolveCaliber();
-  return `# Find Skills
-
-Search the public skill registry for community-contributed skills
-relevant to the user's current task and install them into this project.
-
-## Instructions
-
-1. Identify the key technologies, frameworks, or task types from the
-   user's request that might have community skills available
-2. Ask the user: "Would you like me to search for community skills
-   for [identified technologies]?"
-3. If the user agrees, run:
-   \`\`\`bash
-   ${bin} skills --query "<relevant terms>"
-   \`\`\`
-   This outputs the top 5 matching skills with scores and descriptions.
-4. Present the results to the user and ask which ones to install
-5. Install the selected skills:
-   \`\`\`bash
-   ${bin} skills --install <slug1>,<slug2>
-   \`\`\`
-6. Read the installed SKILL.md files to load them into your current
-   context so you can use them immediately in this session
-7. Summarize what was installed and continue with the user's task
-
-## Examples
-
-User: "let's build a web app using React"
--> "I notice you want to work with React. Would you like me to search
-   for community skills that could help with React development?"
--> If yes: run \`${bin} skills --query "react frontend"\`
--> Show the user the results, ask which to install
--> Run \`${bin} skills --install <selected-slugs>\`
--> Read the installed files and continue
+User: "let's build a web app using React"
+-> "I notice you want to work with React. Would you like me to search
+   for community skills that could help with React development?"
+-> If yes: run \`${bin} skills --query "react frontend"\`
+-> Show the user the results, ask which to install
+-> Run \`${bin} skills --install <selected-slugs>\`
+-> Read the installed files and continue
 
 User: "help me set up Docker for this project"
 -> "Would you like me to search for Docker-related skills?"
@@ -516,18 +218,19 @@ then only act if something is missing.
 command -v caliber >/dev/null 2>&1 && caliber --version || echo "NOT_INSTALLED"
 \`\`\`
 
-- If a version prints \u2192 Caliber is installed. Move to Step 2.
-- If NOT_INSTALLED \u2192 Tell the user: "Caliber isn't installed yet. I'll install it now."
-  Then run:
+- If a version prints \u2192 Caliber is installed globally. Set \`CALIBER="caliber"\` and move to Step 2.
+- If NOT_INSTALLED \u2192 Install it globally (faster for daily use since the pre-commit hook runs on every commit):
   \`\`\`bash
   npm install -g @rely-ai/caliber
   \`\`\`
-  If npm fails (permissions, no Node, etc.), try:
+  Set \`CALIBER="caliber"\`.
+
+  If npm fails (permissions, no sudo, etc.), fall back to npx:
   \`\`\`bash
-  npx @rely-ai/caliber --version
+  npx @rely-ai/caliber --version 2>/dev/null || echo "NO_NODE"
   \`\`\`
-  If npx works, use \`npx @rely-ai/caliber\` as the command prefix for all subsequent steps.
-  If both fail, tell the user: "Caliber requires Node.js >= 20. Install Node first, then run /setup-caliber again."
+  - If npx works \u2192 Set \`CALIBER="npx @rely-ai/caliber"\`. This works but adds ~500ms per invocation.
+  - If NO_NODE \u2192 Tell the user: "Caliber requires Node.js >= 20. Install Node first, then run /setup-caliber again." Stop here.
 
 ### Step 2: Check if pre-commit hook is installed
 
@@ -538,35 +241,52 @@ grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "HOOK_ACTIVE" || ech
 - If HOOK_ACTIVE \u2192 Tell the user: "Pre-commit hook is active \u2014 configs sync on every commit." Move to Step 3.
 - If NO_HOOK \u2192 Tell the user: "I'll install the pre-commit hook so your agent configs sync automatically on every commit."
   \`\`\`bash
-  caliber hooks --install
+  $CALIBER hooks --install
   \`\`\`
 
-### Step 3: Check if agent configs exist
+### Step 3: Detect agents and check if configs exist
 
+First, detect which coding agents are configured in this project:
+\`\`\`bash
+AGENTS=""
+[ -d .claude ] && AGENTS="claude"
+[ -d .cursor ] && AGENTS="\${AGENTS:+$AGENTS,}cursor"
+[ -d .agents ] || [ -f AGENTS.md ] && AGENTS="\${AGENTS:+$AGENTS,}codex"
+[ -f .github/copilot-instructions.md ] && AGENTS="\${AGENTS:+$AGENTS,}github-copilot"
+echo "DETECTED_AGENTS=\${AGENTS:-none}"
+\`\`\`
+
+If no agents are detected, ask the user which coding agents they use (Claude Code, Cursor, Codex, GitHub Copilot).
+Build the agent list from their answer as a comma-separated string (e.g. "claude,cursor").
+
+Then check if agent configs exist:
 \`\`\`bash
 echo "CLAUDE_MD=$([ -f CLAUDE.md ] && echo exists || echo missing)"
 echo "CURSOR_RULES=$([ -d .cursor/rules ] && ls .cursor/rules/*.mdc 2>/dev/null | wc -l | tr -d ' ' || echo 0)"
 echo "AGENTS_MD=$([ -f AGENTS.md ] && echo exists || echo missing)"
+echo "COPILOT=$([ -f .github/copilot-instructions.md ] && echo exists || echo missing)"
 \`\`\`
 
-- If configs exist \u2192 Tell the user which configs are present. Move to Step 4.
+- If configs exist for the detected agents \u2192 Tell the user which configs are present. Move to Step 4.
 - If configs are missing \u2192 Tell the user: "No agent configs found. I'll generate them now."
+  Use the detected or user-selected agent list:
   \`\`\`bash
-  caliber init --auto-approve
+  $CALIBER init --auto-approve --agent <comma-separated-agents>
   \`\`\`
-  This generates CLAUDE.md, Cursor rules, AGENTS.md, and skills for all detected agents.
+  For example: \`$CALIBER init --auto-approve --agent claude,cursor\`
+  This generates CLAUDE.md, Cursor rules, AGENTS.md, skills, and sync infrastructure for the specified agents.
 
 ### Step 4: Check if configs are fresh
 
 \`\`\`bash
-caliber score --json --quiet 2>/dev/null | head -1
+$CALIBER score --json --quiet 2>/dev/null | head -1
 \`\`\`
 
 - If score is 80+ \u2192 Tell the user: "Your configs are in good shape (score: X/100)."
 - If score is below 80 \u2192 Tell the user: "Your configs could be improved (score: X/100). Want me to run a refresh?"
   If yes:
   \`\`\`bash
-  caliber refresh
+  $CALIBER refresh
   \`\`\`
 
 ### Step 5: Ask about team setup
@@ -577,20 +297,20 @@ Ask the user: "Are you setting up for yourself only, or for your team too?"
 
   Check if session learning is enabled:
   \`\`\`bash
-  caliber learn status 2>/dev/null | head -3
+  $CALIBER learn status 2>/dev/null | head -3
   \`\`\`
   - If learning is already enabled \u2192 note it in the summary.
   - If not enabled \u2192 ask the user: "Caliber can learn from your coding sessions \u2014 when you correct a mistake or fix a pattern, it remembers for next time. Enable session learning?"
     If yes:
     \`\`\`bash
-    caliber learn install
+    $CALIBER learn install
     \`\`\`
 
   Then tell the user:
   "You're all set! Here's what happens next:
   - Every time you commit, Caliber syncs your agent configs automatically
   - Your CLAUDE.md, Cursor rules, and AGENTS.md stay current with your code
-  - Run \`caliber skills\` anytime to discover community skills for your stack"
+  - Run \`$CALIBER skills\` anytime to discover community skills for your stack"
 
   Then show the summary (see below) and stop.
 
@@ -625,7 +345,7 @@ Ask the user: "Are you setting up for yourself only, or for your team too?"
     \`\`\`
     Now determine which LLM provider the team uses. Check the local Caliber config:
     \`\`\`bash
-    caliber config --show 2>/dev/null || echo "NO_CONFIG"
+    $CALIBER config --show 2>/dev/null || echo "NO_CONFIG"
     \`\`\`
 
     Based on the provider, the GitHub Action needs the corresponding secret:
@@ -691,11 +411,11 @@ From now on, every commit keeps all your agent configs in sync automatically.
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs17.existsSync(platformDir)) continue;
+    if (!fs3.existsSync(platformDir)) continue;
     for (const skill of BUILTIN_SKILLS) {
-      const skillPath = path16.join(skillsDir, skill.name, "SKILL.md");
-      fs17.mkdirSync(path16.dirname(skillPath), { recursive: true });
-      fs17.writeFileSync(skillPath, buildSkillContent(skill));
+      const skillPath = path3.join(skillsDir, skill.name, "SKILL.md");
+      fs3.mkdirSync(path3.dirname(skillPath), { recursive: true });
+      fs3.writeFileSync(skillPath, buildSkillContent(skill));
       written.push(skillPath);
     }
   }
@@ -713,27 +433,394 @@ var init_builtin_skills = __esm({
         return getFindSkillsContent();
       }
     };
-    SAVE_LEARNING_SKILL = {
-      name: "save-learning",
-      description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
-      get content() {
-        return getSaveLearningContent();
-      }
+    SAVE_LEARNING_SKILL = {
+      name: "save-learning",
+      description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
+      get content() {
+        return getSaveLearningContent();
+      }
+    };
+    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();
+      }
+    };
+    BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL, SETUP_CALIBER_SKILL];
+    PLATFORM_CONFIGS = [
+      { platformDir: ".claude", skillsDir: path3.join(".claude", "skills") },
+      { platformDir: ".cursor", skillsDir: path3.join(".cursor", "skills") },
+      { platformDir: ".agents", skillsDir: path3.join(".agents", "skills") }
+    ];
+    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
+  }
+});
+
+// src/writers/pre-commit-block.ts
+var pre_commit_block_exports = {};
+__export(pre_commit_block_exports, {
+  appendLearningsBlock: () => appendLearningsBlock,
+  appendManagedBlocks: () => appendManagedBlocks,
+  appendPreCommitBlock: () => appendPreCommitBlock,
+  appendSyncBlock: () => appendSyncBlock,
+  getCursorLearningsRule: () => getCursorLearningsRule,
+  getCursorPreCommitRule: () => getCursorPreCommitRule,
+  getCursorSetupRule: () => getCursorSetupRule,
+  getCursorSyncRule: () => getCursorSyncRule,
+  hasLearningsBlock: () => hasLearningsBlock,
+  hasPreCommitBlock: () => hasPreCommitBlock,
+  hasSyncBlock: () => hasSyncBlock,
+  stripManagedBlocks: () => stripManagedBlocks
+});
+function getCaliberNotFoundFallback(platform, bin) {
+  switch (platform) {
+    case "claude":
+      return `If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."`;
+    case "codex":
+      return `If \`${bin}\` is not found, read \`.agents/skills/setup-caliber/SKILL.md\` and follow its instructions to install Caliber.`;
+    case "copilot":
+      return `If \`${bin}\` is not found, tell the developer to set up Caliber by running \`/setup-caliber\` in Claude Code or Cursor. Alternatively, they can run these commands in their terminal:
+\`\`\`
+npx @rely-ai/caliber hooks --install
+npx @rely-ai/caliber refresh
+\`\`\``;
+  }
+}
+function getPreCommitBlock(platform = "claude") {
+  const bin = resolveCaliber();
+  return `${BLOCK_START}
+## 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
+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.
+
+${getCaliberNotFoundFallback(platform, bin)}
+${BLOCK_END}`;
+}
+function getCursorRuleContent() {
+  const bin = resolveCaliber();
+  return `---
+description: Run Caliber sync before git commits to keep agent configs up to date
+alwaysApply: true
+---
+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, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
+`;
+}
+function hasPreCommitBlock(content) {
+  return content.includes(BLOCK_START);
+}
+function appendPreCommitBlock(content, platform = "claude") {
+  if (hasPreCommitBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + getPreCommitBlock(platform) + "\n";
+}
+function getCursorPreCommitRule() {
+  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
+}
+function hasLearningsBlock(content) {
+  return content.includes(LEARNINGS_BLOCK_START);
+}
+function appendLearningsBlock(content) {
+  if (hasLearningsBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + LEARNINGS_BLOCK + "\n";
+}
+function getCursorLearningsRule() {
+  return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
+}
+function getSyncSetupInstruction(platform, bin) {
+  switch (platform) {
+    case "claude":
+      return `If the pre-commit hook is not set up, run \`/setup-caliber\` to configure everything automatically.`;
+    case "codex":
+      return `If the pre-commit hook is not set up, read \`.agents/skills/setup-caliber/SKILL.md\` and follow the setup instructions.`;
+    case "copilot":
+      return `If the pre-commit hook is not set up, the developer should run \`/setup-caliber\` in Claude Code or Cursor for automated setup. Alternatively, run in terminal:
+\`\`\`bash
+npx @rely-ai/caliber hooks --install
+npx @rely-ai/caliber refresh
+git add ${MANAGED_DOC_PATHS} 2>/dev/null
+\`\`\``;
+  }
+}
+function getSyncBlock(platform = "claude") {
+  const bin = resolveCaliber();
+  return `${SYNC_BLOCK_START}
+## Context Sync
+
+This project uses [Caliber](https://github.com/caliber-ai-org/ai-setup) to keep AI agent configs in sync across Claude Code, Cursor, Copilot, and Codex.
+Configs update automatically before each commit via \`${bin} refresh\`.
+${getSyncSetupInstruction(platform, bin)}
+${SYNC_BLOCK_END}`;
+}
+function hasSyncBlock(content) {
+  return content.includes(SYNC_BLOCK_START);
+}
+function appendSyncBlock(content, platform = "claude") {
+  if (hasSyncBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + getSyncBlock(platform) + "\n";
+}
+function appendManagedBlocks(content, platform = "claude") {
+  return appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(content, platform)), platform);
+}
+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, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
+`;
+}
+function getCursorSyncRule() {
+  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
+}
+function getCursorSetupContent() {
+  return `---
+description: Check if Caliber agent config sync is set up and offer installation on new sessions
+alwaysApply: true
+---
+This project uses Caliber to keep AI agent configs in sync automatically.
+At the start of each session, silently check if sync is active:
+
+Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "SYNC_ACTIVE" || echo "NO_SYNC"\`
+
+If SYNC_ACTIVE: No action needed \u2014 Caliber syncs automatically on every commit.
+If NO_SYNC: Tell the user: "This project uses Caliber for automatic agent config sync, but it's not set up on your machine yet. Want me to set it up? It takes about 30 seconds."
+
+If the user agrees, read \`.cursor/skills/setup-caliber/SKILL.md\` and follow its instructions step by step.
+`;
+}
+function getCursorSetupRule() {
+  return { filename: CURSOR_SETUP_FILENAME, content: getCursorSetupContent() };
+}
+function stripManagedBlocks(content) {
+  let result = content;
+  for (const [start, end] of MANAGED_BLOCK_PAIRS) {
+    const regex = new RegExp(`\\n?${start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g");
+    result = result.replace(regex, "\n");
+  }
+  return result.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+var BLOCK_START, BLOCK_END, MANAGED_DOC_PATHS, CURSOR_RULE_FILENAME, LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END, LEARNINGS_BLOCK, CURSOR_LEARNINGS_FILENAME, CURSOR_LEARNINGS_CONTENT, SYNC_BLOCK_START, SYNC_BLOCK_END, CURSOR_SYNC_FILENAME, CURSOR_SETUP_FILENAME, MANAGED_BLOCK_PAIRS;
+var init_pre_commit_block = __esm({
+  "src/writers/pre-commit-block.ts"() {
+    "use strict";
+    init_resolve_caliber();
+    BLOCK_START = "<!-- caliber:managed:pre-commit -->";
+    BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
+    MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
+    CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
+    LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
+    LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
+    LEARNINGS_BLOCK = `${LEARNINGS_BLOCK_START}
+## Session Learnings
+
+Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
+These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
+${LEARNINGS_BLOCK_END}`;
+    CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
+    CURSOR_LEARNINGS_CONTENT = `---
+description: Reference session-learned patterns from CALIBER_LEARNINGS.md
+alwaysApply: true
+---
+Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
+These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
+`;
+    SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
+    SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
+    CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
+    CURSOR_SETUP_FILENAME = "caliber-setup.mdc";
+    MANAGED_BLOCK_PAIRS = [
+      [BLOCK_START, BLOCK_END],
+      [LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END],
+      [SYNC_BLOCK_START, SYNC_BLOCK_END]
+    ];
+  }
+});
+
+// src/llm/config.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
+  DEFAULT_MODELS: () => DEFAULT_MODELS,
+  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
+  getConfigFilePath: () => getConfigFilePath,
+  getDisplayModel: () => getDisplayModel,
+  getFastModel: () => getFastModel,
+  getMaxPromptTokens: () => getMaxPromptTokens,
+  loadConfig: () => loadConfig,
+  readConfigFile: () => readConfigFile,
+  resolveFromEnv: () => resolveFromEnv,
+  writeConfigFile: () => writeConfigFile
+});
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
+function getMaxPromptTokens() {
+  const config = loadConfig();
+  const model = process.env.CALIBER_MODEL || config?.model;
+  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
+  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
+  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
+}
+function loadConfig() {
+  const envConfig = resolveFromEnv();
+  if (envConfig) return envConfig;
+  return readConfigFile();
+}
+function resolveFromEnv() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return {
+      provider: "anthropic",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.anthropic
+    };
+  }
+  if (process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID) {
+    return {
+      provider: "vertex",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.vertex,
+      vertexProjectId: process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID,
+      vertexRegion: process.env.VERTEX_REGION || process.env.GCP_REGION || "us-east5",
+      vertexCredentials: process.env.VERTEX_SA_CREDENTIALS || process.env.GOOGLE_APPLICATION_CREDENTIALS
+    };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return {
+      provider: "openai",
+      apiKey: process.env.OPENAI_API_KEY,
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.openai,
+      baseUrl: process.env.OPENAI_BASE_URL
+    };
+  }
+  if (process.env.CALIBER_USE_CURSOR_SEAT === "1" || process.env.CALIBER_USE_CURSOR_SEAT === "true") {
+    return {
+      provider: "cursor",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.cursor
+    };
+  }
+  if (process.env.CALIBER_USE_CLAUDE_CLI === "1" || process.env.CALIBER_USE_CLAUDE_CLI === "true") {
+    return {
+      provider: "claude-cli",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS["claude-cli"]
+    };
+  }
+  return null;
+}
+function readConfigFile() {
+  try {
+    if (!fs6.existsSync(CONFIG_FILE)) return null;
+    const raw = fs6.readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeConfigFile(config) {
+  if (!fs6.existsSync(CONFIG_DIR)) {
+    fs6.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const sanitized = { ...config };
+  if (sanitized.apiKey) {
+    sanitized.apiKey = sanitized.apiKey.trim();
+  }
+  fs6.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
+}
+function getConfigFilePath() {
+  return CONFIG_FILE;
+}
+function getDisplayModel(config) {
+  if (config.model === "default" && config.provider === "claude-cli") {
+    return process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)";
+  }
+  return config.model;
+}
+function getFastModel() {
+  if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
+  const config = loadConfig();
+  const provider = config?.provider;
+  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex" || provider === "claude-cli")) {
+    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  }
+  if (config?.fastModel) return config.fastModel;
+  if (provider) return DEFAULT_FAST_MODELS[provider];
+  return void 0;
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
+var init_config = __esm({
+  "src/llm/config.ts"() {
+    "use strict";
+    CONFIG_DIR = path6.join(os2.homedir(), ".caliber");
+    CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-6",
+      vertex: "claude-sonnet-4-6",
+      openai: "gpt-4.1",
+      cursor: "sonnet-4.6",
+      "claude-cli": "default"
+    };
+    MODEL_CONTEXT_WINDOWS = {
+      "claude-sonnet-4-6": 2e5,
+      "claude-opus-4-6": 2e5,
+      "claude-haiku-4-5-20251001": 2e5,
+      "claude-sonnet-4-5-20250514": 2e5,
+      "gpt-4.1": 1e6,
+      "gpt-4.1-mini": 1e6,
+      "gpt-4o": 128e3,
+      "gpt-4o-mini": 128e3,
+      "sonnet-4.6": 2e5
     };
-    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();
-      }
+    DEFAULT_CONTEXT_WINDOW = 2e5;
+    INPUT_BUDGET_FRACTION = 0.6;
+    MAX_PROMPT_TOKENS_CAP = 3e5;
+    MIN_PROMPT_TOKENS = 3e4;
+    DEFAULT_FAST_MODELS = {
+      anthropic: "claude-haiku-4-5-20251001",
+      vertex: "claude-haiku-4-5-20251001",
+      openai: "gpt-4.1-mini",
+      cursor: "gpt-5.3-codex-fast"
     };
-    BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL, SETUP_CALIBER_SKILL];
-    PLATFORM_CONFIGS = [
-      { platformDir: ".claude", skillsDir: path16.join(".claude", "skills") },
-      { platformDir: ".cursor", skillsDir: path16.join(".cursor", "skills") },
-      { platformDir: ".agents", skillsDir: path16.join(".agents", "skills") }
-    ];
-    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
+  }
+});
+
+// src/llm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isSeatBased: () => isSeatBased
+});
+function isSeatBased(provider) {
+  return SEAT_BASED_PROVIDERS.has(provider);
+}
+var SEAT_BASED_PROVIDERS;
+var init_types = __esm({
+  "src/llm/types.ts"() {
+    "use strict";
+    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
   }
 });
 
@@ -1052,8 +1139,8 @@ var init_lock = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs47 from "fs";
-import path38 from "path";
+import fs49 from "fs";
+import path39 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
@@ -1062,8 +1149,8 @@ import chalk14 from "chalk";
 import fs33 from "fs";
 
 // src/fingerprint/index.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -1171,8 +1258,8 @@ function scan(base, rel, depth, maxDepth, result) {
 }
 
 // src/fingerprint/existing-config.ts
-import fs2 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // src/constants.ts
 import path2 from "path";
@@ -1207,97 +1294,121 @@ var LEARNING_LAST_ERROR_FILE = "last-error.json";
 var MIN_SESSIONS_FOR_COMPARISON = 3;
 
 // src/fingerprint/existing-config.ts
+init_builtin_skills();
+init_pre_commit_block();
+var MANAGED_CURSOR_RULES = /* @__PURE__ */ new Set([
+  getCursorPreCommitRule().filename,
+  getCursorLearningsRule().filename,
+  getCursorSyncRule().filename,
+  getCursorSetupRule().filename
+]);
 function readExistingConfigs(dir) {
   const configs = {};
-  const readmeMdPath = path3.join(dir, "README.md");
-  if (fs2.existsSync(readmeMdPath)) {
-    configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
+  const readmeMdPath = path4.join(dir, "README.md");
+  if (fs4.existsSync(readmeMdPath)) {
+    configs.readmeMd = fs4.readFileSync(readmeMdPath, "utf-8");
   }
-  const agentsMdPath = path3.join(dir, "AGENTS.md");
-  if (fs2.existsSync(agentsMdPath)) {
-    configs.agentsMd = fs2.readFileSync(agentsMdPath, "utf-8");
+  const agentsMdPath = path4.join(dir, "AGENTS.md");
+  if (fs4.existsSync(agentsMdPath)) {
+    configs.agentsMd = fs4.readFileSync(agentsMdPath, "utf-8");
   }
-  const claudeMdPath = path3.join(dir, "CLAUDE.md");
-  if (fs2.existsSync(claudeMdPath)) {
-    configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path4.join(dir, "CLAUDE.md");
+  if (fs4.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path3.join(dir, ".claude", "settings.json");
-  if (fs2.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = path4.join(dir, ".claude", "settings.json");
+  if (fs4.existsSync(claudeSettingsPath)) {
     try {
-      configs.claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath, "utf-8"));
+      configs.claudeSettings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path3.join(dir, ".claude", "skills");
-  if (fs2.existsSync(skillsDir)) {
+  const skillsDir = path4.join(dir, ".claude", "skills");
+  if (fs4.existsSync(skillsDir)) {
     try {
-      const entries = fs2.readdirSync(skillsDir);
+      const entries = fs4.readdirSync(skillsDir);
       const skills = [];
       for (const entry of entries) {
-        const entryPath = path3.join(skillsDir, entry);
-        const skillMdPath = path3.join(entryPath, "SKILL.md");
-        if (fs2.statSync(entryPath).isDirectory() && fs2.existsSync(skillMdPath)) {
-          skills.push({ filename: `${entry}/SKILL.md`, content: fs2.readFileSync(skillMdPath, "utf-8") });
+        if (BUILTIN_SKILL_NAMES.has(entry)) continue;
+        const entryPath = path4.join(skillsDir, entry);
+        const skillMdPath = path4.join(entryPath, "SKILL.md");
+        if (fs4.statSync(entryPath).isDirectory() && fs4.existsSync(skillMdPath)) {
+          skills.push({ filename: `${entry}/SKILL.md`, content: fs4.readFileSync(skillMdPath, "utf-8") });
         } else if (entry.endsWith(".md")) {
-          skills.push({ filename: entry, content: fs2.readFileSync(entryPath, "utf-8") });
+          skills.push({ filename: entry, content: fs4.readFileSync(entryPath, "utf-8") });
         }
       }
       if (skills.length > 0) configs.claudeSkills = skills;
     } catch {
     }
   }
-  const cursorrulesPath = path3.join(dir, ".cursorrules");
-  if (fs2.existsSync(cursorrulesPath)) {
-    configs.cursorrules = fs2.readFileSync(cursorrulesPath, "utf-8");
+  const cursorrulesPath = path4.join(dir, ".cursorrules");
+  if (fs4.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs4.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path3.join(dir, ".cursor", "rules");
-  if (fs2.existsSync(cursorRulesDir)) {
+  const cursorRulesDir = path4.join(dir, ".cursor", "rules");
+  if (fs4.existsSync(cursorRulesDir)) {
     try {
-      const files = fs2.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
+      const files = fs4.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc") && !MANAGED_CURSOR_RULES.has(f));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs2.readFileSync(path3.join(cursorRulesDir, f), "utf-8")
+        content: fs4.readFileSync(path4.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorSkillsDir = path3.join(dir, ".cursor", "skills");
-  if (fs2.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path4.join(dir, ".cursor", "skills");
+  if (fs4.existsSync(cursorSkillsDir)) {
     try {
-      const slugs = fs2.readdirSync(cursorSkillsDir).filter((f) => {
-        return fs2.statSync(path3.join(cursorSkillsDir, f)).isDirectory();
+      const slugs = fs4.readdirSync(cursorSkillsDir).filter((f) => {
+        return fs4.statSync(path4.join(cursorSkillsDir, f)).isDirectory() && !BUILTIN_SKILL_NAMES.has(f);
       });
-      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path3.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
+      configs.cursorSkills = slugs.filter((slug) => fs4.existsSync(path4.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
         name,
         filename: "SKILL.md",
-        content: fs2.readFileSync(path3.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
+        content: fs4.readFileSync(path4.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
       }));
     } catch {
     }
   }
-  const mcpJsonPath = path3.join(dir, ".mcp.json");
-  if (fs2.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path4.join(dir, ".mcp.json");
+  if (fs4.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs4.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         configs.claudeMcpServers = mcpJson.mcpServers;
       }
     } catch {
     }
   }
-  const cursorMcpPath = path3.join(dir, ".cursor", "mcp.json");
-  if (fs2.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path4.join(dir, ".cursor", "mcp.json");
+  if (fs4.existsSync(cursorMcpPath)) {
     try {
-      const cursorMcpJson = JSON.parse(fs2.readFileSync(cursorMcpPath, "utf-8"));
+      const cursorMcpJson = JSON.parse(fs4.readFileSync(cursorMcpPath, "utf-8"));
       if (cursorMcpJson.mcpServers) {
         configs.cursorMcpServers = cursorMcpJson.mcpServers;
       }
     } catch {
     }
   }
-  if (fs2.existsSync(PERSONAL_LEARNINGS_FILE)) {
+  const copilotPath = path4.join(dir, ".github", "copilot-instructions.md");
+  if (fs4.existsSync(copilotPath)) {
+    configs.copilotInstructions = fs4.readFileSync(copilotPath, "utf-8");
+  }
+  const instructionsDir = path4.join(dir, ".github", "instructions");
+  if (fs4.existsSync(instructionsDir)) {
+    try {
+      const files = fs4.readdirSync(instructionsDir).filter((f) => f.endsWith(".md"));
+      configs.copilotInstructionFiles = files.map((f) => ({
+        filename: f,
+        content: fs4.readFileSync(path4.join(instructionsDir, f), "utf-8")
+      }));
+    } catch {
+    }
+  }
+  if (fs4.existsSync(PERSONAL_LEARNINGS_FILE)) {
     try {
-      const content = fs2.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+      const content = fs4.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
       const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
       if (bullets) configs.personalLearnings = bullets;
     } catch {
@@ -1307,9 +1418,9 @@ function readExistingConfigs(dir) {
 }
 
 // src/fingerprint/code-analysis.ts
-import fs3 from "fs";
-import path4 from "path";
-import { execSync as execSync3 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+import { execSync as execSync4 } from "child_process";
 
 // src/lib/sanitize.ts
 var KNOWN_PREFIX_PATTERNS = [
@@ -1653,18 +1764,18 @@ function extractSkeletonIndentBased(lines, ext) {
 }
 function extractImports(content, filePath) {
   const imports = [];
-  const dir = path4.dirname(filePath);
+  const dir = path5.dirname(filePath);
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     const jsMatch = trimmed.match(/(?:from|require\()\s*['"]([^'"]+)['"]/);
     if (jsMatch && jsMatch[1].startsWith(".")) {
-      imports.push(path4.normalize(path4.join(dir, jsMatch[1])));
+      imports.push(path5.normalize(path5.join(dir, jsMatch[1])));
       continue;
     }
     const pyMatch = trimmed.match(/^from\s+(\.[.\w]*)\s+import/);
     if (pyMatch) {
       const modulePath = pyMatch[1].replace(/\./g, "/");
-      imports.push(path4.normalize(path4.join(dir, modulePath)));
+      imports.push(path5.normalize(path5.join(dir, modulePath)));
       continue;
     }
     const goMatch = trimmed.match(/^\s*"([^"]+)"/);
@@ -1677,7 +1788,7 @@ function extractImports(content, filePath) {
 function buildImportCounts(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const [filePath, content] of files) {
-    const ext = path4.extname(filePath).toLowerCase();
+    const ext = path5.extname(filePath).toLowerCase();
     if (!SOURCE_EXTENSIONS.has(ext)) continue;
     const imports = extractImports(content, filePath);
     for (const imp of imports) {
@@ -1696,7 +1807,7 @@ function buildImportCounts(files) {
 function getGitFrequency(dir) {
   const freq = /* @__PURE__ */ new Map();
   try {
-    const output = execSync3(
+    const output = execSync4(
       'git log --since="6 months ago" --format="" --name-only --diff-filter=ACMR 2>/dev/null | head -10000',
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
     );
@@ -1711,7 +1822,7 @@ function getGitFrequency(dir) {
 function groupByDirectory(files) {
   const groups = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path4.dirname(f.path);
+    const dir = path5.dirname(f.path);
     const group = groups.get(dir) || [];
     group.push(f);
     groups.set(dir, group);
@@ -1732,14 +1843,14 @@ function analyzeCode(dir) {
   let totalChars = 0;
   for (const relPath of allPaths) {
     try {
-      totalChars += fs3.statSync(path4.join(dir, relPath)).size;
+      totalChars += fs5.statSync(path5.join(dir, relPath)).size;
     } catch {
     }
   }
   const fileContents = /* @__PURE__ */ new Map();
   for (const relPath of allPaths) {
     try {
-      const content = fs3.readFileSync(path4.join(dir, relPath), "utf-8");
+      const content = fs5.readFileSync(path5.join(dir, relPath), "utf-8");
       if (content.split("\n").length <= 500) fileContents.set(relPath, content);
     } catch {
     }
@@ -1749,7 +1860,7 @@ function analyzeCode(dir) {
   const scored = [];
   let compressedChars = 0;
   for (const [relPath, rawContent] of fileContents) {
-    const ext = path4.extname(relPath).toLowerCase();
+    const ext = path5.extname(relPath).toLowerCase();
     const compressed = compressContent(rawContent, ext);
     const skeleton = extractSkeleton(compressed, ext);
     compressedChars += compressed.length;
@@ -1778,7 +1889,7 @@ function analyzeCode(dir) {
     }
     if (similar.length > 0) {
       dupGroups++;
-      const names = similar.map((f) => path4.basename(f.path));
+      const names = similar.map((f) => path5.basename(f.path));
       const summary = `(${similar.length} similar file${similar.length === 1 ? "" : "s"} in ${dirPath}/: ${names.join(", ")})`;
       const summarySize = summary.length + 30;
       if (includedChars + summarySize <= CHAR_BUDGET) {
@@ -1815,10 +1926,10 @@ function analyzeCode(dir) {
 }
 function walkDir(base, rel, depth, maxDepth, files) {
   if (depth > maxDepth) return;
-  const fullPath = path4.join(base, rel);
+  const fullPath = path5.join(base, rel);
   let entries;
   try {
-    entries = fs3.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs5.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -1831,7 +1942,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
     } else if (entry.isFile()) {
       if (SKIP_FILES.has(entry.name)) continue;
       if (SKIP_PATTERNS.some((p) => p.test(entry.name))) continue;
-      const ext = path4.extname(entry.name).toLowerCase();
+      const ext = path5.extname(entry.name).toLowerCase();
       if (TEXT_EXTENSIONS.has(ext) || depth === 0 && !ext && !entry.name.startsWith(".")) {
         files.push(relPath);
       }
@@ -1839,7 +1950,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
   }
 }
 function filePriority(filePath) {
-  const base = path4.basename(filePath);
+  const base = path5.basename(filePath);
   const entryPoints = /* @__PURE__ */ new Set([
     "index.ts",
     "index.js",
@@ -1971,7 +2082,7 @@ var AnthropicProvider = class {
 };
 
 // src/llm/vertex.ts
-import fs5 from "fs";
+import fs7 from "fs";
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
 import { GoogleAuth } from "google-auth-library";
 var VertexProvider = class {
@@ -1994,7 +2105,7 @@ var VertexProvider = class {
         }
       } else {
         try {
-          creds = JSON.parse(fs5.readFileSync(raw, "utf-8"));
+          creds = JSON.parse(fs7.readFileSync(raw, "utf-8"));
         } catch {
           throw new Error(`Cannot read credentials file: ${raw}`);
         }
@@ -3163,6 +3274,11 @@ CONSERVATIVE UPDATE means:
 - NEVER remove code blocks, backtick references, or architecture paths unless the diff deleted them
 - NEVER replace specific paths/commands with generic prose
 
+Cross-agent sync:
+- When a change affects CLAUDE.md, apply the same semantic update to AGENTS.md and copilot instructions if they exist
+- Each file uses its own format and conventions \u2014 do NOT copy content verbatim between them
+- The goal is consistency: all agent config files should reflect the same project state after refresh
+
 Quality constraints (the output is scored deterministically):
 - 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
@@ -3171,16 +3287,17 @@ Quality constraints (the output is scored deterministically):
 - Preserve the existing structure (headings, bullet style, formatting)
 
 Managed content:
-- Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
-- Keep context sync blocks (<!-- caliber:managed:sync --> ... <!-- /caliber:managed:sync -->) intact
+- All blocks between <!-- caliber:managed:* --> and <!-- /caliber:managed:* --> are managed by Caliber \u2014 copy them verbatim, do NOT modify their contents
+- This includes: pre-commit, sync, and learnings blocks
 - Do NOT modify CALIBER_LEARNINGS.md \u2014 it is managed separately
-- Preserve any references to CALIBER_LEARNINGS.md in CLAUDE.md
+- Preserve any references to CALIBER_LEARNINGS.md
 
 Return a JSON object with this exact shape:
 {
   "updatedDocs": {
     "claudeMd": "<updated content or null>",
     "readmeMd": "<updated content or null>",
+    "agentsMd": "<updated content or null>",
     "cursorrules": "<updated content or null>",
     "cursorRules": [{"filename": "name.mdc", "content": "..."}] or null,
     "claudeSkills": [{"filename": "name.md", "content": "..."}] or null,
@@ -3342,15 +3459,15 @@ async function detectProjectStack(fileTree, suffixCounts) {
 init_config();
 
 // src/fingerprint/cache.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 import crypto from "crypto";
 import { execSync as execSync7 } from "child_process";
 var CACHE_VERSION = 1;
 var CACHE_DIR = ".caliber/cache";
 var CACHE_FILE = "fingerprint.json";
 function getCachePath(dir) {
-  return path6.join(dir, CACHE_DIR, CACHE_FILE);
+  return path7.join(dir, CACHE_DIR, CACHE_FILE);
 }
 function getGitHead(dir) {
   try {
@@ -3387,8 +3504,8 @@ function computeTreeSignature(fileTree, dir) {
 function loadFingerprintCache(dir, fileTree) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return null;
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return null;
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (cache.version !== CACHE_VERSION) return null;
     const currentHead = getGitHead(dir);
@@ -3409,9 +3526,9 @@ function loadFingerprintCache(dir, fileTree) {
 function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks, tools, workspaces) {
   const cachePath = getCachePath(dir);
   try {
-    const cacheDir = path6.dirname(cachePath);
-    if (!fs7.existsSync(cacheDir)) {
-      fs7.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path7.dirname(cachePath);
+    if (!fs8.existsSync(cacheDir)) {
+      fs8.mkdirSync(cacheDir, { recursive: true });
     }
     const cache = {
       version: CACHE_VERSION,
@@ -3423,15 +3540,15 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       tools,
       workspaces
     };
-    fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    fs8.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 function getDetectedWorkspaces(dir) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return [];
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return [];
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     return cache.workspaces ?? [];
   } catch {
@@ -3483,9 +3600,9 @@ async function collectFingerprint(dir) {
 }
 function readPackageName(dir) {
   try {
-    const pkgPath = path7.join(dir, "package.json");
-    if (!fs8.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path8.join(dir, "package.json");
+    if (!fs9.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -3499,7 +3616,7 @@ async function enrichWithLLM(fingerprint) {
     const suffixCounts = {};
     for (const entry of fingerprint.fileTree) {
       if (entry.endsWith("/")) continue;
-      const ext = path7.extname(entry).toLowerCase();
+      const ext = path8.extname(entry).toLowerCase();
       if (ext) {
         suffixCounts[ext] = (suffixCounts[ext] || 0) + 1;
       }
@@ -3515,22 +3632,22 @@ async function enrichWithLLM(fingerprint) {
 }
 
 // src/scanner/index.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 import crypto2 from "crypto";
 import os4 from "os";
 function detectPlatforms() {
   const home = os4.homedir();
   return {
-    claude: fs9.existsSync(path8.join(home, ".claude")),
-    cursor: fs9.existsSync(getCursorConfigDir()),
-    codex: fs9.existsSync(path8.join(home, ".codex"))
+    claude: fs10.existsSync(path9.join(home, ".claude")),
+    cursor: fs10.existsSync(getCursorConfigDir()),
+    codex: fs10.existsSync(path9.join(home, ".codex"))
   };
 }
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path8.join(dir, "CLAUDE.md");
-  if (fs9.existsSync(claudeMdPath)) {
+  const claudeMdPath = path9.join(dir, "CLAUDE.md");
+  if (fs10.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -3539,10 +3656,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path8.join(dir, ".claude", "skills");
-  if (fs9.existsSync(skillsDir)) {
-    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path8.join(skillsDir, file);
+  const skillsDir = path9.join(dir, ".claude", "skills");
+  if (fs10.existsSync(skillsDir)) {
+    for (const file of fs10.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path9.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -3552,10 +3669,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path8.join(dir, ".mcp.json");
-  if (fs9.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path9.join(dir, ".mcp.json");
+  if (fs10.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3571,8 +3688,8 @@ function scanLocalState(dir) {
       warnScanSkip(".mcp.json", error);
     }
   }
-  const agentsMdPath = path8.join(dir, "AGENTS.md");
-  if (fs9.existsSync(agentsMdPath)) {
+  const agentsMdPath = path9.join(dir, "AGENTS.md");
+  if (fs10.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -3581,12 +3698,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path8.join(dir, ".agents", "skills");
-  if (fs9.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path9.join(dir, ".agents", "skills");
+  if (fs10.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(codexSkillsDir)) {
-        const skillFile = path8.join(codexSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+      for (const name of fs10.readdirSync(codexSkillsDir)) {
+        const skillFile = path9.join(codexSkillsDir, name, "SKILL.md");
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -3600,8 +3717,8 @@ function scanLocalState(dir) {
       warnScanSkip(".agents/skills", error);
     }
   }
-  const cursorrulesPath = path8.join(dir, ".cursorrules");
-  if (fs9.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path9.join(dir, ".cursorrules");
+  if (fs10.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -3610,10 +3727,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path8.join(dir, ".cursor", "rules");
-  if (fs9.existsSync(cursorRulesDir)) {
-    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path8.join(cursorRulesDir, file);
+  const cursorRulesDir = path9.join(dir, ".cursor", "rules");
+  if (fs10.existsSync(cursorRulesDir)) {
+    for (const file of fs10.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path9.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -3623,12 +3740,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path8.join(dir, ".cursor", "skills");
-  if (fs9.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path9.join(dir, ".cursor", "skills");
+  if (fs10.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(cursorSkillsDir)) {
-        const skillFile = path8.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+      for (const name of fs10.readdirSync(cursorSkillsDir)) {
+        const skillFile = path9.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -3642,10 +3759,10 @@ function scanLocalState(dir) {
       warnScanSkip(".cursor/skills", error);
     }
   }
-  const cursorMcpPath = path8.join(dir, ".cursor", "mcp.json");
-  if (fs9.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
+  if (fs10.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3664,7 +3781,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs9.readFileSync(filePath, "utf-8");
+  const text = fs10.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -3677,37 +3794,37 @@ function warnScanSkip(target, error) {
 function getCursorConfigDir() {
   const home = os4.homedir();
   if (process.platform === "darwin") {
-    return path8.join(home, "Library", "Application Support", "Cursor");
+    return path9.join(home, "Library", "Application Support", "Cursor");
   }
   if (process.platform === "win32") {
-    return path8.join(home, "AppData", "Roaming", "Cursor");
+    return path9.join(home, "AppData", "Roaming", "Cursor");
   }
-  return path8.join(home, ".config", "Cursor");
+  return path9.join(home, ".config", "Cursor");
 }
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { execSync as execSync8 } from "child_process";
-var SETTINGS_PATH = path9.join(".claude", "settings.json");
+var SETTINGS_PATH = path10.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 {};
+  if (!fs11.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs11.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));
+  const dir = path10.dirname(SETTINGS_PATH);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3773,19 +3890,19 @@ ${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");
+    return path10.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path9.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path10.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) return false;
-  const content = fs10.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs11.existsSync(hookPath)) return false;
+  const content = fs11.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3794,42 +3911,42 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path9.dirname(hookPath);
-  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path10.dirname(hookPath);
+  if (!fs11.existsSync(hooksDir)) fs11.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs10.existsSync(hookPath)) {
-    content = fs10.readFileSync(hookPath, "utf-8");
+  if (fs11.existsSync(hookPath)) {
+    content = fs11.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);
+  fs11.writeFileSync(hookPath, content);
+  fs11.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) {
+  if (!hookPath || !fs11.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs10.readFileSync(hookPath, "utf-8");
+  let content = fs11.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);
+    fs11.unlinkSync(hookPath);
   } else {
-    fs10.writeFileSync(hookPath, content);
+    fs11.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/fingerprint/sources.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
@@ -4148,7 +4265,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 = path10.join(dir, ".caliber", "sources.json");
+  const configPath = path11.join(dir, ".caliber", "sources.json");
   const content = readFileOrNull(configPath);
   if (!content) return [];
   try {
@@ -4166,29 +4283,29 @@ function loadSourcesConfig(dir) {
   }
 }
 function writeSourcesConfig(dir, sources2) {
-  const configDir = path10.join(dir, ".caliber");
-  if (!fs11.existsSync(configDir)) {
-    fs11.mkdirSync(configDir, { recursive: true });
+  const configDir = path11.join(dir, ".caliber");
+  if (!fs12.existsSync(configDir)) {
+    fs12.mkdirSync(configDir, { recursive: true });
   }
-  const configPath = path10.join(configDir, "sources.json");
-  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  const configPath = path11.join(configDir, "sources.json");
+  fs12.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs12.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
 }
 function isInsideDir(childPath, parentDir) {
-  const relative2 = path10.relative(parentDir, childPath);
-  return !relative2.startsWith("..") && !path10.isAbsolute(relative2);
+  const relative2 = path11.relative(parentDir, childPath);
+  return !relative2.startsWith("..") && !path11.isAbsolute(relative2);
 }
 function resolveAllSources(dir, cliSources, workspaces) {
   const seen = /* @__PURE__ */ new Map();
-  const projectRoot = path10.resolve(dir);
+  const projectRoot = path11.resolve(dir);
   for (const src of cliSources) {
-    const absPath = path10.resolve(dir, src);
+    const absPath = path11.resolve(dir, src);
     if (seen.has(absPath)) continue;
     const type = detectSourceType(absPath);
     seen.set(absPath, {
@@ -4201,12 +4318,12 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const cfg of configSources) {
     if (cfg.type === "url") continue;
     if (!cfg.path) continue;
-    const absPath = path10.resolve(dir, cfg.path);
+    const absPath = path11.resolve(dir, cfg.path);
     if (seen.has(absPath)) continue;
     seen.set(absPath, { absPath, config: cfg, origin: "config" });
   }
   for (const ws of workspaces) {
-    const absPath = path10.resolve(dir, ws);
+    const absPath = path11.resolve(dir, ws);
     if (seen.has(absPath)) continue;
     if (!isInsideDir(absPath, projectRoot)) continue;
     seen.set(absPath, {
@@ -4219,7 +4336,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs11.statSync(absPath);
+      stat = fs12.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -4248,13 +4365,13 @@ function collectSourceSummary(resolved, projectDir) {
   if (config.type === "file") {
     return collectFileSummary(resolved, projectDir);
   }
-  const summaryPath = path10.join(absPath, ".caliber", "summary.json");
+  const summaryPath = path11.join(absPath, ".caliber", "summary.json");
   const summaryContent = readFileOrNull(summaryPath);
   if (summaryContent) {
     try {
       const published = JSON.parse(summaryContent);
       return {
-        name: published.name || path10.basename(absPath),
+        name: published.name || path11.basename(absPath),
         type: "repo",
         role: config.role || published.role || "related-repo",
         description: config.description || published.description || "",
@@ -4274,18 +4391,18 @@ function collectRepoSummary(resolved, projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs11.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs12.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(path10.join(absPath, "CLAUDE.md"));
+  const claudeMdContent = readFileOrNull(path11.join(absPath, "CLAUDE.md"));
   const existingClaudeMd = claudeMdContent ? claudeMdContent.slice(0, SOURCE_CONTENT_LIMIT) : void 0;
-  const readmeContent = readFileOrNull(path10.join(absPath, "README.md"));
+  const readmeContent = readFileOrNull(path11.join(absPath, "README.md"));
   const readmeExcerpt = readmeContent ? readmeContent.slice(0, README_CONTENT_LIMIT) : void 0;
   const gitRemoteUrl = getGitRemoteUrl(absPath);
   return {
-    name: packageName || path10.basename(absPath),
+    name: packageName || path11.basename(absPath),
     type: "repo",
     role: config.role || "related-repo",
     description: config.description || "",
@@ -4302,7 +4419,7 @@ function collectFileSummary(resolved, projectDir) {
   const { config, origin, absPath } = resolved;
   const content = readFileOrNull(absPath);
   return {
-    name: path10.basename(absPath),
+    name: path11.basename(absPath),
     type: "file",
     role: config.role || "reference-doc",
     description: config.description || content?.slice(0, 100).split("\n")[0] || "",
@@ -4346,15 +4463,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
-function readFileOrNull2(path40) {
+function readFileOrNull2(path41) {
   try {
-    return readFileSync2(path40, "utf-8");
+    return readFileSync2(path41, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path40) {
-  const content = readFileOrNull2(path40);
+function readJsonOrNull(path41) {
+  const content = readFileOrNull2(path41);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -4945,17 +5062,17 @@ import fs19 from "fs";
 
 // src/writers/claude/index.ts
 init_pre_commit_block();
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs12.writeFileSync("CLAUDE.md", appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.claudeMd))));
+  fs13.writeFileSync("CLAUDE.md", appendManagedBlocks(config.claudeMd, "claude"));
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      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 skillDir = path12.join(".claude", "skills", skill.name);
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4963,21 +5080,21 @@ function writeClaudeConfig(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) {
     let existingServers = {};
     try {
-      if (fs12.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
+      if (fs13.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs13.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs13.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
@@ -4985,30 +5102,31 @@ function writeClaudeConfig(config) {
 
 // src/writers/cursor/index.ts
 init_pre_commit_block();
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs13.writeFileSync(".cursorrules", config.cursorrules);
+    fs14.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
   const learningsRule = getCursorLearningsRule();
   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 });
+  const setupRule = getCursorSetupRule();
+  const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule, setupRule];
+  const rulesDir = path13.join(".cursor", "rules");
+  if (!fs14.existsSync(rulesDir)) fs14.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
-    const rulePath = path12.join(rulesDir, rule.filename);
-    fs13.writeFileSync(rulePath, rule.content);
+    const rulePath = path13.join(rulesDir, rule.filename);
+    fs14.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      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 skillDir = path13.join(".cursor", "skills", skill.name);
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path13.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -5016,24 +5134,24 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs13.existsSync(cursorDir)) fs13.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path12.join(cursorDir, "mcp.json");
+    if (!fs14.existsSync(cursorDir)) fs14.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path13.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs13.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
+      if (fs14.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs14.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs14.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -5041,17 +5159,17 @@ function writeCursorConfig(config) {
 
 // src/writers/codex/index.ts
 init_pre_commit_block();
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs14.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  fs15.writeFileSync("AGENTS.md", appendManagedBlocks(config.agentsMd, "codex"));
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      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 skillDir = path14.join(".agents", "skills", skill.name);
+      if (!fs15.existsSync(skillDir)) fs15.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path14.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -5059,7 +5177,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs14.writeFileSync(skillPath, frontmatter + skill.content);
+      fs15.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -5068,20 +5186,20 @@ function writeCodexConfig(config) {
 
 // src/writers/github-copilot/index.ts
 init_pre_commit_block();
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path15 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs15.mkdirSync(".github", { recursive: true });
-    fs15.writeFileSync(path14.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.instructions))));
+    fs16.mkdirSync(".github", { recursive: true });
+    fs16.writeFileSync(path15.join(".github", "copilot-instructions.md"), appendManagedBlocks(config.instructions, "copilot"));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
-    const instructionsDir = path14.join(".github", "instructions");
-    fs15.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path15.join(".github", "instructions");
+    fs16.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs15.writeFileSync(path14.join(instructionsDir, file.filename), file.content);
+      fs16.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -5089,30 +5207,30 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs16 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path16 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path15.join(BACKUPS_DIR, timestamp);
+  const backupDir = path16.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    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 });
+    if (!fs17.existsSync(file)) continue;
+    const dest = path16.join(backupDir, file);
+    const destDir = path16.dirname(dest);
+    if (!fs17.existsSync(destDir)) {
+      fs17.mkdirSync(destDir, { recursive: true });
     }
-    fs16.copyFileSync(file, dest);
+    fs17.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  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 });
+  const backupFile = path16.join(backupDir, file);
+  if (!fs17.existsSync(backupFile)) return false;
+  const destDir = path16.dirname(file);
+  if (!fs17.existsSync(destDir)) {
+    fs17.mkdirSync(destDir, { recursive: true });
   }
-  fs16.copyFileSync(backupFile, file);
+  fs17.copyFileSync(backupFile, file);
   return true;
 }
 
@@ -5674,6 +5792,9 @@ async function runInteractiveProviderSetup(options) {
   return config;
 }
 
+// src/commands/init.ts
+import confirm2 from "@inquirer/confirm";
+
 // src/scoring/index.ts
 import { existsSync as existsSync7 } from "fs";
 import { join as join9 } from "path";
@@ -6672,8 +6793,8 @@ function detectTargetAgent(dir) {
   const agents = [];
   if (existsSync7(join9(dir, "CLAUDE.md")) || existsSync7(join9(dir, ".claude", "skills"))) agents.push("claude");
   if (existsSync7(join9(dir, ".cursorrules")) || existsSync7(join9(dir, ".cursor", "rules"))) agents.push("cursor");
-  if (existsSync7(join9(dir, ".codex")) || existsSync7(join9(dir, ".agents", "skills"))) agents.push("codex");
-  if (existsSync7(join9(dir, ".github", "copilot-instructions.md"))) agents.push("github-copilot");
+  if (existsSync7(join9(dir, ".codex")) || existsSync7(join9(dir, ".agents", "skills")) || existsSync7(join9(dir, "AGENTS.md"))) agents.push("codex");
+  if (existsSync7(join9(dir, ".github", "copilot-instructions.md")) || existsSync7(join9(dir, ".github", "instructions"))) agents.push("github-copilot");
   return agents.length > 0 ? agents : ["claude"];
 }
 function computeLocalScore(dir, targetAgent) {
@@ -6927,11 +7048,57 @@ function getMachineId() {
   return machineId;
 }
 var EMAIL_HASH_KEY = "caliber-telemetry-v1";
-function getGitEmailHash() {
+var PERSONAL_DOMAINS = /* @__PURE__ */ new Set([
+  "gmail.com",
+  "googlemail.com",
+  "outlook.com",
+  "hotmail.com",
+  "live.com",
+  "yahoo.com",
+  "yahoo.co.uk",
+  "icloud.com",
+  "me.com",
+  "mac.com",
+  "aol.com",
+  "protonmail.com",
+  "proton.me",
+  "pm.me",
+  "mail.com",
+  "zoho.com",
+  "yandex.com",
+  "gmx.com",
+  "gmx.net",
+  "fastmail.com",
+  "tutanota.com",
+  "tuta.io"
+]);
+function getGitEmail() {
   try {
     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");
+    return email || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getGitEmailInfo() {
+  const email = getGitEmail();
+  if (!email) return {};
+  const hash = crypto4.createHmac("sha256", EMAIL_HASH_KEY).update(email).digest("hex");
+  let domain;
+  if (email.includes("@")) {
+    const d = email.split("@")[1].toLowerCase();
+    if (!PERSONAL_DOMAINS.has(d)) domain = d;
+  }
+  return { hash, domain };
+}
+function getRepoHash() {
+  try {
+    const remote = execSync13("git remote get-url origin || git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!remote) return void 0;
+    return crypto4.createHmac("sha256", EMAIL_HASH_KEY).update(remote).digest("hex").slice(0, 16);
   } catch {
     return void 0;
   }
@@ -6956,6 +7123,7 @@ function markNoticeShown() {
 var POSTHOG_KEY = "phc_XXrV0pSX4s2QVxVoOaeuyXDvtlRwPAjovt1ttMGVMPp";
 var client = null;
 var distinctId = null;
+var superProperties = {};
 function initTelemetry() {
   if (isTelemetryDisabled()) return;
   const machineId = getMachineId();
@@ -6971,11 +7139,17 @@ function initTelemetry() {
     );
     markNoticeShown();
   }
-  const gitEmailHash = getGitEmailHash();
+  const { hash: gitEmailHash, domain: emailDomain } = getGitEmailInfo();
+  const repoHash = getRepoHash();
+  superProperties = {
+    ...repoHash ? { repo_hash: repoHash } : {},
+    ...emailDomain ? { email_domain: emailDomain } : {}
+  };
   client.identify({
     distinctId: machineId,
     properties: {
-      ...gitEmailHash ? { git_email_hash: gitEmailHash } : {}
+      ...gitEmailHash ? { git_email_hash: gitEmailHash } : {},
+      ...emailDomain ? { email_domain: emailDomain } : {}
     }
   });
 }
@@ -6984,7 +7158,7 @@ function trackEvent(name, properties) {
   client.capture({
     distinctId,
     event: name,
-    properties: properties ?? {}
+    properties: { ...superProperties, ...properties }
   });
 }
 async function flushTelemetry() {
@@ -7033,11 +7207,14 @@ function trackInitSkillsSearch(searched, installedCount) {
 function trackInitScoreRegression(oldScore, newScore) {
   trackEvent("init_score_regression", { old_score: oldScore, new_score: newScore });
 }
+function trackInitCompleted(path41, score) {
+  trackEvent("init_completed", { path: path41, score });
+}
 function trackRegenerateCompleted(action, durationMs) {
   trackEvent("regenerate_completed", { action, duration_ms: durationMs });
 }
-function trackRefreshCompleted(changesCount, durationMs) {
-  trackEvent("refresh_completed", { changes_count: changesCount, duration_ms: durationMs });
+function trackRefreshCompleted(changesCount, durationMs, trigger) {
+  trackEvent("refresh_completed", { changes_count: changesCount, duration_ms: durationMs, trigger: trigger ?? "manual" });
 }
 function trackScoreComputed(score, agent) {
   trackEvent("score_computed", { score, agent });
@@ -7051,6 +7228,9 @@ function trackSkillsInstalled(count) {
 function trackUndoExecuted() {
   trackEvent("undo_executed");
 }
+function trackUninstallExecuted() {
+  trackEvent("uninstall_executed");
+}
 function trackInitLearnEnabled(enabled) {
   trackEvent("init_learn_enabled", { enabled });
 }
@@ -7985,11 +8165,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path40) => {
-    const cached = existsCache.get(path40);
+  const cachedExists = (path41) => {
+    const cached = existsCache.get(path41);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path40);
-    existsCache.set(path40, result);
+    const result = existsSync9(path41);
+    existsCache.set(path41, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -8769,25 +8949,6 @@ async function promptAgent(detected) {
   });
   return selected;
 }
-async function promptLearnInstall(targetAgent) {
-  const hasClaude = targetAgent.includes("claude");
-  const hasCursor = targetAgent.includes("cursor");
-  const agentName = hasClaude && hasCursor ? "Claude and Cursor" : hasClaude ? "Claude" : "Cursor";
-  console.log(chalk11.bold(`
-  Session Learning
-`));
-  console.log(chalk11.dim(`  Caliber can learn from your ${agentName} sessions \u2014 when a tool fails`));
-  console.log(chalk11.dim(`  or you correct a mistake, it captures the lesson so it won't`));
-  console.log(chalk11.dim(`  happen again. Runs once at session end using the fast model.
-`));
-  return select5({
-    message: "Enable session learning?",
-    choices: [
-      { name: "Enable session learning (recommended)", value: true },
-      { name: "Skip for now", value: false }
-    ]
-  });
-}
 async function promptReviewAction(hasSkillResults, hasChanges, staged) {
   if (!hasChanges && !hasSkillResults) return "accept";
   const choices = [];
@@ -9246,10 +9407,9 @@ async function initCommand(options) {
     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. Setup      Detect stack, install sync hooks & skills"));
-    console.log(chalk14.dim("  3. Generate   Audit existing config or generate from scratch"));
-    console.log(chalk14.dim("  4. Finalize   Review changes and score your setup\n"));
+    console.log(chalk14.dim("  1. Connect    Auto-detect your LLM provider and agents"));
+    console.log(chalk14.dim("  2. Build      Install sync, scan your project, generate configs"));
+    console.log(chalk14.dim("  3. Done       Review score and start syncing\n"));
   } else {
     console.log(brand.bold("\n  CALIBER") + chalk14.dim("  \u2014 setting up continuous sync\n"));
   }
@@ -9259,19 +9419,50 @@ async function initCommand(options) {
     console.log(chalk14.yellow("    Caliber will still generate config files, but they won't be auto-installed.\n"));
   }
   const report = options.debugReport ? new DebugReport() : null;
-  console.log(title.bold("  Step 1/4 \u2014 Connect\n"));
+  console.log(title.bold("  Step 1/3 \u2014 Connect\n"));
   let config = loadConfig();
+  if (!config && !options.autoApprove) {
+    if (isClaudeCliAvailable()) {
+      console.log(chalk14.dim("  Detected: Claude Code CLI (uses your Pro/Max/Team subscription)\n"));
+      const useIt = await confirm2({ message: "Use Claude Code as your LLM provider?" });
+      if (useIt) {
+        const autoConfig = { provider: "claude-cli", model: "default" };
+        writeConfigFile(autoConfig);
+        config = autoConfig;
+      }
+    } else if (isCursorAgentAvailable() && isCursorLoggedIn()) {
+      console.log(chalk14.dim("  Detected: Cursor (uses your existing subscription)\n"));
+      const useIt = await confirm2({ message: "Use Cursor as your LLM provider?" });
+      if (useIt) {
+        const autoConfig = { provider: "cursor", model: "sonnet-4.6" };
+        writeConfigFile(autoConfig);
+        config = autoConfig;
+      }
+    }
+  }
   if (!config) {
-    console.log(chalk14.dim("  No LLM provider configured yet.\n"));
-    await runInteractiveProviderSetup({
-      selectMessage: "How do you want to use Caliber? (choose LLM provider)"
-    });
-    config = loadConfig();
+    if (options.autoApprove) {
+      if (isClaudeCliAvailable()) {
+        const autoConfig = { provider: "claude-cli", model: "default" };
+        writeConfigFile(autoConfig);
+        config = autoConfig;
+      } else if (isCursorAgentAvailable() && isCursorLoggedIn()) {
+        const autoConfig = { provider: "cursor", model: "sonnet-4.6" };
+        writeConfigFile(autoConfig);
+        config = autoConfig;
+      }
+    }
     if (!config) {
-      console.log(chalk14.red("  Configuration cancelled or failed.\n"));
-      throw new Error("__exit__");
+      console.log(chalk14.dim("  No LLM provider detected.\n"));
+      await runInteractiveProviderSetup({
+        selectMessage: "How do you want to use Caliber? (choose LLM provider)"
+      });
+      config = loadConfig();
+      if (!config) {
+        console.log(chalk14.red("  Configuration cancelled or failed.\n"));
+        throw new Error("__exit__");
+      }
     }
-    console.log(chalk14.green("  \u2713 Provider saved\n"));
   }
   trackInitProviderSelected(config.provider, config.model, firstRun);
   const displayModel = getDisplayModel(config);
@@ -9289,21 +9480,28 @@ async function initCommand(options) {
   const agentAutoDetected = !options.agent;
   if (options.agent) {
     targetAgent = options.agent;
-  } else if (options.autoApprove) {
-    targetAgent = ["claude"];
-    log(options.verbose, "Auto-approve: defaulting to claude agent");
   } else {
     const detected = detectAgents(process.cwd());
-    targetAgent = await promptAgent(detected.length > 0 ? detected : void 0);
+    if (detected.length > 0 && (options.autoApprove || firstRun)) {
+      targetAgent = detected;
+      console.log(chalk14.dim(`  Detected agents: ${detected.join(", ")}
+`));
+    } else if (detected.length > 0) {
+      console.log(chalk14.dim(`  Detected agents: ${detected.join(", ")}
+`));
+      const useDetected = await confirm2({ message: "Use detected agents?" });
+      targetAgent = useDetected ? detected : await promptAgent();
+    } else {
+      targetAgent = options.autoApprove ? ["claude"] : await promptAgent();
+    }
   }
   console.log(chalk14.dim(`  Target: ${targetAgent.join(", ")}
 `));
   trackInitAgentSelected(targetAgent, agentAutoDetected);
-  console.log(title.bold("  Step 2/4 \u2014 Setup\n"));
-  console.log(chalk14.dim("  Installing sync infrastructure...\n"));
+  console.log(title.bold("  Step 2/3 \u2014 Build\n"));
   const hookResult = installPreCommitHook();
   if (hookResult.installed) {
-    console.log(`  ${chalk14.green("\u2713")} Pre-commit hook installed \u2014 configs sync on every commit`);
+    console.log(`  ${chalk14.green("\u2713")} Pre-commit hook installed`);
   } else if (hookResult.alreadyInstalled) {
     console.log(`  ${chalk14.green("\u2713")} Pre-commit hook \u2014 active`);
   }
@@ -9315,21 +9513,18 @@ async function initCommand(options) {
   }
   const skillsWritten = ensureBuiltinSkills2();
   if (skillsWritten.length > 0) {
-    console.log(`  ${chalk14.green("\u2713")} Agent skills installed \u2014 /setup-caliber, /find-skills, /save-learning`);
-  } else {
-    console.log(`  ${chalk14.green("\u2713")} Agent skills \u2014 already installed`);
+    console.log(`  ${chalk14.green("\u2713")} Agent skills installed`);
+  }
+  const hasLearnableAgent = targetAgent.includes("claude") || targetAgent.includes("cursor");
+  if (hasLearnableAgent) {
+    if (targetAgent.includes("claude")) installLearningHooks();
+    if (targetAgent.includes("cursor")) installCursorLearningHooks();
+    console.log(`  ${chalk14.green("\u2713")} Session learning enabled`);
+    trackInitLearnEnabled(true);
   }
   console.log("");
-  console.log(chalk14.dim("  New team members can run /setup-caliber inside their coding agent"));
-  console.log(chalk14.dim("  (Claude Code or Cursor) to get set up automatically.\n"));
   let baselineScore = computeLocalScore(process.cwd(), targetAgent);
-  console.log(chalk14.dim("  Current config score:"));
-  displayScoreSummary(baselineScore);
-  if (options.verbose) {
-    for (const c of baselineScore.checks) {
-      log(options.verbose, `  ${c.passed ? "\u2713" : "\u2717"} ${c.name}: ${c.earnedPoints}/${c.maxPoints}${c.suggestion ? ` \u2014 ${c.suggestion}` : ""}`);
-    }
-  }
+  log(options.verbose, `Baseline score: ${baselineScore.score}/100`);
   if (report) {
     report.markStep("Baseline scoring");
     report.addSection("Scoring: Baseline", `**Score**: ${baselineScore.score}/100
@@ -9350,34 +9545,23 @@ async function initCommand(options) {
   ]);
   const passingCount = baselineScore.checks.filter((c) => c.passed).length;
   const failingCount = baselineScore.checks.filter((c) => !c.passed).length;
+  trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
   let skipGeneration = false;
-  if (hasExistingConfig && baselineScore.score === 100) {
-    trackInitScoreComputed(baselineScore.score, passingCount, failingCount, true);
-    console.log(chalk14.bold.green("\n  Your config is already optimal.\n"));
-    skipGeneration = !options.force;
+  if (hasExistingConfig && baselineScore.score === 100 && !options.force) {
+    skipGeneration = true;
   } else if (hasExistingConfig && !options.force && !options.autoApprove) {
-    trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
-    console.log(chalk14.dim("\n  Sync infrastructure is ready. Caliber can also audit your existing"));
-    console.log(chalk14.dim("  configs and improve them using AI.\n"));
-    const auditAnswer = await promptInput("  Audit and improve your existing config? (Y/n) ");
-    skipGeneration = auditAnswer.toLowerCase() === "n";
-  } else if (!hasExistingConfig && !options.force && !options.autoApprove) {
-    trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
-    console.log(chalk14.dim("\n  Sync infrastructure is ready. Caliber can also generate tailored"));
-    console.log(chalk14.dim("  CLAUDE.md, Cursor rules, and Codex configs for your project.\n"));
-    const generateAnswer = await promptInput("  Generate agent configs? (Y/n) ");
-    skipGeneration = generateAnswer.toLowerCase() === "n";
-  } else {
-    trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
+    console.log(chalk14.dim(`  Config score: ${baselineScore.score}/100 \u2014 Caliber can improve this.
+`));
+    const improveAnswer = await confirm2({ message: "Improve your existing configs?" });
+    skipGeneration = !improveAnswer;
   }
   if (skipGeneration) {
     const {
-      appendPreCommitBlock: appendPreCommitBlock2,
-      appendLearningsBlock: appendLearningsBlock2,
-      appendSyncBlock: appendSyncBlock2,
+      appendManagedBlocks: appendManagedBlocks2,
       getCursorPreCommitRule: getCursorPreCommitRule2,
       getCursorLearningsRule: getCursorLearningsRule2,
-      getCursorSyncRule: getCursorSyncRule2
+      getCursorSyncRule: getCursorSyncRule2,
+      getCursorSetupRule: getCursorSetupRule2
     } = await Promise.resolve().then(() => (init_pre_commit_block(), pre_commit_block_exports));
     const claudeMdPath = "CLAUDE.md";
     let claudeContent = "";
@@ -9389,7 +9573,7 @@ async function initCommand(options) {
       claudeContent = `# ${path26.basename(process.cwd())}
 `;
     }
-    const updatedClaude = appendSyncBlock2(appendLearningsBlock2(appendPreCommitBlock2(claudeContent)));
+    const updatedClaude = appendManagedBlocks2(claudeContent, "claude");
     if (updatedClaude !== claudeContent || !fs33.existsSync(claudeMdPath)) {
       fs33.writeFileSync(claudeMdPath, updatedClaude);
       console.log(`  ${chalk14.green("\u2713")} CLAUDE.md \u2014 added Caliber sync instructions`);
@@ -9397,7 +9581,7 @@ async function initCommand(options) {
     if (targetAgent.includes("cursor")) {
       const rulesDir = path26.join(".cursor", "rules");
       if (!fs33.existsSync(rulesDir)) fs33.mkdirSync(rulesDir, { recursive: true });
-      for (const rule of [getCursorPreCommitRule2(), getCursorLearningsRule2(), getCursorSyncRule2()]) {
+      for (const rule of [getCursorPreCommitRule2(), getCursorLearningsRule2(), getCursorSyncRule2(), getCursorSetupRule2()]) {
         fs33.writeFileSync(path26.join(rulesDir, rule.filename), rule.content);
       }
       console.log(`  ${chalk14.green("\u2713")} Cursor rules \u2014 added Caliber sync rules`);
@@ -9414,7 +9598,7 @@ async function initCommand(options) {
         copilotContent = `# ${path26.basename(process.cwd())}
 `;
       }
-      const updatedCopilot = appendSyncBlock2(appendLearningsBlock2(appendPreCommitBlock2(copilotContent)));
+      const updatedCopilot = appendManagedBlocks2(copilotContent, "copilot");
       if (updatedCopilot !== copilotContent) {
         fs33.writeFileSync(copilotPath, updatedCopilot);
         console.log(`  ${chalk14.green("\u2713")} Copilot instructions \u2014 added Caliber sync instructions`);
@@ -9426,6 +9610,7 @@ async function initCommand(options) {
       lastRefreshTimestamp: (/* @__PURE__ */ new Date()).toISOString(),
       targetAgent
     });
+    trackInitCompleted("sync-only", baselineScore.score);
     console.log(chalk14.bold.green("\n  Caliber sync is set up!\n"));
     console.log(chalk14.dim("  Your agent configs will sync automatically on every commit."));
     console.log(chalk14.dim("  Run ") + title(`${bin} init --force`) + chalk14.dim(" anytime to generate or improve configs.\n"));
@@ -9433,7 +9618,6 @@ async function initCommand(options) {
   }
   const allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
   const llmFixableChecks = allFailingChecks.filter((c) => !NON_LLM_CHECKS.has(c.id));
-  console.log(title.bold("\n  Step 3/4 \u2014 Generate\n"));
   const genModelInfo = fastModel ? `  Using ${displayModel} for docs, ${fastModel} for skills` : `  Using ${displayModel}`;
   console.log(chalk14.dim(genModelInfo + "\n"));
   if (report) report.markStep("Generation");
@@ -9632,7 +9816,7 @@ async function initCommand(options) {
     report.addJson("Generation: Parsed Config", generatedSetup);
   }
   log(options.verbose, `Generation completed: ${elapsedMs}ms, stopReason: ${genStopReason || "end_turn"}`);
-  console.log(title.bold("  Step 4/4 \u2014 Finalize\n"));
+  console.log(title.bold("  Step 3/3 \u2014 Done\n"));
   const setupFiles = collectSetupFiles(generatedSetup, targetAgent);
   const staged = stageFiles(setupFiles, process.cwd());
   const totalChanges = staged.newFiles + staged.modifiedFiles;
@@ -9776,6 +9960,7 @@ ${agentRefs.join(" ")}
 ` + afterScore.checks.map((c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.earnedPoints} | ${c.maxPoints} |`).join("\n"));
   }
   recordScore(afterScore, "init");
+  trackInitCompleted("full-generation", afterScore.score);
   displayScoreDelta(baselineScore, afterScore);
   if (options.verbose) {
     log(options.verbose, `Final score: ${afterScore.score}/100`);
@@ -9793,64 +9978,26 @@ ${agentRefs.join(" ")}
       communitySkillsInstalled = selected.length;
     }
   }
-  console.log("");
-  console.log(`  ${chalk14.green("\u2713")} Docs auto-refresh          ${chalk14.dim(`agents run ${resolveCaliber()} refresh before commits`)}`);
   trackInitHookSelected("config-instructions");
-  const hasLearnableAgent = targetAgent.includes("claude") || targetAgent.includes("cursor");
-  let enableLearn = false;
-  if (hasLearnableAgent) {
-    if (!options.autoApprove) {
-      enableLearn = await promptLearnInstall(targetAgent);
-      trackInitLearnEnabled(enableLearn);
-      if (enableLearn) {
-        if (targetAgent.includes("claude")) {
-          const r = installLearningHooks();
-          if (r.installed) console.log(`  ${chalk14.green("\u2713")} Learning hooks installed for Claude Code`);
-          else if (r.alreadyInstalled) console.log(chalk14.dim("  Claude Code learning hooks already installed"));
-        }
-        if (targetAgent.includes("cursor")) {
-          const r = installCursorLearningHooks();
-          if (r.installed) console.log(`  ${chalk14.green("\u2713")} Learning hooks installed for Cursor`);
-          else if (r.alreadyInstalled) console.log(chalk14.dim("  Cursor learning hooks already installed"));
-        }
-        console.log(chalk14.dim("    Run ") + chalk14.hex("#83D1EB")(`${bin} learn status`) + chalk14.dim(" to see insights"));
-      } else {
-        console.log(chalk14.dim("  Skipped. Run ") + chalk14.hex("#83D1EB")(`${bin} learn install`) + chalk14.dim(" later to enable."));
-      }
-    } else {
-      enableLearn = true;
-      if (targetAgent.includes("claude")) installLearningHooks();
-      if (targetAgent.includes("cursor")) installCursorLearningHooks();
-    }
-  }
-  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"));
-  console.log(`    ${done}  Continuous sync          ${chalk14.dim("pre-commit hook keeps all agent configs in sync")}`);
-  console.log(`    ${done}  Config generated         ${title(`${bin} score`)} ${chalk14.dim("for full breakdown")}`);
-  console.log(`    ${done}  Agent skills             ${chalk14.dim("/setup-caliber for new team members")}`);
+  console.log(chalk14.bold.green("\n  Caliber is set up!\n"));
+  console.log(chalk14.bold("  What's configured:\n"));
+  console.log(`    ${done}  Continuous sync     ${chalk14.dim("pre-commit hook keeps all agent configs in sync")}`);
+  console.log(`    ${done}  Config generated    ${chalk14.dim(`score: ${afterScore.score}/100`)}`);
+  console.log(`    ${done}  Agent skills        ${chalk14.dim("/setup-caliber for new team members")}`);
   if (hasLearnableAgent) {
-    if (enableLearn) {
-      console.log(`    ${done}  Session learning         ${chalk14.dim("agent learns from your feedback")}`);
-    } else {
-      console.log(`    ${skip}  Session learning         ${title(`${bin} learn install`)} ${chalk14.dim("to enable later")}`);
-    }
+    console.log(`    ${done}  Session learning    ${chalk14.dim("learns from your corrections")}`);
   }
   if (communitySkillsInstalled > 0) {
-    console.log(`    ${done}  Community skills         ${chalk14.dim(`${communitySkillsInstalled} skill${communitySkillsInstalled > 1 ? "s" : ""} installed for your stack`)}`);
-  } else if (skillSearchResult.results.length > 0) {
-    console.log(`    ${skip}  Community skills         ${chalk14.dim("available but skipped")}`);
+    console.log(`    ${done}  Community skills    ${chalk14.dim(`${communitySkillsInstalled} installed for your stack`)}`);
   }
   console.log(chalk14.bold("\n  What happens next:\n"));
-  console.log(chalk14.dim("    Every commit will automatically sync your agent configs."));
-  console.log(chalk14.dim("    New team members can run /setup-caliber to get set up instantly.\n"));
-  console.log(chalk14.bold("  Explore:\n"));
-  console.log(`    ${title(`${bin} score`)}        Full scoring breakdown with improvement tips`);
-  console.log(`    ${title(`${bin} skills`)}       Find community skills for your stack`);
-  console.log(`    ${title(`${bin} undo`)}         Revert all changes from this run`);
+  console.log(chalk14.dim("    Every commit syncs your agent configs automatically."));
+  console.log(chalk14.dim("    New team members run /setup-caliber to get set up instantly.\n"));
+  console.log(`    ${title(`${bin} score`)}        Full scoring breakdown`);
+  console.log(`    ${title(`${bin} skills`)}       Find community skills`);
+  console.log(`    ${title(`${bin} undo`)}         Revert changes`);
+  console.log(`    ${title(`${bin} uninstall`)}    Remove Caliber completely`);
   console.log("");
   if (options.showTokens) {
     displayTokenUsage();
@@ -10193,14 +10340,24 @@ var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
   "README.md",
+  "AGENTS.md",
   ".cursorrules",
   ".cursor/rules/",
+  ".cursor/skills/",
   ".claude/skills/",
+  ".agents/skills/",
+  ".github/copilot-instructions.md",
+  ".github/instructions/",
   "CALIBER_LEARNINGS.md"
 ];
 function excludeArgs() {
   return DOC_PATTERNS.flatMap((p) => ["--", `:!${p}`]);
 }
+function truncateAtLine(text, maxBytes) {
+  if (text.length <= maxBytes) return text;
+  const cut = text.lastIndexOf("\n", maxBytes);
+  return cut > 0 ? text.slice(0, cut) : text.slice(0, maxBytes);
+}
 function safeExec(cmd) {
   try {
     return execSync15(cmd, {
@@ -10246,9 +10403,9 @@ function collectDiff(lastSha) {
   const totalSize = committedDiff.length + stagedDiff.length + unstagedDiff.length;
   if (totalSize > MAX_DIFF_BYTES) {
     const ratio = MAX_DIFF_BYTES / totalSize;
-    committedDiff = committedDiff.slice(0, Math.floor(committedDiff.length * ratio));
-    stagedDiff = stagedDiff.slice(0, Math.floor(stagedDiff.length * ratio));
-    unstagedDiff = unstagedDiff.slice(0, Math.floor(unstagedDiff.length * ratio));
+    committedDiff = truncateAtLine(committedDiff, Math.floor(committedDiff.length * ratio));
+    stagedDiff = truncateAtLine(stagedDiff, Math.floor(stagedDiff.length * ratio));
+    unstagedDiff = truncateAtLine(unstagedDiff, Math.floor(unstagedDiff.length * ratio));
   }
   const hasChanges = !!(committedDiff || stagedDiff || unstagedDiff || changedFiles.length);
   const parts = [];
@@ -10267,13 +10424,17 @@ import path28 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs36.writeFileSync("CLAUDE.md", appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.claudeMd))));
+    fs36.writeFileSync("CLAUDE.md", appendManagedBlocks(docs.claudeMd, "claude"));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
     fs36.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
+  if (docs.agentsMd) {
+    fs36.writeFileSync("AGENTS.md", appendManagedBlocks(docs.agentsMd, "codex"));
+    written.push("AGENTS.md");
+  }
   if (docs.cursorrules) {
     fs36.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
@@ -10296,7 +10457,7 @@ function writeRefreshDocs(docs) {
   }
   if (docs.copilotInstructions) {
     fs36.mkdirSync(".github", { recursive: true });
-    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions))));
+    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendManagedBlocks(docs.copilotInstructions, "copilot"));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
@@ -10315,10 +10476,18 @@ init_config();
 async function refreshDocs(diff, existingDocs, projectContext, learnedSection, sources2) {
   const prompt = buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection, sources2);
   const fastModel = getFastModel();
+  const docCount = [
+    existingDocs.claudeMd,
+    existingDocs.readmeMd,
+    existingDocs.agentsMd,
+    existingDocs.cursorrules,
+    existingDocs.copilotInstructions
+  ].filter(Boolean).length + (existingDocs.cursorRules?.length ?? 0) + (existingDocs.claudeSkills?.length ?? 0);
+  const maxTokens = Math.min(32768, Math.max(8192, docCount * 4096));
   const raw = await llmCall({
     system: REFRESH_SYSTEM_PROMPT,
     prompt,
-    maxTokens: 16384,
+    maxTokens,
     ...fastModel ? { model: fastModel } : {}
   });
   return parseJsonResponse(raw);
@@ -10377,6 +10546,21 @@ Changed files: ${diff.changedFiles.join(", ")}`);
       parts.push(rule.content);
     }
   }
+  if (existingDocs.agentsMd) {
+    parts.push("\n[AGENTS.md]");
+    parts.push(existingDocs.agentsMd);
+  }
+  if (existingDocs.copilotInstructions) {
+    parts.push("\n[.github/copilot-instructions.md]");
+    parts.push(existingDocs.copilotInstructions);
+  }
+  if (existingDocs.copilotInstructionFiles?.length) {
+    for (const file of existingDocs.copilotInstructionFiles) {
+      parts.push(`
+[.github/instructions/${file.filename}]`);
+      parts.push(file.content);
+    }
+  }
   if (learnedSection) {
     parts.push("\n--- Learned Patterns (from session learning) ---");
     parts.push("Consider these accumulated learnings when deciding what to update:");
@@ -10699,7 +10883,8 @@ async function refreshSingleRepo(repoDir, options) {
     }
   }
   const written = writeRefreshDocs(response.updatedDocs);
-  trackRefreshCompleted(written.length, Date.now());
+  const trigger = quiet ? "hook" : "manual";
+  trackRefreshCompleted(written.length, Date.now(), trigger);
   const postScore = computeLocalScore(repoDir, targetAgent);
   if (postScore.score < preScore.score) {
     for (const [filePath, content] of preRefreshContents) {
@@ -12403,10 +12588,199 @@ async function publishCommand() {
   }
 }
 
+// src/commands/bootstrap.ts
+init_builtin_skills();
+import fs47 from "fs";
+import chalk27 from "chalk";
+var PLATFORM_SKILL_DIRS = {
+  claude: ".claude/skills",
+  cursor: ".cursor/skills",
+  codex: ".agents/skills"
+};
+async function bootstrapCommand() {
+  const platforms = detectPlatforms();
+  const detected = [];
+  if (platforms.claude) detected.push("claude");
+  if (platforms.cursor) detected.push("cursor");
+  if (platforms.codex) detected.push("codex");
+  if (detected.length === 0) detected.push("claude");
+  const written = [];
+  for (const platform of detected) {
+    const skillsDir = PLATFORM_SKILL_DIRS[platform];
+    if (!skillsDir) continue;
+    for (const skill of BUILTIN_SKILLS) {
+      const skillDir = `${skillsDir}/${skill.name}`;
+      const skillPath = `${skillDir}/SKILL.md`;
+      fs47.mkdirSync(skillDir, { recursive: true });
+      fs47.writeFileSync(skillPath, buildSkillContent(skill));
+      written.push(skillPath);
+    }
+  }
+  if (written.length === 0) {
+    console.log(chalk27.yellow("No skills were written."));
+    return;
+  }
+  console.log(chalk27.bold.green("\n  Caliber skills installed!\n"));
+  for (const file of written) {
+    console.log(`  ${chalk27.green("\u2713")} ${file}`);
+  }
+  console.log(chalk27.dim("\n  Your agent can now run /setup-caliber to complete the setup."));
+  console.log(chalk27.dim('  Just tell your agent: "Run /setup-caliber"\n'));
+}
+
+// src/commands/uninstall.ts
+import fs48 from "fs";
+import path38 from "path";
+import chalk28 from "chalk";
+import confirm3 from "@inquirer/confirm";
+init_pre_commit_block();
+init_builtin_skills();
+init_config();
+var MANAGED_DOC_FILES = [
+  "CLAUDE.md",
+  path38.join(".github", "copilot-instructions.md"),
+  "AGENTS.md"
+];
+var SKILL_DIRS = PLATFORM_CONFIGS.map((c) => c.skillsDir);
+var CURSOR_RULES_DIR = path38.join(".cursor", "rules");
+function removeCaliberCursorRules() {
+  const removed = [];
+  if (!fs48.existsSync(CURSOR_RULES_DIR)) return removed;
+  for (const file of fs48.readdirSync(CURSOR_RULES_DIR)) {
+    if (file.startsWith("caliber-") && file.endsWith(".mdc")) {
+      const fullPath = path38.join(CURSOR_RULES_DIR, file);
+      fs48.unlinkSync(fullPath);
+      removed.push(fullPath);
+    }
+  }
+  return removed;
+}
+function removeBuiltinSkills() {
+  const removed = [];
+  for (const skillsDir of SKILL_DIRS) {
+    if (!fs48.existsSync(skillsDir)) continue;
+    for (const name of BUILTIN_SKILL_NAMES) {
+      const skillDir = path38.join(skillsDir, name);
+      if (fs48.existsSync(skillDir)) {
+        fs48.rmSync(skillDir, { recursive: true });
+        removed.push(skillDir);
+      }
+    }
+  }
+  return removed;
+}
+function stripManagedBlocksFromFiles() {
+  const modified = [];
+  for (const filePath of MANAGED_DOC_FILES) {
+    if (!fs48.existsSync(filePath)) continue;
+    const original = fs48.readFileSync(filePath, "utf-8");
+    const stripped = stripManagedBlocks(original);
+    if (stripped !== original) {
+      const trimmed = stripped.trim();
+      if (!trimmed || /^#\s*\S*$/.test(trimmed)) {
+        fs48.unlinkSync(filePath);
+      } else {
+        fs48.writeFileSync(filePath, stripped);
+      }
+      modified.push(filePath);
+    }
+  }
+  return modified;
+}
+function removeDirectory(dir) {
+  if (!fs48.existsSync(dir)) return false;
+  fs48.rmSync(dir, { recursive: true });
+  return true;
+}
+async function uninstallCommand(options) {
+  console.log(chalk28.bold("\n  Caliber Uninstall\n"));
+  console.log(chalk28.dim("  This will remove all Caliber resources from this project:\n"));
+  console.log(chalk28.dim("    \u2022 Pre-commit hook"));
+  console.log(chalk28.dim("    \u2022 Session learning hooks"));
+  console.log(chalk28.dim("    \u2022 Managed blocks in CLAUDE.md, AGENTS.md, copilot-instructions.md"));
+  console.log(chalk28.dim("    \u2022 Cursor rules (caliber-*.mdc)"));
+  console.log(chalk28.dim("    \u2022 Built-in skills (setup-caliber, find-skills, save-learning)"));
+  console.log(chalk28.dim("    \u2022 CALIBER_LEARNINGS.md"));
+  console.log(chalk28.dim("    \u2022 .caliber/ directory (backups, cache, state)\n"));
+  if (!options.force) {
+    const proceed = await confirm3({ message: "Continue with uninstall?" });
+    if (!proceed) {
+      console.log(chalk28.dim("\n  Cancelled.\n"));
+      return;
+    }
+  }
+  console.log("");
+  const actions = [];
+  const hookResult = removePreCommitHook();
+  if (hookResult.removed) {
+    console.log(`  ${chalk28.red("\u2717")} Pre-commit hook removed`);
+    actions.push("pre-commit hook");
+  }
+  const learnResult = removeLearningHooks();
+  if (learnResult.removed) {
+    console.log(`  ${chalk28.red("\u2717")} Claude Code learning hooks removed`);
+    actions.push("claude learning hooks");
+  }
+  const cursorLearnResult = removeCursorLearningHooks();
+  if (cursorLearnResult.removed) {
+    console.log(`  ${chalk28.red("\u2717")} Cursor learning hooks removed`);
+    actions.push("cursor learning hooks");
+  }
+  const strippedFiles = stripManagedBlocksFromFiles();
+  for (const file of strippedFiles) {
+    console.log(`  ${chalk28.yellow("~")} ${file} \u2014 managed blocks removed`);
+    actions.push(file);
+  }
+  const removedRules = removeCaliberCursorRules();
+  for (const rule of removedRules) {
+    console.log(`  ${chalk28.red("\u2717")} ${rule}`);
+  }
+  if (removedRules.length > 0) actions.push("cursor rules");
+  const removedSkills = removeBuiltinSkills();
+  for (const skill of removedSkills) {
+    console.log(`  ${chalk28.red("\u2717")} ${skill}/`);
+  }
+  if (removedSkills.length > 0) actions.push("builtin skills");
+  if (fs48.existsSync("CALIBER_LEARNINGS.md")) {
+    fs48.unlinkSync("CALIBER_LEARNINGS.md");
+    console.log(`  ${chalk28.red("\u2717")} CALIBER_LEARNINGS.md`);
+    actions.push("learnings file");
+  }
+  if (removeDirectory(CALIBER_DIR)) {
+    console.log(`  ${chalk28.red("\u2717")} .caliber/ directory`);
+    actions.push(".caliber directory");
+  }
+  if (actions.length === 0) {
+    console.log(chalk28.dim("  Nothing to remove \u2014 Caliber is not installed in this project.\n"));
+    return;
+  }
+  trackUninstallExecuted();
+  const configPath = getConfigFilePath();
+  if (fs48.existsSync(configPath)) {
+    console.log("");
+    const removeConfig = options.force || await confirm3({
+      message: `Remove global config (~/.caliber/config.json)? This affects all projects.`
+    });
+    if (removeConfig) {
+      fs48.unlinkSync(configPath);
+      console.log(`  ${chalk28.red("\u2717")} ${configPath}`);
+      const configDir = path38.dirname(configPath);
+      try {
+        const remaining = fs48.readdirSync(configDir);
+        if (remaining.length === 0) fs48.rmdirSync(configDir);
+      } catch {
+      }
+    }
+  }
+  console.log(chalk28.bold.green(`
+  Caliber has been removed from this project.`));
+  console.log(chalk28.dim("  Your code is untouched \u2014 only Caliber config files were removed.\n"));
+}
+
 // src/cli.ts
-var __dirname = path38.dirname(fileURLToPath(import.meta.url));
+var __dirname = path39.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs47.readFileSync(path38.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs49.readFileSync(path39.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -12414,9 +12788,11 @@ program.name(process.env.CALIBER_LOCAL ? "caloc" : "caliber").description("AI co
 function tracked(commandName, handler) {
   const wrapper = async (...args) => {
     const start = Date.now();
+    const isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS);
     trackEvent("command_started", {
       command: commandName,
-      cli_version: pkg.version
+      cli_version: pkg.version,
+      is_ci: isCI
     });
     try {
       await handler(...args);
@@ -12468,7 +12844,9 @@ function parseAgentOption(value) {
   return agents;
 }
 program.command("init").description("Initialize your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex, github-copilot", parseAgentOption).option("--source <paths...>", "Related source paths to include as context").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing config without prompting").option("--debug-report", void 0, false).option("--show-tokens", "Show token usage summary at the end").option("--auto-approve", "Run without interactive prompts (auto-accept all)").option("--verbose", "Show detailed logs of each step").action(tracked("init", initCommand));
+program.command("bootstrap").description("Install agent skills (/setup-caliber, /find-skills, /save-learning) without running init").action(tracked("bootstrap", bootstrapCommand));
 program.command("undo").description("Revert all config changes made by Caliber").action(tracked("undo", undoCommand));
+program.command("uninstall").description("Remove all Caliber resources from this project").option("--force", "Skip confirmation prompt").action(tracked("uninstall", (options) => uninstallCommand(options)));
 program.command("status").description("Show current Caliber config status").option("--json", "Output as JSON").action(tracked("status", statusCommand));
 program.command("regenerate").alias("regen").alias("re").description("Re-analyze project and regenerate config").option("--dry-run", "Preview changes without writing files").action(tracked("regenerate", regenerateCommand));
 program.command("config").description("Configure LLM provider, API key, and model").action(tracked("config", configCommand));
@@ -12493,16 +12871,16 @@ learn.command("delete <index>").description("Delete a learning by its index numb
 learn.command("add <content>").description("Add a learning directly (used by agent skills)").option("--personal", "Save as a personal learning instead of project-level").action(tracked("learn:add", learnAddCommand));
 
 // src/utils/version-check.ts
-import fs48 from "fs";
-import path39 from "path";
+import fs50 from "fs";
+import path40 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync16, execFileSync as execFileSync3 } from "child_process";
-import chalk27 from "chalk";
+import chalk29 from "chalk";
 import ora8 from "ora";
-import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path39.dirname(fileURLToPath2(import.meta.url));
+import confirm4 from "@inquirer/confirm";
+var __dirname_vc = path40.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs48.readFileSync(path39.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs50.readFileSync(path40.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
@@ -12527,8 +12905,8 @@ function isNewer(registry, current) {
 function getInstalledVersion() {
   try {
     const globalRoot = execSync16("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path39.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs48.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path40.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs50.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -12553,20 +12931,20 @@ async function checkForUpdates() {
     if (!isInteractive) {
       const installTag = channel === "latest" ? "" : `@${channel}`;
       console.log(
-        chalk27.yellow(
+        chalk29.yellow(
           `
 Update available: ${current} -> ${latest}
-Run ${chalk27.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
+Run ${chalk29.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
 `
         )
       );
       return;
     }
     console.log(
-      chalk27.yellow(`
+      chalk29.yellow(`
 Update available: ${current} -> ${latest}`)
     );
-    const shouldUpdate = await confirm2({ message: "Would you like to update now? (Y/n)", default: true });
+    const shouldUpdate = await confirm4({ message: "Would you like to update now? (Y/n)", default: true });
     if (!shouldUpdate) {
       console.log();
       return;
@@ -12583,13 +12961,13 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk27.yellow(`Run ${chalk27.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
+        console.log(chalk29.yellow(`Run ${chalk29.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
 `));
         return;
       }
-      spinner.succeed(chalk27.green(`Updated to ${latest}`));
+      spinner.succeed(chalk29.green(`Updated to ${latest}`));
       const args = process.argv.slice(2);
-      console.log(chalk27.dim(`
+      console.log(chalk29.dim(`
 Restarting: caliber ${args.join(" ")}
 `));
       execFileSync3("caliber", args, {
@@ -12602,11 +12980,11 @@ Restarting: caliber ${args.join(" ")}
       if (err instanceof Error) {
         const stderr = err.stderr;
         const errMsg = stderr ? String(stderr).trim().split("\n").pop() : err.message.split("\n")[0];
-        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk27.dim(`  ${errMsg}`));
+        if (errMsg && !errMsg.includes("SIGTERM")) console.log(chalk29.dim(`  ${errMsg}`));
       }
       console.log(
-        chalk27.yellow(
-          `Run ${chalk27.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
+        chalk29.yellow(
+          `Run ${chalk29.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually to upgrade.
 `
         )
       );