@rely-ai/caliber 1.33.4 → 1.34.0-dev.1774825558

package/dist/bin.js

@@ -230,21 +230,614 @@ var init_types = __esm({
   }
 });
 
+// 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) {
+  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)}
+${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
+---
+IMPORTANT: At the start of each session, before responding to the user's first message, run this check:
+
+\`\`\`bash
+grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "SYNCED" || echo "NOT_SYNCED"
+\`\`\`
+
+If SYNCED: proceed normally.
+If NOT_SYNCED: Tell the user: "This project uses Caliber to keep agent configs in sync. It's not set up on your machine yet \u2014 want me to set it up? (~30 seconds)". If they agree, read \`.cursor/skills/setup-caliber/SKILL.md\` and follow its instructions.
+`;
+}
+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/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 fs17 from "fs";
+import path17 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: "help me set up Docker for this project"
+-> "Would you like me to search for Docker-related skills?"
+-> If yes: run \`${bin} skills --query "docker deployment"\`
+
+User: "I need to write tests for this Python ML pipeline"
+-> "Would you like me to find skills for Python ML testing?"
+-> If yes: run \`${bin} skills --query "python machine-learning testing"\`
+
+## When NOT to trigger
+
+- The user is working within an already well-configured area
+- You already suggested skills for this technology in this session
+- The user is in the middle of urgent debugging or time-sensitive work
+- The technology is too generic (e.g. just "code" or "programming")
+`;
+}
+function getSaveLearningContent() {
+  const bin = resolveCaliber();
+  return `# Save Learning
+
+Save a user's instruction or preference as a persistent learning that
+will be applied in all future sessions on this project.
+
+## Instructions
+
+1. Detect when the user gives an instruction to remember, such as:
+   - "remember this", "save this", "always do X", "never do Y"
+   - "from now on", "going forward", "in this project we..."
+   - Any stated convention, preference, or rule
+2. Refine the instruction into a clean, actionable learning bullet with
+   an appropriate type prefix:
+   - \`**[convention]**\` \u2014 coding style, workflow, git conventions
+   - \`**[pattern]**\` \u2014 reusable code patterns
+   - \`**[anti-pattern]**\` \u2014 things to avoid
+   - \`**[preference]**\` \u2014 personal/team preferences
+   - \`**[context]**\` \u2014 project-specific context
+3. Show the refined learning to the user and ask for confirmation
+4. If confirmed, run:
+   \`\`\`bash
+   ${bin} learn add "<refined learning>"
+   \`\`\`
+   For personal preferences (not project-level), add \`--personal\`:
+   \`\`\`bash
+   ${bin} learn add --personal "<refined learning>"
+   \`\`\`
+5. Stage the learnings file for the next commit:
+   \`\`\`bash
+   git add CALIBER_LEARNINGS.md
+   \`\`\`
+
+## Examples
+
+User: "when developing features, push to next branch not master, remember it"
+-> Refine: \`**[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`\`
+-> "I'll save this as a project learning:
+    **[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`
+    Save for future sessions?"
+-> If yes: run \`${bin} learn add "**[convention]** Push feature commits to the next branch, not master"\`
+-> Run \`git add CALIBER_LEARNINGS.md\`
+
+User: "always use bun instead of npm"
+-> Refine: \`**[preference]** Use \\\`bun\\\` instead of \\\`npm\\\` for package management\`
+-> Confirm and save
+
+User: "never use any in TypeScript, use unknown instead"
+-> Refine: \`**[convention]** Use \\\`unknown\\\` instead of \\\`any\\\` in TypeScript\`
+-> Confirm and save
+
+## When NOT to trigger
+
+- The user is giving a one-time instruction for the current task only
+- The instruction is too vague to be actionable
+- The user explicitly says "just for now" or "only this time"
+`;
+}
+function getSetupCaliberContent() {
+  return `# Setup Caliber
+
+Dynamic onboarding for Caliber \u2014 automatic AI agent context sync.
+Run all diagnostic steps below on every invocation to determine what's already
+set up and what still needs to be done.
+
+## Instructions
+
+Run these checks in order. For each step, check the current state first,
+then only act if something is missing.
+
+### Step 1: Check if Caliber is installed
+
+\`\`\`bash
+command -v caliber >/dev/null 2>&1 && caliber --version || echo "NOT_INSTALLED"
+\`\`\`
+
+- 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
+  \`\`\`
+  Set \`CALIBER="caliber"\`.
+
+  If npm fails (permissions, no sudo, etc.), fall back to npx:
+  \`\`\`bash
+  npx @rely-ai/caliber --version 2>/dev/null || echo "NO_NODE"
+  \`\`\`
+  - 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
+
+\`\`\`bash
+grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "HOOK_ACTIVE" || echo "NO_HOOK"
+\`\`\`
+
+- 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
+  \`\`\`
+
+### 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 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 --agent <comma-separated-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
+\`\`\`
+
+- 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
+  \`\`\`
+
+### Step 5: Ask about team setup
+
+Ask the user: "Are you setting up for yourself only, or for your team too?"
+
+- If **solo** \u2192 Continue with solo setup:
+
+  Check if session learning is enabled:
+  \`\`\`bash
+  $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
+    \`\`\`
+
+  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"
+
+  Then show the summary (see below) and stop.
+
+- If **team** \u2192 Check if the GitHub Action already exists:
+  \`\`\`bash
+  [ -f .github/workflows/caliber-sync.yml ] && echo "ACTION_EXISTS" || echo "NO_ACTION"
+  \`\`\`
+  - If ACTION_EXISTS \u2192 Tell the user: "GitHub Action is already configured."
+  - If NO_ACTION \u2192 Tell the user: "I'll create a GitHub Action that syncs configs nightly and on every PR."
+    Write this file to \`.github/workflows/caliber-sync.yml\`:
+    \`\`\`yaml
+    name: Caliber Sync
+    on:
+      schedule:
+        - cron: '0 3 * * 1-5'
+      pull_request:
+        types: [opened, synchronize]
+      workflow_dispatch:
+    jobs:
+      sync:
+        runs-on: ubuntu-latest
+        steps:
+          - uses: actions/checkout@v4
+          - uses: caliber-ai-org/ai-setup@v1
+            with:
+              mode: sync
+              auto-refresh: true
+              comment: true
+              github-token: \${{ secrets.GITHUB_TOKEN }}
+            env:
+              ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+    \`\`\`
+    Now determine which LLM provider the team uses. Check the local Caliber config:
+    \`\`\`bash
+    $CALIBER config --show 2>/dev/null || echo "NO_CONFIG"
+    \`\`\`
+
+    Based on the provider, the GitHub Action needs the corresponding secret:
+    - **anthropic** \u2192 \`ANTHROPIC_API_KEY\`
+    - **openai** \u2192 \`OPENAI_API_KEY\`
+    - **vertex** \u2192 \`VERTEX_PROJECT_ID\` and \`GOOGLE_APPLICATION_CREDENTIALS\` (service account JSON)
+
+    Update the workflow env block to match the provider. For example, if using OpenAI:
+    \`\`\`yaml
+            env:
+              OPENAI_API_KEY: \${{ secrets.OPENAI_API_KEY }}
+    \`\`\`
+
+    Then check if the \`gh\` CLI is available to set the secret:
+    \`\`\`bash
+    command -v gh >/dev/null 2>&1 && echo "GH_AVAILABLE" || echo "NO_GH"
+    \`\`\`
+
+    - If GH_AVAILABLE \u2192 Ask the user for their API key and set it:
+      \`\`\`bash
+      gh secret set ANTHROPIC_API_KEY
+      \`\`\`
+      (This prompts for the value securely via stdin)
+    - If NO_GH \u2192 Tell the user exactly what to do:
+      "Go to your repo on GitHub \u2192 Settings \u2192 Secrets and variables \u2192 Actions \u2192 New repository secret.
+       Name: ANTHROPIC_API_KEY (or OPENAI_API_KEY depending on provider)
+       Value: your API key"
+
+    Finally, offer to commit and push the workflow file:
+    \`\`\`bash
+    git add .github/workflows/caliber-sync.yml
+    git commit -m "feat: add Caliber sync GitHub Action"
+    git push
+    \`\`\`
+
+### Summary
+
+After completing all steps, show the user what's configured:
+
+\`\`\`
+Caliber Setup Complete:
+\u2713 Caliber installed (vX.X.X)
+\u2713 Pre-commit hook \u2014 configs sync on every commit
+\u2713 Agent configs \u2014 CLAUDE.md, Cursor rules, AGENTS.md
+\u2713 Config score: X/100
+\u2713 GitHub Action \u2014 nightly sync + PR checks (team only)
+
+From now on, every commit keeps all your agent configs in sync automatically.
+\`\`\`
+
+## When to trigger
+
+- When a developer first opens this project
+- When the user asks about keeping agent configs up to date
+- When the user asks "how do I set up Caliber" or "what is Caliber"
+- When the user sees a message saying "Run /setup-caliber to get set up"
+
+## When NOT to trigger
+
+- The user is in the middle of time-sensitive work
+`;
+}
+function ensureBuiltinSkills() {
+  const written = [];
+  for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
+    if (!fs17.existsSync(platformDir)) continue;
+    for (const skill of BUILTIN_SKILLS) {
+      const skillPath = path17.join(skillsDir, skill.name, "SKILL.md");
+      fs17.mkdirSync(path17.dirname(skillPath), { recursive: true });
+      fs17.writeFileSync(skillPath, buildSkillContent(skill));
+      written.push(skillPath);
+    }
+  }
+  return written;
+}
+var FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL, SETUP_CALIBER_SKILL, BUILTIN_SKILLS, PLATFORM_CONFIGS, BUILTIN_SKILL_NAMES;
+var init_builtin_skills = __esm({
+  "src/lib/builtin-skills.ts"() {
+    "use strict";
+    init_resolve_caliber();
+    FIND_SKILLS_SKILL = {
+      name: "find-skills",
+      description: "Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.",
+      get content() {
+        return getFindSkillsContent();
+      }
+    };
+    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: path17.join(".claude", "skills") },
+      { platformDir: ".cursor", skillsDir: path17.join(".cursor", "skills") },
+      { platformDir: ".agents", skillsDir: path17.join(".agents", "skills") }
+    ];
+    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
+  }
+});
+
 // src/utils/editor.ts
