@rely-ai/caliber 1.31.0-dev.1774714955 → 1.31.0-dev.1774743306

package/dist/bin.js

@@ -9,155 +9,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/llm/config.ts
-var config_exports = {};
-__export(config_exports, {
-  DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
-  DEFAULT_MODELS: () => DEFAULT_MODELS,
-  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
-  getConfigFilePath: () => getConfigFilePath,
-  getDisplayModel: () => getDisplayModel,
-  getFastModel: () => getFastModel,
-  getMaxPromptTokens: () => getMaxPromptTokens,
-  loadConfig: () => loadConfig,
-  readConfigFile: () => readConfigFile,
-  resolveFromEnv: () => resolveFromEnv,
-  writeConfigFile: () => writeConfigFile
-});
-import fs4 from "fs";
-import path5 from "path";
-import os2 from "os";
-function getMaxPromptTokens() {
-  const config = loadConfig();
-  const model = process.env.CALIBER_MODEL || config?.model;
-  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
-  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
-  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
-}
-function loadConfig() {
-  const envConfig = resolveFromEnv();
-  if (envConfig) return envConfig;
-  return readConfigFile();
-}
-function resolveFromEnv() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return {
-      provider: "anthropic",
-      apiKey: process.env.ANTHROPIC_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.anthropic
-    };
-  }
-  if (process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID) {
-    return {
-      provider: "vertex",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.vertex,
-      vertexProjectId: process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID,
-      vertexRegion: process.env.VERTEX_REGION || process.env.GCP_REGION || "us-east5",
-      vertexCredentials: process.env.VERTEX_SA_CREDENTIALS || process.env.GOOGLE_APPLICATION_CREDENTIALS
-    };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return {
-      provider: "openai",
-      apiKey: process.env.OPENAI_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.openai,
-      baseUrl: process.env.OPENAI_BASE_URL
-    };
-  }
-  if (process.env.CALIBER_USE_CURSOR_SEAT === "1" || process.env.CALIBER_USE_CURSOR_SEAT === "true") {
-    return {
-      provider: "cursor",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.cursor
-    };
-  }
-  if (process.env.CALIBER_USE_CLAUDE_CLI === "1" || process.env.CALIBER_USE_CLAUDE_CLI === "true") {
-    return {
-      provider: "claude-cli",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS["claude-cli"]
-    };
-  }
-  return null;
-}
-function readConfigFile() {
-  try {
-    if (!fs4.existsSync(CONFIG_FILE)) return null;
-    const raw = fs4.readFileSync(CONFIG_FILE, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function writeConfigFile(config) {
-  if (!fs4.existsSync(CONFIG_DIR)) {
-    fs4.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  const sanitized = { ...config };
-  if (sanitized.apiKey) {
-    sanitized.apiKey = sanitized.apiKey.trim();
-  }
-  fs4.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
-}
-function getConfigFilePath() {
-  return CONFIG_FILE;
-}
-function getDisplayModel(config) {
-  if (config.model === "default" && config.provider === "claude-cli") {
-    return process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)";
-  }
-  return config.model;
-}
-function getFastModel() {
-  if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
-  const config = loadConfig();
-  const provider = config?.provider;
-  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex" || provider === "claude-cli")) {
-    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
-  }
-  if (config?.fastModel) return config.fastModel;
-  if (provider) return DEFAULT_FAST_MODELS[provider];
-  return void 0;
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
-var init_config = __esm({
-  "src/llm/config.ts"() {
-    "use strict";
-    CONFIG_DIR = path5.join(os2.homedir(), ".caliber");
-    CONFIG_FILE = path5.join(CONFIG_DIR, "config.json");
-    DEFAULT_MODELS = {
-      anthropic: "claude-sonnet-4-6",
-      vertex: "claude-sonnet-4-6",
-      openai: "gpt-4.1",
-      cursor: "sonnet-4.6",
-      "claude-cli": "default"
-    };
-    MODEL_CONTEXT_WINDOWS = {
-      "claude-sonnet-4-6": 2e5,
-      "claude-opus-4-6": 2e5,
-      "claude-haiku-4-5-20251001": 2e5,
-      "claude-sonnet-4-5-20250514": 2e5,
-      "gpt-4.1": 1e6,
-      "gpt-4.1-mini": 1e6,
-      "gpt-4o": 128e3,
-      "gpt-4o-mini": 128e3,
-      "sonnet-4.6": 2e5
-    };
-    DEFAULT_CONTEXT_WINDOW = 2e5;
-    INPUT_BUDGET_FRACTION = 0.6;
-    MAX_PROMPT_TOKENS_CAP = 3e5;
-    MIN_PROMPT_TOKENS = 3e4;
-    DEFAULT_FAST_MODELS = {
-      anthropic: "claude-haiku-4-5-20251001",
-      vertex: "claude-haiku-4-5-20251001",
-      openai: "gpt-4.1-mini",
-      cursor: "gpt-5.3-codex-fast"
-    };
-  }
-});
-
 // src/lib/resolve-caliber.ts
 var resolve_caliber_exports = {};
 __export(resolve_caliber_exports, {
@@ -166,8 +17,8 @@ __export(resolve_caliber_exports, {
   resetResolvedCaliber: () => resetResolvedCaliber,
   resolveCaliber: () => resolveCaliber
 });
-import fs6 from "fs";
-import { execSync as execSync4 } from "child_process";
+import fs2 from "fs";
+import { execSync as execSync3 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
   const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
@@ -177,7 +28,7 @@ function resolveCaliber() {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    execSync4(whichCmd, {
+    execSync3(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -186,7 +37,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && /caliber/.test(binPath) && fs6.existsSync(binPath)) {
+  if (binPath && /caliber/.test(binPath) && fs2.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -214,156 +65,6 @@ var init_resolve_caliber = __esm({
   }
 });
 
-// src/llm/types.ts
-var types_exports = {};
-__export(types_exports, {
-  isSeatBased: () => isSeatBased
-});
-function isSeatBased(provider) {
-  return SEAT_BASED_PROVIDERS.has(provider);
-}
-var SEAT_BASED_PROVIDERS;
-var init_types = __esm({
-  "src/llm/types.ts"() {
-    "use strict";
-    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
-  }
-});
-
-// src/writers/pre-commit-block.ts
-var pre_commit_block_exports = {};
-__export(pre_commit_block_exports, {
-  appendLearningsBlock: () => appendLearningsBlock,
-  appendPreCommitBlock: () => appendPreCommitBlock,
-  appendSyncBlock: () => appendSyncBlock,
-  getCursorLearningsRule: () => getCursorLearningsRule,
-  getCursorPreCommitRule: () => getCursorPreCommitRule,
-  getCursorSyncRule: () => getCursorSyncRule,
-  hasLearningsBlock: () => hasLearningsBlock,
-  hasPreCommitBlock: () => hasPreCommitBlock,
-  hasSyncBlock: () => hasSyncBlock
-});
-function getPreCommitBlock() {
-  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.
-
-If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."
-${BLOCK_END}`;
-}
-function getCursorRuleContent() {
-  const bin = resolveCaliber();
-  return `---
-description: Run Caliber sync before git commits to keep agent configs up to date
-alwaysApply: true
----
-Before every git commit, check if the Caliber pre-commit hook is installed:
-Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"\`
-
-If hook-active: just commit normally \u2014 Caliber syncs automatically via the hook. Tell the user: "Caliber will sync your agent configs automatically."
-If no-hook: run \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\` before committing, and tell the user what was updated.
-
-If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."
-`;
-}
-function hasPreCommitBlock(content) {
-  return content.includes(BLOCK_START);
-}
-function appendPreCommitBlock(content) {
-  if (hasPreCommitBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getPreCommitBlock() + "\n";
-}
-function getCursorPreCommitRule() {
-  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
-}
-function hasLearningsBlock(content) {
-  return content.includes(LEARNINGS_BLOCK_START);
-}
-function appendLearningsBlock(content) {
-  if (hasLearningsBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + LEARNINGS_BLOCK + "\n";
-}
-function getCursorLearningsRule() {
-  return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
-}
-function getSyncBlock() {
-  const bin = resolveCaliber();
-  return `${SYNC_BLOCK_START}
-## Context Sync
-
-This project uses [Caliber](https://github.com/caliber-ai-org/ai-setup) to keep AI agent configs in sync across Claude Code, Cursor, Copilot, and Codex.
-Configs update automatically before each commit via \`${bin} refresh\`.
-If the pre-commit hook is not set up, run \`${bin} hooks --install\` to enable automatic sync.
-${SYNC_BLOCK_END}`;
-}
-function hasSyncBlock(content) {
-  return content.includes(SYNC_BLOCK_START);
-}
-function appendSyncBlock(content) {
-  if (hasSyncBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getSyncBlock() + "\n";
-}
-function getCursorSyncContent() {
-  const bin = resolveCaliber();
-  return `---
-description: This project uses Caliber for automatic AI agent context sync
-alwaysApply: true
----
-This project uses Caliber to keep AI agent configs (CLAUDE.md, Cursor rules, Copilot instructions)
-in sync with the codebase automatically. Before each commit, run \`${bin} refresh\` to sync configs.
-If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."
-`;
-}
-function getCursorSyncRule() {
-  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
-}
-var BLOCK_START, BLOCK_END, MANAGED_DOC_PATHS, CURSOR_RULE_FILENAME, LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END, LEARNINGS_BLOCK, CURSOR_LEARNINGS_FILENAME, CURSOR_LEARNINGS_CONTENT, SYNC_BLOCK_START, SYNC_BLOCK_END, CURSOR_SYNC_FILENAME;
-var init_pre_commit_block = __esm({
-  "src/writers/pre-commit-block.ts"() {
-    "use strict";
-    init_resolve_caliber();
-    BLOCK_START = "<!-- caliber:managed:pre-commit -->";
-    BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
-    MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
-    CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
-    LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
-    LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
-    LEARNINGS_BLOCK = `${LEARNINGS_BLOCK_START}
-## Session Learnings
-
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-${LEARNINGS_BLOCK_END}`;
-    CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
-    CURSOR_LEARNINGS_CONTENT = `---
-description: Reference session-learned patterns from CALIBER_LEARNINGS.md
-alwaysApply: true
----
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-`;
-    SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
-    SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
-    CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
-  }
-});
-
 // src/lib/builtin-skills.ts
 var builtin_skills_exports = {};
 __export(builtin_skills_exports, {
@@ -375,8 +76,8 @@ __export(builtin_skills_exports, {
   buildSkillContent: () => buildSkillContent,
   ensureBuiltinSkills: () => ensureBuiltinSkills
 });
-import fs17 from "fs";
-import path16 from "path";
+import fs3 from "fs";
+import path3 from "path";
 function buildSkillContent(skill) {
   const frontmatter = `---
 name: ${skill.name}
@@ -541,20 +242,37 @@ grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "HOOK_ACTIVE" || ech
   caliber hooks --install
   \`\`\`
 
-### Step 3: Check if agent configs exist
+### Step 3: Detect agents and check if configs exist
+
+First, detect which coding agents are configured in this project:
+\`\`\`bash
+AGENTS=""
+[ -d .claude ] && AGENTS="claude"
+[ -d .cursor ] && AGENTS="\${AGENTS:+$AGENTS,}cursor"
+[ -d .agents ] || [ -f AGENTS.md ] && AGENTS="\${AGENTS:+$AGENTS,}codex"
+[ -f .github/copilot-instructions.md ] && AGENTS="\${AGENTS:+$AGENTS,}github-copilot"
+echo "DETECTED_AGENTS=\${AGENTS:-none}"
+\`\`\`
+
+If no agents are detected, ask the user which coding agents they use (Claude Code, Cursor, Codex, GitHub Copilot).
+Build the agent list from their answer as a comma-separated string (e.g. "claude,cursor").
 
+Then check if agent configs exist:
 \`\`\`bash
 echo "CLAUDE_MD=$([ -f CLAUDE.md ] && echo exists || echo missing)"
 echo "CURSOR_RULES=$([ -d .cursor/rules ] && ls .cursor/rules/*.mdc 2>/dev/null | wc -l | tr -d ' ' || echo 0)"
 echo "AGENTS_MD=$([ -f AGENTS.md ] && echo exists || echo missing)"
+echo "COPILOT=$([ -f .github/copilot-instructions.md ] && echo exists || echo missing)"
 \`\`\`
 
-- If configs exist \u2192 Tell the user which configs are present. Move to Step 4.
+- If configs exist for the detected agents \u2192 Tell the user which configs are present. Move to Step 4.
 - If configs are missing \u2192 Tell the user: "No agent configs found. I'll generate them now."
+  Use the detected or user-selected agent list:
   \`\`\`bash
-  caliber init --auto-approve
+  caliber init --auto-approve --agent <comma-separated-agents>
   \`\`\`
-  This generates CLAUDE.md, Cursor rules, AGENTS.md, and skills for all detected agents.
+  For example: \`caliber init --auto-approve --agent claude,cursor\`
+  This generates CLAUDE.md, Cursor rules, AGENTS.md, skills, and sync infrastructure for the specified agents.
 
 ### Step 4: Check if configs are fresh
 
@@ -573,7 +291,27 @@ caliber score --json --quiet 2>/dev/null | head -1
 
 Ask the user: "Are you setting up for yourself only, or for your team too?"
 
-- If **solo** \u2192 Tell the user the summary (see below) and stop.
+- 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"
@@ -603,7 +341,43 @@ Ask the user: "Are you setting up for yourself only, or for your team too?"
             env:
               ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
     \`\`\`
-    Tell the user: "Add your ANTHROPIC_API_KEY to repo secrets (Settings \u2192 Secrets \u2192 Actions), then commit and push."
+    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
 
@@ -632,52 +406,402 @@ From now on, every commit keeps all your agent configs in sync automatically.
 - 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 = path16.join(skillsDir, skill.name, "SKILL.md");
-      fs17.mkdirSync(path16.dirname(skillPath), { recursive: true });
-      fs17.writeFileSync(skillPath, buildSkillContent(skill));
-      written.push(skillPath);
+function ensureBuiltinSkills() {
+  const written = [];
+  for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
+    if (!fs3.existsSync(platformDir)) continue;
+    for (const skill of BUILTIN_SKILLS) {
+      const skillPath = path3.join(skillsDir, skill.name, "SKILL.md");
+      fs3.mkdirSync(path3.dirname(skillPath), { recursive: true });
+      fs3.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: path3.join(".claude", "skills") },
+      { platformDir: ".cursor", skillsDir: path3.join(".cursor", "skills") },
+      { platformDir: ".agents", skillsDir: path3.join(".agents", "skills") }
+    ];
+    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
+  }
+});
+
+// src/writers/pre-commit-block.ts
+var pre_commit_block_exports = {};
+__export(pre_commit_block_exports, {
+  appendLearningsBlock: () => appendLearningsBlock,
+  appendManagedBlocks: () => appendManagedBlocks,
+  appendPreCommitBlock: () => appendPreCommitBlock,
+  appendSyncBlock: () => appendSyncBlock,
+  getCursorLearningsRule: () => getCursorLearningsRule,
+  getCursorPreCommitRule: () => getCursorPreCommitRule,
+  getCursorSetupRule: () => getCursorSetupRule,
+  getCursorSyncRule: () => getCursorSyncRule,
+  hasLearningsBlock: () => hasLearningsBlock,
+  hasPreCommitBlock: () => hasPreCommitBlock,
+  hasSyncBlock: () => hasSyncBlock
+});
+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, install it by running \`npm install -g @rely-ai/caliber\`, then run \`caliber hooks --install\` and \`caliber refresh\`.`;
+  }
+}
+function getPreCommitBlock(platform = "claude") {
+  const bin = resolveCaliber();
+  return `${BLOCK_START}
+## Before Committing
+
+**IMPORTANT:** Before every git commit, you MUST ensure Caliber syncs agent configs with the latest code changes.
+
+First, check if the pre-commit hook is already installed:
+\`\`\`bash
+grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"
+\`\`\`
+
+- If **hook-active**: the hook handles sync automatically \u2014 just commit normally. Tell the user: "Caliber will sync your agent configs automatically via the pre-commit hook."
+- If **no-hook**: run Caliber manually before committing:
+  1. Tell the user: "Caliber: Syncing agent configs with your latest changes..."
+  2. Run: \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\`
+  3. After it completes, briefly tell the user what Caliber updated. Then proceed with the commit.
+
+${getCaliberNotFoundFallback(platform, bin)}
+${BLOCK_END}`;
+}
+function getCursorRuleContent() {
+  const bin = resolveCaliber();
+  return `---
+description: Run Caliber sync before git commits to keep agent configs up to date
+alwaysApply: true
+---
+Before every git commit, check if the Caliber pre-commit hook is installed:
+Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"\`
+
+If hook-active: just commit normally \u2014 Caliber syncs automatically via the hook. Tell the user: "Caliber will sync your agent configs automatically."
+If no-hook: run \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\` before committing, and tell the user what was updated.
+
+If \`${bin}\` is not found, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
+`;
+}
+function hasPreCommitBlock(content) {
+  return content.includes(BLOCK_START);
+}
+function appendPreCommitBlock(content, platform = "claude") {
+  if (hasPreCommitBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + getPreCommitBlock(platform) + "\n";
+}
+function getCursorPreCommitRule() {
+  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
+}
+function hasLearningsBlock(content) {
+  return content.includes(LEARNINGS_BLOCK_START);
+}
+function appendLearningsBlock(content) {
+  if (hasLearningsBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + LEARNINGS_BLOCK + "\n";
+}
+function getCursorLearningsRule() {
+  return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
+}
+function getSyncSetupInstruction(platform, bin) {
+  switch (platform) {
+    case "claude":
+      return `If the pre-commit hook is not set up, run \`/setup-caliber\` to configure everything automatically.`;
+    case "codex":
+      return `If the pre-commit hook is not set up, read \`.agents/skills/setup-caliber/SKILL.md\` and follow the setup instructions.`;
+    case "copilot":
+      return `If the pre-commit hook is not set up, install it by running:
+\`\`\`bash
+npm install -g @rely-ai/caliber
+caliber hooks --install
+caliber refresh
+git add ${MANAGED_DOC_PATHS} 2>/dev/null
+\`\`\``;
+  }
+}
+function getSyncBlock(platform = "claude") {
+  const bin = resolveCaliber();
+  return `${SYNC_BLOCK_START}
+## Context Sync
+
+This project uses [Caliber](https://github.com/caliber-ai-org/ai-setup) to keep AI agent configs in sync across Claude Code, Cursor, Copilot, and Codex.
+Configs update automatically before each commit via \`${bin} refresh\`.
+${getSyncSetupInstruction(platform, bin)}
+${SYNC_BLOCK_END}`;
+}
+function hasSyncBlock(content) {
+  return content.includes(SYNC_BLOCK_START);
+}
+function appendSyncBlock(content, platform = "claude") {
+  if (hasSyncBlock(content)) return content;
+  const trimmed = content.trimEnd();
+  return trimmed + "\n\n" + getSyncBlock(platform) + "\n";
+}
+function appendManagedBlocks(content, platform = "claude") {
+  return appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(content, platform)), platform);
+}
+function getCursorSyncContent() {
+  const bin = resolveCaliber();
+  return `---
+description: This project uses Caliber for automatic AI agent context sync
+alwaysApply: true
+---
+This project uses Caliber to keep AI agent configs (CLAUDE.md, Cursor rules, Copilot instructions)
+in sync with the codebase automatically. Before each commit, run \`${bin} refresh\` to sync configs.
+If \`${bin}\` is not found, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
+`;
+}
+function getCursorSyncRule() {
+  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
+}
+function getCursorSetupContent() {
+  return `---
+description: Check if Caliber agent config sync is set up and offer installation on new sessions
+alwaysApply: true
+---
+This project uses Caliber to keep AI agent configs in sync automatically.
+At the start of each session, silently check if sync is active:
+
+Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "SYNC_ACTIVE" || echo "NO_SYNC"\`
+
+If SYNC_ACTIVE: No action needed \u2014 Caliber syncs automatically on every commit.
+If NO_SYNC: Tell the user: "This project uses Caliber for automatic agent config sync, but it's not set up on your machine yet. Want me to set it up? It takes about 30 seconds."
+
+If the user agrees, read \`.cursor/skills/setup-caliber/SKILL.md\` and follow its instructions step by step.
+`;
+}
+function getCursorSetupRule() {
+  return { filename: CURSOR_SETUP_FILENAME, content: getCursorSetupContent() };
+}
+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;
+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";
+  }
+});
+
+// src/llm/config.ts
+var config_exports = {};
+__export(config_exports, {
+  DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
+  DEFAULT_MODELS: () => DEFAULT_MODELS,
+  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
+  getConfigFilePath: () => getConfigFilePath,
+  getDisplayModel: () => getDisplayModel,
+  getFastModel: () => getFastModel,
+  getMaxPromptTokens: () => getMaxPromptTokens,
+  loadConfig: () => loadConfig,
+  readConfigFile: () => readConfigFile,
+  resolveFromEnv: () => resolveFromEnv,
+  writeConfigFile: () => writeConfigFile
+});
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
+function getMaxPromptTokens() {
+  const config = loadConfig();
+  const model = process.env.CALIBER_MODEL || config?.model;
+  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
+  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
+  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
+}
+function loadConfig() {
+  const envConfig = resolveFromEnv();
+  if (envConfig) return envConfig;
+  return readConfigFile();
+}
+function resolveFromEnv() {
+  if (process.env.ANTHROPIC_API_KEY) {
+    return {
+      provider: "anthropic",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.anthropic
+    };
+  }
+  if (process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID) {
+    return {
+      provider: "vertex",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.vertex,
+      vertexProjectId: process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID,
+      vertexRegion: process.env.VERTEX_REGION || process.env.GCP_REGION || "us-east5",
+      vertexCredentials: process.env.VERTEX_SA_CREDENTIALS || process.env.GOOGLE_APPLICATION_CREDENTIALS
+    };
+  }
+  if (process.env.OPENAI_API_KEY) {
+    return {
+      provider: "openai",
+      apiKey: process.env.OPENAI_API_KEY,
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.openai,
+      baseUrl: process.env.OPENAI_BASE_URL
+    };
+  }
+  if (process.env.CALIBER_USE_CURSOR_SEAT === "1" || process.env.CALIBER_USE_CURSOR_SEAT === "true") {
+    return {
+      provider: "cursor",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.cursor
+    };
+  }
+  if (process.env.CALIBER_USE_CLAUDE_CLI === "1" || process.env.CALIBER_USE_CLAUDE_CLI === "true") {
+    return {
+      provider: "claude-cli",
+      model: process.env.CALIBER_MODEL || DEFAULT_MODELS["claude-cli"]
+    };
+  }
+  return null;
+}
+function readConfigFile() {
+  try {
+    if (!fs6.existsSync(CONFIG_FILE)) return null;
+    const raw = fs6.readFileSync(CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
+      return null;
     }
+    return parsed;
+  } catch {
+    return null;
   }
-  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"() {
+function writeConfigFile(config) {
+  if (!fs6.existsSync(CONFIG_DIR)) {
+    fs6.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const sanitized = { ...config };
+  if (sanitized.apiKey) {
+    sanitized.apiKey = sanitized.apiKey.trim();
+  }
+  fs6.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
+}
+function getConfigFilePath() {
+  return CONFIG_FILE;
+}
+function getDisplayModel(config) {
+  if (config.model === "default" && config.provider === "claude-cli") {
+    return process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)";
+  }
+  return config.model;
+}
+function getFastModel() {
+  if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
+  const config = loadConfig();
+  const provider = config?.provider;
+  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex" || provider === "claude-cli")) {
+    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
+  }
+  if (config?.fastModel) return config.fastModel;
+  if (provider) return DEFAULT_FAST_MODELS[provider];
+  return void 0;
+}
+var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
+var init_config = __esm({
+  "src/llm/config.ts"() {
     "use strict";
-    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();
-      }
+    CONFIG_DIR = path6.join(os2.homedir(), ".caliber");
+    CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-6",
+      vertex: "claude-sonnet-4-6",
+      openai: "gpt-4.1",
+      cursor: "sonnet-4.6",
+      "claude-cli": "default"
     };
-    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();
-      }
+    MODEL_CONTEXT_WINDOWS = {
+      "claude-sonnet-4-6": 2e5,
+      "claude-opus-4-6": 2e5,
+      "claude-haiku-4-5-20251001": 2e5,
+      "claude-sonnet-4-5-20250514": 2e5,
+      "gpt-4.1": 1e6,
+      "gpt-4.1-mini": 1e6,
+      "gpt-4o": 128e3,
+      "gpt-4o-mini": 128e3,
+      "sonnet-4.6": 2e5
     };
-    SETUP_CALIBER_SKILL = {
-      name: "setup-caliber",
-      description: "Sets up Caliber for automatic AI agent context sync. Installs pre-commit hooks so CLAUDE.md, Cursor rules, and Copilot instructions update automatically on every commit. Use when Caliber hooks are not yet installed or when the user asks about keeping agent configs in sync.",
-      get content() {
-        return getSetupCaliberContent();
-      }
+    DEFAULT_CONTEXT_WINDOW = 2e5;
+    INPUT_BUDGET_FRACTION = 0.6;
+    MAX_PROMPT_TOKENS_CAP = 3e5;
+    MIN_PROMPT_TOKENS = 3e4;
+    DEFAULT_FAST_MODELS = {
+      anthropic: "claude-haiku-4-5-20251001",
+      vertex: "claude-haiku-4-5-20251001",
+      openai: "gpt-4.1-mini",
+      cursor: "gpt-5.3-codex-fast"
     };
-    BUILTIN_SKILLS = [FIND_SKILLS_SKILL, SAVE_LEARNING_SKILL, SETUP_CALIBER_SKILL];
-    PLATFORM_CONFIGS = [
-      { platformDir: ".claude", skillsDir: path16.join(".claude", "skills") },
-      { platformDir: ".cursor", skillsDir: path16.join(".cursor", "skills") },
-      { platformDir: ".agents", skillsDir: path16.join(".agents", "skills") }
-    ];
-    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
+  }
+});
+
+// src/llm/types.ts
+var types_exports = {};
+__export(types_exports, {
+  isSeatBased: () => isSeatBased
+});
+function isSeatBased(provider) {
+  return SEAT_BASED_PROVIDERS.has(provider);
+}
+var SEAT_BASED_PROVIDERS;
+var init_types = __esm({
+  "src/llm/types.ts"() {
+    "use strict";
+    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
   }
 });
 
@@ -1006,8 +1130,8 @@ import chalk14 from "chalk";
 import fs33 from "fs";
 
 // src/fingerprint/index.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path8 from "path";
 
 // src/fingerprint/git.ts
 import { execSync } from "child_process";
@@ -1115,8 +1239,8 @@ function scan(base, rel, depth, maxDepth, result) {
 }
 
 // src/fingerprint/existing-config.ts
-import fs2 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 
 // src/constants.ts
 import path2 from "path";
@@ -1151,97 +1275,121 @@ var LEARNING_LAST_ERROR_FILE = "last-error.json";
 var MIN_SESSIONS_FOR_COMPARISON = 3;
 
 // src/fingerprint/existing-config.ts
+init_builtin_skills();
+init_pre_commit_block();
+var MANAGED_CURSOR_RULES = /* @__PURE__ */ new Set([
+  getCursorPreCommitRule().filename,
+  getCursorLearningsRule().filename,
+  getCursorSyncRule().filename,
+  getCursorSetupRule().filename
+]);
 function readExistingConfigs(dir) {
   const configs = {};
-  const readmeMdPath = path3.join(dir, "README.md");
-  if (fs2.existsSync(readmeMdPath)) {
-    configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
+  const readmeMdPath = path4.join(dir, "README.md");
+  if (fs4.existsSync(readmeMdPath)) {
+    configs.readmeMd = fs4.readFileSync(readmeMdPath, "utf-8");
   }
-  const agentsMdPath = path3.join(dir, "AGENTS.md");
-  if (fs2.existsSync(agentsMdPath)) {
-    configs.agentsMd = fs2.readFileSync(agentsMdPath, "utf-8");
+  const agentsMdPath = path4.join(dir, "AGENTS.md");
+  if (fs4.existsSync(agentsMdPath)) {
+    configs.agentsMd = fs4.readFileSync(agentsMdPath, "utf-8");
   }
-  const claudeMdPath = path3.join(dir, "CLAUDE.md");
-  if (fs2.existsSync(claudeMdPath)) {
-    configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path4.join(dir, "CLAUDE.md");
+  if (fs4.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path3.join(dir, ".claude", "settings.json");
-  if (fs2.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = path4.join(dir, ".claude", "settings.json");
+  if (fs4.existsSync(claudeSettingsPath)) {
     try {
-      configs.claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath, "utf-8"));
+      configs.claudeSettings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path3.join(dir, ".claude", "skills");
-  if (fs2.existsSync(skillsDir)) {
+  const skillsDir = path4.join(dir, ".claude", "skills");
+  if (fs4.existsSync(skillsDir)) {
     try {
-      const entries = fs2.readdirSync(skillsDir);
+      const entries = fs4.readdirSync(skillsDir);
       const skills = [];
       for (const entry of entries) {
-        const entryPath = path3.join(skillsDir, entry);
-        const skillMdPath = path3.join(entryPath, "SKILL.md");
-        if (fs2.statSync(entryPath).isDirectory() && fs2.existsSync(skillMdPath)) {
-          skills.push({ filename: `${entry}/SKILL.md`, content: fs2.readFileSync(skillMdPath, "utf-8") });
+        if (BUILTIN_SKILL_NAMES.has(entry)) continue;
+        const entryPath = path4.join(skillsDir, entry);
+        const skillMdPath = path4.join(entryPath, "SKILL.md");
+        if (fs4.statSync(entryPath).isDirectory() && fs4.existsSync(skillMdPath)) {
+          skills.push({ filename: `${entry}/SKILL.md`, content: fs4.readFileSync(skillMdPath, "utf-8") });
         } else if (entry.endsWith(".md")) {
-          skills.push({ filename: entry, content: fs2.readFileSync(entryPath, "utf-8") });
+          skills.push({ filename: entry, content: fs4.readFileSync(entryPath, "utf-8") });
         }
       }
       if (skills.length > 0) configs.claudeSkills = skills;
     } catch {
     }
   }
-  const cursorrulesPath = path3.join(dir, ".cursorrules");
-  if (fs2.existsSync(cursorrulesPath)) {
-    configs.cursorrules = fs2.readFileSync(cursorrulesPath, "utf-8");
+  const cursorrulesPath = path4.join(dir, ".cursorrules");
+  if (fs4.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs4.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path3.join(dir, ".cursor", "rules");
-  if (fs2.existsSync(cursorRulesDir)) {
+  const cursorRulesDir = path4.join(dir, ".cursor", "rules");
+  if (fs4.existsSync(cursorRulesDir)) {
     try {
-      const files = fs2.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
+      const files = fs4.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc") && !MANAGED_CURSOR_RULES.has(f));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs2.readFileSync(path3.join(cursorRulesDir, f), "utf-8")
+        content: fs4.readFileSync(path4.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorSkillsDir = path3.join(dir, ".cursor", "skills");
-  if (fs2.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path4.join(dir, ".cursor", "skills");
+  if (fs4.existsSync(cursorSkillsDir)) {
     try {
-      const slugs = fs2.readdirSync(cursorSkillsDir).filter((f) => {
-        return fs2.statSync(path3.join(cursorSkillsDir, f)).isDirectory();
+      const slugs = fs4.readdirSync(cursorSkillsDir).filter((f) => {
+        return fs4.statSync(path4.join(cursorSkillsDir, f)).isDirectory() && !BUILTIN_SKILL_NAMES.has(f);
       });
-      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path3.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
+      configs.cursorSkills = slugs.filter((slug) => fs4.existsSync(path4.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
         name,
         filename: "SKILL.md",
-        content: fs2.readFileSync(path3.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
+        content: fs4.readFileSync(path4.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
       }));
     } catch {
     }
   }
-  const mcpJsonPath = path3.join(dir, ".mcp.json");
-  if (fs2.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path4.join(dir, ".mcp.json");
+  if (fs4.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs4.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         configs.claudeMcpServers = mcpJson.mcpServers;
       }
     } catch {
     }
   }
-  const cursorMcpPath = path3.join(dir, ".cursor", "mcp.json");
-  if (fs2.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path4.join(dir, ".cursor", "mcp.json");
+  if (fs4.existsSync(cursorMcpPath)) {
     try {
-      const cursorMcpJson = JSON.parse(fs2.readFileSync(cursorMcpPath, "utf-8"));
+      const cursorMcpJson = JSON.parse(fs4.readFileSync(cursorMcpPath, "utf-8"));
       if (cursorMcpJson.mcpServers) {
         configs.cursorMcpServers = cursorMcpJson.mcpServers;
       }
     } catch {
     }
   }
-  if (fs2.existsSync(PERSONAL_LEARNINGS_FILE)) {
+  const copilotPath = path4.join(dir, ".github", "copilot-instructions.md");
+  if (fs4.existsSync(copilotPath)) {
+    configs.copilotInstructions = fs4.readFileSync(copilotPath, "utf-8");
+  }
+  const instructionsDir = path4.join(dir, ".github", "instructions");
+  if (fs4.existsSync(instructionsDir)) {
+    try {
+      const files = fs4.readdirSync(instructionsDir).filter((f) => f.endsWith(".md"));
+      configs.copilotInstructionFiles = files.map((f) => ({
+        filename: f,
+        content: fs4.readFileSync(path4.join(instructionsDir, f), "utf-8")
+      }));
+    } catch {
+    }
+  }
+  if (fs4.existsSync(PERSONAL_LEARNINGS_FILE)) {
     try {
-      const content = fs2.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+      const content = fs4.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
       const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
       if (bullets) configs.personalLearnings = bullets;
     } catch {
@@ -1251,9 +1399,9 @@ function readExistingConfigs(dir) {
 }
 
 // src/fingerprint/code-analysis.ts
-import fs3 from "fs";
-import path4 from "path";
-import { execSync as execSync3 } from "child_process";
+import fs5 from "fs";
+import path5 from "path";
+import { execSync as execSync4 } from "child_process";
 
 // src/lib/sanitize.ts
 var KNOWN_PREFIX_PATTERNS = [
@@ -1597,18 +1745,18 @@ function extractSkeletonIndentBased(lines, ext) {
 }
 function extractImports(content, filePath) {
   const imports = [];
-  const dir = path4.dirname(filePath);
+  const dir = path5.dirname(filePath);
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     const jsMatch = trimmed.match(/(?:from|require\()\s*['"]([^'"]+)['"]/);
     if (jsMatch && jsMatch[1].startsWith(".")) {
-      imports.push(path4.normalize(path4.join(dir, jsMatch[1])));
+      imports.push(path5.normalize(path5.join(dir, jsMatch[1])));
       continue;
     }
     const pyMatch = trimmed.match(/^from\s+(\.[.\w]*)\s+import/);
     if (pyMatch) {
       const modulePath = pyMatch[1].replace(/\./g, "/");
-      imports.push(path4.normalize(path4.join(dir, modulePath)));
+      imports.push(path5.normalize(path5.join(dir, modulePath)));
       continue;
     }
     const goMatch = trimmed.match(/^\s*"([^"]+)"/);
@@ -1621,7 +1769,7 @@ function extractImports(content, filePath) {
 function buildImportCounts(files) {
   const counts = /* @__PURE__ */ new Map();
   for (const [filePath, content] of files) {
-    const ext = path4.extname(filePath).toLowerCase();
+    const ext = path5.extname(filePath).toLowerCase();
     if (!SOURCE_EXTENSIONS.has(ext)) continue;
     const imports = extractImports(content, filePath);
     for (const imp of imports) {
@@ -1640,7 +1788,7 @@ function buildImportCounts(files) {
 function getGitFrequency(dir) {
   const freq = /* @__PURE__ */ new Map();
   try {
-    const output = execSync3(
+    const output = execSync4(
       'git log --since="6 months ago" --format="" --name-only --diff-filter=ACMR 2>/dev/null | head -10000',
       { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5e3 }
     );
@@ -1655,7 +1803,7 @@ function getGitFrequency(dir) {
 function groupByDirectory(files) {
   const groups = /* @__PURE__ */ new Map();
   for (const f of files) {
-    const dir = path4.dirname(f.path);
+    const dir = path5.dirname(f.path);
     const group = groups.get(dir) || [];
     group.push(f);
     groups.set(dir, group);
@@ -1676,14 +1824,14 @@ function analyzeCode(dir) {
   let totalChars = 0;
   for (const relPath of allPaths) {
     try {
-      totalChars += fs3.statSync(path4.join(dir, relPath)).size;
+      totalChars += fs5.statSync(path5.join(dir, relPath)).size;
     } catch {
     }
   }
   const fileContents = /* @__PURE__ */ new Map();
   for (const relPath of allPaths) {
     try {
-      const content = fs3.readFileSync(path4.join(dir, relPath), "utf-8");
+      const content = fs5.readFileSync(path5.join(dir, relPath), "utf-8");
       if (content.split("\n").length <= 500) fileContents.set(relPath, content);
     } catch {
     }
@@ -1693,7 +1841,7 @@ function analyzeCode(dir) {
   const scored = [];
   let compressedChars = 0;
   for (const [relPath, rawContent] of fileContents) {
-    const ext = path4.extname(relPath).toLowerCase();
+    const ext = path5.extname(relPath).toLowerCase();
     const compressed = compressContent(rawContent, ext);
     const skeleton = extractSkeleton(compressed, ext);
     compressedChars += compressed.length;
@@ -1722,7 +1870,7 @@ function analyzeCode(dir) {
     }
     if (similar.length > 0) {
       dupGroups++;
-      const names = similar.map((f) => path4.basename(f.path));
+      const names = similar.map((f) => path5.basename(f.path));
       const summary = `(${similar.length} similar file${similar.length === 1 ? "" : "s"} in ${dirPath}/: ${names.join(", ")})`;
       const summarySize = summary.length + 30;
       if (includedChars + summarySize <= CHAR_BUDGET) {
@@ -1759,10 +1907,10 @@ function analyzeCode(dir) {
 }
 function walkDir(base, rel, depth, maxDepth, files) {
   if (depth > maxDepth) return;
-  const fullPath = path4.join(base, rel);
+  const fullPath = path5.join(base, rel);
   let entries;
   try {
-    entries = fs3.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs5.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -1775,7 +1923,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
     } else if (entry.isFile()) {
       if (SKIP_FILES.has(entry.name)) continue;
       if (SKIP_PATTERNS.some((p) => p.test(entry.name))) continue;
-      const ext = path4.extname(entry.name).toLowerCase();
+      const ext = path5.extname(entry.name).toLowerCase();
       if (TEXT_EXTENSIONS.has(ext) || depth === 0 && !ext && !entry.name.startsWith(".")) {
         files.push(relPath);
       }
@@ -1783,7 +1931,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
   }
 }
 function filePriority(filePath) {
-  const base = path4.basename(filePath);
+  const base = path5.basename(filePath);
   const entryPoints = /* @__PURE__ */ new Set([
     "index.ts",
     "index.js",
@@ -1915,7 +2063,7 @@ var AnthropicProvider = class {
 };
 
 // src/llm/vertex.ts
-import fs5 from "fs";
+import fs7 from "fs";
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
 import { GoogleAuth } from "google-auth-library";
 var VertexProvider = class {
@@ -1938,7 +2086,7 @@ var VertexProvider = class {
         }
       } else {
         try {
-          creds = JSON.parse(fs5.readFileSync(raw, "utf-8"));
+          creds = JSON.parse(fs7.readFileSync(raw, "utf-8"));
         } catch {
           throw new Error(`Cannot read credentials file: ${raw}`);
         }
@@ -3107,6 +3255,11 @@ CONSERVATIVE UPDATE means:
 - NEVER remove code blocks, backtick references, or architecture paths unless the diff deleted them
 - NEVER replace specific paths/commands with generic prose
 
+Cross-agent sync:
+- When a change affects CLAUDE.md, apply the same semantic update to AGENTS.md and copilot instructions if they exist
+- Each file uses its own format and conventions \u2014 do NOT copy content verbatim between them
+- The goal is consistency: all agent config files should reflect the same project state after refresh
+
 Quality constraints (the output is scored deterministically):
 - CLAUDE.md / AGENTS.md: MUST stay under 400 lines. If the diff adds content, trim the least important lines elsewhere.
 - Keep 3+ code blocks with executable commands \u2014 do not remove code blocks
@@ -3115,16 +3268,17 @@ Quality constraints (the output is scored deterministically):
 - Preserve the existing structure (headings, bullet style, formatting)
 
 Managed content:
-- Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
-- Keep context sync blocks (<!-- caliber:managed:sync --> ... <!-- /caliber:managed:sync -->) intact
+- All blocks between <!-- caliber:managed:* --> and <!-- /caliber:managed:* --> are managed by Caliber \u2014 copy them verbatim, do NOT modify their contents
+- This includes: pre-commit, sync, and learnings blocks
 - Do NOT modify CALIBER_LEARNINGS.md \u2014 it is managed separately
-- Preserve any references to CALIBER_LEARNINGS.md in CLAUDE.md
+- Preserve any references to CALIBER_LEARNINGS.md
 
 Return a JSON object with this exact shape:
 {
   "updatedDocs": {
     "claudeMd": "<updated content or null>",
     "readmeMd": "<updated content or null>",
+    "agentsMd": "<updated content or null>",
     "cursorrules": "<updated content or null>",
     "cursorRules": [{"filename": "name.mdc", "content": "..."}] or null,
     "claudeSkills": [{"filename": "name.md", "content": "..."}] or null,
@@ -3286,15 +3440,15 @@ async function detectProjectStack(fileTree, suffixCounts) {
 init_config();
 
 // src/fingerprint/cache.ts
-import fs7 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path7 from "path";
 import crypto from "crypto";
 import { execSync as execSync7 } from "child_process";
 var CACHE_VERSION = 1;
 var CACHE_DIR = ".caliber/cache";
 var CACHE_FILE = "fingerprint.json";
 function getCachePath(dir) {
-  return path6.join(dir, CACHE_DIR, CACHE_FILE);
+  return path7.join(dir, CACHE_DIR, CACHE_FILE);
 }
 function getGitHead(dir) {
   try {
@@ -3331,8 +3485,8 @@ function computeTreeSignature(fileTree, dir) {
 function loadFingerprintCache(dir, fileTree) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return null;
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return null;
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (cache.version !== CACHE_VERSION) return null;
     const currentHead = getGitHead(dir);
@@ -3353,9 +3507,9 @@ function loadFingerprintCache(dir, fileTree) {
 function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks, tools, workspaces) {
   const cachePath = getCachePath(dir);
   try {
-    const cacheDir = path6.dirname(cachePath);
-    if (!fs7.existsSync(cacheDir)) {
-      fs7.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path7.dirname(cachePath);
+    if (!fs8.existsSync(cacheDir)) {
+      fs8.mkdirSync(cacheDir, { recursive: true });
     }
     const cache = {
       version: CACHE_VERSION,
@@ -3367,15 +3521,15 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       tools,
       workspaces
     };
-    fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    fs8.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 function getDetectedWorkspaces(dir) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs7.existsSync(cachePath)) return [];
-    const raw = fs7.readFileSync(cachePath, "utf-8");
+    if (!fs8.existsSync(cachePath)) return [];
+    const raw = fs8.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     return cache.workspaces ?? [];
   } catch {
@@ -3427,9 +3581,9 @@ async function collectFingerprint(dir) {
 }
 function readPackageName(dir) {
   try {
-    const pkgPath = path7.join(dir, "package.json");
-    if (!fs8.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path8.join(dir, "package.json");
+    if (!fs9.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -3443,7 +3597,7 @@ async function enrichWithLLM(fingerprint) {
     const suffixCounts = {};
     for (const entry of fingerprint.fileTree) {
       if (entry.endsWith("/")) continue;
-      const ext = path7.extname(entry).toLowerCase();
+      const ext = path8.extname(entry).toLowerCase();
       if (ext) {
         suffixCounts[ext] = (suffixCounts[ext] || 0) + 1;
       }
@@ -3459,22 +3613,22 @@ async function enrichWithLLM(fingerprint) {
 }
 
 // src/scanner/index.ts
-import fs9 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path9 from "path";
 import crypto2 from "crypto";
 import os4 from "os";
 function detectPlatforms() {
   const home = os4.homedir();
   return {
-    claude: fs9.existsSync(path8.join(home, ".claude")),
-    cursor: fs9.existsSync(getCursorConfigDir()),
-    codex: fs9.existsSync(path8.join(home, ".codex"))
+    claude: fs10.existsSync(path9.join(home, ".claude")),
+    cursor: fs10.existsSync(getCursorConfigDir()),
+    codex: fs10.existsSync(path9.join(home, ".codex"))
   };
 }
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path8.join(dir, "CLAUDE.md");
-  if (fs9.existsSync(claudeMdPath)) {
+  const claudeMdPath = path9.join(dir, "CLAUDE.md");
+  if (fs10.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -3483,10 +3637,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path8.join(dir, ".claude", "skills");
-  if (fs9.existsSync(skillsDir)) {
-    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path8.join(skillsDir, file);
+  const skillsDir = path9.join(dir, ".claude", "skills");
+  if (fs10.existsSync(skillsDir)) {
+    for (const file of fs10.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path9.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -3496,10 +3650,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path8.join(dir, ".mcp.json");
-  if (fs9.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path9.join(dir, ".mcp.json");
+  if (fs10.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3515,8 +3669,8 @@ function scanLocalState(dir) {
       warnScanSkip(".mcp.json", error);
     }
   }
-  const agentsMdPath = path8.join(dir, "AGENTS.md");
-  if (fs9.existsSync(agentsMdPath)) {
+  const agentsMdPath = path9.join(dir, "AGENTS.md");
+  if (fs10.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -3525,12 +3679,12 @@ function scanLocalState(dir) {
       path: agentsMdPath
     });
   }
-  const codexSkillsDir = path8.join(dir, ".agents", "skills");
-  if (fs9.existsSync(codexSkillsDir)) {
+  const codexSkillsDir = path9.join(dir, ".agents", "skills");
+  if (fs10.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(codexSkillsDir)) {
-        const skillFile = path8.join(codexSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+      for (const name of fs10.readdirSync(codexSkillsDir)) {
+        const skillFile = path9.join(codexSkillsDir, name, "SKILL.md");
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -3544,8 +3698,8 @@ function scanLocalState(dir) {
       warnScanSkip(".agents/skills", error);
     }
   }
-  const cursorrulesPath = path8.join(dir, ".cursorrules");
-  if (fs9.existsSync(cursorrulesPath)) {
+  const cursorrulesPath = path9.join(dir, ".cursorrules");
+  if (fs10.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -3554,10 +3708,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path8.join(dir, ".cursor", "rules");
-  if (fs9.existsSync(cursorRulesDir)) {
-    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path8.join(cursorRulesDir, file);
+  const cursorRulesDir = path9.join(dir, ".cursor", "rules");
+  if (fs10.existsSync(cursorRulesDir)) {
+    for (const file of fs10.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path9.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -3567,12 +3721,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path8.join(dir, ".cursor", "skills");
-  if (fs9.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path9.join(dir, ".cursor", "skills");
+  if (fs10.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs9.readdirSync(cursorSkillsDir)) {
-        const skillFile = path8.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs9.existsSync(skillFile)) {
+      for (const name of fs10.readdirSync(cursorSkillsDir)) {
+        const skillFile = path9.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs10.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -3586,10 +3740,10 @@ function scanLocalState(dir) {
       warnScanSkip(".cursor/skills", error);
     }
   }
-  const cursorMcpPath = path8.join(dir, ".cursor", "mcp.json");
-  if (fs9.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
+  if (fs10.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs10.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3608,7 +3762,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs9.readFileSync(filePath, "utf-8");
+  const text = fs10.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -3621,37 +3775,37 @@ function warnScanSkip(target, error) {
 function getCursorConfigDir() {
   const home = os4.homedir();
   if (process.platform === "darwin") {
-    return path8.join(home, "Library", "Application Support", "Cursor");
+    return path9.join(home, "Library", "Application Support", "Cursor");
   }
   if (process.platform === "win32") {
-    return path8.join(home, "AppData", "Roaming", "Cursor");
+    return path9.join(home, "AppData", "Roaming", "Cursor");
   }
-  return path8.join(home, ".config", "Cursor");
+  return path9.join(home, ".config", "Cursor");
 }
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { execSync as execSync8 } from "child_process";
-var SETTINGS_PATH = path9.join(".claude", "settings.json");
+var SETTINGS_PATH = path10.join(".claude", "settings.json");
 var REFRESH_TAIL = "refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs10.existsSync(SETTINGS_PATH)) return {};
+  if (!fs11.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs11.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path9.dirname(SETTINGS_PATH);
-  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
-  fs10.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path10.dirname(SETTINGS_PATH);
+  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
+  fs11.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3717,19 +3871,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync8("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path9.join(gitDir, "hooks");
+    return path10.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path9.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path10.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) return false;
-  const content = fs10.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs11.existsSync(hookPath)) return false;
+  const content = fs11.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3738,42 +3892,42 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path9.dirname(hookPath);
-  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path10.dirname(hookPath);
+  if (!fs11.existsSync(hooksDir)) fs11.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs10.existsSync(hookPath)) {
-    content = fs10.readFileSync(hookPath, "utf-8");
+  if (fs11.existsSync(hookPath)) {
+    content = fs11.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + getPrecommitBlock() + "\n";
   } else {
     content = "#!/bin/sh\n\n" + getPrecommitBlock() + "\n";
   }
-  fs10.writeFileSync(hookPath, content);
-  fs10.chmodSync(hookPath, 493);
+  fs11.writeFileSync(hookPath, content);
+  fs11.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs10.existsSync(hookPath)) {
+  if (!hookPath || !fs11.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs10.readFileSync(hookPath, "utf-8");
+  let content = fs11.readFileSync(hookPath, "utf-8");
   if (!content.includes(PRECOMMIT_START)) {
     return { removed: false, notFound: true };
   }
   const regex = new RegExp(`\\n?${PRECOMMIT_START}[\\s\\S]*?${PRECOMMIT_END}\\n?`);
   content = content.replace(regex, "\n");
   if (content.trim() === "#!/bin/sh" || content.trim() === "") {
-    fs10.unlinkSync(hookPath);
+    fs11.unlinkSync(hookPath);
   } else {
-    fs10.writeFileSync(hookPath, content);
+    fs11.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/fingerprint/sources.ts
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 
 // src/scoring/utils.ts
 import { existsSync as existsSync2, readFileSync, readdirSync } from "fs";
@@ -4092,7 +4246,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 {
@@ -4110,29 +4264,29 @@ function loadSourcesConfig(dir) {
   }
 }
 function writeSourcesConfig(dir, sources2) {
-  const configDir = path10.join(dir, ".caliber");
-  if (!fs11.existsSync(configDir)) {
-    fs11.mkdirSync(configDir, { recursive: true });
+  const configDir = path11.join(dir, ".caliber");
+  if (!fs12.existsSync(configDir)) {
+    fs12.mkdirSync(configDir, { recursive: true });
   }
-  const configPath = path10.join(configDir, "sources.json");
-  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  const configPath = path11.join(configDir, "sources.json");
+  fs12.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs12.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
 }
 function isInsideDir(childPath, parentDir) {
-  const relative2 = path10.relative(parentDir, childPath);
-  return !relative2.startsWith("..") && !path10.isAbsolute(relative2);
+  const relative2 = path11.relative(parentDir, childPath);
+  return !relative2.startsWith("..") && !path11.isAbsolute(relative2);
 }
 function resolveAllSources(dir, cliSources, workspaces) {
   const seen = /* @__PURE__ */ new Map();
-  const projectRoot = path10.resolve(dir);
+  const projectRoot = path11.resolve(dir);
   for (const src of cliSources) {
-    const absPath = path10.resolve(dir, src);
+    const absPath = path11.resolve(dir, src);
     if (seen.has(absPath)) continue;
     const type = detectSourceType(absPath);
     seen.set(absPath, {
@@ -4145,12 +4299,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, {
@@ -4163,7 +4317,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs11.statSync(absPath);
+      stat = fs12.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -4192,13 +4346,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 || "",
@@ -4218,18 +4372,18 @@ function collectRepoSummary(resolved, projectDir) {
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs11.readdirSync(absPath, { withFileTypes: true });
+    const entries = fs12.readdirSync(absPath, { withFileTypes: true });
     topLevelDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).slice(0, 20);
     keyFiles = entries.filter((e) => e.isFile() && !e.name.startsWith(".")).map((e) => e.name).slice(0, 15);
   } catch {
   }
-  const claudeMdContent = readFileOrNull(path10.join(absPath, "CLAUDE.md"));
+  const claudeMdContent = readFileOrNull(path11.join(absPath, "CLAUDE.md"));
   const existingClaudeMd = claudeMdContent ? claudeMdContent.slice(0, SOURCE_CONTENT_LIMIT) : void 0;
-  const readmeContent = readFileOrNull(path10.join(absPath, "README.md"));
+  const readmeContent = readFileOrNull(path11.join(absPath, "README.md"));
   const readmeExcerpt = readmeContent ? readmeContent.slice(0, README_CONTENT_LIMIT) : void 0;
   const gitRemoteUrl = getGitRemoteUrl(absPath);
   return {
-    name: packageName || path10.basename(absPath),
+    name: packageName || path11.basename(absPath),
     type: "repo",
     role: config.role || "related-repo",
     description: config.description || "",
@@ -4246,7 +4400,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] || "",
@@ -4889,17 +5043,17 @@ import fs19 from "fs";
 
 // src/writers/claude/index.ts
 init_pre_commit_block();
-import fs12 from "fs";
-import path11 from "path";
+import fs13 from "fs";
+import path12 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs12.writeFileSync("CLAUDE.md", appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.claudeMd))));
+  fs13.writeFileSync("CLAUDE.md", appendManagedBlocks(config.claudeMd, "claude"));
   written.push("CLAUDE.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path11.join(".claude", "skills", skill.name);
-      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path11.join(skillDir, "SKILL.md");
+      const skillDir = path12.join(".claude", "skills", skill.name);
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4907,21 +5061,21 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs12.writeFileSync(skillPath, frontmatter + skill.content);
+      fs13.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs12.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
+      if (fs13.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs13.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs13.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
@@ -4929,30 +5083,31 @@ function writeClaudeConfig(config) {
 
 // src/writers/cursor/index.ts
 init_pre_commit_block();
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs13.writeFileSync(".cursorrules", config.cursorrules);
+    fs14.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
   const learningsRule = getCursorLearningsRule();
   const syncRule = getCursorSyncRule();
-  const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule];
-  const rulesDir = path12.join(".cursor", "rules");
-  if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
+  const setupRule = getCursorSetupRule();
+  const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule, setupRule];
+  const rulesDir = path13.join(".cursor", "rules");
+  if (!fs14.existsSync(rulesDir)) fs14.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
-    const rulePath = path12.join(rulesDir, rule.filename);
-    fs13.writeFileSync(rulePath, rule.content);
+    const rulePath = path13.join(rulesDir, rule.filename);
+    fs14.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path12.join(".cursor", "skills", skill.name);
-      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path12.join(skillDir, "SKILL.md");
+      const skillDir = path13.join(".cursor", "skills", skill.name);
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path13.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -4960,24 +5115,24 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs13.existsSync(cursorDir)) fs13.mkdirSync(cursorDir, { recursive: true });
-    const mcpPath = path12.join(cursorDir, "mcp.json");
+    if (!fs14.existsSync(cursorDir)) fs14.mkdirSync(cursorDir, { recursive: true });
+    const mcpPath = path13.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs13.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
+      if (fs14.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs14.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs14.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -4985,17 +5140,17 @@ function writeCursorConfig(config) {
 
 // src/writers/codex/index.ts
 init_pre_commit_block();
-import fs14 from "fs";
-import path13 from "path";
+import fs15 from "fs";
+import path14 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs14.writeFileSync("AGENTS.md", appendLearningsBlock(appendPreCommitBlock(config.agentsMd)));
+  fs15.writeFileSync("AGENTS.md", appendManagedBlocks(config.agentsMd, "codex"));
   written.push("AGENTS.md");
   if (config.skills?.length) {
     for (const skill of config.skills) {
-      const skillDir = path13.join(".agents", "skills", skill.name);
-      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
-      const skillPath = path13.join(skillDir, "SKILL.md");
+      const skillDir = path14.join(".agents", "skills", skill.name);
+      if (!fs15.existsSync(skillDir)) fs15.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path14.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
         `name: ${skill.name}`,
@@ -5003,7 +5158,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs14.writeFileSync(skillPath, frontmatter + skill.content);
+      fs15.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -5012,20 +5167,20 @@ function writeCodexConfig(config) {
 
 // src/writers/github-copilot/index.ts
 init_pre_commit_block();
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path15 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs15.mkdirSync(".github", { recursive: true });
-    fs15.writeFileSync(path14.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(config.instructions))));
+    fs16.mkdirSync(".github", { recursive: true });
+    fs16.writeFileSync(path15.join(".github", "copilot-instructions.md"), appendManagedBlocks(config.instructions, "copilot"));
     written.push(".github/copilot-instructions.md");
   }
   if (config.instructionFiles?.length) {
-    const instructionsDir = path14.join(".github", "instructions");
-    fs15.mkdirSync(instructionsDir, { recursive: true });
+    const instructionsDir = path15.join(".github", "instructions");
+    fs16.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs15.writeFileSync(path14.join(instructionsDir, file.filename), file.content);
+      fs16.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -5033,30 +5188,30 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs16 from "fs";
-import path15 from "path";
+import fs17 from "fs";
+import path16 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path15.join(BACKUPS_DIR, timestamp);
+  const backupDir = path16.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs16.existsSync(file)) continue;
-    const dest = path15.join(backupDir, file);
-    const destDir = path15.dirname(dest);
-    if (!fs16.existsSync(destDir)) {
-      fs16.mkdirSync(destDir, { recursive: true });
+    if (!fs17.existsSync(file)) continue;
+    const dest = path16.join(backupDir, file);
+    const destDir = path16.dirname(dest);
+    if (!fs17.existsSync(destDir)) {
+      fs17.mkdirSync(destDir, { recursive: true });
     }
-    fs16.copyFileSync(file, dest);
+    fs17.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path15.join(backupDir, file);
-  if (!fs16.existsSync(backupFile)) return false;
-  const destDir = path15.dirname(file);
-  if (!fs16.existsSync(destDir)) {
-    fs16.mkdirSync(destDir, { recursive: true });
+  const backupFile = path16.join(backupDir, file);
+  if (!fs17.existsSync(backupFile)) return false;
+  const destDir = path16.dirname(file);
+  if (!fs17.existsSync(destDir)) {
+    fs17.mkdirSync(destDir, { recursive: true });
   }
-  fs16.copyFileSync(backupFile, file);
+  fs17.copyFileSync(backupFile, file);
   return true;
 }
 
@@ -9234,8 +9389,9 @@ async function initCommand(options) {
   if (options.agent) {
     targetAgent = options.agent;
   } else if (options.autoApprove) {
-    targetAgent = ["claude"];
-    log(options.verbose, "Auto-approve: defaulting to claude agent");
+    const detected = detectAgents(process.cwd());
+    targetAgent = detected.length > 0 ? detected : ["claude"];
+    log(options.verbose, `Auto-approve: using ${targetAgent.join(", ")}`);
   } else {
     const detected = detectAgents(process.cwd());
     targetAgent = await promptAgent(detected.length > 0 ? detected : void 0);
@@ -9316,12 +9472,11 @@ async function initCommand(options) {
   }
   if (skipGeneration) {
     const {
-      appendPreCommitBlock: appendPreCommitBlock2,
-      appendLearningsBlock: appendLearningsBlock2,
-      appendSyncBlock: appendSyncBlock2,
+      appendManagedBlocks: appendManagedBlocks2,
       getCursorPreCommitRule: getCursorPreCommitRule2,
       getCursorLearningsRule: getCursorLearningsRule2,
-      getCursorSyncRule: getCursorSyncRule2
+      getCursorSyncRule: getCursorSyncRule2,
+      getCursorSetupRule: getCursorSetupRule2
     } = await Promise.resolve().then(() => (init_pre_commit_block(), pre_commit_block_exports));
     const claudeMdPath = "CLAUDE.md";
     let claudeContent = "";
@@ -9333,7 +9488,7 @@ async function initCommand(options) {
       claudeContent = `# ${path26.basename(process.cwd())}
 `;
     }
-    const updatedClaude = appendSyncBlock2(appendLearningsBlock2(appendPreCommitBlock2(claudeContent)));
+    const updatedClaude = appendManagedBlocks2(claudeContent, "claude");
     if (updatedClaude !== claudeContent || !fs33.existsSync(claudeMdPath)) {
       fs33.writeFileSync(claudeMdPath, updatedClaude);
       console.log(`  ${chalk14.green("\u2713")} CLAUDE.md \u2014 added Caliber sync instructions`);
@@ -9341,7 +9496,7 @@ async function initCommand(options) {
     if (targetAgent.includes("cursor")) {
       const rulesDir = path26.join(".cursor", "rules");
       if (!fs33.existsSync(rulesDir)) fs33.mkdirSync(rulesDir, { recursive: true });
-      for (const rule of [getCursorPreCommitRule2(), getCursorLearningsRule2(), getCursorSyncRule2()]) {
+      for (const rule of [getCursorPreCommitRule2(), getCursorLearningsRule2(), getCursorSyncRule2(), getCursorSetupRule2()]) {
         fs33.writeFileSync(path26.join(rulesDir, rule.filename), rule.content);
       }
       console.log(`  ${chalk14.green("\u2713")} Cursor rules \u2014 added Caliber sync rules`);
@@ -9358,7 +9513,7 @@ async function initCommand(options) {
         copilotContent = `# ${path26.basename(process.cwd())}
 `;
       }
-      const updatedCopilot = appendSyncBlock2(appendLearningsBlock2(appendPreCommitBlock2(copilotContent)));
+      const updatedCopilot = appendManagedBlocks2(copilotContent, "copilot");
       if (updatedCopilot !== copilotContent) {
         fs33.writeFileSync(copilotPath, updatedCopilot);
         console.log(`  ${chalk14.green("\u2713")} Copilot instructions \u2014 added Caliber sync instructions`);
@@ -10137,14 +10292,24 @@ var MAX_DIFF_BYTES = 1e5;
 var DOC_PATTERNS = [
   "CLAUDE.md",
   "README.md",
+  "AGENTS.md",
   ".cursorrules",
   ".cursor/rules/",
+  ".cursor/skills/",
   ".claude/skills/",
+  ".agents/skills/",
+  ".github/copilot-instructions.md",
+  ".github/instructions/",
   "CALIBER_LEARNINGS.md"
 ];
 function excludeArgs() {
   return DOC_PATTERNS.flatMap((p) => ["--", `:!${p}`]);
 }
+function truncateAtLine(text, maxBytes) {
+  if (text.length <= maxBytes) return text;
+  const cut = text.lastIndexOf("\n", maxBytes);
+  return cut > 0 ? text.slice(0, cut) : text.slice(0, maxBytes);
+}
 function safeExec(cmd) {
   try {
     return execSync15(cmd, {
@@ -10190,9 +10355,9 @@ function collectDiff(lastSha) {
   const totalSize = committedDiff.length + stagedDiff.length + unstagedDiff.length;
   if (totalSize > MAX_DIFF_BYTES) {
     const ratio = MAX_DIFF_BYTES / totalSize;
-    committedDiff = committedDiff.slice(0, Math.floor(committedDiff.length * ratio));
-    stagedDiff = stagedDiff.slice(0, Math.floor(stagedDiff.length * ratio));
-    unstagedDiff = unstagedDiff.slice(0, Math.floor(unstagedDiff.length * ratio));
+    committedDiff = truncateAtLine(committedDiff, Math.floor(committedDiff.length * ratio));
+    stagedDiff = truncateAtLine(stagedDiff, Math.floor(stagedDiff.length * ratio));
+    unstagedDiff = truncateAtLine(unstagedDiff, Math.floor(unstagedDiff.length * ratio));
   }
   const hasChanges = !!(committedDiff || stagedDiff || unstagedDiff || changedFiles.length);
   const parts = [];
@@ -10211,13 +10376,17 @@ import path28 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs36.writeFileSync("CLAUDE.md", appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.claudeMd))));
+    fs36.writeFileSync("CLAUDE.md", appendManagedBlocks(docs.claudeMd, "claude"));
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
     fs36.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
+  if (docs.agentsMd) {
+    fs36.writeFileSync("AGENTS.md", appendManagedBlocks(docs.agentsMd, "codex"));
+    written.push("AGENTS.md");
+  }
   if (docs.cursorrules) {
     fs36.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
@@ -10240,7 +10409,7 @@ function writeRefreshDocs(docs) {
   }
   if (docs.copilotInstructions) {
     fs36.mkdirSync(".github", { recursive: true });
-    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(docs.copilotInstructions))));
+    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendManagedBlocks(docs.copilotInstructions, "copilot"));
     written.push(".github/copilot-instructions.md");
   }
   if (docs.copilotInstructionFiles) {
@@ -10259,10 +10428,18 @@ init_config();
 async function refreshDocs(diff, existingDocs, projectContext, learnedSection, sources2) {
   const prompt = buildRefreshPrompt(diff, existingDocs, projectContext, learnedSection, sources2);
   const fastModel = getFastModel();
+  const docCount = [
+    existingDocs.claudeMd,
+    existingDocs.readmeMd,
+    existingDocs.agentsMd,
+    existingDocs.cursorrules,
+    existingDocs.copilotInstructions
+  ].filter(Boolean).length + (existingDocs.cursorRules?.length ?? 0) + (existingDocs.claudeSkills?.length ?? 0);
+  const maxTokens = Math.min(32768, Math.max(8192, docCount * 4096));
   const raw = await llmCall({
     system: REFRESH_SYSTEM_PROMPT,
     prompt,
-    maxTokens: 16384,
+    maxTokens,
     ...fastModel ? { model: fastModel } : {}
   });
   return parseJsonResponse(raw);
@@ -10321,6 +10498,21 @@ Changed files: ${diff.changedFiles.join(", ")}`);
       parts.push(rule.content);
     }
   }
+  if (existingDocs.agentsMd) {
+    parts.push("\n[AGENTS.md]");
+    parts.push(existingDocs.agentsMd);
+  }
+  if (existingDocs.copilotInstructions) {
+    parts.push("\n[.github/copilot-instructions.md]");
+    parts.push(existingDocs.copilotInstructions);
+  }
+  if (existingDocs.copilotInstructionFiles?.length) {
+    for (const file of existingDocs.copilotInstructionFiles) {
+      parts.push(`
+[.github/instructions/${file.filename}]`);
+      parts.push(file.content);
+    }
+  }
   if (learnedSection) {
     parts.push("\n--- Learned Patterns (from session learning) ---");
     parts.push("Consider these accumulated learnings when deciding what to update:");