-import { execSync as execSync13, spawn as spawn3 } from "child_process";
-import fs26 from "fs";
-import path23 from "path";
+import { execSync as execSync14, spawn as spawn3 } from "child_process";
+import fs27 from "fs";
+import path24 from "path";
 import os6 from "os";
 function getEmptyFilePath(proposedPath) {
-  fs26.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path23.join(DIFF_TEMP_DIR, path23.basename(proposedPath));
-  fs26.writeFileSync(tempPath, "");
+  fs27.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
+  const tempPath = path24.join(DIFF_TEMP_DIR, path24.basename(proposedPath));
+  fs27.writeFileSync(tempPath, "");
   return tempPath;
 }
 function commandExists(cmd) {
   try {
     const check = process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`;
-    execSync13(check, { stdio: "ignore" });
+    execSync14(check, { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -278,7 +871,7 @@ var init_editor = __esm({
   "src/utils/editor.ts"() {
     "use strict";
     IS_WINDOWS3 = process.platform === "win32";
-    DIFF_TEMP_DIR = path23.join(os6.tmpdir(), "caliber-diff");
+    DIFF_TEMP_DIR = path24.join(os6.tmpdir(), "caliber-diff");
   }
 });
 
@@ -290,7 +883,7 @@ __export(review_exports, {
   promptWantsReview: () => promptWantsReview
 });
 import chalk10 from "chalk";
-import fs27 from "fs";
+import fs28 from "fs";
 import select4 from "@inquirer/select";
 import { createTwoFilesPatch } from "diff";
 async function promptWantsReview() {
@@ -327,8 +920,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs27.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs27.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs28.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs28.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -502,14 +1095,14 @@ __export(lock_exports, {
   acquireLock: () => acquireLock,
   isCaliberRunning: () => isCaliberRunning,
   releaseLock: () => releaseLock
-});
-import fs37 from "fs";
-import path30 from "path";
+});
+import fs38 from "fs";
+import path31 from "path";
 import os8 from "os";
 function isCaliberRunning() {
   try {
-    if (!fs37.existsSync(LOCK_FILE)) return false;
-    const raw = fs37.readFileSync(LOCK_FILE, "utf-8").trim();
+    if (!fs38.existsSync(LOCK_FILE)) return false;
+    const raw = fs38.readFileSync(LOCK_FILE, "utf-8").trim();
     const { pid, ts } = JSON.parse(raw);
     if (Date.now() - ts > STALE_MS) return false;
     try {
@@ -524,13 +1117,13 @@ function isCaliberRunning() {
 }
 function acquireLock() {
   try {
-    fs37.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs38.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, ts: Date.now() }));
   } catch {
   }
 }
 function releaseLock() {
   try {
-    if (fs37.existsSync(LOCK_FILE)) fs37.unlinkSync(LOCK_FILE);
+    if (fs38.existsSync(LOCK_FILE)) fs38.unlinkSync(LOCK_FILE);
   } catch {
   }
 }
@@ -538,21 +1131,21 @@ var LOCK_FILE, STALE_MS;
 var init_lock = __esm({
   "src/lib/lock.ts"() {
     "use strict";
-    LOCK_FILE = path30.join(os8.tmpdir(), ".caliber.lock");
+    LOCK_FILE = path31.join(os8.tmpdir(), ".caliber.lock");
     STALE_MS = 10 * 60 * 1e3;
   }
 });
 
 // src/cli.ts
 import { Command } from "commander";
-import fs47 from "fs";
-import path39 from "path";
+import fs49 from "fs";
+import path40 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/init.ts
-import path26 from "path";
+import path27 from "path";
 import chalk14 from "chalk";
-import fs32 from "fs";
+import fs33 from "fs";
 
 // src/fingerprint/index.ts
 import fs8 from "fs";
@@ -3227,9 +3820,151 @@ function getCursorConfigDir() {
   return path9.join(home, ".config", "Cursor");
 }
 
-// src/fingerprint/sources.ts
+// src/lib/hooks.ts
+init_resolve_caliber();
 import fs10 from "fs";
 import path10 from "path";
+import { execSync as execSync8 } from "child_process";
+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 {};
+  try {
+    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  const dir = path10.dirname(SETTINGS_PATH);
+  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+function findHookIndex(sessionEnd) {
+  return sessionEnd.findIndex(
+    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
+  );
+}
+function isHookInstalled() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) return false;
+  return findHookIndex(sessionEnd) !== -1;
+}
+function installHook() {
+  const settings = readSettings();
+  if (!settings.hooks) settings.hooks = {};
+  if (!Array.isArray(settings.hooks.SessionEnd)) settings.hooks.SessionEnd = [];
+  if (findHookIndex(settings.hooks.SessionEnd) !== -1) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  settings.hooks.SessionEnd.push({
+    matcher: "",
+    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
+  });
+  writeSettings(settings);
+  return { installed: true, alreadyInstalled: false };
+}
+function removeHook() {
+  const settings = readSettings();
+  const sessionEnd = settings.hooks?.SessionEnd;
+  if (!Array.isArray(sessionEnd)) {
+    return { removed: false, notFound: true };
+  }
+  const idx = findHookIndex(sessionEnd);
+  if (idx === -1) {
+    return { removed: false, notFound: true };
+  }
+  sessionEnd.splice(idx, 1);
+  if (sessionEnd.length === 0) {
+    delete settings.hooks.SessionEnd;
+  }
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  writeSettings(settings);
+  return { removed: true, notFound: false };
+}
+var PRECOMMIT_START = "# caliber:pre-commit:start";
+var PRECOMMIT_END = "# caliber:pre-commit:end";
+function getPrecommitBlock() {
+  const bin = resolveCaliber();
+  const npx = isNpxResolution();
+  const guard = npx ? "command -v npx >/dev/null 2>&1" : `[ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1`;
+  const invoke = npx ? bin : `"${bin}"`;
+  return `${PRECOMMIT_START}
+if ${guard}; then
+  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
+  ${invoke} refresh 2>/dev/null || true
+  ${invoke} learn finalize 2>/dev/null || true
+  git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md CALIBER_LEARNINGS.md 2>/dev/null | xargs git add 2>/dev/null || true
+fi
+${PRECOMMIT_END}`;
+}
+function getGitHooksDir() {
+  try {
+    const gitDir = execSync8("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return path10.join(gitDir, "hooks");
+  } catch {
+    return null;
+  }
+}
+function getPreCommitPath() {
+  const hooksDir = getGitHooksDir();
+  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");
+  return content.includes(PRECOMMIT_START);
+}
+function installPreCommitHook() {
+  if (isPreCommitHookInstalled()) {
+    return { installed: false, alreadyInstalled: true };
+  }
+  const hookPath = getPreCommitPath();
+  if (!hookPath) return { installed: false, alreadyInstalled: false };
+  const hooksDir = path10.dirname(hookPath);
+  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
+  let content = "";
+  if (fs10.existsSync(hookPath)) {
+    content = fs10.readFileSync(hookPath, "utf-8");
+    if (!content.endsWith("\n")) content += "\n";
+    content += "\n" + getPrecommitBlock() + "\n";
+  } else {
+    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
+  }
+  fs10.writeFileSync(hookPath, content);
+  fs10.chmodSync(hookPath, 493);
+  return { installed: true, alreadyInstalled: false };
+}
+function removePreCommitHook() {
+  const hookPath = getPreCommitPath();
+  if (!hookPath || !fs10.existsSync(hookPath)) {
+    return { removed: false, notFound: true };
+  }
+  let content = fs10.readFileSync(hookPath, "utf-8");
+  if (!content.includes(PRECOMMIT_START)) {
+    return { removed: false, notFound: true };
+  }
+  const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
+  content = content.replace(regex, "\n");
+  if (content.trim() === "#!/bin/sh" || content.trim() === "") {
+    fs10.unlinkSync(hookPath);
+  } else {
+    fs10.writeFileSync(hookPath, content);
+  }
+  return { removed: true, notFound: false };
+}
+
+// src/fingerprint/sources.ts
+import fs11 from "fs";
+import path11 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
@@ -3558,7 +4293,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 {
@@ -3576,29 +4311,29 @@ function loadSourcesConfig(dir) {
   }
 }
 function writeSourcesConfig(dir, sources2) {
-  const configDir = path10.join(dir, ".caliber");
-  if (!fs10.existsSync(configDir)) {
-    fs10.mkdirSync(configDir, { recursive: true });
+  const configDir = path11.join(dir, ".caliber");
+  if (!fs11.existsSync(configDir)) {
+    fs11.mkdirSync(configDir, { recursive: true });
   }
-  const configPath = path10.join(configDir, "sources.json");
-  fs10.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  const configPath = path11.join(configDir, "sources.json");
+  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs10.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
 }
 function isInsideDir(childPath, parentDir) {
-  const relative2 = 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, {
@@ -3611,12 +4346,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, {
@@ -3629,7 +4364,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs10.statSync(absPath);
+      stat = fs11.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -3658,13 +4393,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 || "",
@@ -3684,18 +4419,18 @@ function collectRepoSummary(resolved, _projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs10.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs11.readdirSync(absPath, { withFileTypes: true });
     topLevelDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, 20);
     keyFiles = entries.filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => e.name).slice(0, 15);
   } catch {
   }
-  const claudeMdContent = readFileOrNull(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 || "",
@@ -3712,7 +4447,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] || "",
@@ -3756,15 +4491,15 @@ init_config();
 // src/utils/dependencies.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
-function readFileOrNull2(path41) {
+function readFileOrNull2(path42) {
   try {
-    return readFileSync2(path41, "utf-8");
+    return readFileSync2(path42, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path41) {
-  const content = readFileOrNull2(path41);
+function readJsonOrNull(path42) {
+  const content = readFileOrNull2(path42);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -4305,191 +5040,71 @@ ${existing.personalLearnings}`);
   if (allDeps.length > 0) {
     parts.push(`
 Project dependencies (${allDeps.length}):`);
-    parts.push(allDeps.join(", "));
-  }
-  if (prompt) parts.push(`
-User instructions: ${prompt}`);
-  if (fingerprint.codeAnalysis) {
-    const ca = fingerprint.codeAnalysis;
-    const basePrompt = parts.join("\n");
-    const maxPromptTokens = getMaxPromptTokens();
-    const baseTokens = estimateTokens(basePrompt);
-    const tokenBudgetForCode = Math.max(0, maxPromptTokens - baseTokens);
-    const codeLines = [];
-    let codeChars = 0;
-    const introLine = "Study these files to extract patterns for skills. Use the exact code patterns you see here.\n";
-    codeLines.push(introLine);
-    let runningCodeLen = introLine.length;
-    const sortedFiles = [...ca.files].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
-    let includedFiles = 0;
-    for (const f of sortedFiles) {
-      const entry = `[${f.path}]
-${f.content}
-`;
-      const projectedLen = runningCodeLen + 1 + entry.length;
-      if (Math.ceil(projectedLen / 4) > tokenBudgetForCode && includedFiles > 0) break;
-      codeLines.push(entry);
-      codeChars += f.content.length;
-      runningCodeLen = projectedLen;
-      includedFiles++;
-    }
-    const includedTokens = Math.ceil(codeChars / 4);
-    let header;
-    if (includedFiles < ca.files.length) {
-      const pct = ca.totalProjectTokens > 0 ? Math.round(includedTokens / ca.totalProjectTokens * 100) : 100;
-      header = `
---- Project Files (trimmed to ~${includedTokens.toLocaleString()}/${ca.totalProjectTokens.toLocaleString()} tokens, ${pct}% of total) ---`;
-    } else if (ca.truncated) {
-      const pct = ca.totalProjectTokens > 0 ? Math.round(ca.includedTokens / ca.totalProjectTokens * 100) : 100;
-      header = `
---- Project Files (trimmed to ~${ca.includedTokens.toLocaleString()}/${ca.totalProjectTokens.toLocaleString()} tokens, ${pct}% of total) ---`;
-    } else {
-      header = `
---- Project Files (${ca.files.length} files, ~${ca.includedTokens.toLocaleString()} tokens) ---`;
-    }
-    parts.push(header);
-    parts.push(codeLines.join("\n"));
-  }
-  if (fingerprint.sources?.length) {
-    parts.push(formatSourcesForPrompt(fingerprint.sources));
-  }
-  return parts.join("\n");
-}
-
-// src/writers/index.ts
-import fs18 from "fs";
-
-// src/writers/claude/index.ts
-import fs11 from "fs";
-import path11 from "path";
-
-// src/writers/pre-commit-block.ts
-init_resolve_caliber();
-var BLOCK_START = "<!-- caliber:managed:pre-commit -->";
-var BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
-var MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .github/copilot-instructions.md AGENTS.md CALIBER_LEARNINGS.md";
-function getPreCommitBlock() {
-  const bin = resolveCaliber();
-  return `${BLOCK_START}
-## Before Committing
-
-Run \`${bin} refresh\` before creating git commits to keep docs in sync with code changes.
-After it completes, stage any modified doc files before committing:
-
-\`\`\`bash
-${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null
-\`\`\`
-${BLOCK_END}`;
-}
-var CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
-function getCursorRuleContent() {
-  const bin = resolveCaliber();
-  return `---
-description: Run caliber refresh before git commits to keep docs in sync
-alwaysApply: true
----
-Before creating git commits, run \`${bin} refresh\` to update docs based on code changes,
-then stage modified doc files (${MANAGED_DOC_PATHS}).
-`;
-}
-function hasPreCommitBlock(content) {
-  return content.includes(BLOCK_START);
-}
-function appendPreCommitBlock(content) {
-  if (hasPreCommitBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getPreCommitBlock() + "\n";
-}
-function getCursorPreCommitRule() {
-  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
-}
-var LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
-var LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
-var 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}`;
-var CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
-var 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.
-`;
-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 };
-}
-
-// src/writers/claude/index.ts
-function writeClaudeConfig(config) {
-  const written = [];
-  fs11.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
-  written.push("CLAUDE.md");
-  if (config.skills?.length) {
-    for (const skill of config.skills) {
-      const skillDir = path11.join(".claude", "skills", skill.name);
-      if (!fs11.existsSync(skillDir)) fs11.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path11.join(skillDir, "SKILL.md");
-      const frontmatter = [
-        "---",
-        `name: ${skill.name}`,
-        `description: ${skill.description}`,
-        "---",
-        ""
-      ].join("\n");
-      fs11.writeFileSync(skillPath, frontmatter + skill.content);
-      written.push(skillPath);
-    }
+    parts.push(allDeps.join(", "));
   }
-  if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
-    let existingServers = {};
-    try {
-      if (fs11.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs11.readFileSync(".mcp.json", "utf-8"));
-        if (existing.mcpServers) existingServers = existing.mcpServers;
-      }
-    } catch {
+  if (prompt) parts.push(`
+User instructions: ${prompt}`);
+  if (fingerprint.codeAnalysis) {
+    const ca = fingerprint.codeAnalysis;
+    const basePrompt = parts.join("\n");
+    const maxPromptTokens = getMaxPromptTokens();
+    const baseTokens = estimateTokens(basePrompt);
+    const tokenBudgetForCode = Math.max(0, maxPromptTokens - baseTokens);
+    const codeLines = [];
+    let codeChars = 0;
+    const introLine = "Study these files to extract patterns for skills. Use the exact code patterns you see here.\n";
+    codeLines.push(introLine);
+    let runningCodeLen = introLine.length;
+    const sortedFiles = [...ca.files].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    let includedFiles = 0;
+    for (const f of sortedFiles) {
+      const entry = `[${f.path}]
+${f.content}
+`;
+      const projectedLen = runningCodeLen + 1 + entry.length;
+      if (Math.ceil(projectedLen / 4) > tokenBudgetForCode && includedFiles > 0) break;
+      codeLines.push(entry);
+      codeChars += f.content.length;
+      runningCodeLen = projectedLen;
+      includedFiles++;
     }
-    const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs11.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
-    written.push(".mcp.json");
+    const includedTokens = Math.ceil(codeChars / 4);
+    let header;
+    if (includedFiles < ca.files.length) {
+      const pct = ca.totalProjectTokens > 0 ? Math.round(includedTokens / ca.totalProjectTokens * 100) : 100;
+      header = `
+--- Project Files (trimmed to ~${includedTokens.toLocaleString()}/${ca.totalProjectTokens.toLocaleString()} tokens, ${pct}% of total) ---`;
+    } else if (ca.truncated) {
+      const pct = ca.totalProjectTokens > 0 ? Math.round(ca.includedTokens / ca.totalProjectTokens * 100) : 100;
+      header = `
+--- Project Files (trimmed to ~${ca.includedTokens.toLocaleString()}/${ca.totalProjectTokens.toLocaleString()} tokens, ${pct}% of total) ---`;
+    } else {
+      header = `
+--- Project Files (${ca.files.length} files, ~${ca.includedTokens.toLocaleString()} tokens) ---`;
+    }
+    parts.push(header);
+    parts.push(codeLines.join("\n"));
   }
-  return written;
+  if (fingerprint.sources?.length) {
+    parts.push(formatSourcesForPrompt(fingerprint.sources));
+  }
+  return parts.join("\n");
 }
 
-// src/writers/cursor/index.ts
+// src/writers/index.ts
+import fs19 from "fs";
+
+// src/writers/claude/index.ts
+init_pre_commit_block();
 import fs12 from "fs";
 import path12 from "path";
-function writeCursorConfig(config) {
+function writeClaudeConfig(config) {
   const written = [];
-  if (config.cursorrules) {
-    fs12.writeFileSync(".cursorrules", config.cursorrules);
-    written.push(".cursorrules");
-  }
-  const preCommitRule = getCursorPreCommitRule();
-  const learningsRule = getCursorLearningsRule();
-  const allRules = [...config.rules || [], preCommitRule, learningsRule];
-  const rulesDir = path12.join(".cursor", "rules");
-  if (!fs12.existsSync(rulesDir)) fs12.mkdirSync(rulesDir, { recursive: true });
-  for (const rule of allRules) {
-    const rulePath = path12.join(rulesDir, rule.filename);
-    fs12.writeFileSync(rulePath, rule.content);
-    written.push(rulePath);
-  }
+  fs12.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(config.claudeMd)));
+  written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path12.join(".cursor", "skills", skill.name);
+      const skillDir = path12.join(".claude", "skills", skill.name);
       if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
       const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
@@ -4504,286 +5119,183 @@ function writeCursorConfig(config) {
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
-    const cursorDir = ".cursor";
-    if (!fs12.existsSync(cursorDir)) fs12.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path12.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs12.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs12.readFileSync(mcpPath, "utf-8"));
+      if (fs12.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs12.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
-    written.push(mcpPath);
-  }
-  return written;
-}
-
-// src/writers/codex/index.ts
-import fs13 from "fs";
-import path13 from "path";
-function writeCodexConfig(config) {
-  const written = [];
-  fs13.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
-  written.push("AGENTS.md");
-  if (config.skills?.length) {
-    for (const skill of config.skills) {
-      const skillDir = path13.join(".agents", "skills", skill.name);
-      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path13.join(skillDir, "SKILL.md");
-      const frontmatter = [
-        "---",
-        `name: ${skill.name}`,
-        `description: ${skill.description}`,
-        "---",
-        ""
-      ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
-      written.push(skillPath);
-    }
-  }
-  return written;
-}
-
-// src/writers/github-copilot/index.ts
-import fs14 from "fs";
-import path14 from "path";
-function writeGithubCopilotConfig(config) {
-  const written = [];
-  if (config.instructions) {
-    fs14.mkdirSync(".github", { recursive: true });
-    fs14.writeFileSync(path14.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
-    written.push(".github/copilot-instructions.md");
-  }
-  if (config.instructionFiles?.length) {
-    const instructionsDir = path14.join(".github", "instructions");
-    fs14.mkdirSync(instructionsDir, { recursive: true });
-    for (const file of config.instructionFiles) {
-      fs14.writeFileSync(path14.join(instructionsDir, file.filename), file.content);
-      written.push(`.github/instructions/${file.filename}`);
-    }
+    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    written.push(".mcp.json");
   }
   return written;
 }
 
-// src/writers/backup.ts
-import fs15 from "fs";
-import path15 from "path";
-function createBackup(files) {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path15.join(BACKUPS_DIR, timestamp);
-  for (const file of files) {
-    if (!fs15.existsSync(file)) continue;
-    const dest = path15.join(backupDir, file);
-    const destDir = path15.dirname(dest);
-    if (!fs15.existsSync(destDir)) {
-      fs15.mkdirSync(destDir, { recursive: true });
-    }
-    fs15.copyFileSync(file, dest);
-  }
-  return backupDir;
-}
-function restoreBackup(backupDir, file) {
-  const backupFile = path15.join(backupDir, file);
-  if (!fs15.existsSync(backupFile)) return false;
-  const destDir = path15.dirname(file);
-  if (!fs15.existsSync(destDir)) {
-    fs15.mkdirSync(destDir, { recursive: true });
-  }
-  fs15.copyFileSync(backupFile, file);
-  return true;
-}
-
-// src/lib/builtin-skills.ts
-init_resolve_caliber();
-import fs16 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: "help me set up Docker for this project"
--> "Would you like me to search for Docker-related skills?"
--> If yes: run \`${bin} skills --query "docker deployment"\`
-
-User: "I need to write tests for this Python ML pipeline"
--> "Would you like me to find skills for Python ML testing?"
--> If yes: run \`${bin} skills --query "python machine-learning testing"\`
-
-## When NOT to trigger
-
-- The user is working within an already well-configured area
-- You already suggested skills for this technology in this session
-- The user is in the middle of urgent debugging or time-sensitive work
-- The technology is too generic (e.g. just "code" or "programming")
-`;
-}
-function getSaveLearningContent() {
-  const bin = resolveCaliber();
-  return `# Save Learning
-
-Save a user's instruction or preference as a persistent learning that
-will be applied in all future sessions on this project.
-
-## Instructions
-
-1. Detect when the user gives an instruction to remember, such as:
-   - "remember this", "save this", "always do X", "never do Y"
-   - "from now on", "going forward", "in this project we..."
-   - Any stated convention, preference, or rule
-2. Refine the instruction into a clean, actionable learning bullet with
-   an appropriate type prefix:
-   - \`**[convention]**\` \u2014 coding style, workflow, git conventions
-   - \`**[pattern]**\` \u2014 reusable code patterns
-   - \`**[anti-pattern]**\` \u2014 things to avoid
-   - \`**[preference]**\` \u2014 personal/team preferences
-   - \`**[context]**\` \u2014 project-specific context
-3. Show the refined learning to the user and ask for confirmation
-4. If confirmed, run:
-   \`\`\`bash
-   ${bin} learn add "<refined learning>"
-   \`\`\`
-   For personal preferences (not project-level), add \`--personal\`:
-   \`\`\`bash
-   ${bin} learn add --personal "<refined learning>"
-   \`\`\`
-5. Stage the learnings file for the next commit:
-   \`\`\`bash
-   git add CALIBER_LEARNINGS.md
-   \`\`\`
-
-## Examples
-
-User: "when developing features, push to next branch not master, remember it"
--> Refine: \`**[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`\`
--> "I'll save this as a project learning:
-    **[convention]** Push feature commits to the \\\`next\\\` branch, not \\\`master\\\`
-    Save for future sessions?"
--> If yes: run \`${bin} learn add "**[convention]** Push feature commits to the next branch, not master"\`
--> Run \`git add CALIBER_LEARNINGS.md\`
-
-User: "always use bun instead of npm"
--> Refine: \`**[preference]** Use \\\`bun\\\` instead of \\\`npm\\\` for package management\`
--> Confirm and save
-
-User: "never use any in TypeScript, use unknown instead"
--> Refine: \`**[convention]** Use \\\`unknown\\\` instead of \\\`any\\\` in TypeScript\`
--> Confirm and save
-
-## When NOT to trigger
-
-- The user is giving a one-time instruction for the current task only
-- The instruction is too vague to be actionable
-- The user explicitly says "just for now" or "only this time"
-`;
-}
-var FIND_SKILLS_SKILL = {
-  name: "find-skills",
-  description: "Discovers and installs community skills from the public registry. Use when the user mentions a technology, framework, or task that could benefit from specialized skills not yet installed, asks 'how do I do X', 'find a skill for X', or starts work in a new technology area. Proactively suggest when the user's task involves tools or frameworks without existing skills.",
-  get content() {
-    return getFindSkillsContent();
+// src/writers/cursor/index.ts
+init_pre_commit_block();
+import fs13 from "fs";
+import path13 from "path";
+function writeCursorConfig(config) {
+  const written = [];
+  if (config.cursorrules) {
+    fs13.writeFileSync(".cursorrules", config.cursorrules);
+    written.push(".cursorrules");
   }
-};
-var SAVE_LEARNING_SKILL = {
-  name: "save-learning",
-  description: "Saves user instructions as persistent learnings for future sessions. Use when the user says 'remember this', 'always do X', 'from now on', 'never do Y', or gives any instruction they want persisted across sessions. Proactively suggest when the user states a preference, convention, or rule they clearly want followed in the future.",
-  get content() {
-    return getSaveLearningContent();
+  const preCommitRule = getCursorPreCommitRule();
+  const learningsRule = getCursorLearningsRule();
+  const allRules = [...config.rules || [], preCommitRule, learningsRule];
+  const rulesDir = path13.join(".cursor", "rules");
+  if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
+  for (const rule of allRules) {
+    const rulePath = path13.join(rulesDir, rule.filename);
+    fs13.writeFileSync(rulePath, rule.content);
+    written.push(rulePath);
   }
-};
-var BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL];
-var PLATFORM_CONFIGS = [
-  { platformDir: ".claude", skillsDir: path16.join(".claude", "skills") },
-  { platformDir: ".cursor", skillsDir: path16.join(".cursor", "skills") },
-  { platformDir: ".agents", skillsDir: path16.join(".agents", "skills") }
-];
-function ensureBuiltinSkills() {
+  if (config.skills?.length) {
+    for (const skill of config.skills) {
+      const skillDir = path13.join(".cursor", "skills", skill.name);
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path13.join(skillDir, "SKILL.md");
+      const frontmatter = [
+        "---",
+        `name: ${skill.name}`,
+        `description: ${skill.description}`,
+        "---",
+        ""
+      ].join("\n");
+      fs13.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 = path13.join(cursorDir, "mcp.json");
+    let existingServers = {};
+    try {
+      if (fs13.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
+        if (existing.mcpServers) existingServers = existing.mcpServers;
+      }
+    } catch {
+    }
+    const mergedServers = { ...existingServers, ...config.mcpServers };
+    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    written.push(mcpPath);
+  }
+  return written;
+}
+
+// src/writers/codex/index.ts
+init_pre_commit_block();
+import fs14 from "fs";
+import path14 from "path";
+function writeCodexConfig(config) {
   const written = [];
-  for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs16.existsSync(platformDir)) continue;
-    for (const skill of BUILTIN_SKILLS) {
-      const skillPath = path16.join(skillsDir, skill.name, "SKILL.md");
-      if (fs16.existsSync(skillPath)) continue;
-      fs16.mkdirSync(path16.dirname(skillPath), { recursive: true });
-      fs16.writeFileSync(skillPath, buildSkillContent(skill));
+  fs14.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  written.push("AGENTS.md");
+  if (config.skills?.length) {
+    for (const skill of config.skills) {
+      const skillDir = path14.join(".agents", "skills", skill.name);
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path14.join(skillDir, "SKILL.md");
+      const frontmatter = [
+        "---",
+        `name: ${skill.name}`,
+        `description: ${skill.description}`,
+        "---",
+        ""
+      ].join("\n");
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   return written;
 }
 
+// src/writers/github-copilot/index.ts
+init_pre_commit_block();
+import fs15 from "fs";
+import path15 from "path";
+function writeGithubCopilotConfig(config) {
+  const written = [];
+  if (config.instructions) {
+    fs15.mkdirSync(".github", { recursive: true });
+    fs15.writeFileSync(path15.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(config.instructions)));
+    written.push(".github/copilot-instructions.md");
+  }
+  if (config.instructionFiles?.length) {
+    const instructionsDir = path15.join(".github", "instructions");
+    fs15.mkdirSync(instructionsDir, { recursive: true });
+    for (const file of config.instructionFiles) {
+      fs15.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
+      written.push(`.github/instructions/${file.filename}`);
+    }
+  }
+  return written;
+}
+
+// src/writers/backup.ts
+import fs16 from "fs";
+import path16 from "path";
+function createBackup(files) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = path16.join(BACKUPS_DIR, timestamp);
+  for (const file of files) {
+    if (!fs16.existsSync(file)) continue;
+    const dest = path16.join(backupDir, file);
+    const destDir = path16.dirname(dest);
+    if (!fs16.existsSync(destDir)) {
+      fs16.mkdirSync(destDir, { recursive: true });
+    }
+    fs16.copyFileSync(file, dest);
+  }
+  return backupDir;
+}
+function restoreBackup(backupDir, file) {
+  const backupFile = path16.join(backupDir, file);
+  if (!fs16.existsSync(backupFile)) return false;
+  const destDir = path16.dirname(file);
+  if (!fs16.existsSync(destDir)) {
+    fs16.mkdirSync(destDir, { recursive: true });
+  }
+  fs16.copyFileSync(backupFile, file);
+  return true;
+}
+
+// src/writers/index.ts
+init_builtin_skills();
+
 // src/writers/manifest.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import crypto3 from "crypto";
 function readManifest() {
   try {
-    if (!fs17.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs17.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs18.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs18.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs17.existsSync(CALIBER_DIR)) {
-    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs18.existsSync(CALIBER_DIR)) {
+    fs18.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs17.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs18.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs17.readFileSync(filePath);
+  const content = fs18.readFileSync(filePath);
   return crypto3.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs18.existsSync(f));
-  const existingFiles = [...filesToWrite.filter((f) => fs18.existsSync(f)), ...filesToDelete];
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs19.existsSync(f));
+  const existingFiles = [...filesToWrite.filter((f) => fs19.existsSync(f)), ...filesToDelete];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
   const written = [];
   if (setup.targetAgent.includes("claude") && setup.claude) {
@@ -4800,7 +5312,7 @@ function writeSetup(setup) {
   }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs18.unlinkSync(filePath);
+    fs19.unlinkSync(filePath);
     deleted.push(filePath);
   }
   written.push(...ensureBuiltinSkills());
@@ -4831,8 +5343,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs18.existsSync(entry.path)) {
-        fs18.unlinkSync(entry.path);
+      if (fs19.existsSync(entry.path)) {
+        fs19.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -4841,8 +5353,8 @@ function undoSetup() {
       }
     }
   }
-  if (fs18.existsSync(MANIFEST_FILE)) {
-    fs18.unlinkSync(MANIFEST_FILE);
+  if (fs19.existsSync(MANIFEST_FILE)) {
+    fs19.unlinkSync(MANIFEST_FILE);
   }
   return { restored, removed };
 }
@@ -4884,22 +5396,22 @@ function getFilesToWrite(setup) {
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs18.existsSync(gitignorePath)) {
-    const content = fs18.readFileSync(gitignorePath, "utf-8");
+  if (fs19.existsSync(gitignorePath)) {
+    const content = fs19.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs18.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs19.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs18.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs19.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
-import fs19 from "fs";
-import path17 from "path";
-var STAGED_DIR = path17.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path17.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path17.join(STAGED_DIR, "current");
+import fs20 from "fs";
+import path18 from "path";
+var STAGED_DIR = path18.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path18.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path18.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -4910,20 +5422,20 @@ function stageFiles(files, projectDir) {
   const stagedFiles = [];
   for (const file of files) {
     assertPathWithinDir(file.path, projectDir);
-    const originalPath = path17.join(projectDir, file.path);
-    if (fs19.existsSync(originalPath)) {
-      const existing = fs19.readFileSync(originalPath, "utf-8");
+    const originalPath = path18.join(projectDir, file.path);
+    if (fs20.existsSync(originalPath)) {
+      const existing = fs20.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path17.join(PROPOSED_DIR, file.path);
-    fs19.mkdirSync(path17.dirname(proposedPath), { recursive: true });
-    fs19.writeFileSync(proposedPath, file.content);
-    if (fs19.existsSync(originalPath)) {
-      const currentPath = path17.join(CURRENT_DIR, file.path);
-      fs19.mkdirSync(path17.dirname(currentPath), { recursive: true });
-      fs19.copyFileSync(originalPath, currentPath);
+    const proposedPath = path18.join(PROPOSED_DIR, file.path);
+    fs20.mkdirSync(path18.dirname(proposedPath), { recursive: true });
+    fs20.writeFileSync(proposedPath, file.content);
+    if (fs20.existsSync(originalPath)) {
+      const currentPath = path18.join(CURRENT_DIR, file.path);
+      fs20.mkdirSync(path18.dirname(currentPath), { recursive: true });
+      fs20.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({
         relativePath: file.path,
@@ -4940,13 +5452,14 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs19.existsSync(STAGED_DIR)) {
-    fs19.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs20.existsSync(STAGED_DIR)) {
+    fs20.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
 // src/commands/setup-files.ts
-import fs20 from "fs";
+init_builtin_skills();
+import fs21 from "fs";
 function collectSetupFiles(setup, targetAgent) {
   const files = [];
   const claude = setup.claude;
@@ -5031,7 +5544,7 @@ function collectSetupFiles(setup, targetAgent) {
     }
   }
   const codexTargeted = targetAgent ? targetAgent.includes("codex") : false;
-  if (codexTargeted && !fs20.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
+  if (codexTargeted && !fs21.existsSync("AGENTS.md") && !(codex && codex.agentsMd)) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -5050,9 +5563,9 @@ ${agentRefs.join(" ")}
 
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
-import fs21 from "fs";
-import path18 from "path";
-var SETTINGS_PATH = path18.join(".claude", "settings.json");
+import fs22 from "fs";
+import path19 from "path";
+var SETTINGS_PATH2 = path19.join(".claude", "settings.json");
 var HOOK_TAILS = [
   { event: "PostToolUse", tail: "learn observe", description: "Caliber: recording tool usage for session learning" },
   { event: "PostToolUseFailure", tail: "learn observe --failure", description: "Caliber: recording tool failure for session learning" },
@@ -5068,24 +5581,24 @@ function getHookConfigs() {
     description
   }));
 }
-function readSettings() {
-  if (!fs21.existsSync(SETTINGS_PATH)) return {};
+function readSettings2() {
+  if (!fs22.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs21.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs22.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
-function writeSettings(settings) {
-  const dir = path18.dirname(SETTINGS_PATH);
-  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
-  fs21.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+function writeSettings2(settings) {
+  const dir = path19.dirname(SETTINGS_PATH2);
+  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+  fs22.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, tail) {
   return matchers.some((entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, tail)));
 }
 function areLearningHooksInstalled() {
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) return false;
   return HOOK_TAILS.every((cfg) => {
     const matchers = settings.hooks[cfg.event];
@@ -5096,7 +5609,7 @@ function installLearningHooks() {
   if (areLearningHooksInstalled()) {
     return { installed: false, alreadyInstalled: true };
   }
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) settings.hooks = {};
   const configs = getHookConfigs();
   for (const cfg of configs) {
@@ -5110,10 +5623,10 @@ function installLearningHooks() {
       });
     }
   }
-  writeSettings(settings);
+  writeSettings2(settings);
   return { installed: true, alreadyInstalled: false };
 }
-var CURSOR_HOOKS_PATH = path18.join(".cursor", "hooks.json");
+var CURSOR_HOOKS_PATH = path19.join(".cursor", "hooks.json");
 var CURSOR_HOOK_EVENTS = [
   { event: "postToolUse", tail: "learn observe" },
   { event: "postToolUseFailure", tail: "learn observe --failure" },
@@ -5121,17 +5634,17 @@ var CURSOR_HOOK_EVENTS = [
   { event: "sessionEnd", tail: "learn finalize --auto" }
 ];
 function readCursorHooks() {
-  if (!fs21.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
+  if (!fs22.existsSync(CURSOR_HOOKS_PATH)) return { version: 1, hooks: {} };
   try {
-    return JSON.parse(fs21.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
+    return JSON.parse(fs22.readFileSync(CURSOR_HOOKS_PATH, "utf-8"));
   } catch {
     return { version: 1, hooks: {} };
   }
 }
 function writeCursorHooks(config) {
-  const dir = path18.dirname(CURSOR_HOOKS_PATH);
-  if (!fs21.existsSync(dir)) fs21.mkdirSync(dir, { recursive: true });
-  fs21.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
+  const dir = path19.dirname(CURSOR_HOOKS_PATH);
+  if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
+  fs22.writeFileSync(CURSOR_HOOKS_PATH, JSON.stringify(config, null, 2));
 }
 function hasCursorHook(entries, tail) {
   return entries.some((e) => isCaliberCommand(e.command, tail));
@@ -5178,7 +5691,7 @@ function removeCursorLearningHooks() {
   return { removed: true, notFound: false };
 }
 function removeLearningHooks() {
-  const settings = readSettings();
+  const settings = readSettings2();
   if (!settings.hooks) return { removed: false, notFound: true };
   let removedAny = false;
   for (const cfg of HOOK_TAILS) {
@@ -5195,7 +5708,7 @@ function removeLearningHooks() {
     delete settings.hooks;
   }
   if (!removedAny) return { removed: false, notFound: true };
-  writeSettings(settings);
+  writeSettings2(settings);
   return { removed: true, notFound: false };
 }
 
@@ -5203,10 +5716,10 @@ function removeLearningHooks() {
 init_resolve_caliber();
 
 // src/lib/state.ts
-import fs22 from "fs";
-import path19 from "path";
-import { execSync as execSync8 } from "child_process";
-var STATE_FILE = path19.join(CALIBER_DIR, ".caliber-state.json");
+import fs23 from "fs";
+import path20 from "path";
+import { execSync as execSync9 } from "child_process";
+var STATE_FILE = path20.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -5217,8 +5730,8 @@ function normalizeTargetAgent(value) {
 }
 function readState() {
   try {
-    if (!fs22.existsSync(STATE_FILE)) return null;
-    const raw = JSON.parse(fs22.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs23.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs23.readFileSync(STATE_FILE, "utf-8"));
     if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
     return raw;
   } catch {
@@ -5226,14 +5739,14 @@ function readState() {
   }
 }
 function writeState(state) {
-  if (!fs22.existsSync(CALIBER_DIR)) {
-    fs22.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs23.existsSync(CALIBER_DIR)) {
+    fs23.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs22.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs23.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
-    return execSync8("git rev-parse HEAD", {
+    return execSync9("git rev-parse HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -5343,6 +5856,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";
@@ -5833,7 +6349,7 @@ function checkGrounding(dir) {
 
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync4, statSync } from "fs";
-import { execSync as execSync9 } from "child_process";
+import { execSync as execSync10 } from "child_process";
 import { join as join5 } from "path";
 init_resolve_caliber();
 function validateReferences(dir) {
@@ -5843,13 +6359,13 @@ function validateReferences(dir) {
 }
 function detectGitDrift(dir) {
   try {
-    execSync9("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
+    execSync10("git rev-parse --git-dir", { cwd: dir, stdio: ["pipe", "pipe", "pipe"] });
   } catch {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: false };
   }
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules", ".cursor/rules"];
   try {
-    const headTimestamp = execSync9(
+    const headTimestamp = execSync10(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5870,7 +6386,7 @@ function detectGitDrift(dir) {
   let latestConfigCommitHash = null;
   for (const file of configFiles) {
     try {
-      const hash = execSync9(
+      const hash = execSync10(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -5879,7 +6395,7 @@ function detectGitDrift(dir) {
         latestConfigCommitHash = hash;
       } else {
         try {
-          execSync9(
+          execSync10(
             `git merge-base --is-ancestor ${latestConfigCommitHash} ${hash}`,
             { cwd: dir, stdio: ["pipe", "pipe", "pipe"] }
           );
@@ -5894,12 +6410,12 @@ function detectGitDrift(dir) {
     return { commitsSinceConfigUpdate: 0, lastConfigCommit: null, isGitRepo: true };
   }
   try {
-    const countStr = execSync9(
+    const countStr = execSync10(
       `git rev-list --count ${latestConfigCommitHash}..HEAD`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     const commitsSince = parseInt(countStr, 10) || 0;
-    const lastDate = execSync9(
+    const lastDate = execSync10(
       `git log -1 --format=%ci ${latestConfigCommitHash}`,
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5972,12 +6488,12 @@ function checkAccuracy(dir) {
 // src/scoring/checks/freshness.ts
 init_resolve_caliber();
 import { existsSync as existsSync5, statSync as statSync2 } from "fs";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync11 } from "child_process";
 import { join as join6 } from "path";
 function getCommitsSinceConfigUpdate(dir) {
   const configFiles = ["CLAUDE.md", "AGENTS.md", ".cursorrules"];
   try {
-    const headTimestamp = execSync10(
+    const headTimestamp = execSync11(
       "git log -1 --format=%ct HEAD",
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
@@ -5997,12 +6513,12 @@ function getCommitsSinceConfigUpdate(dir) {
   }
   for (const file of configFiles) {
     try {
-      const hash = execSync10(
+      const hash = execSync11(
         `git log -1 --format=%H -- "${file}"`,
         { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
       if (hash) {
-        const countStr = execSync10(
+        const countStr = execSync11(
           `git rev-list --count ${hash}..HEAD`,
           { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         ).trim();
@@ -6120,12 +6636,13 @@ function checkFreshness(dir) {
 
 // src/scoring/checks/bonus.ts
 import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
-import { execSync as execSync11 } from "child_process";
+import { execSync as execSync12 } from "child_process";
 import { join as join7 } from "path";
 init_resolve_caliber();
+init_pre_commit_block();
 function hasPreCommitHook(dir) {
   try {
-    const gitDir = execSync11("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    const gitDir = execSync12("git rev-parse --git-dir", { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     const hookPath = join7(gitDir, "hooks", "pre-commit");
     const content = readFileOrNull(hookPath);
     return content ? content.includes("caliber") : false;
@@ -6282,22 +6799,22 @@ function checkSources(dir) {
 }
 
 // src/scoring/dismissed.ts
-import fs23 from "fs";
-import path20 from "path";
-var DISMISSED_FILE = path20.join(CALIBER_DIR, "dismissed-checks.json");
+import fs24 from "fs";
+import path21 from "path";
+var DISMISSED_FILE = path21.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs23.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs23.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs24.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs24.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs23.existsSync(CALIBER_DIR)) {
-    fs23.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs24.existsSync(CALIBER_DIR)) {
+    fs24.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs23.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs24.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -6327,8 +6844,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) {
@@ -6552,27 +7069,27 @@ import { PostHog } from "posthog-node";
 import chalk5 from "chalk";
 
 // src/telemetry/config.ts
-import fs24 from "fs";
-import path21 from "path";
+import fs25 from "fs";
+import path22 from "path";
 import os5 from "os";
 import crypto4 from "crypto";
-import { execSync as execSync12 } from "child_process";
-var CONFIG_DIR2 = path21.join(os5.homedir(), ".caliber");
-var CONFIG_FILE2 = path21.join(CONFIG_DIR2, "config.json");
+import { execSync as execSync13 } from "child_process";
+var CONFIG_DIR2 = path22.join(os5.homedir(), ".caliber");
+var CONFIG_FILE2 = path22.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
-    if (!fs24.existsSync(CONFIG_FILE2)) return {};
-    return JSON.parse(fs24.readFileSync(CONFIG_FILE2, "utf-8"));
+    if (!fs25.existsSync(CONFIG_FILE2)) return {};
+    return JSON.parse(fs25.readFileSync(CONFIG_FILE2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(config) {
-  if (!fs24.existsSync(CONFIG_DIR2)) {
-    fs24.mkdirSync(CONFIG_DIR2, { recursive: true });
+  if (!fs25.existsSync(CONFIG_DIR2)) {
+    fs25.mkdirSync(CONFIG_DIR2, { recursive: true });
   }
-  fs24.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs25.writeFileSync(CONFIG_FILE2, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function getMachineId() {
   const config = readConfig();
@@ -6582,11 +7099,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 = execSync12("git config user.email", { encoding: "utf-8" }).trim();
-    if (!email) return void 0;
-    return crypto4.createHmac("sha256", EMAIL_HASH_KEY).update(email).digest("hex");
+    const email = execSync13("git config user.email", { encoding: "utf-8" }).trim();
+    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;
   }
@@ -6611,6 +7174,7 @@ function markNoticeShown() {
 var POSTHOG_KEY = "phc_XXrV0pSX4s2QVxVoOaeuyXDvtlRwPAjovt1ttMGVMPp";
 var client = null;
 var distinctId = null;
+var superProperties = {};
 function initTelemetry() {
   if (isTelemetryDisabled()) return;
   const machineId = getMachineId();
@@ -6626,11 +7190,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 } : {}
     }
   });
 }
@@ -6639,7 +7209,7 @@ function trackEvent(name, properties) {
   client.capture({
     distinctId,
     event: name,
-    properties: properties ?? {}
+    properties: { ...superProperties, ...properties }
   });
 }
 async function flushTelemetry() {
@@ -6688,11 +7258,14 @@ function trackInitSkillsSearch(searched, installedCount) {
 function trackInitScoreRegression(oldScore, newScore) {
   trackEvent("init_score_regression", { old_score: oldScore, new_score: newScore });
 }
+function trackInitCompleted(path42, score) {
+  trackEvent("init_completed", { path: path42, 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 });
@@ -6706,6 +7279,9 @@ function trackSkillsInstalled(count) {
 function trackUndoExecuted() {
   trackEvent("undo_executed");
 }
+function trackUninstallExecuted() {
+  trackEvent("uninstall_executed");
+}
 function trackInitLearnEnabled(enabled) {
   trackEvent("init_learn_enabled", { enabled });
 }
@@ -7677,11 +8253,11 @@ function countIssuePoints(issues) {
 }
 async function scoreAndRefine(setup, dir, sessionHistory, callbacks) {
   const existsCache = /* @__PURE__ */ new Map();
-  const cachedExists = (path41) => {
-    const cached = existsCache.get(path41);
+  const cachedExists = (path42) => {
+    const cached = existsCache.get(path42);
     if (cached !== void 0) return cached;
-    const result = existsSync9(path41);
-    existsCache.set(path41, result);
+    const result = existsSync9(path42);
+    existsCache.set(path42, result);
     return result;
   };
   const projectStructure = collectProjectStructure(dir);
@@ -7820,8 +8396,8 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 }
 
 // src/lib/debug-report.ts
-import fs25 from "fs";
-import path22 from "path";
+import fs26 from "fs";
+import path23 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -7890,11 +8466,11 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path22.dirname(outputPath);
-    if (!fs25.existsSync(dir)) {
-      fs25.mkdirSync(dir, { recursive: true });
+    const dir = path23.dirname(outputPath);
+    if (!fs26.existsSync(dir)) {
+      fs26.mkdirSync(dir, { recursive: true });
     }
-    fs25.writeFileSync(outputPath, lines.join("\n"));
+    fs26.writeFileSync(outputPath, lines.join("\n"));
   }
 };
 function formatMs(ms) {
@@ -8295,7 +8871,7 @@ import chalk11 from "chalk";
 import ora3 from "ora";
 import select5 from "@inquirer/select";
 import checkbox from "@inquirer/checkbox";
-import fs28 from "fs";
+import fs29 from "fs";
 
 // src/ai/refine.ts
 async function refineSetup(currentSetup, message, conversationHistory, callbacks) {
@@ -8436,10 +9012,10 @@ init_config();
 init_review();
 function detectAgents(dir) {
   const agents = [];
-  if (fs28.existsSync(`${dir}/.claude`)) agents.push("claude");
-  if (fs28.existsSync(`${dir}/.cursor`)) agents.push("cursor");
-  if (fs28.existsSync(`${dir}/.agents`) || fs28.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
-  if (fs28.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
+  if (fs29.existsSync(`${dir}/.claude`)) agents.push("claude");
+  if (fs29.existsSync(`${dir}/.cursor`)) agents.push("cursor");
+  if (fs29.existsSync(`${dir}/.agents`) || fs29.existsSync(`${dir}/AGENTS.md`)) agents.push("codex");
+  if (fs29.existsSync(`${dir}/.github/copilot-instructions.md`)) agents.push("github-copilot");
   return agents;
 }
 async function promptAgent(detected) {
@@ -8461,25 +9037,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 = [];
@@ -8561,18 +9118,18 @@ async function refineLoop(currentSetup, sessionHistory, summarizeSetup2, printSu
 
 // src/commands/init-display.ts
 import chalk12 from "chalk";
-import fs29 from "fs";
+import fs30 from "fs";
 function formatWhatChanged(setup) {
   const lines = [];
   const claude = setup.claude;
   const codex = setup.codex;
   const cursor = setup.cursor;
   if (claude?.claudeMd) {
-    const action = fs29.existsSync("CLAUDE.md") ? "Updated" : "Created";
+    const action = fs30.existsSync("CLAUDE.md") ? "Updated" : "Created";
     lines.push(`${action} CLAUDE.md`);
   }
   if (codex?.agentsMd) {
-    const action = fs29.existsSync("AGENTS.md") ? "Updated" : "Created";
+    const action = fs30.existsSync("AGENTS.md") ? "Updated" : "Created";
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
@@ -8615,7 +9172,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs29.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync("CLAUDE.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk12.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8625,7 +9182,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8636,7 +9193,7 @@ function printSetupSummary(setup) {
   const codex = setup.codex;
   if (codex) {
     if (codex.agentsMd) {
-      const icon = fs29.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync("AGENTS.md") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription("AGENTS.md");
       console.log(`  ${icon} ${chalk12.bold("AGENTS.md")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8646,7 +9203,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(codexSkills) && codexSkills.length > 0) {
       for (const skill of codexSkills) {
         const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
-        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8656,7 +9213,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs29.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
+      const icon = fs30.existsSync(".cursorrules") ? chalk12.yellow("~") : chalk12.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk12.bold(".cursorrules")}`);
       if (desc) console.log(chalk12.dim(`    ${desc}`));
@@ -8666,7 +9223,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs29.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(skillPath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk12.bold(skillPath)}`);
         console.log(chalk12.dim(`    ${desc || skill.description || skill.name}`));
@@ -8677,7 +9234,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rulesArr) && rulesArr.length > 0) {
       for (const rule of rulesArr) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs29.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
+        const icon = fs30.existsSync(rulePath) ? chalk12.yellow("~") : chalk12.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk12.bold(rulePath)}`);
         if (desc) {
@@ -8732,12 +9289,12 @@ function displayTokenUsage() {
 // src/commands/init-helpers.ts
 init_config();
 import chalk13 from "chalk";
-import fs30 from "fs";
-import path24 from "path";
+import fs31 from "fs";
+import path25 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path24.join(dir, ".caliber");
+  const caliberDir = path25.join(dir, ".caliber");
   try {
-    const stat = fs30.statSync(caliberDir);
+    const stat = fs31.statSync(caliberDir);
     return !stat.isDirectory();
   } catch {
     return true;
@@ -8790,8 +9347,8 @@ function ensurePermissions(fingerprint) {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs30.existsSync(settingsPath)) {
-      settings = JSON.parse(fs30.readFileSync(settingsPath, "utf-8"));
+    if (fs31.existsSync(settingsPath)) {
+      settings = JSON.parse(fs31.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -8800,12 +9357,12 @@ function ensurePermissions(fingerprint) {
   if (Array.isArray(allow) && allow.length > 0) return;
   permissions.allow = derivePermissions(fingerprint);
   settings.permissions = permissions;
-  if (!fs30.existsSync(".claude")) fs30.mkdirSync(".claude", { recursive: true });
-  fs30.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs31.existsSync(".claude")) fs31.mkdirSync(".claude", { recursive: true });
+  fs31.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function writeErrorLog(config, rawOutput, error, stopReason) {
   try {
-    const logPath = path24.join(process.cwd(), ".caliber", "error-log.md");
+    const logPath = path25.join(process.cwd(), ".caliber", "error-log.md");
     const lines = [
       `# Generation Error \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
       "",
@@ -8818,8 +9375,8 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs30.mkdirSync(path24.join(process.cwd(), ".caliber"), { recursive: true });
-    fs30.writeFileSync(logPath, lines.join("\n"));
+    fs31.mkdirSync(path25.join(process.cwd(), ".caliber"), { recursive: true });
+    fs31.writeFileSync(logPath, lines.join("\n"));
     console.log(chalk13.dim(`
   Error log written to .caliber/error-log.md`));
   } catch {
@@ -8870,13 +9427,13 @@ ${JSON.stringify(checkList, null, 2)}`,
 }
 
 // src/scoring/history.ts
-import fs31 from "fs";
-import path25 from "path";
+import fs32 from "fs";
+import path26 from "path";
 var HISTORY_FILE = "score-history.jsonl";
 var MAX_ENTRIES = 500;
 var TRIM_THRESHOLD = MAX_ENTRIES + 50;
 function historyFilePath() {
-  return path25.join(CALIBER_DIR, HISTORY_FILE);
+  return path26.join(CALIBER_DIR, HISTORY_FILE);
 }
 function recordScore(result, trigger) {
   const entry = {
@@ -8887,14 +9444,14 @@ function recordScore(result, trigger) {
     trigger
   };
   try {
-    fs31.mkdirSync(CALIBER_DIR, { recursive: true });
+    fs32.mkdirSync(CALIBER_DIR, { recursive: true });
     const filePath = historyFilePath();
-    fs31.appendFileSync(filePath, JSON.stringify(entry) + "\n");
-    const stat = fs31.statSync(filePath);
+    fs32.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+    const stat = fs32.statSync(filePath);
     if (stat.size > TRIM_THRESHOLD * 120) {
-      const lines = fs31.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+      const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
       if (lines.length > MAX_ENTRIES) {
-        fs31.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
+        fs32.writeFileSync(filePath, lines.slice(-MAX_ENTRIES).join("\n") + "\n");
       }
     }
   } catch {
@@ -8903,7 +9460,7 @@ function recordScore(result, trigger) {
 function readScoreHistory() {
   const filePath = historyFilePath();
   try {
-    const content = fs31.readFileSync(filePath, "utf-8");
+    const content = fs32.readFileSync(filePath, "utf-8");
     const entries = [];
     for (const line of content.split("\n")) {
       if (!line) continue;
@@ -8941,49 +9498,73 @@ async function initCommand(options) {
   const bin = resolveCaliber();
   const firstRun = isFirstRun(process.cwd());
   if (firstRun) {
-    console.log(
-      brand.bold(`
+    console.log(brand.bold(`
    \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557     \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
   \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
   \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
    \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
-  `)
-    );
-    console.log(chalk14.dim("  Scan your project and generate tailored config files for"));
-    console.log(chalk14.dim("  Claude Code, Cursor, Codex, and GitHub Copilot.\n"));
+  `));
+    console.log(chalk14.dim("  Keep your AI agent configs in sync \u2014 automatically."));
+    console.log(chalk14.dim("  Works across Claude Code, Cursor, Codex, and GitHub Copilot.\n"));
     console.log(title.bold("  How it works:\n"));
-    console.log(chalk14.dim("  1. Connect    Link your LLM provider and select your agents"));
-    console.log(chalk14.dim("  2. Engine     Detect stack, generate configs & skills in parallel"));
-    console.log(chalk14.dim("  3. Review     See all changes \u2014 accept, refine, or decline"));
-    console.log(chalk14.dim("  4. Finalize   Score check and auto-sync hooks\n"));
+    console.log(chalk14.dim("  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 regenerating config\n"));
+    console.log(brand.bold("\n  CALIBER") + chalk14.dim("  \u2014 setting up continuous sync\n"));
   }
   const platforms = detectPlatforms();
   if (!platforms.claude && !platforms.cursor && !platforms.codex) {
     console.log(chalk14.yellow("  \u26A0 No supported AI platforms detected (Claude, Cursor, Codex)."));
-    console.log(
-      chalk14.yellow(
-        "    Caliber will still generate config files, but they won't be auto-installed.\n"
-      )
-    );
+    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);
@@ -8992,51 +9573,67 @@ async function initCommand(options) {
   console.log(chalk14.dim(modelLine + "\n"));
   if (report) {
     report.markStep("Provider connection");
-    report.addSection(
-      "LLM Provider",
-      `- **Provider**: ${config.provider}
+    report.addSection("LLM Provider", `- **Provider**: ${config.provider}
 - **Model**: ${displayModel}
-- **Fast model**: ${fastModel || "none"}`
-    );
+- **Fast model**: ${fastModel || "none"}`);
   }
   await validateModel({ fast: true });
   let targetAgent;
   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(`  Coding agents in this repo: ${detected.join(", ")}
+`));
+    } else if (detected.length > 0) {
+      console.log(chalk14.dim(`  Coding agents in this repo: ${detected.join(", ")}
+`));
+      const useDetected = await confirm2({ message: "Generate configs for these agents?" });
+      targetAgent = useDetected ? detected : await promptAgent();
+    } else {
+      targetAgent = options.autoApprove ? ["claude"] : await promptAgent();
+    }
   }
   console.log(chalk14.dim(`  Target: ${targetAgent.join(", ")}
 `));
   trackInitAgentSelected(targetAgent, agentAutoDetected);
-  const baselineScore = computeLocalScore(process.cwd(), targetAgent);
-  console.log(chalk14.dim("\n  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}` : ""}`
-      );
-    }
+  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`);
+  } else if (hookResult.alreadyInstalled) {
+    console.log(`  ${chalk14.green("\u2713")} Pre-commit hook \u2014 active`);
+  }
+  const { ensureBuiltinSkills: ensureBuiltinSkills2 } = await Promise.resolve().then(() => (init_builtin_skills(), builtin_skills_exports));
+  for (const agent of targetAgent) {
+    if (agent === "claude" && !fs33.existsSync(".claude")) fs33.mkdirSync(".claude", { recursive: true });
+    if (agent === "cursor" && !fs33.existsSync(".cursor")) fs33.mkdirSync(".cursor", { recursive: true });
+    if (agent === "codex" && !fs33.existsSync(".agents")) fs33.mkdirSync(".agents", { recursive: true });
+  }
+  const skillsWritten = ensureBuiltinSkills2();
+  if (skillsWritten.length > 0) {
+    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("");
+  const baselineScore = computeLocalScore(process.cwd(), targetAgent);
+  log(options.verbose, `Baseline score: ${baselineScore.score}/100`);
   if (report) {
     report.markStep("Baseline scoring");
-    report.addSection(
-      "Scoring: Baseline",
-      `**Score**: ${baselineScore.score}/100
+    report.addSection("Scoring: Baseline", `**Score**: ${baselineScore.score}/100
 
 | Check | Passed | Points | Max |
 |-------|--------|--------|-----|
-` + baselineScore.checks.map(
-        (c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.earnedPoints} | ${c.maxPoints} |`
-      ).join("\n")
-    );
+` + baselineScore.checks.map((c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.earnedPoints} | ${c.maxPoints} |`).join("\n"));
     report.addSection("Generation: Target Agents", targetAgent.join(", "));
   }
   const hasExistingConfig = !!(baselineScore.checks.some((c) => c.id === "claude_md_exists" && c.passed) || baselineScore.checks.some((c) => c.id === "cursorrules_exists" && c.passed));
@@ -9050,33 +9647,77 @@ async function initCommand(options) {
   ]);
   const passingCount = baselineScore.checks.filter((c) => c.passed).length;
   const failingCount = baselineScore.checks.filter((c) => !c.passed).length;
-  if (hasExistingConfig && baselineScore.score === 100) {
-    trackInitScoreComputed(baselineScore.score, passingCount, failingCount, true);
-    console.log(chalk14.bold.green("  Your config is already optimal \u2014 nothing to change.\n"));
-    console.log(
-      chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to regenerate anyway.\n")
-    );
-    if (!options.force) return;
-  }
-  const allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
-  const llmFixableChecks = allFailingChecks.filter((c) => !NON_LLM_CHECKS.has(c.id));
   trackInitScoreComputed(baselineScore.score, passingCount, failingCount, false);
-  if (hasExistingConfig && llmFixableChecks.length === 0 && allFailingChecks.length > 0 && !options.force) {
-    console.log(chalk14.bold.green("\n  Your config is fully optimized for LLM generation.\n"));
-    console.log(chalk14.dim("  Remaining items need CLI actions:\n"));
-    for (const check of allFailingChecks) {
-      console.log(chalk14.dim(`    \u2022 ${check.name}`));
-      if (check.suggestion) {
-        console.log(`      ${chalk14.hex("#83D1EB")(check.suggestion)}`);
+  let skipGeneration = false;
+  if (hasExistingConfig && baselineScore.score === 100 && !options.force) {
+    skipGeneration = true;
+  } else if (hasExistingConfig && !options.force && !options.autoApprove) {
+    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 {
+      appendManagedBlocks: appendManagedBlocks2,
+      getCursorPreCommitRule: getCursorPreCommitRule2,
+      getCursorLearningsRule: getCursorLearningsRule2,
+      getCursorSyncRule: getCursorSyncRule2,
+      getCursorSetupRule: getCursorSetupRule2
+    } = await Promise.resolve().then(() => (init_pre_commit_block(), pre_commit_block_exports));
+    const claudeMdPath = "CLAUDE.md";
+    let claudeContent = "";
+    try {
+      claudeContent = fs33.readFileSync(claudeMdPath, "utf-8");
+    } catch {
+    }
+    if (!claudeContent) {
+      claudeContent = `# ${path27.basename(process.cwd())}
+`;
+    }
+    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`);
+    }
+    if (targetAgent.includes("cursor")) {
+      const rulesDir = path27.join(".cursor", "rules");
+      if (!fs33.existsSync(rulesDir)) fs33.mkdirSync(rulesDir, { recursive: true });
+      for (const rule of [getCursorPreCommitRule2(), getCursorLearningsRule2(), getCursorSyncRule2(), getCursorSetupRule2()]) {
+        fs33.writeFileSync(path27.join(rulesDir, rule.filename), rule.content);
       }
+      console.log(`  ${chalk14.green("\u2713")} Cursor rules \u2014 added Caliber sync rules`);
     }
-    console.log("");
-    console.log(
-      chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to regenerate anyway.\n")
-    );
+    if (targetAgent.includes("github-copilot")) {
+      const copilotPath = path27.join(".github", "copilot-instructions.md");
+      let copilotContent = "";
+      try {
+        copilotContent = fs33.readFileSync(copilotPath, "utf-8");
+      } catch {
+      }
+      if (!copilotContent) {
+        fs33.mkdirSync(".github", { recursive: true });
+        copilotContent = `# ${path27.basename(process.cwd())}
+`;
+      }
+      const updatedCopilot = appendManagedBlocks2(copilotContent, "copilot");
+      if (updatedCopilot !== copilotContent) {
+        fs33.writeFileSync(copilotPath, updatedCopilot);
+        console.log(`  ${chalk14.green("\u2713")} Copilot instructions \u2014 added Caliber sync instructions`);
+      }
+    }
+    const sha2 = getCurrentHeadSha();
+    writeState({
+      lastRefreshSha: sha2 ?? "",
+      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"));
     return;
   }
-  console.log(title.bold("  Step 2/4 \u2014 Engine\n"));
   const genModelInfo = fastModel ? `  Using ${displayModel} for docs, ${fastModel} for skills` : `  Using ${displayModel}`;
   console.log(chalk14.dim(genModelInfo + "\n"));
   if (report) report.markStep("Generation");
@@ -9092,14 +9733,8 @@ async function initCommand(options) {
   const TASK_STACK = display.add("Detecting project stack", { pipelineLabel: "Scan" });
   const TASK_CONFIG = display.add("Generating configs", { depth: 1, pipelineLabel: "Generate" });
   const TASK_SKILLS_GEN = display.add("Generating skills", { depth: 2, pipelineLabel: "Skills" });
-  const TASK_SKILLS_SEARCH = display.add("Searching community skills", {
-    depth: 1,
-    pipelineLabel: "Search",
-    pipelineRow: 1
-  });
-  const TASK_SCORE_REFINE = display.add("Validating & refining config", {
-    pipelineLabel: "Validate"
-  });
+  const TASK_SKILLS_SEARCH = display.add("Searching community skills", { depth: 1, pipelineLabel: "Search", pipelineRow: 1 });
+  const TASK_SCORE_REFINE = display.add("Validating & refining config", { pipelineLabel: "Validate" });
   display.start();
   display.enableWaitingContent();
   try {
@@ -9109,39 +9744,21 @@ async function initCommand(options) {
     const stackSummary = stackParts.join(", ") || "no languages";
     const largeRepoNote = fingerprint.fileTree.length > 5e3 ? ` (${fingerprint.fileTree.length.toLocaleString()} files, smart sampling active)` : "";
     display.update(TASK_STACK, "done", stackSummary + largeRepoNote);
-    trackInitProjectDiscovered(
-      fingerprint.languages.length,
-      fingerprint.frameworks.length,
-      fingerprint.fileTree.length
-    );
-    log(
-      options.verbose,
-      `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`
-    );
+    trackInitProjectDiscovered(fingerprint.languages.length, fingerprint.frameworks.length, fingerprint.fileTree.length);
+    log(options.verbose, `Fingerprint: ${fingerprint.languages.length} languages, ${fingerprint.frameworks.length} frameworks, ${fingerprint.fileTree.length} files`);
     const cliSources = options.source || [];
     const workspaces = getDetectedWorkspaces(process.cwd());
     const sources2 = resolveAllSources(process.cwd(), cliSources, workspaces);
     if (sources2.length > 0) {
       fingerprint.sources = sources2;
-      log(
-        options.verbose,
-        `Sources: ${sources2.length} resolved (${sources2.map((s) => s.name).join(", ")})`
-      );
+      log(options.verbose, `Sources: ${sources2.length} resolved (${sources2.map((s) => s.name).join(", ")})`);
     }
     if (report) {
-      report.addJson("Fingerprint: Git", {
-        remote: fingerprint.gitRemoteUrl,
-        packageName: fingerprint.packageName
-      });
+      report.addJson("Fingerprint: Git", { remote: fingerprint.gitRemoteUrl, packageName: fingerprint.packageName });
       report.addCodeBlock("Fingerprint: File Tree", fingerprint.fileTree.join("\n"));
-      report.addJson("Fingerprint: Detected Stack", {
-        languages: fingerprint.languages,
-        frameworks: fingerprint.frameworks,
-        tools: fingerprint.tools
-      });
+      report.addJson("Fingerprint: Detected Stack", { languages: fingerprint.languages, frameworks: fingerprint.frameworks, tools: fingerprint.tools });
       report.addJson("Fingerprint: Existing Configs", fingerprint.existingConfigs);
-      if (fingerprint.codeAnalysis)
-        report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
+      if (fingerprint.codeAnalysis) report.addJson("Fingerprint: Code Analysis", fingerprint.codeAnalysis);
     }
     const isEmpty = fingerprint.fileTree.length < 3;
     if (isEmpty) {
@@ -9172,26 +9789,13 @@ async function initCommand(options) {
       let passingChecks;
       let currentScore;
       if (hasExistingConfig && localBaseline.score >= 95 && !options.force) {
-        const currentLlmFixable = localBaseline.checks.filter(
-          (c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id)
-        );
-        failingChecks = currentLlmFixable.map((c) => ({
-          name: c.name,
-          suggestion: c.suggestion,
-          fix: c.fix
-        }));
+        const currentLlmFixable = localBaseline.checks.filter((c) => !c.passed && c.maxPoints > 0 && !NON_LLM_CHECKS.has(c.id));
+        failingChecks = currentLlmFixable.map((c) => ({ name: c.name, suggestion: c.suggestion, fix: c.fix }));
         passingChecks = localBaseline.checks.filter((c) => c.passed).map((c) => ({ name: c.name }));
         currentScore = localBaseline.score;
       }
       if (report) {
-        const fullPrompt = buildGeneratePrompt(
-          fingerprint,
-          targetAgent,
-          fingerprint.description,
-          failingChecks,
-          currentScore,
-          passingChecks
-        );
+        const fullPrompt = buildGeneratePrompt(fingerprint, targetAgent, fingerprint.description, failingChecks, currentScore, passingChecks);
         report.addCodeBlock("Generation: Full LLM Prompt", fullPrompt);
       }
       const result = await generateSetup(
@@ -9311,11 +9915,8 @@ async function initCommand(options) {
     if (rawOutput) report.addCodeBlock("Generation: Raw LLM Response", rawOutput);
     report.addJson("Generation: Parsed Config", generatedSetup);
   }
-  log(
-    options.verbose,
-    `Generation completed: ${elapsedMs}ms, stopReason: ${genStopReason || "end_turn"}`
-  );
-  console.log(title.bold("  Step 3/4 \u2014 Review\n"));
+  log(options.verbose, `Generation completed: ${elapsedMs}ms, stopReason: ${genStopReason || "end_turn"}`);
+  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;
@@ -9324,20 +9925,12 @@ async function initCommand(options) {
     for (const line of changes) {
       console.log(`  ${chalk14.dim("\u2022")} ${line}`);
     }
-    console.log("");
-  }
-  console.log(
-    chalk14.dim(
-      `  ${chalk14.green(`${staged.newFiles} new`)} / ${chalk14.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}`
-    )
-  );
+    console.log("");
+  }
+  console.log(chalk14.dim(`  ${chalk14.green(`${staged.newFiles} new`)} / ${chalk14.yellow(`${staged.modifiedFiles} modified`)} file${totalChanges !== 1 ? "s" : ""}`));
   if (skillSearchResult.results.length > 0) {
-    console.log(
-      chalk14.dim(
-        `  ${chalk14.cyan(`${skillSearchResult.results.length}`)} community skills available to install
-`
-      )
-    );
+    console.log(chalk14.dim(`  ${chalk14.cyan(`${skillSearchResult.results.length}`)} community skills available to install
+`));
   } else {
     console.log("");
   }
@@ -9373,12 +9966,8 @@ async function initCommand(options) {
     }
     const updatedFiles = collectSetupFiles(generatedSetup, targetAgent);
     const restaged = stageFiles(updatedFiles, process.cwd());
-    console.log(
-      chalk14.dim(
-        `  ${chalk14.green(`${restaged.newFiles} new`)} / ${chalk14.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
-`
-      )
-    );
+    console.log(chalk14.dim(`  ${chalk14.green(`${restaged.newFiles} new`)} / ${chalk14.yellow(`${restaged.modifiedFiles} modified`)} file${restaged.newFiles + restaged.modifiedFiles !== 1 ? "s" : ""}
+`));
     printSetupSummary(generatedSetup);
     const { openReview: openRev } = await Promise.resolve().then(() => (init_review(), review_exports));
     await openRev("terminal", restaged.stagedFiles);
@@ -9390,7 +9979,6 @@ async function initCommand(options) {
     console.log(chalk14.dim("Declined. No files were modified."));
     return;
   }
-  console.log(title.bold("\n  Step 4/4 \u2014 Finalize\n"));
   if (options.dryRun) {
     console.log(chalk14.yellow("\n[Dry run] Would write the following files:"));
     console.log(JSON.stringify(generatedSetup, null, 2));
@@ -9399,14 +9987,13 @@ async function initCommand(options) {
   const { default: ora9 } = await import("ora");
   const writeSpinner = ora9("Writing config files...").start();
   try {
-    if (targetAgent.includes("codex") && !fs32.existsSync("AGENTS.md") && !generatedSetup.codex) {
+    if (targetAgent.includes("codex") && !fs33.existsSync("AGENTS.md") && !generatedSetup.codex) {
       const claude = generatedSetup.claude;
       const cursor = generatedSetup.cursor;
       const agentRefs = [];
       if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
       if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
-      if (agentRefs.length === 0)
-        agentRefs.push("See CLAUDE.md and .cursor/rules/ for agent configurations.");
+      if (agentRefs.length === 0) agentRefs.push("See CLAUDE.md and .cursor/rules/ for agent configurations.");
       const stubContent = `# AGENTS.md
 
 This project uses AI coding agents configured by [Caliber](https://github.com/caliber-ai-org/ai-setup).
@@ -9453,49 +10040,32 @@ ${agentRefs.join(" ")}
   if (afterScore.score < baselineScore.score) {
     trackInitScoreRegression(baselineScore.score, afterScore.score);
     console.log("");
-    console.log(
-      chalk14.yellow(
-        `  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`
-      )
-    );
+    console.log(chalk14.yellow(`  Score would drop from ${baselineScore.score} to ${afterScore.score} \u2014 reverting changes.`));
     try {
       const { restored, removed } = undoSetup();
       if (restored.length > 0 || removed.length > 0) {
-        console.log(
-          chalk14.dim(
-            `  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`
-          )
-        );
+        console.log(chalk14.dim(`  Reverted ${restored.length + removed.length} file${restored.length + removed.length === 1 ? "" : "s"} from backup.`));
       }
     } catch {
     }
-    console.log(
-      chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to override.\n")
-    );
+    console.log(chalk14.dim("  Run ") + chalk14.hex("#83D1EB")(`${bin} init --force`) + chalk14.dim(" to override.\n"));
     return;
   }
   if (report) {
     report.markStep("Post-write scoring");
-    report.addSection(
-      "Scoring: Post-Write",
-      `**Score**: ${afterScore.score}/100 (delta: ${afterScore.score - baselineScore.score >= 0 ? "+" : ""}${afterScore.score - baselineScore.score})
+    report.addSection("Scoring: Post-Write", `**Score**: ${afterScore.score}/100 (delta: ${afterScore.score - baselineScore.score >= 0 ? "+" : ""}${afterScore.score - baselineScore.score})
 
 | Check | Passed | Points | Max |
 |-------|--------|--------|-----|
-` + afterScore.checks.map(
-        (c) => `| ${c.name} | ${c.passed ? "Yes" : "No"} | ${c.earnedPoints} | ${c.maxPoints} |`
-      ).join("\n")
-    );
+` + 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`);
     for (const c of afterScore.checks.filter((ch) => !ch.passed)) {
-      log(
-        options.verbose,
-        `  Still failing: ${c.name} (${c.earnedPoints}/${c.maxPoints})${c.suggestion ? ` \u2014 ${c.suggestion}` : ""}`
-      );
+      log(options.verbose, `  Still failing: ${c.name} (${c.earnedPoints}/${c.maxPoints})${c.suggestion ? ` \u2014 ${c.suggestion}` : ""}`);
     }
   }
   let communitySkillsInstalled = 0;
@@ -9508,99 +10078,36 @@ ${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  Configuration complete!"));
-  console.log(
-    chalk14.dim("  Your AI agents now understand your project's architecture, build commands,")
-  );
-  console.log(
-    chalk14.dim("  testing patterns, and conventions. All changes are backed up automatically.\n")
-  );
   const done = chalk14.green("\u2713");
-  const skip = chalk14.dim("\u2013");
-  console.log(chalk14.bold("  What was configured:\n"));
-  console.log(
-    `    ${done}  Config generated          ${title(`${bin} score`)} ${chalk14.dim("for full breakdown")}`
-  );
-  console.log(
-    `    ${done}  Docs auto-refresh        ${chalk14.dim(`agents run ${bin} refresh before commits`)}`
-  );
+  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`)} 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(chalk14.bold("\n  Explore next:\n"));
-  console.log(
-    `    ${title(`${bin} skills`)}       Find more community skills as your codebase evolves`
-  );
-  console.log(
-    `    ${title(`${bin} score`)}        See the full scoring breakdown with improvement tips`
-  );
-  console.log(`    ${title(`${bin} undo`)}         Revert all changes from this run`);
+    console.log(`    ${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 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();
   }
   if (report) {
     report.markStep("Finished");
-    const reportPath = path26.join(process.cwd(), ".caliber", "debug-report.md");
+    const reportPath = path27.join(process.cwd(), ".caliber", "debug-report.md");
     report.write(reportPath);
-    console.log(
-      chalk14.dim(`  Debug report written to ${path26.relative(process.cwd(), reportPath)}
-`)
-    );
+    console.log(chalk14.dim(`  Debug report written to ${path27.relative(process.cwd(), reportPath)}
+`));
   }
 }
 
@@ -9638,7 +10145,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk16 from "chalk";
-import fs33 from "fs";
+import fs34 from "fs";
 init_config();
 init_resolve_caliber();
 async function statusCommand(options) {
@@ -9667,7 +10174,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk16.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs33.existsSync(entry.path);
+    const exists = fs34.existsSync(entry.path);
     const icon = exists ? chalk16.green("\u2713") : chalk16.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -9824,9 +10331,9 @@ async function regenerateCommand(options) {
 }
 
 // src/commands/score.ts
-import fs34 from "fs";
+import fs35 from "fs";
 import os7 from "os";
-import path27 from "path";
+import path28 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 import chalk18 from "chalk";
 init_resolve_caliber();
@@ -9834,7 +10341,7 @@ var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
   if (!/^[\w.\-/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs34.mkdtempSync(path27.join(os7.tmpdir(), "caliber-compare-"));
+  const tmpDir = fs35.mkdtempSync(path28.join(os7.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
@@ -9842,7 +10349,7 @@ function scoreBaseRef(ref, target) {
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
-        fs34.writeFileSync(path27.join(tmpDir, file), content);
+        fs35.writeFileSync(path28.join(tmpDir, file), content);
       } catch {
       }
     }
@@ -9853,13 +10360,13 @@ function scoreBaseRef(ref, target) {
           stdio: ["pipe", "pipe", "pipe"]
         }).trim().split("\n").filter(Boolean);
         for (const file of files) {
-          const filePath = path27.join(tmpDir, file);
-          fs34.mkdirSync(path27.dirname(filePath), { recursive: true });
+          const filePath = path28.join(tmpDir, file);
+          fs35.mkdirSync(path28.dirname(filePath), { recursive: true });
           const content = execFileSync2("git", ["show", `${ref}:${file}`], {
             encoding: "utf-8",
             stdio: ["pipe", "pipe", "pipe"]
           });
-          fs34.writeFileSync(filePath, content);
+          fs35.writeFileSync(filePath, content);
         }
       } catch {
       }
@@ -9869,7 +10376,7 @@ function scoreBaseRef(ref, target) {
   } catch {
     return null;
   } finally {
-    fs34.rmSync(tmpDir, { recursive: true, force: true });
+    fs35.rmSync(tmpDir, { recursive: true, force: true });
   }
 }
 async function scoreCommand(options) {
@@ -9953,13 +10460,13 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs38 from "fs";
-import path31 from "path";
+import fs39 from "fs";
+import path32 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
 
 // src/lib/git-diff.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
@@ -9974,7 +10481,7 @@ function excludeArgs() {
 }
 function safeExec(cmd) {
   try {
-    return execSync14(cmd, {
+    return execSync15(cmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       maxBuffer: 10 * 1024 * 1024
@@ -10032,48 +10539,49 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs35 from "fs";
-import path28 from "path";
+init_pre_commit_block();
+import fs36 from "fs";
+import path29 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs35.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
+    fs36.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs35.writeFileSync("README.md", docs.readmeMd);
+    fs36.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs35.writeFileSync(".cursorrules", docs.cursorrules);
+    fs36.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path28.join(".cursor", "rules");
-    if (!fs35.existsSync(rulesDir)) fs35.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path29.join(".cursor", "rules");
+    if (!fs36.existsSync(rulesDir)) fs36.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      fs35.writeFileSync(path28.join(rulesDir, rule.filename), rule.content);
+      fs36.writeFileSync(path29.join(rulesDir, rule.filename), rule.content);
       written.push(`.cursor/rules/${rule.filename}`);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path28.join(".claude", "skills");
-    if (!fs35.existsSync(skillsDir)) fs35.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path29.join(".claude", "skills");
+    if (!fs36.existsSync(skillsDir)) fs36.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      fs35.writeFileSync(path28.join(skillsDir, skill.filename), skill.content);
+      fs36.writeFileSync(path29.join(skillsDir, skill.filename), skill.content);
       written.push(`.claude/skills/${skill.filename}`);
     }
   }
   if (docs.copilotInstructions) {
-    fs35.mkdirSync(".github", { recursive: true });
-    fs35.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions)));
+    fs36.mkdirSync(".github", { recursive: true });
+    fs36.writeFileSync(path29.join(".github", "copilot-instructions.md"), appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions)));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
-    const instructionsDir = path28.join(".github", "instructions");
-    fs35.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path29.join(".github", "instructions");
+    fs36.mkdirSync(instructionsDir, { recursive: true });
     for (const file of docs.copilotInstructionFiles) {
-      fs35.writeFileSync(path28.join(instructionsDir, file.filename), file.content);
+      fs36.writeFileSync(path29.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -10159,8 +10667,8 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 }
 
 // src/learner/writer.ts
-import fs36 from "fs";
-import path29 from "path";
+import fs37 from "fs";
+import path30 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -10277,20 +10785,20 @@ function deduplicateLearnedItems(existing, incoming) {
 }
 function writeLearnedSectionTo(filePath, header, existing, incoming, mode) {
   const { merged, newCount, newItems } = deduplicateLearnedItems(existing, incoming);
-  fs36.writeFileSync(filePath, header + merged + "\n");
-  if (mode) fs36.chmodSync(filePath, mode);
+  fs37.writeFileSync(filePath, header + merged + "\n");
+  if (mode) fs37.chmodSync(filePath, mode);
   return { newCount, newItems };
 }
 function writeLearnedSection(content) {
   return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path29.join(".claude", "skills", skill.name);
-  if (!fs36.existsSync(skillDir)) fs36.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path29.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs36.existsSync(skillPath)) {
-    const existing = fs36.readFileSync(skillPath, "utf-8");
-    fs36.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path30.join(".claude", "skills", skill.name);
+  if (!fs37.existsSync(skillDir)) fs37.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path30.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs37.existsSync(skillPath)) {
+    const existing = fs37.readFileSync(skillPath, "utf-8");
+    fs37.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -10299,12 +10807,12 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs36.writeFileSync(skillPath, frontmatter + skill.content);
+    fs37.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function writePersonalLearnedSection(content) {
-  if (!fs36.existsSync(AUTH_DIR)) fs36.mkdirSync(AUTH_DIR, { recursive: true });
+  if (!fs37.existsSync(AUTH_DIR)) fs37.mkdirSync(AUTH_DIR, { recursive: true });
   return writeLearnedSectionTo(PERSONAL_LEARNINGS_FILE, PERSONAL_LEARNINGS_HEADER, readPersonalLearnings(), content, 384);
 }
 function addLearning(bullet, scope = "project") {
@@ -10317,55 +10825,56 @@ function addLearning(bullet, scope = "project") {
   return { file: LEARNINGS_FILE, added: result.newCount > 0 };
 }
 function readPersonalLearnings() {
-  if (!fs36.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
-  const content = fs36.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+  if (!fs37.existsSync(PERSONAL_LEARNINGS_FILE)) return null;
+  const content = fs37.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
   const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
   return bullets || null;
 }
 function readLearnedSection() {
-  if (fs36.existsSync(LEARNINGS_FILE)) {
-    const content2 = fs36.readFileSync(LEARNINGS_FILE, "utf-8");
+  if (fs37.existsSync(LEARNINGS_FILE)) {
+    const content2 = fs37.readFileSync(LEARNINGS_FILE, "utf-8");
     const bullets = content2.split("\n").filter((l) => l.startsWith("- ")).join("\n");
     return bullets || null;
   }
   const claudeMdPath = "CLAUDE.md";
-  if (!fs36.existsSync(claudeMdPath)) return null;
-  const content = fs36.readFileSync(claudeMdPath, "utf-8");
+  if (!fs37.existsSync(claudeMdPath)) return null;
+  const content = fs37.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
   return content.slice(startIdx + LEARNED_START.length, endIdx).trim() || null;
 }
 function migrateInlineLearnings() {
-  if (fs36.existsSync(LEARNINGS_FILE)) return false;
+  if (fs37.existsSync(LEARNINGS_FILE)) return false;
   const claudeMdPath = "CLAUDE.md";
-  if (!fs36.existsSync(claudeMdPath)) return false;
-  const content = fs36.readFileSync(claudeMdPath, "utf-8");
+  if (!fs37.existsSync(claudeMdPath)) return false;
+  const content = fs37.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return false;
   const section = content.slice(startIdx + LEARNED_START.length, endIdx).trim();
   if (!section) return false;
-  fs36.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
+  fs37.writeFileSync(LEARNINGS_FILE, LEARNINGS_HEADER + section + "\n");
   const cleaned = content.slice(0, startIdx) + content.slice(endIdx + LEARNED_END.length);
-  fs36.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
+  fs37.writeFileSync(claudeMdPath, cleaned.replace(/\n{3,}/g, "\n\n").trim() + "\n");
   return true;
 }
 
 // src/commands/refresh.ts
 init_config();
 init_resolve_caliber();
+init_builtin_skills();
 function log2(quiet, ...args) {
   if (!quiet) console.log(...args);
 }
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs38.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs39.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path31.join(parentDir, entry.name);
-      if (fs38.existsSync(path31.join(childPath, ".git"))) {
+      const childPath = path32.join(parentDir, entry.name);
+      if (fs39.existsSync(path32.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -10451,26 +10960,27 @@ async function refreshSingleRepo(repoDir, options) {
   const filesToWrite = response.docsUpdated || [];
   const preRefreshContents = /* @__PURE__ */ new Map();
   for (const filePath of filesToWrite) {
-    const fullPath = path31.resolve(repoDir, filePath);
+    const fullPath = path32.resolve(repoDir, filePath);
     try {
-      preRefreshContents.set(filePath, fs38.readFileSync(fullPath, "utf-8"));
+      preRefreshContents.set(filePath, fs39.readFileSync(fullPath, "utf-8"));
     } catch {
       preRefreshContents.set(filePath, null);
     }
   }
   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) {
-      const fullPath = path31.resolve(repoDir, filePath);
+      const fullPath = path32.resolve(repoDir, filePath);
       if (content === null) {
         try {
-          fs38.unlinkSync(fullPath);
+          fs39.unlinkSync(fullPath);
         } catch {
         }
       } else {
-        fs38.writeFileSync(fullPath, content);
+        fs39.writeFileSync(fullPath, content);
       }
     }
     spinner?.warn(`${prefix}Refresh reverted \u2014 score would drop from ${preScore.score} to ${postScore.score}`);
@@ -10525,7 +11035,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path31.basename(repo);
+      const repoName = path32.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -10547,150 +11057,6 @@ async function refreshCommand(options) {
 // src/commands/hooks.ts
 import chalk20 from "chalk";
 import fs40 from "fs";
-
-// src/lib/hooks.ts
-init_resolve_caliber();
-import fs39 from "fs";
-import path32 from "path";
-import { execSync as execSync15 } from "child_process";
-var SETTINGS_PATH2 = path32.join(".claude", "settings.json");
-var REFRESH_TAIL = "refresh --quiet";
-var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
-function getHookCommand() {
-  return `${resolveCaliber()} ${REFRESH_TAIL}`;
-}
-function readSettings2() {
-  if (!fs39.existsSync(SETTINGS_PATH2)) return {};
-  try {
-    return JSON.parse(fs39.readFileSync(SETTINGS_PATH2, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeSettings2(settings) {
-  const dir = path32.dirname(SETTINGS_PATH2);
-  if (!fs39.existsSync(dir)) fs39.mkdirSync(dir, { recursive: true });
-  fs39.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
-}
-function findHookIndex(sessionEnd) {
-  return sessionEnd.findIndex(
-    (entry) => entry.hooks?.some((h) => isCaliberCommand(h.command, REFRESH_TAIL))
-  );
-}
-function isHookInstalled() {
-  const settings = readSettings2();
-  const sessionEnd = settings.hooks?.SessionEnd;
-  if (!Array.isArray(sessionEnd)) return false;
-  return findHookIndex(sessionEnd) !== -1;
-}
-function installHook() {
-  const settings = readSettings2();
-  if (!settings.hooks) settings.hooks = {};
-  if (!Array.isArray(settings.hooks.SessionEnd)) settings.hooks.SessionEnd = [];
-  if (findHookIndex(settings.hooks.SessionEnd) !== -1) {
-    return { installed: false, alreadyInstalled: true };
-  }
-  settings.hooks.SessionEnd.push({
-    matcher: "",
-    hooks: [{ type: "command", command: getHookCommand(), description: HOOK_DESCRIPTION }]
-  });
-  writeSettings2(settings);
-  return { installed: true, alreadyInstalled: false };
-}
-function removeHook() {
-  const settings = readSettings2();
-  const sessionEnd = settings.hooks?.SessionEnd;
-  if (!Array.isArray(sessionEnd)) {
-    return { removed: false, notFound: true };
-  }
-  const idx = findHookIndex(sessionEnd);
-  if (idx === -1) {
-    return { removed: false, notFound: true };
-  }
-  sessionEnd.splice(idx, 1);
-  if (sessionEnd.length === 0) {
-    delete settings.hooks.SessionEnd;
-  }
-  if (settings.hooks && Object.keys(settings.hooks).length === 0) {
-    delete settings.hooks;
-  }
-  writeSettings2(settings);
-  return { removed: true, notFound: false };
-}
-var PRECOMMIT_START = "# caliber:pre-commit:start";
-var PRECOMMIT_END = "# caliber:pre-commit:end";
-function getPrecommitBlock() {
-  const bin = resolveCaliber();
-  const npx = isNpxResolution();
-  const guard = npx ? "command -v npx >/dev/null 2>&1" : `[ -x "${bin}" ] || command -v "${bin}" >/dev/null 2>&1`;
-  const invoke = npx ? bin : `"${bin}"`;
-  return `${PRECOMMIT_START}
-if ${guard}; then
-  echo "\\033[2mcaliber: refreshing docs...\\033[0m"
-  ${invoke} refresh 2>/dev/null || true
-  ${invoke} learn finalize 2>/dev/null || true
-  git diff --name-only -- CLAUDE.md .claude/ .cursor/ AGENTS.md CALIBER_LEARNINGS.md 2>/dev/null | xargs git add 2>/dev/null || true
-fi
-${PRECOMMIT_END}`;
-}
-function getGitHooksDir() {
-  try {
-    const gitDir = execSync15("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path32.join(gitDir, "hooks");
-  } catch {
-    return null;
-  }
-}
-function getPreCommitPath() {
-  const hooksDir = getGitHooksDir();
-  return hooksDir ? path32.join(hooksDir, "pre-commit") : null;
-}
-function isPreCommitHookInstalled() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs39.existsSync(hookPath)) return false;
-  const content = fs39.readFileSync(hookPath, "utf-8");
-  return content.includes(PRECOMMIT_START);
-}
-function installPreCommitHook() {
-  if (isPreCommitHookInstalled()) {
-    return { installed: false, alreadyInstalled: true };
-  }
-  const hookPath = getPreCommitPath();
-  if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path32.dirname(hookPath);
-  if (!fs39.existsSync(hooksDir)) fs39.mkdirSync(hooksDir, { recursive: true });
-  let content = "";
-  if (fs39.existsSync(hookPath)) {
-    content = fs39.readFileSync(hookPath, "utf-8");
-    if (!content.endsWith("\n")) content += "\n";
-    content += "\n" + getPrecommitBlock() + "\n";
-  } else {
-    content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
-  }
-  fs39.writeFileSync(hookPath, content);
-  fs39.chmodSync(hookPath, 493);
-  return { installed: true, alreadyInstalled: false };
-}
-function removePreCommitHook() {
-  const hookPath = getPreCommitPath();
-  if (!hookPath || !fs39.existsSync(hookPath)) {
-    return { removed: false, notFound: true };
-  }
-  let content = fs39.readFileSync(hookPath, "utf-8");
-  if (!content.includes(PRECOMMIT_START)) {
-    return { removed: false, notFound: true };
-  }
-  const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
-  content = content.replace(regex, "\n");
-  if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs39.unlinkSync(hookPath);
-  } else {
-    fs39.writeFileSync(hookPath, content);
-  }
-  return { removed: true, notFound: false };
-}
-
-// src/commands/hooks.ts
 var HOOKS = [
   {
     id: "session-end",
@@ -12299,10 +12665,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 path39 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",
+  path39.join(".github", "copilot-instructions.md"),
+  "AGENTS.md"
+];
+var SKILL_DIRS = PLATFORM_CONFIGS.map((c) => c.skillsDir);
+var CURSOR_RULES_DIR = path39.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 = path39.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 = path39.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 = path39.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 = path39.dirname(fileURLToPath(import.meta.url));
+var __dirname = path40.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs47.readFileSync(path39.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs49.readFileSync(path40.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
@@ -12310,9 +12865,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);
@@ -12364,7 +12921,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));
@@ -12389,15 +12948,15 @@ 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 path40 from "path";
+import fs50 from "fs";
+import path41 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 = path40.dirname(fileURLToPath2(import.meta.url));
-var pkg2 = JSON.parse(fs48.readFileSync(path40.resolve(__dirname_vc, "..", "package.json"), "utf-8"));
+import confirm4 from "@inquirer/confirm";
+var __dirname_vc = path41.dirname(fileURLToPath2(import.meta.url));
+var pkg2 = JSON.parse(fs50.readFileSync(path41.resolve(__dirname_vc, "..", "package.json"), "utf-8"));
 function getChannel(version) {
   const match = version.match(/-(dev|next)\./);
   return match ? match[1] : "latest";
@@ -12424,8 +12983,8 @@ function getInstalledVersion() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const pkgPath = path40.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs48.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path41.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs50.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }
@@ -12450,18 +13009,18 @@ 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(`
+    console.log(chalk29.yellow(`
 Update available: ${current} -> ${latest}`));
-    const shouldUpdate = await confirm2({
+    const shouldUpdate = await confirm4({
       message: "Would you like to update now? (Y/n)",
       default: true
     });
@@ -12482,14 +13041,14 @@ Update available: ${current} -> ${latest}`));
       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.
+          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, {
@@ -12502,11 +13061,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.
 `
         )
       );