@rely-ai/caliber 1.31.0-dev.1774815271 → 1.32.0-dev.1774815754

package/dist/bin.js

@@ -9,6 +9,155 @@ 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 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 (!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 = path6.join(os2.homedir(), ".caliber");
+    CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
+    DEFAULT_MODELS = {
+      anthropic: "claude-sonnet-4-6",
+      vertex: "claude-sonnet-4-6",
+      openai: "gpt-4.1",
+      cursor: "sonnet-4.6",
+      "claude-cli": "default"
+    };
+    MODEL_CONTEXT_WINDOWS = {
+      "claude-sonnet-4-6": 2e5,
+      "claude-opus-4-6": 2e5,
+      "claude-haiku-4-5-20251001": 2e5,
+      "claude-sonnet-4-5-20250514": 2e5,
+      "gpt-4.1": 1e6,
+      "gpt-4.1-mini": 1e6,
+      "gpt-4o": 128e3,
+      "gpt-4o-mini": 128e3,
+      "sonnet-4.6": 2e5
+    };
+    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, {
@@ -17,8 +166,8 @@ __export(resolve_caliber_exports, {
   resetResolvedCaliber: () => resetResolvedCaliber,
   resolveCaliber: () => resolveCaliber
 });
-import fs2 from "fs";
-import { execSync as execSync3 } from "child_process";
+import fs6 from "fs";
+import { execSync as execSync4 } from "child_process";
 function resolveCaliber() {
   if (_resolved) return _resolved;
   const isNpx = process.argv[1]?.includes("_npx") || process.env.npm_execpath?.includes("npx");
@@ -28,7 +177,7 @@ function resolveCaliber() {
   }
   try {
     const whichCmd = process.platform === "win32" ? "where caliber" : "which caliber";
-    execSync3(whichCmd, {
+    execSync4(whichCmd, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -37,7 +186,7 @@ function resolveCaliber() {
   } catch {
   }
   const binPath = process.argv[1];
-  if (binPath && /caliber/.test(binPath) && fs2.existsSync(binPath)) {
+  if (binPath && /caliber/.test(binPath) && fs6.existsSync(binPath)) {
     _resolved = binPath;
     return _resolved;
   }
@@ -65,65 +214,283 @@ var init_resolve_caliber = __esm({
   }
 });
 
-// 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
+// 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"]);
+  }
 });
-import fs3 from "fs";
-import path3 from "path";
-function buildSkillContent(skill) {
-  const frontmatter = `---
-name: ${skill.name}
-description: ${skill.description}
----
 
-`;
-  return frontmatter + skill.content;
+// 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 getFindSkillsContent() {
+function getPreCommitBlock(platform = "claude") {
   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
+  return `${BLOCK_START}
+## Before Committing
 
-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
+**IMPORTANT:** Before every git commit, you MUST ensure Caliber syncs agent configs with the latest code changes.
 
-## Examples
+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"
+\`\`\`
 
-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
+- 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
+---
+This project uses Caliber to keep AI agent configs in sync automatically.
+At the start of each session, silently check if sync is active:
+
+Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "SYNC_ACTIVE" || echo "NO_SYNC"\`
+
+If SYNC_ACTIVE: No action needed \u2014 Caliber syncs automatically on every commit.
+If NO_SYNC: Tell the user: "This project uses Caliber for automatic agent config sync, but it's not set up on your machine yet. Want me to set it up? It takes about 30 seconds."
+
+If the user agrees, read \`.cursor/skills/setup-caliber/SKILL.md\` and follow its instructions step by step.
+`;
+}
+function getCursorSetupRule() {
+  return { filename: CURSOR_SETUP_FILENAME, content: getCursorSetupContent() };
+}
+function stripManagedBlocks(content) {
+  let result = content;
+  for (const [start, end] of MANAGED_BLOCK_PAIRS) {
+    const regex = new RegExp(`\\n?${start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g");
+    result = result.replace(regex, "\n");
+  }
+  return result.replace(/\n{3,}/g, "\n\n").trim() + "\n";
+}
+var BLOCK_START, BLOCK_END, MANAGED_DOC_PATHS, CURSOR_RULE_FILENAME, LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END, LEARNINGS_BLOCK, CURSOR_LEARNINGS_FILENAME, CURSOR_LEARNINGS_CONTENT, SYNC_BLOCK_START, SYNC_BLOCK_END, CURSOR_SYNC_FILENAME, CURSOR_SETUP_FILENAME, MANAGED_BLOCK_PAIRS;
+var init_pre_commit_block = __esm({
+  "src/writers/pre-commit-block.ts"() {
+    "use strict";
+    init_resolve_caliber();
+    BLOCK_START = "<!-- caliber:managed:pre-commit -->";
+    BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
+    MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
+    CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
+    LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
+    LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
+    LEARNINGS_BLOCK = `${LEARNINGS_BLOCK_START}
+## Session Learnings
+
+Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
+These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
+${LEARNINGS_BLOCK_END}`;
+    CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
+    CURSOR_LEARNINGS_CONTENT = `---
+description: Reference session-learned patterns from CALIBER_LEARNINGS.md
+alwaysApply: true
+---
+Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
+These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
+`;
+    SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
+    SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
+    CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
+    CURSOR_SETUP_FILENAME = "caliber-setup.mdc";
+    MANAGED_BLOCK_PAIRS = [
+      [BLOCK_START, BLOCK_END],
+      [LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END],
+      [SYNC_BLOCK_START, SYNC_BLOCK_END]
+    ];
+  }
+});
+
+// src/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?"
@@ -411,427 +778,60 @@ From now on, every commit keeps all your agent configs in sync automatically.
 function ensureBuiltinSkills() {
   const written = [];
   for (const { platformDir, skillsDir } of PLATFORM_CONFIGS) {
-    if (!fs3.existsSync(platformDir)) continue;
+    if (!fs17.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));
+      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: path3.join(".claude", "skills") },
-      { platformDir: ".cursor", skillsDir: path3.join(".cursor", "skills") },
-      { platformDir: ".agents", skillsDir: path3.join(".agents", "skills") }
-    ];
-    BUILTIN_SKILL_NAMES = new Set(BUILTIN_SKILLS.map((s) => s.name));
-  }
-});
-
-// src/writers/pre-commit-block.ts
-var pre_commit_block_exports = {};
-__export(pre_commit_block_exports, {
-  appendLearningsBlock: () => appendLearningsBlock,
-  appendManagedBlocks: () => appendManagedBlocks,
-  appendPreCommitBlock: () => appendPreCommitBlock,
-  appendSyncBlock: () => appendSyncBlock,
-  getCursorLearningsRule: () => getCursorLearningsRule,
-  getCursorPreCommitRule: () => getCursorPreCommitRule,
-  getCursorSetupRule: () => getCursorSetupRule,
-  getCursorSyncRule: () => getCursorSyncRule,
-  hasLearningsBlock: () => hasLearningsBlock,
-  hasPreCommitBlock: () => hasPreCommitBlock,
-  hasSyncBlock: () => hasSyncBlock,
-  stripManagedBlocks: () => stripManagedBlocks
-});
-function getCaliberNotFoundFallback(platform, bin) {
-  switch (platform) {
-    case "claude":
-      return `If \`${bin}\` is not found, tell the user: "This project uses Caliber for agent config sync. Run /setup-caliber to get set up."`;
-    case "codex":
-      return `If \`${bin}\` is not found, read \`.agents/skills/setup-caliber/SKILL.md\` and follow its instructions to install Caliber.`;
-    case "copilot":
-      return `If \`${bin}\` is not found, tell the developer to set up Caliber by running \`/setup-caliber\` in Claude Code or Cursor. Alternatively, they can run these commands in their terminal:
-\`\`\`
-npx @rely-ai/caliber hooks --install
-npx @rely-ai/caliber refresh
-\`\`\``;
-  }
-}
-function getPreCommitBlock(platform = "claude") {
-  const bin = resolveCaliber();
-  return `${BLOCK_START}
-## Before Committing
-
-**IMPORTANT:** Before every git commit, you MUST ensure Caliber syncs agent configs with the latest code changes.
-
-First, check if the pre-commit hook is already installed:
-\`\`\`bash
-grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"
-\`\`\`
-
-- If **hook-active**: the hook handles sync automatically \u2014 just commit normally. Tell the user: "Caliber will sync your agent configs automatically via the pre-commit hook."
-- If **no-hook**: run Caliber manually before committing:
-  1. Tell the user: "Caliber: Syncing agent configs with your latest changes..."
-  2. Run: \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\`
-  3. After it completes, briefly tell the user what Caliber updated. Then proceed with the commit.
-
-${getCaliberNotFoundFallback(platform, bin)}
-${BLOCK_END}`;
-}
-function getCursorRuleContent() {
-  const bin = resolveCaliber();
-  return `---
-description: Run Caliber sync before git commits to keep agent configs up to date
-alwaysApply: true
----
-Before every git commit, check if the Caliber pre-commit hook is installed:
-Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "hook-active" || echo "no-hook"\`
-
-If hook-active: just commit normally \u2014 Caliber syncs automatically via the hook. Tell the user: "Caliber will sync your agent configs automatically."
-If no-hook: run \`${bin} refresh && git add ${MANAGED_DOC_PATHS} 2>/dev/null\` before committing, and tell the user what was updated.
-
-If \`${bin}\` is not found, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
-`;
-}
-function hasPreCommitBlock(content) {
-  return content.includes(BLOCK_START);
-}
-function appendPreCommitBlock(content, platform = "claude") {
-  if (hasPreCommitBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getPreCommitBlock(platform) + "\n";
-}
-function getCursorPreCommitRule() {
-  return { filename: CURSOR_RULE_FILENAME, content: getCursorRuleContent() };
-}
-function hasLearningsBlock(content) {
-  return content.includes(LEARNINGS_BLOCK_START);
-}
-function appendLearningsBlock(content) {
-  if (hasLearningsBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + LEARNINGS_BLOCK + "\n";
-}
-function getCursorLearningsRule() {
-  return { filename: CURSOR_LEARNINGS_FILENAME, content: CURSOR_LEARNINGS_CONTENT };
-}
-function getSyncSetupInstruction(platform, bin) {
-  switch (platform) {
-    case "claude":
-      return `If the pre-commit hook is not set up, run \`/setup-caliber\` to configure everything automatically.`;
-    case "codex":
-      return `If the pre-commit hook is not set up, read \`.agents/skills/setup-caliber/SKILL.md\` and follow the setup instructions.`;
-    case "copilot":
-      return `If the pre-commit hook is not set up, the developer should run \`/setup-caliber\` in Claude Code or Cursor for automated setup. Alternatively, run in terminal:
-\`\`\`bash
-npx @rely-ai/caliber hooks --install
-npx @rely-ai/caliber refresh
-git add ${MANAGED_DOC_PATHS} 2>/dev/null
-\`\`\``;
-  }
-}
-function getSyncBlock(platform = "claude") {
-  const bin = resolveCaliber();
-  return `${SYNC_BLOCK_START}
-## Context Sync
-
-This project uses [Caliber](https://github.com/caliber-ai-org/ai-setup) to keep AI agent configs in sync across Claude Code, Cursor, Copilot, and Codex.
-Configs update automatically before each commit via \`${bin} refresh\`.
-${getSyncSetupInstruction(platform, bin)}
-${SYNC_BLOCK_END}`;
-}
-function hasSyncBlock(content) {
-  return content.includes(SYNC_BLOCK_START);
-}
-function appendSyncBlock(content, platform = "claude") {
-  if (hasSyncBlock(content)) return content;
-  const trimmed = content.trimEnd();
-  return trimmed + "\n\n" + getSyncBlock(platform) + "\n";
-}
-function appendManagedBlocks(content, platform = "claude") {
-  return appendSyncBlock(appendLearningsBlock(appendPreCommitBlock(content, platform)), platform);
-}
-function getCursorSyncContent() {
-  const bin = resolveCaliber();
-  return `---
-description: This project uses Caliber for automatic AI agent context sync
-alwaysApply: true
----
-This project uses Caliber to keep AI agent configs (CLAUDE.md, Cursor rules, Copilot instructions)
-in sync with the codebase automatically. Before each commit, run \`${bin} refresh\` to sync configs.
-If \`${bin}\` is not found, read the setup-caliber skill from .cursor/skills/setup-caliber/SKILL.md and follow its instructions to install Caliber.
-`;
-}
-function getCursorSyncRule() {
-  return { filename: CURSOR_SYNC_FILENAME, content: getCursorSyncContent() };
-}
-function getCursorSetupContent() {
-  return `---
-description: Check if Caliber agent config sync is set up and offer installation on new sessions
-alwaysApply: true
----
-This project uses Caliber to keep AI agent configs in sync automatically.
-At the start of each session, silently check if sync is active:
-
-Run: \`grep -q "caliber" .git/hooks/pre-commit 2>/dev/null && echo "SYNC_ACTIVE" || echo "NO_SYNC"\`
-
-If SYNC_ACTIVE: No action needed \u2014 Caliber syncs automatically on every commit.
-If NO_SYNC: Tell the user: "This project uses Caliber for automatic agent config sync, but it's not set up on your machine yet. Want me to set it up? It takes about 30 seconds."
-
-If the user agrees, read \`.cursor/skills/setup-caliber/SKILL.md\` and follow its instructions step by step.
-`;
-}
-function getCursorSetupRule() {
-  return { filename: CURSOR_SETUP_FILENAME, content: getCursorSetupContent() };
-}
-function stripManagedBlocks(content) {
-  let result = content;
-  for (const [start, end] of MANAGED_BLOCK_PAIRS) {
-    const regex = new RegExp(`\\n?${start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`, "g");
-    result = result.replace(regex, "\n");
-  }
-  return result.replace(/\n{3,}/g, "\n\n").trim() + "\n";
-}
-var BLOCK_START, BLOCK_END, MANAGED_DOC_PATHS, CURSOR_RULE_FILENAME, LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END, LEARNINGS_BLOCK, CURSOR_LEARNINGS_FILENAME, CURSOR_LEARNINGS_CONTENT, SYNC_BLOCK_START, SYNC_BLOCK_END, CURSOR_SYNC_FILENAME, CURSOR_SETUP_FILENAME, MANAGED_BLOCK_PAIRS;
-var init_pre_commit_block = __esm({
-  "src/writers/pre-commit-block.ts"() {
-    "use strict";
-    init_resolve_caliber();
-    BLOCK_START = "<!-- caliber:managed:pre-commit -->";
-    BLOCK_END = "<!-- /caliber:managed:pre-commit -->";
-    MANAGED_DOC_PATHS = "CLAUDE.md .claude/ .cursor/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md";
-    CURSOR_RULE_FILENAME = "caliber-pre-commit.mdc";
-    LEARNINGS_BLOCK_START = "<!-- caliber:managed:learnings -->";
-    LEARNINGS_BLOCK_END = "<!-- /caliber:managed:learnings -->";
-    LEARNINGS_BLOCK = `${LEARNINGS_BLOCK_START}
-## Session Learnings
-
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-${LEARNINGS_BLOCK_END}`;
-    CURSOR_LEARNINGS_FILENAME = "caliber-learnings.mdc";
-    CURSOR_LEARNINGS_CONTENT = `---
-description: Reference session-learned patterns from CALIBER_LEARNINGS.md
-alwaysApply: true
----
-Read \`CALIBER_LEARNINGS.md\` for patterns and anti-patterns learned from previous sessions.
-These are auto-extracted from real tool usage \u2014 treat them as project-specific rules.
-`;
-    SYNC_BLOCK_START = "<!-- caliber:managed:sync -->";
-    SYNC_BLOCK_END = "<!-- /caliber:managed:sync -->";
-    CURSOR_SYNC_FILENAME = "caliber-sync.mdc";
-    CURSOR_SETUP_FILENAME = "caliber-setup.mdc";
-    MANAGED_BLOCK_PAIRS = [
-      [BLOCK_START, BLOCK_END],
-      [LEARNINGS_BLOCK_START, LEARNINGS_BLOCK_END],
-      [SYNC_BLOCK_START, SYNC_BLOCK_END]
-    ];
-  }
-});
-
-// src/llm/config.ts
-var config_exports = {};
-__export(config_exports, {
-  DEFAULT_FAST_MODELS: () => DEFAULT_FAST_MODELS,
-  DEFAULT_MODELS: () => DEFAULT_MODELS,
-  MODEL_CONTEXT_WINDOWS: () => MODEL_CONTEXT_WINDOWS,
-  getConfigFilePath: () => getConfigFilePath,
-  getDisplayModel: () => getDisplayModel,
-  getFastModel: () => getFastModel,
-  getMaxPromptTokens: () => getMaxPromptTokens,
-  loadConfig: () => loadConfig,
-  readConfigFile: () => readConfigFile,
-  resolveFromEnv: () => resolveFromEnv,
-  writeConfigFile: () => writeConfigFile
-});
-import fs6 from "fs";
-import path6 from "path";
-import os2 from "os";
-function getMaxPromptTokens() {
-  const config = loadConfig();
-  const model = process.env.CALIBER_MODEL || config?.model;
-  const contextWindow = model ? MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW : DEFAULT_CONTEXT_WINDOW;
-  const budget = Math.floor(contextWindow * INPUT_BUDGET_FRACTION);
-  return Math.max(MIN_PROMPT_TOKENS, Math.min(budget, MAX_PROMPT_TOKENS_CAP));
-}
-function loadConfig() {
-  const envConfig = resolveFromEnv();
-  if (envConfig) return envConfig;
-  return readConfigFile();
-}
-function resolveFromEnv() {
-  if (process.env.ANTHROPIC_API_KEY) {
-    return {
-      provider: "anthropic",
-      apiKey: process.env.ANTHROPIC_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.anthropic
-    };
-  }
-  if (process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID) {
-    return {
-      provider: "vertex",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.vertex,
-      vertexProjectId: process.env.VERTEX_PROJECT_ID || process.env.GCP_PROJECT_ID,
-      vertexRegion: process.env.VERTEX_REGION || process.env.GCP_REGION || "us-east5",
-      vertexCredentials: process.env.VERTEX_SA_CREDENTIALS || process.env.GOOGLE_APPLICATION_CREDENTIALS
-    };
-  }
-  if (process.env.OPENAI_API_KEY) {
-    return {
-      provider: "openai",
-      apiKey: process.env.OPENAI_API_KEY,
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.openai,
-      baseUrl: process.env.OPENAI_BASE_URL
-    };
-  }
-  if (process.env.CALIBER_USE_CURSOR_SEAT === "1" || process.env.CALIBER_USE_CURSOR_SEAT === "true") {
-    return {
-      provider: "cursor",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS.cursor
-    };
-  }
-  if (process.env.CALIBER_USE_CLAUDE_CLI === "1" || process.env.CALIBER_USE_CLAUDE_CLI === "true") {
-    return {
-      provider: "claude-cli",
-      model: process.env.CALIBER_MODEL || DEFAULT_MODELS["claude-cli"]
-    };
-  }
-  return null;
-}
-function readConfigFile() {
-  try {
-    if (!fs6.existsSync(CONFIG_FILE)) return null;
-    const raw = fs6.readFileSync(CONFIG_FILE, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.provider || !["anthropic", "vertex", "openai", "cursor", "claude-cli"].includes(parsed.provider)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function writeConfigFile(config) {
-  if (!fs6.existsSync(CONFIG_DIR)) {
-    fs6.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  const sanitized = { ...config };
-  if (sanitized.apiKey) {
-    sanitized.apiKey = sanitized.apiKey.trim();
-  }
-  fs6.writeFileSync(CONFIG_FILE, JSON.stringify(sanitized, null, 2) + "\n", { mode: 384 });
-}
-function getConfigFilePath() {
-  return CONFIG_FILE;
-}
-function getDisplayModel(config) {
-  if (config.model === "default" && config.provider === "claude-cli") {
-    return process.env.ANTHROPIC_MODEL || "default (inherited from Claude Code)";
-  }
-  return config.model;
-}
-function getFastModel() {
-  if (process.env.CALIBER_FAST_MODEL) return process.env.CALIBER_FAST_MODEL;
-  const config = loadConfig();
-  const provider = config?.provider;
-  if (process.env.ANTHROPIC_SMALL_FAST_MODEL && (!provider || provider === "anthropic" || provider === "vertex" || provider === "claude-cli")) {
-    return process.env.ANTHROPIC_SMALL_FAST_MODEL;
-  }
-  if (config?.fastModel) return config.fastModel;
-  if (provider) return DEFAULT_FAST_MODELS[provider];
-  return void 0;
-}
-var CONFIG_DIR, CONFIG_FILE, DEFAULT_MODELS, MODEL_CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW, INPUT_BUDGET_FRACTION, MAX_PROMPT_TOKENS_CAP, MIN_PROMPT_TOKENS, DEFAULT_FAST_MODELS;
-var init_config = __esm({
-  "src/llm/config.ts"() {
-    "use strict";
-    CONFIG_DIR = path6.join(os2.homedir(), ".caliber");
-    CONFIG_FILE = path6.join(CONFIG_DIR, "config.json");
-    DEFAULT_MODELS = {
-      anthropic: "claude-sonnet-4-6",
-      vertex: "claude-sonnet-4-6",
-      openai: "gpt-4.1",
-      cursor: "sonnet-4.6",
-      "claude-cli": "default"
-    };
-    MODEL_CONTEXT_WINDOWS = {
-      "claude-sonnet-4-6": 2e5,
-      "claude-opus-4-6": 2e5,
-      "claude-haiku-4-5-20251001": 2e5,
-      "claude-sonnet-4-5-20250514": 2e5,
-      "gpt-4.1": 1e6,
-      "gpt-4.1-mini": 1e6,
-      "gpt-4o": 128e3,
-      "gpt-4o-mini": 128e3,
-      "sonnet-4.6": 2e5
-    };
-    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/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"() {
+}
+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";
-    SEAT_BASED_PROVIDERS = /* @__PURE__ */ new Set(["cursor", "claude-cli"]);
+    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 execSync14, spawn as spawn3 } from "child_process";
 import fs27 from "fs";
-import path23 from "path";
+import path24 from "path";
 import os6 from "os";
 function getEmptyFilePath(proposedPath) {
   fs27.mkdirSync(DIFF_TEMP_DIR, { recursive: true });
-  const tempPath = path23.join(DIFF_TEMP_DIR, path23.basename(proposedPath));
+  const tempPath = path24.join(DIFF_TEMP_DIR, path24.basename(proposedPath));
   fs27.writeFileSync(tempPath, "");
   return tempPath;
 }
@@ -872,7 +872,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");
   }
 });
 
@@ -1098,7 +1098,7 @@ __export(lock_exports, {
   releaseLock: () => releaseLock
 });
 import fs38 from "fs";
-import path30 from "path";
+import path31 from "path";
 import os8 from "os";
 function isCaliberRunning() {
   try {
@@ -1132,7 +1132,7 @@ 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;
   }
 });
@@ -1140,16 +1140,16 @@ var init_lock = __esm({
 // src/cli.ts
 import { Command } from "commander";
 import fs49 from "fs";
-import path39 from "path";
+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 fs33 from "fs";
 
 // src/fingerprint/index.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import path8 from "path";
 
 // src/fingerprint/git.ts
@@ -1258,8 +1258,8 @@ function scan(base, rel, depth, maxDepth, result) {
 }
 
 // src/fingerprint/existing-config.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs2 from "fs";
+import path3 from "path";
 
 // src/constants.ts
 import path2 from "path";
@@ -1294,121 +1294,97 @@ 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 = path4.join(dir, "README.md");
-  if (fs4.existsSync(readmeMdPath)) {
-    configs.readmeMd = fs4.readFileSync(readmeMdPath, "utf-8");
+  const readmeMdPath = path3.join(dir, "README.md");
+  if (fs2.existsSync(readmeMdPath)) {
+    configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
   }
-  const agentsMdPath = path4.join(dir, "AGENTS.md");
-  if (fs4.existsSync(agentsMdPath)) {
-    configs.agentsMd = fs4.readFileSync(agentsMdPath, "utf-8");
+  const agentsMdPath = path3.join(dir, "AGENTS.md");
+  if (fs2.existsSync(agentsMdPath)) {
+    configs.agentsMd = fs2.readFileSync(agentsMdPath, "utf-8");
   }
-  const claudeMdPath = path4.join(dir, "CLAUDE.md");
-  if (fs4.existsSync(claudeMdPath)) {
-    configs.claudeMd = fs4.readFileSync(claudeMdPath, "utf-8");
+  const claudeMdPath = path3.join(dir, "CLAUDE.md");
+  if (fs2.existsSync(claudeMdPath)) {
+    configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
   }
-  const claudeSettingsPath = path4.join(dir, ".claude", "settings.json");
-  if (fs4.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = path3.join(dir, ".claude", "settings.json");
+  if (fs2.existsSync(claudeSettingsPath)) {
     try {
-      configs.claudeSettings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
+      configs.claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath, "utf-8"));
     } catch {
     }
   }
-  const skillsDir = path4.join(dir, ".claude", "skills");
-  if (fs4.existsSync(skillsDir)) {
+  const skillsDir = path3.join(dir, ".claude", "skills");
+  if (fs2.existsSync(skillsDir)) {
     try {
-      const entries = fs4.readdirSync(skillsDir);
+      const entries = fs2.readdirSync(skillsDir);
       const skills = [];
       for (const entry of entries) {
-        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") });
+        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") });
         } else if (entry.endsWith(".md")) {
-          skills.push({ filename: entry, content: fs4.readFileSync(entryPath, "utf-8") });
+          skills.push({ filename: entry, content: fs2.readFileSync(entryPath, "utf-8") });
         }
       }
       if (skills.length > 0) configs.claudeSkills = skills;
     } catch {
     }
   }
-  const cursorrulesPath = path4.join(dir, ".cursorrules");
-  if (fs4.existsSync(cursorrulesPath)) {
-    configs.cursorrules = fs4.readFileSync(cursorrulesPath, "utf-8");
+  const cursorrulesPath = path3.join(dir, ".cursorrules");
+  if (fs2.existsSync(cursorrulesPath)) {
+    configs.cursorrules = fs2.readFileSync(cursorrulesPath, "utf-8");
   }
-  const cursorRulesDir = path4.join(dir, ".cursor", "rules");
-  if (fs4.existsSync(cursorRulesDir)) {
+  const cursorRulesDir = path3.join(dir, ".cursor", "rules");
+  if (fs2.existsSync(cursorRulesDir)) {
     try {
-      const files = fs4.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc") && !MANAGED_CURSOR_RULES.has(f));
+      const files = fs2.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"));
       configs.cursorRules = files.map((f) => ({
         filename: f,
-        content: fs4.readFileSync(path4.join(cursorRulesDir, f), "utf-8")
+        content: fs2.readFileSync(path3.join(cursorRulesDir, f), "utf-8")
       }));
     } catch {
     }
   }
-  const cursorSkillsDir = path4.join(dir, ".cursor", "skills");
-  if (fs4.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path3.join(dir, ".cursor", "skills");
+  if (fs2.existsSync(cursorSkillsDir)) {
     try {
-      const slugs = fs4.readdirSync(cursorSkillsDir).filter((f) => {
-        return fs4.statSync(path4.join(cursorSkillsDir, f)).isDirectory() && !BUILTIN_SKILL_NAMES.has(f);
+      const slugs = fs2.readdirSync(cursorSkillsDir).filter((f) => {
+        return fs2.statSync(path3.join(cursorSkillsDir, f)).isDirectory();
       });
-      configs.cursorSkills = slugs.filter((slug) => fs4.existsSync(path4.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
+      configs.cursorSkills = slugs.filter((slug) => fs2.existsSync(path3.join(cursorSkillsDir, slug, "SKILL.md"))).map((name) => ({
         name,
         filename: "SKILL.md",
-        content: fs4.readFileSync(path4.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
+        content: fs2.readFileSync(path3.join(cursorSkillsDir, name, "SKILL.md"), "utf-8")
       }));
     } catch {
     }
   }
-  const mcpJsonPath = path4.join(dir, ".mcp.json");
-  if (fs4.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path3.join(dir, ".mcp.json");
+  if (fs2.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs4.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         configs.claudeMcpServers = mcpJson.mcpServers;
       }
     } catch {
     }
   }
-  const cursorMcpPath = path4.join(dir, ".cursor", "mcp.json");
-  if (fs4.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path3.join(dir, ".cursor", "mcp.json");
+  if (fs2.existsSync(cursorMcpPath)) {
     try {
-      const cursorMcpJson = JSON.parse(fs4.readFileSync(cursorMcpPath, "utf-8"));
+      const cursorMcpJson = JSON.parse(fs2.readFileSync(cursorMcpPath, "utf-8"));
       if (cursorMcpJson.mcpServers) {
         configs.cursorMcpServers = cursorMcpJson.mcpServers;
       }
     } catch {
     }
   }
-  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)) {
+  if (fs2.existsSync(PERSONAL_LEARNINGS_FILE)) {
     try {
-      const content = fs4.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
+      const content = fs2.readFileSync(PERSONAL_LEARNINGS_FILE, "utf-8");
       const bullets = content.split("\n").filter((l) => l.startsWith("- ")).join("\n");
       if (bullets) configs.personalLearnings = bullets;
     } catch {
@@ -1418,11 +1394,26 @@ function readExistingConfigs(dir) {
 }
 
 // src/fingerprint/code-analysis.ts
-import fs5 from "fs";
+import fs3 from "fs";
 import path5 from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 
 // src/lib/sanitize.ts
+import path4 from "path";
+function sanitizePath(component) {
+  const cleaned = component.replace(/\.\./g, "").replace(/[/\\]/g, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+  if (!cleaned) {
+    throw new Error(`Invalid path component: ${component}`);
+  }
+  return cleaned;
+}
+function assertPathWithinDir(filePath, baseDir) {
+  const resolved = path4.resolve(baseDir, filePath);
+  const resolvedBase = path4.resolve(baseDir);
+  if (!resolved.startsWith(resolvedBase + path4.sep) && resolved !== resolvedBase) {
+    throw new Error(`Path traversal detected: ${filePath} escapes ${baseDir}`);
+  }
+}
 var KNOWN_PREFIX_PATTERNS = [
   // Anthropic (before generic sk- pattern)
   [/sk-ant-[A-Za-z0-9_-]{20,}/g, "[REDACTED]"],
@@ -1446,9 +1437,13 @@ var KNOWN_PREFIX_PATTERNS = [
   // Bearer tokens
   [/[Bb]earer\s+[A-Za-z0-9_\-.]{20,}/g, "[REDACTED]"],
   // PEM private keys
-  [/-----BEGIN[A-Z ]+KEY-----[\s\S]+?-----END[A-Z ]+KEY-----/g, "[REDACTED]"]
+  [/-----BEGIN[A-Z ]+KEY-----[\s\S]+?-----END[A-Z ]+KEY-----/g, "[REDACTED]"],
+  // Database connection strings with credentials
+  [/(postgresql|mysql|mongodb(\+srv)?|redis|amqp):\/\/[^@\s]+:[^@\s]+@[^\s'"]+/g, "[REDACTED]"],
+  // GitLab tokens
+  [/glpat-[a-zA-Z0-9_-]{20,}/g, "[REDACTED]"]
 ];
-var SENSITIVE_ASSIGNMENT = /(?:api[_-]?key|secret[_-]?key|password|token|credential|auth[_-]?token|private[_-]?key)\s*[:=]\s*['"]?([^\s'"]{8,500})['"]?/gi;
+var SENSITIVE_ASSIGNMENT = /(?:api[_-]?key|secret[_-]?key|password|token|credential|auth[_-]?token|private[_-]?key|database[_-]?url|connection[_-]?string)\s*[:=]\s*['"]?([^\s'"]{8,500})['"]?/gi;
 function sanitizeSecrets(text) {
   let result = text;
   for (const [pattern, replacement] of KNOWN_PREFIX_PATTERNS) {
@@ -1567,12 +1562,15 @@ var SKIP_PATTERNS = [
   /\.d\.ts$/,
   /\.generated\./,
   /\.snap$/,
-  /^\.env($|\.)/
+  /^\.env($|\.)/,
+  /\.(pem|key|crt|cer|pfx|p12|jks|keystore)$/,
+  /^id_(rsa|ed25519|ecdsa)$/,
+  /^(known_hosts|authorized_keys)$/
 ];
 var COMMENT_LINE = {
-  "c": /^\s*\/\//,
-  "h": /^\s*#/,
-  "x": /^\s*<!--.*-->\s*$/
+  c: /^\s*\/\//,
+  h: /^\s*#/,
+  x: /^\s*<!--.*-->\s*$/
 };
 var EXT_COMMENT = {
   ".ts": "c",
@@ -1678,7 +1676,6 @@ function extractSkeleton(content, ext) {
   const lines = content.split("\n");
   const result = [];
   let braceDepth = 0;
-  let inSignature = false;
   let skipBody = false;
   if ([".py", ".pyw", ".rb"].includes(ext)) {
     return extractSkeletonIndentBased(lines, ext);
@@ -1704,7 +1701,9 @@ function extractSkeleton(content, ext) {
       }
       continue;
     }
-    const isFnOrClass = /^\s*(export\s+)?(default\s+)?(async\s+)?(function|class|const\s+\w+\s*=\s*(async\s*)?\(|pub\s+fn|fn|func)\s/.test(trimmed) || /^\s*(def|func|fn|pub fn|pub async fn)\s/.test(trimmed);
+    const isFnOrClass = /^\s*(export\s+)?(default\s+)?(async\s+)?(function|class|const\s+\w+\s*=\s*(async\s*)?\(|pub\s+fn|fn|func)\s/.test(
+      trimmed
+    ) || /^\s*(def|func|fn|pub fn|pub async fn)\s/.test(trimmed);
     if (isFnOrClass && braceDepth === 0) {
       result.push(line);
       const opens = (line.match(/{/g) || []).length;
@@ -1732,7 +1731,7 @@ function extractSkeleton(content, ext) {
   }
   return result.join("\n");
 }
-function extractSkeletonIndentBased(lines, ext) {
+function extractSkeletonIndentBased(lines, _ext) {
   const result = [];
   let skipIndent = -1;
   for (const line of lines) {
@@ -1792,7 +1791,16 @@ function buildImportCounts(files) {
     if (!SOURCE_EXTENSIONS.has(ext)) continue;
     const imports = extractImports(content, filePath);
     for (const imp of imports) {
-      const candidates = [imp, imp + ".ts", imp + ".js", imp + ".tsx", imp + ".jsx", imp + "/index.ts", imp + "/index.js", imp + ".py"];
+      const candidates = [
+        imp,
+        imp + ".ts",
+        imp + ".js",
+        imp + ".tsx",
+        imp + ".jsx",
+        imp + "/index.ts",
+        imp + "/index.js",
+        imp + ".py"
+      ];
       for (const candidate of candidates) {
         const normalized = candidate.replace(/\\/g, "/");
         if (files.has(normalized)) {
@@ -1807,7 +1815,7 @@ function buildImportCounts(files) {
 function getGitFrequency(dir) {
   const freq = /* @__PURE__ */ new Map();
   try {
-    const output = execSync4(
+    const output = execSync3(
       '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 }
     );
@@ -1834,7 +1842,9 @@ function structuralFingerprint(content, ext) {
   const bucket = Math.floor(lines.length / 10) * 10;
   const first = (lines[0] || "").trim().slice(0, 50);
   const imports = lines.filter((l) => /^\s*(import |from |require\(|use )/.test(l)).length;
-  const fns = lines.filter((l) => /^\s*(export\s+)?(async\s+)?(function |def |func |fn |pub fn |class )/.test(l)).length;
+  const fns = lines.filter(
+    (l) => /^\s*(export\s+)?(async\s+)?(function |def |func |fn |pub fn |class )/.test(l)
+  ).length;
   return `${ext}:${bucket}:${imports}:${fns}:${first}`;
 }
 function analyzeCode(dir) {
@@ -1843,14 +1853,14 @@ function analyzeCode(dir) {
   let totalChars = 0;
   for (const relPath of allPaths) {
     try {
-      totalChars += fs5.statSync(path5.join(dir, relPath)).size;
+      totalChars += fs3.statSync(path5.join(dir, relPath)).size;
     } catch {
     }
   }
   const fileContents = /* @__PURE__ */ new Map();
   for (const relPath of allPaths) {
     try {
-      const content = fs5.readFileSync(path5.join(dir, relPath), "utf-8");
+      const content = fs3.readFileSync(path5.join(dir, relPath), "utf-8");
       if (content.split("\n").length <= 500) fileContents.set(relPath, content);
     } catch {
     }
@@ -1881,7 +1891,12 @@ function analyzeCode(dir) {
     const repFP = structuralFingerprint(rep.compressed, rep.ext);
     const similar = group.slice(1).filter((f) => structuralFingerprint(f.compressed, f.ext) === repFP);
     const unique = group.slice(1).filter((f) => structuralFingerprint(f.compressed, f.ext) !== repFP);
-    const repEntry = { path: rep.path, content: sanitizeSecrets(rep.compressed), size: rep.compressed.length, priority: rep.score };
+    const repEntry = {
+      path: rep.path,
+      content: sanitizeSecrets(rep.compressed),
+      size: rep.compressed.length,
+      priority: rep.score
+    };
     const repSize = rep.path.length + rep.compressed.length + 10;
     if (includedChars + repSize <= CHAR_BUDGET) {
       result.push(repEntry);
@@ -1893,14 +1908,24 @@ function analyzeCode(dir) {
       const summary = `(${similar.length} similar file${similar.length === 1 ? "" : "s"} in ${dirPath}/: ${names.join(", ")})`;
       const summarySize = summary.length + 30;
       if (includedChars + summarySize <= CHAR_BUDGET) {
-        result.push({ path: `[similar to ${rep.path}]`, content: summary, size: summary.length, priority: rep.score });
+        result.push({
+          path: `[similar to ${rep.path}]`,
+          content: summary,
+          size: summary.length,
+          priority: rep.score
+        });
         includedChars += summarySize;
       }
     }
     for (const f of unique) {
       const skeletonSize = f.path.length + f.skeleton.length + 10;
       if (includedChars + skeletonSize <= CHAR_BUDGET) {
-        result.push({ path: f.path, content: sanitizeSecrets(f.skeleton), size: f.skeleton.length, priority: f.score });
+        result.push({
+          path: f.path,
+          content: sanitizeSecrets(f.skeleton),
+          size: f.skeleton.length,
+          priority: f.score
+        });
         includedChars += skeletonSize;
       }
     }
@@ -1910,7 +1935,12 @@ function analyzeCode(dir) {
     if (includedPaths.has(f.path)) continue;
     const skeletonSize = f.path.length + f.skeleton.length + 10;
     if (includedChars + skeletonSize > CHAR_BUDGET) continue;
-    result.push({ path: f.path, content: sanitizeSecrets(f.skeleton), size: f.skeleton.length, priority: f.score });
+    result.push({
+      path: f.path,
+      content: sanitizeSecrets(f.skeleton),
+      size: f.skeleton.length,
+      priority: f.score
+    });
     includedChars += skeletonSize;
   }
   return {
@@ -1929,7 +1959,7 @@ function walkDir(base, rel, depth, maxDepth, files) {
   const fullPath = path5.join(base, rel);
   let entries;
   try {
-    entries = fs5.readdirSync(fullPath, { withFileTypes: true });
+    entries = fs3.readdirSync(fullPath, { withFileTypes: true });
   } catch {
     return;
   }
@@ -2082,7 +2112,7 @@ var AnthropicProvider = class {
 };
 
 // src/llm/vertex.ts
-import fs7 from "fs";
+import fs5 from "fs";
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";
 import { GoogleAuth } from "google-auth-library";
 var VertexProvider = class {
@@ -2105,7 +2135,7 @@ var VertexProvider = class {
         }
       } else {
         try {
-          creds = JSON.parse(fs7.readFileSync(raw, "utf-8"));
+          creds = JSON.parse(fs5.readFileSync(raw, "utf-8"));
         } catch {
           throw new Error(`Cannot read credentials file: ${raw}`);
         }
@@ -2694,7 +2724,7 @@ function isClaudeCliAvailable() {
 
 // src/llm/utils.ts
 function extractJson(text) {
-  const startIdx = text.search(/[\[{]/);
+  const startIdx = text.search(/[[{]/);
   if (startIdx === -1) return null;
   let depth = 0;
   let inString = false;
@@ -3025,7 +3055,6 @@ var SKILL_FORMAT_RULES = `All skills follow the OpenSkills standard (agentskills
 
 Skill field requirements:
 - "name": kebab-case (lowercase letters, numbers, hyphens only). Becomes the directory name.
-- "name" MUST NOT be any of these reserved names (they are managed by Caliber automatically): "setup-caliber", "find-skills", "save-learning". Do NOT generate skills with these names.
 - "description": MUST include WHAT it does + WHEN to use it with specific trigger phrases. Example: "Manages database migrations. Use when user says 'run migration', 'create migration', 'db schema change', or modifies files in db/migrations/."
 - "content": markdown body only \u2014 do NOT include YAML frontmatter, it is generated from name+description.
 
@@ -3069,7 +3098,7 @@ PRIORITY WHEN CONSTRAINTS CONFLICT: Grounding and reference density matter more
 Note: Permissions, hooks, freshness tracking, and OpenSkills frontmatter are scored automatically by caliber \u2014 do not optimize for them.
 README.md is provided for context only \u2014 do NOT include a readmeMd field in your output.`;
 var OUTPUT_SIZE_CONSTRAINTS = `OUTPUT SIZE CONSTRAINTS \u2014 these are critical:
-- CLAUDE.md / AGENTS.md: MUST be under 400 lines for maximum score. Aim for 200-350 lines. Be thorough \u2014 commands, architecture overview, key conventions, data flow, and important patterns. Use bullet points and tables, not prose.
+- CLAUDE.md / AGENTS.md: MUST be under 150 lines for maximum score. Aim for 100-140 lines. Be concise \u2014 commands, architecture overview, and key conventions. Use bullet points and tables, not prose.
 
 Pack project references densely in architecture sections \u2014 use inline paths, not prose paragraphs:
 GOOD: **Entry**: \`src/bin.ts\` \u2192 \`src/cli.ts\` \xB7 **LLM** (\`src/llm/\`): \`anthropic.ts\` \xB7 \`vertex.ts\` \xB7 \`openai-compat.ts\`
@@ -3197,7 +3226,7 @@ Structure:
 5. "## Common Issues" (required) \u2014 specific error messages and their fixes. Not "check your config" but "If you see 'Connection refused on port 5432': 1. Verify postgres is running: docker ps | grep postgres 2. Check .env has correct DATABASE_URL"
 
 Rules:
-- Max 400 lines. Focus on actionable instructions, not documentation prose.
+- Max 150 lines. Focus on actionable instructions, not documentation prose.
 - Study existing code in the project context to extract the real patterns being used. A skill for "create API route" should show the exact file structure, imports, error handling, and naming that existing routes use.
 - Be specific and actionable. GOOD: "Run \`pnpm test -- --filter=api\` to verify". BAD: "Validate the data before proceeding."
 - Never use ambiguous language. Instead of "handle errors properly", write "Wrap the DB call in try/catch. On failure, return { error: string, code: number } matching the ErrorResponse type in \`src/types.ts\`."
@@ -3251,7 +3280,7 @@ Rules:
 - Update the "fileDescriptions" to reflect any changes you make.
 
 Quality constraints \u2014 your changes are scored, so do not break these:
-- CLAUDE.md / AGENTS.md: MUST stay under 400 lines. If adding content, remove less important lines to stay within budget. Do not refuse the user's request \u2014 make the change and trim elsewhere.
+- CLAUDE.md / AGENTS.md: MUST stay under 150 lines. If adding content, remove less important lines to stay within budget. Do not refuse the user's request \u2014 make the change and trim elsewhere.
 - Avoid vague instructions ("follow best practices", "write clean code", "ensure quality").
 - Do NOT add directory tree listings in code blocks.
 - Do NOT remove existing code blocks \u2014 they contribute to the executable content score.
@@ -3274,30 +3303,23 @@ 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.
+- CLAUDE.md / AGENTS.md: MUST stay under 150 lines. If the diff adds content, trim the least important lines elsewhere.
 - Keep 3+ code blocks with executable commands \u2014 do not remove code blocks
 - Every file path, command, and identifier must be in backticks
 - ONLY reference file paths that exist in the provided file tree \u2014 do NOT invent paths
 - Preserve the existing structure (headings, bullet style, formatting)
 
 Managed content:
-- 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
+- Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
 - Do NOT modify CALIBER_LEARNINGS.md \u2014 it is managed separately
-- Preserve any references to CALIBER_LEARNINGS.md
+- Preserve any references to CALIBER_LEARNINGS.md in CLAUDE.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,
@@ -3305,12 +3327,9 @@ Return a JSON object with this exact shape:
     "copilotInstructionFiles": [{"filename": "name.instructions.md", "content": "..."}] or null
   },
   "changesSummary": "<1-2 sentence summary of what was updated and why>",
-  "fileChanges": [{"file": "CLAUDE.md", "description": "added new API routes, updated build commands"}],
   "docsUpdated": ["CLAUDE.md", "README.md"]
 }
 
-The "fileChanges" array MUST include one entry per file that was updated (non-null in updatedDocs). Each entry describes what specifically changed in that file \u2014 be concrete (e.g. "added auth middleware section" not "updated docs").
-
 Respond with ONLY the JSON object, no markdown fences or extra text.`;
 var LEARN_SYSTEM_PROMPT = `You are an expert developer experience engineer. You analyze raw tool call events from AI coding sessions to extract reusable operational lessons that will help future LLM sessions work more effectively in this project.
 
@@ -3459,7 +3478,7 @@ async function detectProjectStack(fileTree, suffixCounts) {
 init_config();
 
 // src/fingerprint/cache.ts
-import fs8 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 import crypto from "crypto";
 import { execSync as execSync7 } from "child_process";
@@ -3504,8 +3523,8 @@ function computeTreeSignature(fileTree, dir) {
 function loadFingerprintCache(dir, fileTree) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs8.existsSync(cachePath)) return null;
-    const raw = fs8.readFileSync(cachePath, "utf-8");
+    if (!fs7.existsSync(cachePath)) return null;
+    const raw = fs7.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     if (cache.version !== CACHE_VERSION) return null;
     const currentHead = getGitHead(dir);
@@ -3527,8 +3546,8 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
   const cachePath = getCachePath(dir);
   try {
     const cacheDir = path7.dirname(cachePath);
-    if (!fs8.existsSync(cacheDir)) {
-      fs8.mkdirSync(cacheDir, { recursive: true });
+    if (!fs7.existsSync(cacheDir)) {
+      fs7.mkdirSync(cacheDir, { recursive: true });
     }
     const cache = {
       version: CACHE_VERSION,
@@ -3540,15 +3559,15 @@ function saveFingerprintCache(dir, fileTree, codeAnalysis, languages, frameworks
       tools,
       workspaces
     };
-    fs8.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
+    fs7.writeFileSync(cachePath, JSON.stringify(cache), "utf-8");
   } catch {
   }
 }
 function getDetectedWorkspaces(dir) {
   const cachePath = getCachePath(dir);
   try {
-    if (!fs8.existsSync(cachePath)) return [];
-    const raw = fs8.readFileSync(cachePath, "utf-8");
+    if (!fs7.existsSync(cachePath)) return [];
+    const raw = fs7.readFileSync(cachePath, "utf-8");
     const cache = JSON.parse(raw);
     return cache.workspaces ?? [];
   } catch {
@@ -3601,8 +3620,8 @@ async function collectFingerprint(dir) {
 function readPackageName(dir) {
   try {
     const pkgPath = path8.join(dir, "package.json");
-    if (!fs9.existsSync(pkgPath)) return void 0;
-    const pkg3 = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+    if (!fs8.existsSync(pkgPath)) return void 0;
+    const pkg3 = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     return pkg3.name;
   } catch {
     return void 0;
@@ -3632,22 +3651,22 @@ async function enrichWithLLM(fingerprint) {
 }
 
 // src/scanner/index.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import path9 from "path";
 import crypto2 from "crypto";
 import os4 from "os";
 function detectPlatforms() {
   const home = os4.homedir();
   return {
-    claude: fs10.existsSync(path9.join(home, ".claude")),
-    cursor: fs10.existsSync(getCursorConfigDir()),
-    codex: fs10.existsSync(path9.join(home, ".codex"))
+    claude: fs9.existsSync(path9.join(home, ".claude")),
+    cursor: fs9.existsSync(getCursorConfigDir()),
+    codex: fs9.existsSync(path9.join(home, ".codex"))
   };
 }
 function scanLocalState(dir) {
   const items = [];
   const claudeMdPath = path9.join(dir, "CLAUDE.md");
-  if (fs10.existsSync(claudeMdPath)) {
+  if (fs9.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -3657,8 +3676,8 @@ function scanLocalState(dir) {
     });
   }
   const skillsDir = path9.join(dir, ".claude", "skills");
-  if (fs10.existsSync(skillsDir)) {
-    for (const file of fs10.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+  if (fs9.existsSync(skillsDir)) {
+    for (const file of fs9.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
       const filePath = path9.join(skillsDir, file);
       items.push({
         type: "skill",
@@ -3670,9 +3689,9 @@ function scanLocalState(dir) {
     }
   }
   const mcpJsonPath = path9.join(dir, ".mcp.json");
-  if (fs10.existsSync(mcpJsonPath)) {
+  if (fs9.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs10.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3689,7 +3708,7 @@ function scanLocalState(dir) {
     }
   }
   const agentsMdPath = path9.join(dir, "AGENTS.md");
-  if (fs10.existsSync(agentsMdPath)) {
+  if (fs9.existsSync(agentsMdPath)) {
     items.push({
       type: "rule",
       platform: "codex",
@@ -3699,11 +3718,11 @@ function scanLocalState(dir) {
     });
   }
   const codexSkillsDir = path9.join(dir, ".agents", "skills");
-  if (fs10.existsSync(codexSkillsDir)) {
+  if (fs9.existsSync(codexSkillsDir)) {
     try {
-      for (const name of fs10.readdirSync(codexSkillsDir)) {
+      for (const name of fs9.readdirSync(codexSkillsDir)) {
         const skillFile = path9.join(codexSkillsDir, name, "SKILL.md");
-        if (fs10.existsSync(skillFile)) {
+        if (fs9.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "codex",
@@ -3718,7 +3737,7 @@ function scanLocalState(dir) {
     }
   }
   const cursorrulesPath = path9.join(dir, ".cursorrules");
-  if (fs10.existsSync(cursorrulesPath)) {
+  if (fs9.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -3728,8 +3747,8 @@ function scanLocalState(dir) {
     });
   }
   const cursorRulesDir = path9.join(dir, ".cursor", "rules");
-  if (fs10.existsSync(cursorRulesDir)) {
-    for (const file of fs10.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+  if (fs9.existsSync(cursorRulesDir)) {
+    for (const file of fs9.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
       const filePath = path9.join(cursorRulesDir, file);
       items.push({
         type: "rule",
@@ -3741,11 +3760,11 @@ function scanLocalState(dir) {
     }
   }
   const cursorSkillsDir = path9.join(dir, ".cursor", "skills");
-  if (fs10.existsSync(cursorSkillsDir)) {
+  if (fs9.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs10.readdirSync(cursorSkillsDir)) {
+      for (const name of fs9.readdirSync(cursorSkillsDir)) {
         const skillFile = path9.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs10.existsSync(skillFile)) {
+        if (fs9.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -3760,9 +3779,9 @@ function scanLocalState(dir) {
     }
   }
   const cursorMcpPath = path9.join(dir, ".cursor", "mcp.json");
-  if (fs10.existsSync(cursorMcpPath)) {
+  if (fs9.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs10.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs9.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -3781,7 +3800,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs10.readFileSync(filePath, "utf-8");
+  const text = fs9.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -3804,7 +3823,7 @@ function getCursorConfigDir() {
 
 // src/lib/hooks.ts
 init_resolve_caliber();
-import fs11 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 import { execSync as execSync8 } from "child_process";
 var SETTINGS_PATH = path10.join(".claude", "settings.json");
@@ -3814,17 +3833,17 @@ function getHookCommand() {
   return `${resolveCaliber()} ${REFRESH_TAIL}`;
 }
 function readSettings() {
-  if (!fs11.existsSync(SETTINGS_PATH)) return {};
+  if (!fs10.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs11.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs10.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
   const dir = path10.dirname(SETTINGS_PATH);
-  if (!fs11.existsSync(dir)) fs11.mkdirSync(dir, { recursive: true });
-  fs11.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  if (!fs10.existsSync(dir)) fs10.mkdirSync(dir, { recursive: true });
+  fs10.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -3883,7 +3902,7 @@ 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/ .cursorrules .github/copilot-instructions.md .github/instructions/ AGENTS.md CALIBER_LEARNINGS.md 2>/dev/null | xargs git add 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}`;
 }
@@ -3901,8 +3920,8 @@ function getPreCommitPath() {
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs11.existsSync(hookPath)) return false;
-  const content = fs11.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs10.existsSync(hookPath)) return false;
+  const content = fs10.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -3912,40 +3931,40 @@ function installPreCommitHook() {
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
   const hooksDir = path10.dirname(hookPath);
-  if (!fs11.existsSync(hooksDir)) fs11.mkdirSync(hooksDir, { recursive: true });
+  if (!fs10.existsSync(hooksDir)) fs10.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs11.existsSync(hookPath)) {
-    content = fs11.readFileSync(hookPath, "utf-8");
+  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";
   }
-  fs11.writeFileSync(hookPath, content);
-  fs11.chmodSync(hookPath, 493);
+  fs10.writeFileSync(hookPath, content);
+  fs10.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs11.existsSync(hookPath)) {
+  if (!hookPath || !fs10.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs11.readFileSync(hookPath, "utf-8");
+  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() === "") {
-    fs11.unlinkSync(hookPath);
+    fs10.unlinkSync(hookPath);
   } else {
-    fs11.writeFileSync(hookPath, content);
+    fs10.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/fingerprint/sources.ts
-import fs12 from "fs";
+import fs11 from "fs";
 import path11 from "path";
 
 // src/scoring/utils.ts
@@ -4013,12 +4032,14 @@ function isGitRepo2(dir) {
 function checkGitIgnored(dir, paths) {
   if (paths.length === 0) return /* @__PURE__ */ new Set();
   try {
-    const result = execFileSync(
-      "git",
-      ["check-ignore", ...paths],
-      { cwd: dir, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    const result = execFileSync("git", ["check-ignore", ...paths], {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return new Set(
+      result.split("\n").map((l) => l.trim()).filter(Boolean)
     );
-    return new Set(result.split("\n").map((l) => l.trim()).filter(Boolean));
   } catch (err) {
     if (err && typeof err === "object" && "status" in err && err.status === 1) {
       return /* @__PURE__ */ new Set();
@@ -4042,7 +4063,10 @@ function collectProjectStructure(dir, maxDepth = 2) {
         if (name.startsWith(".") && IGNORED_DIRS.has(name)) continue;
         dirEntries.push({ name, rel: relative(dir, join(currentDir, name)) });
       }
-      const gitIgnored = useGit ? checkGitIgnored(dir, dirEntries.map((d) => d.rel)) : null;
+      const gitIgnored = useGit ? checkGitIgnored(
+        dir,
+        dirEntries.map((d) => d.rel)
+      ) : null;
       for (const entry of entries) {
         const name = entry.name;
         if (name.startsWith(".") && IGNORED_DIRS.has(name)) continue;
@@ -4225,7 +4249,9 @@ function countTreeLines(content) {
   return count;
 }
 function calculateDuplicatePercent(content1, content2) {
-  const lines1 = new Set(content1.split("\n").map((l) => l.trim()).filter((l) => l.length > 10));
+  const lines1 = new Set(
+    content1.split("\n").map((l) => l.trim()).filter((l) => l.length > 10)
+  );
   const lines2 = content2.split("\n").map((l) => l.trim()).filter((l) => l.length > 10);
   const overlapping = lines2.filter((l) => lines1.has(l)).length;
   return lines2.length > 0 ? Math.round(overlapping / lines2.length * 100) : 0;
@@ -4244,7 +4270,9 @@ function isEntryMentioned(entry, contentLower) {
   if (lastSegment && lastSegment.length > 3) variants.push(lastSegment);
   return variants.some((v) => {
     const escaped = v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`(?:^|[\\s\`/"'\\.,(])${escaped}(?:[\\s\`/"'.,;:!?)\\\\]|$)`, "i").test(contentLower);
+    return new RegExp(`(?:^|[\\s\`/"'\\.,(])${escaped}(?:[\\s\`/"'.,;:!?)\\\\]|$)`, "i").test(
+      contentLower
+    );
   });
 }
 function classifyLine(line, inCodeBlock) {
@@ -4255,7 +4283,8 @@ function classifyLine(line, inCodeBlock) {
   if (/`[^`]+`/.test(trimmed)) return "concrete";
   if (/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+\.[a-zA-Z]{1,5}/.test(trimmed)) return "concrete";
   if (/[a-zA-Z0-9_]{4,}\/[a-zA-Z0-9_.-]/.test(trimmed)) return "concrete";
-  if (/\b[a-zA-Z0-9_-]+\.[a-zA-Z]{1,5}\b/.test(trimmed) && !/\b(e\.g|i\.e|vs|etc)\b/i.test(trimmed)) return "concrete";
+  if (/\b[a-zA-Z0-9_-]+\.[a-zA-Z]{1,5}\b/.test(trimmed) && !/\b(e\.g|i\.e|vs|etc)\b/i.test(trimmed))
+    return "concrete";
   return "abstract";
 }
 
@@ -4271,12 +4300,12 @@ function loadSourcesConfig(dir) {
   try {
     const parsed = JSON.parse(content);
     if (!Array.isArray(parsed.sources)) {
-      console.warn("Warning: .caliber/sources.json is malformed (missing sources array), skipping sources");
+      console.warn(
+        "Warning: .caliber/sources.json is malformed (missing sources array), skipping sources"
+      );
       return [];
     }
-    return parsed.sources.filter(
-      (s) => s.type && (s.path || s.url)
-    );
+    return parsed.sources.filter((s) => s.type && (s.path || s.url));
   } catch {
     console.warn("Warning: .caliber/sources.json is malformed, skipping sources");
     return [];
@@ -4284,15 +4313,15 @@ function loadSourcesConfig(dir) {
 }
 function writeSourcesConfig(dir, sources2) {
   const configDir = path11.join(dir, ".caliber");
-  if (!fs12.existsSync(configDir)) {
-    fs12.mkdirSync(configDir, { recursive: true });
+  if (!fs11.existsSync(configDir)) {
+    fs11.mkdirSync(configDir, { recursive: true });
   }
   const configPath = path11.join(configDir, "sources.json");
-  fs12.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
+  fs11.writeFileSync(configPath, JSON.stringify({ sources: sources2 }, null, 2) + "\n", "utf-8");
 }
 function detectSourceType(absPath) {
   try {
-    return fs12.statSync(absPath).isDirectory() ? "repo" : "file";
+    return fs11.statSync(absPath).isDirectory() ? "repo" : "file";
   } catch {
     return "file";
   }
@@ -4336,7 +4365,7 @@ function resolveAllSources(dir, cliSources, workspaces) {
   for (const [absPath, resolved] of seen) {
     let stat;
     try {
-      stat = fs12.statSync(absPath);
+      stat = fs11.statSync(absPath);
     } catch {
       console.warn(`Source ${resolved.config.path || absPath} not found, skipping`);
       continue;
@@ -4385,13 +4414,13 @@ function collectSourceSummary(resolved, projectDir) {
   }
   return collectRepoSummary(resolved, projectDir);
 }
-function collectRepoSummary(resolved, projectDir) {
+function collectRepoSummary(resolved, _projectDir) {
   const { config, origin, absPath } = resolved;
   const packageName = readPackageName(absPath);
   let topLevelDirs;
   let keyFiles;
   try {
-    const entries = fs12.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 {
@@ -4415,7 +4444,7 @@ function collectRepoSummary(resolved, projectDir) {
     packageName
   };
 }
-function collectFileSummary(resolved, projectDir) {
+function collectFileSummary(resolved, _projectDir) {
   const { config, origin, absPath } = resolved;
   const content = readFileOrNull(absPath);
   return {
@@ -4463,15 +4492,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);
@@ -4513,18 +4542,24 @@ function extractNpmDeps(dir) {
     /^prettier-/,
     /^@typescript-eslint\//
   ];
-  return Object.keys(deps).filter((d) => !trivial.has(d) && !d.startsWith("@types/") && !trivialPatterns.some((p) => p.test(d))).slice(0, 30);
+  return Object.keys(deps).filter(
+    (d) => !trivial.has(d) && !d.startsWith("@types/") && !trivialPatterns.some((p) => p.test(d))
+  ).slice(0, 30);
 }
 function extractPythonDeps(dir) {
   const reqTxt = readFileOrNull2(join2(dir, "requirements.txt"));
   if (reqTxt) {
-    return reqTxt.split("\n").map((l) => l.trim().split(/[=<>!~\[]/)[0].trim()).filter((l) => l && !l.startsWith("#")).slice(0, 30);
+    return reqTxt.split("\n").map(
+      (l) => l.trim().split(/[=<>!~[]/)[0].trim()
+    ).filter((l) => l && !l.startsWith("#")).slice(0, 30);
   }
   const pyproject = readFileOrNull2(join2(dir, "pyproject.toml"));
   if (pyproject) {
     const depMatch = pyproject.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
     if (depMatch) {
-      return depMatch[1].split("\n").map((l) => l.trim().replace(/["',]/g, "").split(/[=<>!~\[]/)[0].trim()).filter((l) => l.length > 0).slice(0, 30);
+      return depMatch[1].split("\n").map(
+        (l) => l.trim().replace(/["',]/g, "").split(/[=<>!~[]/)[0].trim()
+      ).filter((l) => l.length > 0).slice(0, 30);
     }
   }
   return [];
@@ -5062,16 +5097,16 @@ import fs19 from "fs";
 
 // src/writers/claude/index.ts
 init_pre_commit_block();
-import fs13 from "fs";
+import fs12 from "fs";
 import path12 from "path";
 function writeClaudeConfig(config) {
   const written = [];
-  fs13.writeFileSync("CLAUDE.md", appendManagedBlocks(config.claudeMd, "claude"));
+  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(".claude", "skills", skill.name);
-      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
+      if (!fs12.existsSync(skillDir)) fs12.mkdirSync(skillDir, { recursive: true });
       const skillPath = path12.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -5080,21 +5115,21 @@ function writeClaudeConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs13.writeFileSync(skillPath, frontmatter + skill.content);
+      fs12.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     let existingServers = {};
     try {
-      if (fs13.existsSync(".mcp.json")) {
-        const existing = JSON.parse(fs13.readFileSync(".mcp.json", "utf-8"));
+      if (fs12.existsSync(".mcp.json")) {
+        const existing = JSON.parse(fs12.readFileSync(".mcp.json", "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs13.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs12.writeFileSync(".mcp.json", JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(".mcp.json");
   }
   return written;
@@ -5102,30 +5137,28 @@ function writeClaudeConfig(config) {
 
 // src/writers/cursor/index.ts
 init_pre_commit_block();
-import fs14 from "fs";
+import fs13 from "fs";
 import path13 from "path";
 function writeCursorConfig(config) {
   const written = [];
   if (config.cursorrules) {
-    fs14.writeFileSync(".cursorrules", config.cursorrules);
+    fs13.writeFileSync(".cursorrules", config.cursorrules);
     written.push(".cursorrules");
   }
   const preCommitRule = getCursorPreCommitRule();
   const learningsRule = getCursorLearningsRule();
-  const syncRule = getCursorSyncRule();
-  const setupRule = getCursorSetupRule();
-  const allRules = [...config.rules || [], preCommitRule, learningsRule, syncRule, setupRule];
+  const allRules = [...config.rules || [], preCommitRule, learningsRule];
   const rulesDir = path13.join(".cursor", "rules");
-  if (!fs14.existsSync(rulesDir)) fs14.mkdirSync(rulesDir, { recursive: true });
+  if (!fs13.existsSync(rulesDir)) fs13.mkdirSync(rulesDir, { recursive: true });
   for (const rule of allRules) {
     const rulePath = path13.join(rulesDir, rule.filename);
-    fs14.writeFileSync(rulePath, rule.content);
+    fs13.writeFileSync(rulePath, rule.content);
     written.push(rulePath);
   }
   if (config.skills?.length) {
     for (const skill of config.skills) {
       const skillDir = path13.join(".cursor", "skills", skill.name);
-      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
+      if (!fs13.existsSync(skillDir)) fs13.mkdirSync(skillDir, { recursive: true });
       const skillPath = path13.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -5134,24 +5167,24 @@ function writeCursorConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs14.writeFileSync(skillPath, frontmatter + skill.content);
+      fs13.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
   if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
     const cursorDir = ".cursor";
-    if (!fs14.existsSync(cursorDir)) fs14.mkdirSync(cursorDir, { recursive: true });
+    if (!fs13.existsSync(cursorDir)) fs13.mkdirSync(cursorDir, { recursive: true });
     const mcpPath = path13.join(cursorDir, "mcp.json");
     let existingServers = {};
     try {
-      if (fs14.existsSync(mcpPath)) {
-        const existing = JSON.parse(fs14.readFileSync(mcpPath, "utf-8"));
+      if (fs13.existsSync(mcpPath)) {
+        const existing = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
         if (existing.mcpServers) existingServers = existing.mcpServers;
       }
     } catch {
     }
     const mergedServers = { ...existingServers, ...config.mcpServers };
-    fs14.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
+    fs13.writeFileSync(mcpPath, JSON.stringify({ mcpServers: mergedServers }, null, 2));
     written.push(mcpPath);
   }
   return written;
@@ -5159,16 +5192,16 @@ function writeCursorConfig(config) {
 
 // src/writers/codex/index.ts
 init_pre_commit_block();
-import fs15 from "fs";
+import fs14 from "fs";
 import path14 from "path";
 function writeCodexConfig(config) {
   const written = [];
-  fs15.writeFileSync("AGENTS.md", appendManagedBlocks(config.agentsMd, "codex"));
+  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 (!fs15.existsSync(skillDir)) fs15.mkdirSync(skillDir, { recursive: true });
+      if (!fs14.existsSync(skillDir)) fs14.mkdirSync(skillDir, { recursive: true });
       const skillPath = path14.join(skillDir, "SKILL.md");
       const frontmatter = [
         "---",
@@ -5177,7 +5210,7 @@ function writeCodexConfig(config) {
         "---",
         ""
       ].join("\n");
-      fs15.writeFileSync(skillPath, frontmatter + skill.content);
+      fs14.writeFileSync(skillPath, frontmatter + skill.content);
       written.push(skillPath);
     }
   }
@@ -5186,20 +5219,20 @@ function writeCodexConfig(config) {
 
 // src/writers/github-copilot/index.ts
 init_pre_commit_block();
-import fs16 from "fs";
+import fs15 from "fs";
 import path15 from "path";
 function writeGithubCopilotConfig(config) {
   const written = [];
   if (config.instructions) {
-    fs16.mkdirSync(".github", { recursive: true });
-    fs16.writeFileSync(path15.join(".github", "copilot-instructions.md"), appendManagedBlocks(config.instructions, "copilot"));
+    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");
-    fs16.mkdirSync(instructionsDir, { recursive: true });
+    fs15.mkdirSync(instructionsDir, { recursive: true });
     for (const file of config.instructionFiles) {
-      fs16.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
+      fs15.writeFileSync(path15.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -5207,30 +5240,30 @@ function writeGithubCopilotConfig(config) {
 }
 
 // src/writers/backup.ts
-import fs17 from "fs";
+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 (!fs17.existsSync(file)) continue;
+    if (!fs16.existsSync(file)) continue;
     const dest = path16.join(backupDir, file);
     const destDir = path16.dirname(dest);
-    if (!fs17.existsSync(destDir)) {
-      fs17.mkdirSync(destDir, { recursive: true });
+    if (!fs16.existsSync(destDir)) {
+      fs16.mkdirSync(destDir, { recursive: true });
     }
-    fs17.copyFileSync(file, dest);
+    fs16.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
   const backupFile = path16.join(backupDir, file);
-  if (!fs17.existsSync(backupFile)) return false;
+  if (!fs16.existsSync(backupFile)) return false;
   const destDir = path16.dirname(file);
-  if (!fs17.existsSync(destDir)) {
-    fs17.mkdirSync(destDir, { recursive: true });
+  if (!fs16.existsSync(destDir)) {
+    fs16.mkdirSync(destDir, { recursive: true });
   }
-  fs17.copyFileSync(backupFile, file);
+  fs16.copyFileSync(backupFile, file);
   return true;
 }
 
@@ -5263,10 +5296,7 @@ function fileChecksum(filePath) {
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
   const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs19.existsSync(f));
-  const existingFiles = [
-    ...filesToWrite.filter((f) => fs19.existsSync(f)),
-    ...filesToDelete
-  ];
+  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) {
@@ -5359,7 +5389,8 @@ function getFilesToWrite(setup) {
   if (setup.targetAgent.includes("github-copilot") && setup.copilot) {
     if (setup.copilot.instructions) files.push(".github/copilot-instructions.md");
     if (setup.copilot.instructionFiles) {
-      for (const f of setup.copilot.instructionFiles) files.push(`.github/instructions/${f.filename}`);
+      for (const f of setup.copilot.instructionFiles)
+        files.push(`.github/instructions/${f.filename}`);
     }
   }
   return files;
@@ -5378,10 +5409,10 @@ function ensureGitignore() {
 
 // src/writers/staging.ts
 import fs20 from "fs";
-import path17 from "path";
-var STAGED_DIR = path17.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path17.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path17.join(STAGED_DIR, "current");
+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();
 }
@@ -5391,22 +5422,29 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path17.join(projectDir, file.path);
+    assertPathWithinDir(file.path, projectDir);
+    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);
-    fs20.mkdirSync(path17.dirname(proposedPath), { recursive: true });
+    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 = path17.join(CURRENT_DIR, file.path);
-      fs20.mkdirSync(path17.dirname(currentPath), { recursive: true });
+      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, proposedPath, currentPath, originalPath, isNew: false });
+      stagedFiles.push({
+        relativePath: file.path,
+        proposedPath,
+        currentPath,
+        originalPath,
+        isNew: false
+      });
     } else {
       newFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, isNew: true });
@@ -5433,11 +5471,17 @@ function collectSetupFiles(setup, targetAgent) {
     const skills = claude.skills;
     if (Array.isArray(skills)) {
       for (const skill of skills) {
-        files.push({ path: `.claude/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
+        files.push({
+          path: `.claude/skills/${sanitizePath(skill.name)}/SKILL.md`,
+          content: buildSkillContent(skill)
+        });
       }
     }
     for (const builtin of BUILTIN_SKILLS) {
-      files.push({ path: `.claude/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+      files.push({
+        path: `.claude/skills/${builtin.name}/SKILL.md`,
+        content: buildSkillContent(builtin)
+      });
     }
   }
   if (codex) {
@@ -5445,38 +5489,58 @@ function collectSetupFiles(setup, targetAgent) {
     const codexSkills = codex.skills;
     if (Array.isArray(codexSkills)) {
       for (const skill of codexSkills) {
-        files.push({ path: `.agents/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
+        files.push({
+          path: `.agents/skills/${sanitizePath(skill.name)}/SKILL.md`,
+          content: buildSkillContent(skill)
+        });
       }
     }
     for (const builtin of BUILTIN_SKILLS) {
-      files.push({ path: `.agents/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+      files.push({
+        path: `.agents/skills/${builtin.name}/SKILL.md`,
+        content: buildSkillContent(builtin)
+      });
     }
   }
   if (cursor) {
-    if (cursor.cursorrules) files.push({ path: ".cursorrules", content: cursor.cursorrules });
+    if (cursor.cursorrules)
+      files.push({ path: ".cursorrules", content: cursor.cursorrules });
     const cursorSkills = cursor.skills;
     if (Array.isArray(cursorSkills)) {
       for (const skill of cursorSkills) {
-        files.push({ path: `.cursor/skills/${skill.name}/SKILL.md`, content: buildSkillContent(skill) });
+        files.push({
+          path: `.cursor/skills/${sanitizePath(skill.name)}/SKILL.md`,
+          content: buildSkillContent(skill)
+        });
       }
     }
     for (const builtin of BUILTIN_SKILLS) {
-      files.push({ path: `.cursor/skills/${builtin.name}/SKILL.md`, content: buildSkillContent(builtin) });
+      files.push({
+        path: `.cursor/skills/${builtin.name}/SKILL.md`,
+        content: buildSkillContent(builtin)
+      });
     }
     const rules = cursor.rules;
     if (Array.isArray(rules)) {
       for (const rule of rules) {
-        files.push({ path: `.cursor/rules/${rule.filename}`, content: rule.content });
+        files.push({ path: `.cursor/rules/${sanitizePath(rule.filename)}`, content: rule.content });
       }
     }
   }
   const copilot = setup.copilot;
   if (copilot) {
-    if (copilot.instructions) files.push({ path: ".github/copilot-instructions.md", content: copilot.instructions });
+    if (copilot.instructions)
+      files.push({
+        path: ".github/copilot-instructions.md",
+        content: copilot.instructions
+      });
     const instructionFiles = copilot.instructionFiles;
     if (Array.isArray(instructionFiles)) {
       for (const file of instructionFiles) {
-        files.push({ path: `.github/instructions/${file.filename}`, content: file.content });
+        files.push({
+          path: `.github/instructions/${sanitizePath(file.filename)}`,
+          content: file.content
+        });
       }
     }
   }
@@ -5485,7 +5549,8 @@ function collectSetupFiles(setup, targetAgent) {
     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).
@@ -5500,8 +5565,8 @@ ${agentRefs.join(" ")}
 // src/lib/learning-hooks.ts
 init_resolve_caliber();
 import fs22 from "fs";
-import path18 from "path";
-var SETTINGS_PATH2 = path18.join(".claude", "settings.json");
+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" },
@@ -5526,7 +5591,7 @@ function readSettings2() {
   }
 }
 function writeSettings2(settings) {
-  const dir = path18.dirname(SETTINGS_PATH2);
+  const dir = path19.dirname(SETTINGS_PATH2);
   if (!fs22.existsSync(dir)) fs22.mkdirSync(dir, { recursive: true });
   fs22.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
@@ -5562,7 +5627,7 @@ function installLearningHooks() {
   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" },
@@ -5578,7 +5643,7 @@ function readCursorHooks() {
   }
 }
 function writeCursorHooks(config) {
-  const dir = path18.dirname(CURSOR_HOOKS_PATH);
+  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));
 }
@@ -5653,9 +5718,9 @@ init_resolve_caliber();
 
 // src/lib/state.ts
 import fs23 from "fs";
-import path19 from "path";
+import path20 from "path";
 import { execSync as execSync9 } from "child_process";
-var STATE_FILE = path19.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path20.join(CALIBER_DIR, ".caliber-state.json");
 function normalizeTargetAgent(value) {
   if (Array.isArray(value)) return value;
   if (typeof value === "string") {
@@ -5832,11 +5897,11 @@ var POINTS_LEARNED_CONTENT = 2;
 var POINTS_SOURCES_CONFIGURED = 3;
 var POINTS_SOURCES_REFERENCED = 3;
 var TOKEN_BUDGET_THRESHOLDS = [
-  { maxTokens: 5e3, points: 6 },
-  { maxTokens: 8e3, points: 5 },
-  { maxTokens: 12e3, points: 4 },
-  { maxTokens: 16e3, points: 2 },
-  { maxTokens: 24e3, points: 1 }
+  { maxTokens: 2e3, points: 6 },
+  { maxTokens: 3500, points: 5 },
+  { maxTokens: 5e3, points: 4 },
+  { maxTokens: 8e3, points: 2 },
+  { maxTokens: 12e3, points: 1 }
 ];
 var CODE_BLOCK_THRESHOLDS = [
   { minBlocks: 3, points: 8 },
@@ -5866,8 +5931,8 @@ var SECRET_PATTERNS = [
   /AKIA[A-Z0-9]{16}/,
   /ghp_[a-zA-Z0-9]{36}/,
   /ghu_[a-zA-Z0-9]{36}/,
-  /glpat-[a-zA-Z0-9\-_]{20,}/,
-  /xox[bpors]-[a-zA-Z0-9\-]{10,}/,
+  /glpat-[a-zA-Z0-9_-]{20,}/,
+  /xox[bpors]-[a-zA-Z0-9-]{10,}/,
   /(?:password|secret|token|api_key)\s*[:=]\s*["'][^"']{8,}["']/i
 ];
 var SECRET_PLACEHOLDER_PATTERNS = [
@@ -5879,31 +5944,13 @@ var SECRET_PLACEHOLDER_PATTERNS = [
   /CHANGE[_-]?ME/i,
   /<[^>]+>/
 ];
-var CURSOR_ONLY_CHECKS = /* @__PURE__ */ new Set([
-  "cursor_rules_exist",
-  "cursor_mdc_rules"
-]);
-var CLAUDE_ONLY_CHECKS = /* @__PURE__ */ new Set([
-  "claude_md_exists",
-  "claude_md_freshness"
-]);
-var BOTH_ONLY_CHECKS = /* @__PURE__ */ new Set([
-  "cross_platform_parity",
-  "no_duplicate_content"
-]);
-var CODEX_ONLY_CHECKS = /* @__PURE__ */ new Set([
-  "codex_agents_md_exists"
-]);
-var COPILOT_ONLY_CHECKS = /* @__PURE__ */ new Set([
-  "copilot_instructions_exists"
-]);
-var NON_CODEX_CHECKS = /* @__PURE__ */ new Set([
-  "agents_md_exists"
-]);
-var CLAUDE_OR_CODEX_CHECKS = /* @__PURE__ */ new Set([
-  "skills_exist",
-  "open_skills_format"
-]);
+var CURSOR_ONLY_CHECKS = /* @__PURE__ */ new Set(["cursor_rules_exist", "cursor_mdc_rules"]);
+var CLAUDE_ONLY_CHECKS = /* @__PURE__ */ new Set(["claude_md_exists", "claude_md_freshness"]);
+var BOTH_ONLY_CHECKS = /* @__PURE__ */ new Set(["cross_platform_parity", "no_duplicate_content"]);
+var CODEX_ONLY_CHECKS = /* @__PURE__ */ new Set(["codex_agents_md_exists"]);
+var COPILOT_ONLY_CHECKS = /* @__PURE__ */ new Set(["copilot_instructions_exists"]);
+var NON_CODEX_CHECKS = /* @__PURE__ */ new Set(["agents_md_exists"]);
+var CLAUDE_OR_CODEX_CHECKS = /* @__PURE__ */ new Set(["skills_exist", "open_skills_format"]);
 var GRADE_THRESHOLDS = [
   { minScore: 85, grade: "A" },
   { minScore: 70, grade: "B" },
@@ -6170,7 +6217,12 @@ function checkQuality(dir) {
     suggestion: concretenessPoints < 3 && totalMeaningful > 0 ? `${abstractCount} lines are generic prose \u2014 replace with specific instructions referencing project files` : void 0,
     fix: concretenessPoints < 3 && totalMeaningful > 0 ? {
       action: "replace_vague",
-      data: { abstractLines: abstractExamples, abstractCount, concreteCount, ratio: Math.round(concreteRatio * 100) },
+      data: {
+        abstractLines: abstractExamples,
+        abstractCount,
+        concreteCount,
+        ratio: Math.round(concreteRatio * 100)
+      },
       instruction: `Replace generic prose with specific references. Examples of vague lines: ${abstractExamples.join("; ")}`
     } : void 0
   });
@@ -6297,7 +6349,7 @@ function checkGrounding(dir) {
 }
 
 // src/scoring/checks/accuracy.ts
-import { existsSync as existsSync4, statSync as statSync2 } from "fs";
+import { existsSync as existsSync4, statSync } from "fs";
 import { execSync as execSync10 } from "child_process";
 import { join as join5 } from "path";
 init_resolve_caliber();
@@ -6323,7 +6375,7 @@ function detectGitDrift(dir) {
       const filePath = join5(dir, file);
       if (!existsSync4(filePath)) continue;
       try {
-        const mtime = statSync2(filePath).mtime.getTime();
+        const mtime = statSync(filePath).mtime.getTime();
         if (mtime > headTime) {
           return { commitsSinceConfigUpdate: 0, lastConfigCommit: "uncommitted (recently modified)", isGitRepo: true };
         }
@@ -6436,7 +6488,7 @@ function checkAccuracy(dir) {
 
 // src/scoring/checks/freshness.ts
 init_resolve_caliber();
-import { existsSync as existsSync5, statSync as statSync3 } from "fs";
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
 import { execSync as execSync11 } from "child_process";
 import { join as join6 } from "path";
 function getCommitsSinceConfigUpdate(dir) {
@@ -6451,7 +6503,7 @@ function getCommitsSinceConfigUpdate(dir) {
       const filePath = join6(dir, file);
       if (!existsSync5(filePath)) continue;
       try {
-        const mtime = statSync3(filePath).mtime.getTime();
+        const mtime = statSync2(filePath).mtime.getTime();
         if (mtime > headTime) {
           return 0;
         }
@@ -6749,8 +6801,8 @@ function checkSources(dir) {
 
 // src/scoring/dismissed.ts
 import fs24 from "fs";
-import path20 from "path";
-var DISMISSED_FILE = path20.join(CALIBER_DIR, "dismissed-checks.json");
+import path21 from "path";
+var DISMISSED_FILE = path21.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
     if (!fs24.existsSync(DISMISSED_FILE)) return [];
@@ -7019,12 +7071,12 @@ import chalk5 from "chalk";
 
 // src/telemetry/config.ts
 import fs25 from "fs";
-import path21 from "path";
+import path22 from "path";
 import os5 from "os";
 import crypto4 from "crypto";
 import { execSync as execSync13 } from "child_process";
-var CONFIG_DIR2 = path21.join(os5.homedir(), ".caliber");
-var CONFIG_FILE2 = path21.join(CONFIG_DIR2, "config.json");
+var CONFIG_DIR2 = path22.join(os5.homedir(), ".caliber");
+var CONFIG_FILE2 = path22.join(CONFIG_DIR2, "config.json");
 var runtimeDisabled = false;
 function readConfig() {
   try {
@@ -7207,8 +7259,8 @@ function trackInitSkillsSearch(searched, installedCount) {
 function trackInitScoreRegression(oldScore, newScore) {
   trackEvent("init_score_regression", { old_score: oldScore, new_score: newScore });
 }
-function trackInitCompleted(path41, score) {
-  trackEvent("init_completed", { path: path41, score });
+function trackInitCompleted(path42, score) {
+  trackEvent("init_completed", { path: path42, score });
 }
 function trackRegenerateCompleted(action, durationMs) {
   trackEvent("regenerate_completed", { action, duration_ms: durationMs });
@@ -7282,7 +7334,7 @@ function detectLocalPlatforms() {
   return platforms.size > 0 ? Array.from(platforms) : ["claude"];
 }
 function sanitizeSlug(slug) {
-  return slug.replace(/[^a-zA-Z0-9_\-]/g, "-").replace(/^-+|-+$/g, "");
+  return slug.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/^-+|-+$/g, "");
 }
 function getSkillPath(platform, slug) {
   const safe = sanitizeSlug(slug);
@@ -7320,9 +7372,12 @@ async function searchSkillsSh(technologies) {
   const bestBySlug = /* @__PURE__ */ new Map();
   for (const tech of technologies) {
     try {
-      const resp = await fetch(`https://skills.sh/api/search?q=${encodeURIComponent(tech)}&limit=10`, {
-        signal: AbortSignal.timeout(1e4)
-      });
+      const resp = await fetch(
+        `https://skills.sh/api/search?q=${encodeURIComponent(tech)}&limit=10`,
+        {
+          signal: AbortSignal.timeout(1e4)
+        }
+      );
       if (!resp.ok) continue;
       const data = await resp.json();
       if (!data.skills?.length) continue;
@@ -7381,9 +7436,7 @@ async function searchAwesomeClaudeCode(technologies) {
   }
 }
 async function searchAllProviders(technologies, platform) {
-  const searches = [
-    searchSkillsSh(technologies)
-  ];
+  const searches = [searchSkillsSh(technologies)];
   if (platform === "claude" || !platform) {
     searches.push(searchAwesomeClaudeCode(technologies));
   }
@@ -7443,18 +7496,24 @@ ${candidateList}`,
 function buildProjectContext(fingerprint, platforms) {
   const parts = [];
   if (fingerprint.packageName) parts.push(`Package: ${fingerprint.packageName}`);
-  if (fingerprint.languages.length > 0) parts.push(`Languages: ${fingerprint.languages.join(", ")}`);
-  if (fingerprint.frameworks.length > 0) parts.push(`Frameworks: ${fingerprint.frameworks.join(", ")}`);
+  if (fingerprint.languages.length > 0)
+    parts.push(`Languages: ${fingerprint.languages.join(", ")}`);
+  if (fingerprint.frameworks.length > 0)
+    parts.push(`Frameworks: ${fingerprint.frameworks.join(", ")}`);
   if (fingerprint.description) parts.push(`Description: ${fingerprint.description}`);
   if (fingerprint.fileTree.length > 0) {
-    parts.push(`
+    parts.push(
+      `
 File tree (${fingerprint.fileTree.length} files):
-${fingerprint.fileTree.slice(0, 50).join("\n")}`);
+${fingerprint.fileTree.slice(0, 50).join("\n")}`
+    );
   }
   if (fingerprint.existingConfigs.claudeMd) {
-    parts.push(`
+    parts.push(
+      `
 Existing CLAUDE.md (first 500 chars):
-${fingerprint.existingConfigs.claudeMd.slice(0, 500)}`);
+${fingerprint.existingConfigs.claudeMd.slice(0, 500)}`
+    );
   }
   const deps = extractTopDeps();
   if (deps.length > 0) {
@@ -7537,20 +7596,18 @@ function extractTopDeps() {
       /^@typescript-eslint\//,
       /^@commitlint\//
     ];
-    return deps.filter(
-      (d) => !trivial.has(d) && !trivialPatterns.some((p) => p.test(d))
-    );
+    return deps.filter((d) => !trivial.has(d) && !trivialPatterns.some((p) => p.test(d)));
   } catch {
     return [];
   }
 }
 async function searchSkills(fingerprint, targetPlatforms, onStatus) {
   const installedSkills = getInstalledSkills(targetPlatforms);
-  const technologies = [...new Set([
-    ...fingerprint.languages,
-    ...fingerprint.frameworks,
-    ...extractTopDeps()
-  ].filter(Boolean))];
+  const technologies = [
+    ...new Set(
+      [...fingerprint.languages, ...fingerprint.frameworks, ...extractTopDeps()].filter(Boolean)
+    )
+  ];
   if (technologies.length === 0) {
     return { results: [], contentMap: /* @__PURE__ */ new Map() };
   }
@@ -7582,10 +7639,12 @@ async function searchSkills(fingerprint, targetPlatforms, onStatus) {
   }
   onStatus?.("Fetching skill content...");
   const contentMap = /* @__PURE__ */ new Map();
-  await Promise.all(results.map(async (rec) => {
-    const content = await fetchSkillContent(rec);
-    if (content) contentMap.set(rec.slug, content);
-  }));
+  await Promise.all(
+    results.map(async (rec) => {
+      const content = await fetchSkillContent(rec);
+      if (content) contentMap.set(rec.slug, content);
+    })
+  );
   const available = results.filter((r) => contentMap.has(r.slug));
   return { results: available, contentMap };
 }
@@ -7631,10 +7690,12 @@ async function querySkills(query) {
   const top = results.slice(0, 5);
   const fetchSpinner = ora("Verifying availability...").start();
   const contentMap = /* @__PURE__ */ new Map();
-  await Promise.all(top.map(async (rec) => {
-    const content = await fetchSkillContent(rec);
-    if (content) contentMap.set(rec.slug, content);
-  }));
+  await Promise.all(
+    top.map(async (rec) => {
+      const content = await fetchSkillContent(rec);
+      if (content) contentMap.set(rec.slug, content);
+    })
+  );
   const available = top.filter((r) => contentMap.has(r.slug));
   fetchSpinner.succeed(`${available.length} available`);
   if (!available.length) {
@@ -7649,7 +7710,11 @@ async function querySkills(query) {
     console.log(`     ${r.reason || r.name}`);
   }
   console.log("");
-  console.log(chalk6.dim(`  Install with: ${resolveCaliber()} skills --install ${available.map((r) => r.slug).join(",")}`));
+  console.log(
+    chalk6.dim(
+      `  Install with: ${resolveCaliber()} skills --install ${available.map((r) => r.slug).join(",")}`
+    )
+  );
   console.log("");
 }
 async function installBySlug(slugStr) {
@@ -7671,10 +7736,12 @@ async function installBySlug(slugStr) {
     return;
   }
   const contentMap = /* @__PURE__ */ new Map();
-  await Promise.all(matched.map(async (rec) => {
-    const content = await fetchSkillContent(rec);
-    if (content) contentMap.set(rec.slug, content);
-  }));
+  await Promise.all(
+    matched.map(async (rec) => {
+      const content = await fetchSkillContent(rec);
+      if (content) contentMap.set(rec.slug, content);
+    })
+  );
   const installable = matched.filter((r) => contentMap.has(r.slug));
   if (!installable.length) {
     spinner.fail("Could not fetch skill content.");
@@ -7711,13 +7778,17 @@ async function searchAndInstallSkills(targetPlatforms) {
   const fingerprint = await collectFingerprint(process.cwd());
   const platforms = targetPlatforms ?? detectLocalPlatforms();
   const installedSkills = getInstalledSkills(platforms);
-  const technologies = [...new Set([
-    ...fingerprint.languages,
-    ...fingerprint.frameworks,
-    ...extractTopDeps()
-  ].filter(Boolean))];
+  const technologies = [
+    ...new Set(
+      [...fingerprint.languages, ...fingerprint.frameworks, ...extractTopDeps()].filter(Boolean)
+    )
+  ];
   if (technologies.length === 0) {
-    console.log(chalk6.yellow("Could not detect any languages or dependencies. Try running from a project root."));
+    console.log(
+      chalk6.yellow(
+        "Could not detect any languages or dependencies. Try running from a project root."
+      )
+    );
     throw new Error("__exit__");
   }
   const primaryPlatform = platforms.includes("claude") ? "claude" : platforms[0];
@@ -7747,7 +7818,9 @@ async function searchAndInstallSkills(targetPlatforms) {
         scoreSpinner.succeed("No highly relevant skills found for your specific project.");
         return;
       }
-      scoreSpinner.succeed(`${results.length} relevant skill${results.length > 1 ? "s" : ""} for your project`);
+      scoreSpinner.succeed(
+        `${results.length} relevant skill${results.length > 1 ? "s" : ""} for your project`
+      );
     } catch {
       scoreSpinner.warn("Could not score relevance \u2014 showing top results");
       results = newCandidates.slice(0, 20);
@@ -7757,10 +7830,12 @@ async function searchAndInstallSkills(targetPlatforms) {
   }
   const fetchSpinner = ora("Verifying skill availability...").start();
   const contentMap = /* @__PURE__ */ new Map();
-  await Promise.all(results.map(async (rec) => {
-    const content = await fetchSkillContent(rec);
-    if (content) contentMap.set(rec.slug, content);
-  }));
+  await Promise.all(
+    results.map(async (rec) => {
+      const content = await fetchSkillContent(rec);
+      if (content) contentMap.set(rec.slug, content);
+    })
+  );
   const available = results.filter((r) => contentMap.has(r.slug));
   if (!available.length) {
     fetchSpinner.fail("No installable skills found \u2014 content could not be fetched.");
@@ -7808,9 +7883,13 @@ async function interactiveSelect(recs) {
       if (hasScores) {
         const scoreColor = rec.score >= 90 ? chalk6.green : rec.score >= 70 ? chalk6.yellow : chalk6.dim;
         const reasonMax = Math.max(cols - prefixWidth - scoreWidth - nameWidth - 2, 20);
-        lines.push(`  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(nameWidth)}${chalk6.dim(rec.reason.slice(0, reasonMax))}`);
+        lines.push(
+          `  ${ptr} ${check} ${scoreColor(String(rec.score).padStart(3))}   ${rec.name.padEnd(nameWidth)}${chalk6.dim(rec.reason.slice(0, reasonMax))}`
+        );
       } else {
-        lines.push(`  ${ptr} ${check} ${rec.name.padEnd(nameWidth)}${rec.detected_technology.padEnd(16)} ${chalk6.dim(rec.source_url || "")}`);
+        lines.push(
+          `  ${ptr} ${check} ${rec.name.padEnd(nameWidth)}${rec.detected_technology.padEnd(16)} ${chalk6.dim(rec.source_url || "")}`
+        );
       }
     }
     lines.push("");
@@ -7866,7 +7945,9 @@ async function interactiveSelect(recs) {
             console.log(chalk6.dim("\n  No skills selected.\n"));
             resolve3(null);
           } else {
-            resolve3(Array.from(selected).sort().map((i) => recs[i]));
+            resolve3(
+              Array.from(selected).sort().map((i) => recs[i])
+            );
           }
           break;
         case "q":
@@ -7935,17 +8016,25 @@ function printSkills(recs) {
   const prefixWidth = 2;
   console.log(chalk6.bold("\n  Skills\n"));
   if (hasScores) {
-    console.log(" ".repeat(prefixWidth) + chalk6.dim("Score".padEnd(scoreWidth)) + chalk6.dim("Name".padEnd(nameWidth)) + chalk6.dim("Why"));
+    console.log(
+      " ".repeat(prefixWidth) + chalk6.dim("Score".padEnd(scoreWidth)) + chalk6.dim("Name".padEnd(nameWidth)) + chalk6.dim("Why")
+    );
   } else {
-    console.log(" ".repeat(prefixWidth) + chalk6.dim("Name".padEnd(nameWidth)) + chalk6.dim("Technology".padEnd(18)) + chalk6.dim("Source"));
+    console.log(
+      " ".repeat(prefixWidth) + chalk6.dim("Name".padEnd(nameWidth)) + chalk6.dim("Technology".padEnd(18)) + chalk6.dim("Source")
+    );
   }
   console.log(chalk6.dim("  " + "\u2500".repeat(Math.min(cols - 4, 90))));
   for (const rec of recs) {
     if (hasScores) {
       const reasonMax = Math.max(cols - prefixWidth - scoreWidth - nameWidth - 2, 20);
-      console.log(`  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(nameWidth)}${chalk6.dim(rec.reason.slice(0, reasonMax))}`);
+      console.log(
+        `  ${String(rec.score).padStart(3)}   ${rec.name.padEnd(nameWidth)}${chalk6.dim(rec.reason.slice(0, reasonMax))}`
+      );
     } else {
-      console.log(`  ${rec.name.padEnd(nameWidth)}${rec.detected_technology.padEnd(16)} ${chalk6.dim(rec.source_url || "")}`);
+      console.log(
+        `  ${rec.name.padEnd(nameWidth)}${rec.detected_technology.padEnd(16)} ${chalk6.dim(rec.source_url || "")}`
+      );
     }
   }
   console.log("");
@@ -8165,11 +8254,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);
@@ -8309,7 +8398,7 @@ async function runScoreRefineWithSpinner(setup, dir, sessionHistory) {
 
 // src/lib/debug-report.ts
 import fs26 from "fs";
-import path22 from "path";
+import path23 from "path";
 var DebugReport = class {
   sections = [];
   startTime;
@@ -8378,7 +8467,7 @@ var DebugReport = class {
       lines.push(`| **Total** | **${formatMs(totalMs)}** |`);
       lines.push("");
     }
-    const dir = path22.dirname(outputPath);
+    const dir = path23.dirname(outputPath);
     if (!fs26.existsSync(dir)) {
       fs26.mkdirSync(dir, { recursive: true });
     }
@@ -9045,7 +9134,11 @@ function formatWhatChanged(setup) {
     lines.push(`${action} AGENTS.md`);
   }
   const allSkills = [];
-  for (const [platform, obj] of [["claude", claude], ["codex", codex], ["cursor", cursor]]) {
+  for (const [_platform, obj] of [
+    ["claude", claude],
+    ["codex", codex],
+    ["cursor", cursor]
+  ]) {
     const skills = obj?.skills;
     if (Array.isArray(skills)) {
       for (const s of skills) allSkills.push(s.name);
@@ -9062,7 +9155,9 @@ function formatWhatChanged(setup) {
   }
   const deletions = setup.deletions;
   if (Array.isArray(deletions) && deletions.length > 0) {
-    lines.push(`Removing ${deletions.length} file${deletions.length === 1 ? "" : "s"}: ${deletions.map((d) => d.filePath).join(", ")}`);
+    lines.push(
+      `Removing ${deletions.length} file${deletions.length === 1 ? "" : "s"}: ${deletions.map((d) => d.filePath).join(", ")}`
+    );
   }
   return lines;
 }
@@ -9160,7 +9255,9 @@ function printSetupSummary(setup) {
       console.log("");
     }
   }
-  console.log(`  ${chalk12.green("+")} ${chalk12.dim("new")}  ${chalk12.yellow("~")} ${chalk12.dim("modified")}  ${chalk12.red("-")} ${chalk12.dim("removed")}`);
+  console.log(
+    `  ${chalk12.green("+")} ${chalk12.dim("new")}  ${chalk12.yellow("~")} ${chalk12.dim("modified")}  ${chalk12.red("-")} ${chalk12.dim("removed")}`
+  );
   console.log("");
 }
 function displayTokenUsage() {
@@ -9175,11 +9272,17 @@ function displayTokenUsage() {
   for (const m of summary) {
     totalIn += m.inputTokens;
     totalOut += m.outputTokens;
-    const cacheInfo = m.cacheReadTokens > 0 || m.cacheWriteTokens > 0 ? chalk12.dim(` (cache: ${m.cacheReadTokens.toLocaleString()} read, ${m.cacheWriteTokens.toLocaleString()} write)`) : "";
-    console.log(`    ${chalk12.dim(m.model)}: ${m.inputTokens.toLocaleString()} in / ${m.outputTokens.toLocaleString()} out  (${m.calls} call${m.calls === 1 ? "" : "s"})${cacheInfo}`);
+    const cacheInfo = m.cacheReadTokens > 0 || m.cacheWriteTokens > 0 ? chalk12.dim(
+      ` (cache: ${m.cacheReadTokens.toLocaleString()} read, ${m.cacheWriteTokens.toLocaleString()} write)`
+    ) : "";
+    console.log(
+      `    ${chalk12.dim(m.model)}: ${m.inputTokens.toLocaleString()} in / ${m.outputTokens.toLocaleString()} out  (${m.calls} call${m.calls === 1 ? "" : "s"})${cacheInfo}`
+    );
   }
   if (summary.length > 1) {
-    console.log(`    ${chalk12.dim("Total")}: ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out`);
+    console.log(
+      `    ${chalk12.dim("Total")}: ${totalIn.toLocaleString()} in / ${totalOut.toLocaleString()} out`
+    );
   }
   console.log("");
 }
@@ -9188,9 +9291,9 @@ function displayTokenUsage() {
 init_config();
 import chalk13 from "chalk";
 import fs31 from "fs";
-import path24 from "path";
+import path25 from "path";
 function isFirstRun(dir) {
-  const caliberDir = path24.join(dir, ".caliber");
+  const caliberDir = path25.join(dir, ".caliber");
   try {
     const stat = fs31.statSync(caliberDir);
     return !stat.isDirectory();
@@ -9260,7 +9363,7 @@ function ensurePermissions(fingerprint) {
 }
 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()}`,
       "",
@@ -9273,7 +9376,7 @@ function writeErrorLog(config, rawOutput, error, stopReason) {
       lines.push("## Error", "```", error, "```", "");
     }
     lines.push("## Raw LLM Output", "```", rawOutput || "(empty)", "```");
-    fs31.mkdirSync(path24.join(process.cwd(), ".caliber"), { recursive: true });
+    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`));
@@ -9326,12 +9429,12 @@ ${JSON.stringify(checkList, null, 2)}`,
 
 // src/scoring/history.ts
 import fs32 from "fs";
-import path25 from "path";
+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 = {
@@ -9523,7 +9626,7 @@ async function initCommand(options) {
     trackInitLearnEnabled(true);
   }
   console.log("");
-  let baselineScore = computeLocalScore(process.cwd(), targetAgent);
+  const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   log(options.verbose, `Baseline score: ${baselineScore.score}/100`);
   if (report) {
     report.markStep("Baseline scoring");
@@ -9570,7 +9673,7 @@ async function initCommand(options) {
     } catch {
     }
     if (!claudeContent) {
-      claudeContent = `# ${path26.basename(process.cwd())}
+      claudeContent = `# ${path27.basename(process.cwd())}
 `;
     }
     const updatedClaude = appendManagedBlocks2(claudeContent, "claude");
@@ -9579,15 +9682,15 @@ async function initCommand(options) {
       console.log(`  ${chalk14.green("\u2713")} CLAUDE.md \u2014 added Caliber sync instructions`);
     }
     if (targetAgent.includes("cursor")) {
-      const rulesDir = path26.join(".cursor", "rules");
+      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(path26.join(rulesDir, rule.filename), rule.content);
+        fs33.writeFileSync(path27.join(rulesDir, rule.filename), rule.content);
       }
       console.log(`  ${chalk14.green("\u2713")} Cursor rules \u2014 added Caliber sync rules`);
     }
     if (targetAgent.includes("github-copilot")) {
-      const copilotPath = path26.join(".github", "copilot-instructions.md");
+      const copilotPath = path27.join(".github", "copilot-instructions.md");
       let copilotContent = "";
       try {
         copilotContent = fs33.readFileSync(copilotPath, "utf-8");
@@ -9595,7 +9698,7 @@ async function initCommand(options) {
       }
       if (!copilotContent) {
         fs33.mkdirSync(".github", { recursive: true });
-        copilotContent = `# ${path26.basename(process.cwd())}
+        copilotContent = `# ${path27.basename(process.cwd())}
 `;
       }
       const updatedCopilot = appendManagedBlocks2(copilotContent, "copilot");
@@ -9616,8 +9719,6 @@ async function initCommand(options) {
     console.log(chalk14.dim("  Run ") + title(`${bin} init --force`) + chalk14.dim(" anytime to generate or improve configs.\n"));
     return;
   }
-  const allFailingChecks = baselineScore.checks.filter((c) => !c.passed && c.maxPoints > 0);
-  const llmFixableChecks = allFailingChecks.filter((c) => !NON_LLM_CHECKS.has(c.id));
   const genModelInfo = fastModel ? `  Using ${displayModel} for docs, ${fastModel} for skills` : `  Using ${displayModel}`;
   console.log(chalk14.dim(genModelInfo + "\n"));
   if (report) report.markStep("Generation");
@@ -10004,9 +10105,9 @@ ${agentRefs.join(" ")}
   }
   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)}
 `));
   }
 }
@@ -10233,30 +10334,39 @@ async function regenerateCommand(options) {
 // src/commands/score.ts
 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();
 var CONFIG_FILES = ["CLAUDE.md", "AGENTS.md", ".cursorrules", "CALIBER_LEARNINGS.md"];
 var CONFIG_DIRS = [".claude", ".cursor"];
 function scoreBaseRef(ref, target) {
-  if (!/^[\w.\-\/~^@{}]+$/.test(ref)) return null;
-  const tmpDir = fs35.mkdtempSync(path27.join(os7.tmpdir(), "caliber-compare-"));
+  if (!/^[\w.\-/~^@{}]+$/.test(ref)) return null;
+  const tmpDir = fs35.mkdtempSync(path28.join(os7.tmpdir(), "caliber-compare-"));
   try {
     for (const file of CONFIG_FILES) {
       try {
-        const content = execFileSync2("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-        fs35.writeFileSync(path27.join(tmpDir, file), content);
+        const content = execFileSync2("git", ["show", `${ref}:${file}`], {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        fs35.writeFileSync(path28.join(tmpDir, file), content);
       } catch {
       }
     }
     for (const dir of CONFIG_DIRS) {
       try {
-        const files = execFileSync2("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n").filter(Boolean);
+        const files = execFileSync2("git", ["ls-tree", "-r", "--name-only", ref, `${dir}/`], {
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim().split("\n").filter(Boolean);
         for (const file of files) {
-          const filePath = path27.join(tmpDir, file);
-          fs35.mkdirSync(path27.dirname(filePath), { recursive: true });
-          const content = execFileSync2("git", ["show", `${ref}:${file}`], { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+          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"]
+          });
           fs35.writeFileSync(filePath, content);
         }
       } catch {
@@ -10279,13 +10389,25 @@ async function scoreCommand(options) {
   if (options.compare) {
     const baseResult = scoreBaseRef(options.compare, target);
     if (!baseResult) {
-      console.error(chalk18.red(`Could not score ref "${options.compare}" \u2014 branch or ref not found.`));
+      console.error(
+        chalk18.red(`Could not score ref "${options.compare}" \u2014 branch or ref not found.`)
+      );
       process.exitCode = 1;
       return;
     }
     const delta = result.score - baseResult.score;
     if (options.json) {
-      console.log(JSON.stringify({ current: result, base: { score: baseResult.score, grade: baseResult.grade, ref: options.compare }, delta }, null, 2));
+      console.log(
+        JSON.stringify(
+          {
+            current: result,
+            base: { score: baseResult.score, grade: baseResult.grade, ref: options.compare },
+            delta
+          },
+          null,
+          2
+        )
+      );
       return;
     }
     if (options.quiet) {
@@ -10297,9 +10419,13 @@ async function scoreCommand(options) {
     const separator2 = chalk18.gray("  " + "\u2500".repeat(53));
     console.log(separator2);
     if (delta > 0) {
-      console.log(chalk18.green(`  +${delta}`) + chalk18.gray(` from ${options.compare} (${baseResult.score}/100)`));
+      console.log(
+        chalk18.green(`  +${delta}`) + chalk18.gray(` from ${options.compare} (${baseResult.score}/100)`)
+      );
     } else if (delta < 0) {
-      console.log(chalk18.red(`  ${delta}`) + chalk18.gray(` from ${options.compare} (${baseResult.score}/100)`));
+      console.log(
+        chalk18.red(`  ${delta}`) + chalk18.gray(` from ${options.compare} (${baseResult.score}/100)`)
+      );
     } else {
       console.log(chalk18.gray(`  No change from ${options.compare} (${baseResult.score}/100)`));
     }
@@ -10319,18 +10445,24 @@ async function scoreCommand(options) {
   console.log(separator);
   const bin = resolveCaliber();
   if (result.score < 40) {
-    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to generate a complete, optimized config."));
+    console.log(
+      chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to generate a complete, optimized config.")
+    );
   } else if (result.score < 70) {
-    console.log(chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to improve your config."));
+    console.log(
+      chalk18.gray("  Run ") + chalk18.hex("#83D1EB")(`${bin} init`) + chalk18.gray(" to improve your config.")
+    );
   } else {
-    console.log(chalk18.green("  Looking good!") + chalk18.gray(" Run ") + chalk18.hex("#83D1EB")(`${bin} regenerate`) + chalk18.gray(" to rebuild from scratch."));
+    console.log(
+      chalk18.green("  Looking good!") + chalk18.gray(" Run ") + chalk18.hex("#83D1EB")(`${bin} regenerate`) + chalk18.gray(" to rebuild from scratch.")
+    );
   }
   console.log("");
 }
 
 // src/commands/refresh.ts
 import fs39 from "fs";
-import path31 from "path";
+import path32 from "path";
 import chalk19 from "chalk";
 import ora6 from "ora";
 
@@ -10340,24 +10472,14 @@ 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, {
@@ -10403,9 +10525,9 @@ function collectDiff(lastSha) {
   const totalSize = committedDiff.length + stagedDiff.length + unstagedDiff.length;
   if (totalSize > MAX_DIFF_BYTES) {
     const ratio = MAX_DIFF_BYTES / totalSize;
-    committedDiff = truncateAtLine(committedDiff, Math.floor(committedDiff.length * ratio));
-    stagedDiff = truncateAtLine(stagedDiff, Math.floor(stagedDiff.length * ratio));
-    unstagedDiff = truncateAtLine(unstagedDiff, Math.floor(unstagedDiff.length * ratio));
+    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));
   }
   const hasChanges = !!(committedDiff || stagedDiff || unstagedDiff || changedFiles.length);
   const parts = [];
@@ -10420,51 +10542,47 @@ function collectDiff(lastSha) {
 // src/writers/refresh.ts
 init_pre_commit_block();
 import fs36 from "fs";
-import path28 from "path";
+import path29 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs36.writeFileSync("CLAUDE.md", appendManagedBlocks(docs.claudeMd, "claude"));
+    fs36.writeFileSync("CLAUDE.md", appendLearningsBlock(appendPreCommitBlock(docs.claudeMd)));
     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");
   }
   if (docs.cursorRules) {
-    const rulesDir = path28.join(".cursor", "rules");
+    const rulesDir = path29.join(".cursor", "rules");
     if (!fs36.existsSync(rulesDir)) fs36.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      fs36.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");
+    const skillsDir = path29.join(".claude", "skills");
     if (!fs36.existsSync(skillsDir)) fs36.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      fs36.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) {
     fs36.mkdirSync(".github", { recursive: true });
-    fs36.writeFileSync(path28.join(".github", "copilot-instructions.md"), appendManagedBlocks(docs.copilotInstructions, "copilot"));
+    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");
+    const instructionsDir = path29.join(".github", "instructions");
     fs36.mkdirSync(instructionsDir, { recursive: true });
     for (const file of docs.copilotInstructionFiles) {
-      fs36.writeFileSync(path28.join(instructionsDir, file.filename), file.content);
+      fs36.writeFileSync(path29.join(instructionsDir, file.filename), file.content);
       written.push(`.github/instructions/${file.filename}`);
     }
   }
@@ -10476,18 +10594,10 @@ 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,
+    maxTokens: 16384,
     ...fastModel ? { model: fastModel } : {}
   });
   return parseJsonResponse(raw);
@@ -10546,21 +10656,6 @@ 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:");
@@ -10574,7 +10669,7 @@ Changed files: ${diff.changedFiles.join(", ")}`);
 
 // src/learner/writer.ts
 import fs37 from "fs";
-import path29 from "path";
+import path30 from "path";
 
 // src/learner/utils.ts
 var TYPE_PREFIX_RE = /^\*\*\[[^\]]+\]\*\*\s*/;
@@ -10699,9 +10794,9 @@ function writeLearnedSection(content) {
   return writeLearnedSectionTo(LEARNINGS_FILE, LEARNINGS_HEADER, readLearnedSection(), content);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path29.join(".claude", "skills", skill.name);
+  const skillDir = path30.join(".claude", "skills", skill.name);
   if (!fs37.existsSync(skillDir)) fs37.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path29.join(skillDir, "SKILL.md");
+  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);
@@ -10770,15 +10865,6 @@ function migrateInlineLearnings() {
 init_config();
 init_resolve_caliber();
 init_builtin_skills();
-function detectSyncedAgents(writtenFiles) {
-  const agents = [];
-  const joined = writtenFiles.join(" ");
-  if (joined.includes("CLAUDE.md") || joined.includes(".claude/")) agents.push("Claude Code");
-  if (joined.includes(".cursor/") || joined.includes(".cursorrules")) agents.push("Cursor");
-  if (joined.includes("copilot-instructions") || joined.includes(".github/instructions/")) agents.push("Copilot");
-  if (joined.includes("AGENTS.md") || joined.includes(".agents/")) agents.push("Codex");
-  return agents;
-}
 function log2(quiet, ...args) {
   if (!quiet) console.log(...args);
 }
@@ -10788,8 +10874,8 @@ function discoverGitRepos(parentDir) {
     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 (fs39.existsSync(path31.join(childPath, ".git"))) {
+      const childPath = path32.join(parentDir, entry.name);
+      if (fs39.existsSync(path32.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -10875,7 +10961,7 @@ 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, fs39.readFileSync(fullPath, "utf-8"));
     } catch {
@@ -10888,7 +10974,7 @@ async function refreshSingleRepo(repoDir, options) {
   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 {
           fs39.unlinkSync(fullPath);
@@ -10907,18 +10993,8 @@ async function refreshSingleRepo(repoDir, options) {
   }
   recordScore(postScore, "refresh");
   spinner?.succeed(`${prefix}Updated ${written.length} doc${written.length === 1 ? "" : "s"}`);
-  const fileChangesMap = new Map(
-    (response.fileChanges || []).map((fc) => [fc.file, fc.description])
-  );
   for (const file of written) {
-    const desc = fileChangesMap.get(file);
-    const suffix = desc ? chalk19.dim(` \u2014 ${desc}`) : "";
-    log2(quiet, `  ${chalk19.green("\u2713")} ${file}${suffix}`);
-  }
-  const agents = detectSyncedAgents(written);
-  if (agents.length > 1) {
-    log2(quiet, chalk19.cyan(`
-  ${agents.length} agent formats in sync (${agents.join(", ")})`));
+    log2(quiet, `  ${chalk19.green("\u2713")} ${file}`);
   }
   if (response.changesSummary) {
     log2(quiet, chalk19.dim(`
@@ -10960,7 +11036,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 });
@@ -11198,7 +11274,7 @@ async function configCommand() {
 
 // src/commands/learn.ts
 import fs44 from "fs";
-import path35 from "path";
+import path36 from "path";
 import chalk23 from "chalk";
 
 // src/learner/stdin.ts
@@ -11230,7 +11306,7 @@ function readStdin() {
 
 // src/learner/storage.ts
 import fs41 from "fs";
-import path32 from "path";
+import path33 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -11244,10 +11320,10 @@ function ensureLearningDir() {
   }
 }
 function sessionFilePath() {
-  return path32.join(getLearningDir(), LEARNING_SESSION_FILE);
+  return path33.join(getLearningDir(), LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path32.join(getLearningDir(), LEARNING_STATE_FILE);
+  return path33.join(getLearningDir(), LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -11319,7 +11395,7 @@ function resetState() {
 var LOCK_FILE2 = "finalize.lock";
 var LOCK_STALE_MS = 5 * 60 * 1e3;
 function lockFilePath() {
-  return path32.join(getLearningDir(), LOCK_FILE2);
+  return path33.join(getLearningDir(), LOCK_FILE2);
 }
 function acquireFinalizeLock() {
   ensureLearningDir();
@@ -11365,10 +11441,10 @@ function releaseFinalizeLock() {
 
 // src/lib/notifications.ts
 import fs42 from "fs";
-import path33 from "path";
+import path34 from "path";
 import chalk22 from "chalk";
 function notificationFilePath() {
-  return path33.join(getLearningDir(), "last-finalize-summary.json");
+  return path34.join(getLearningDir(), "last-finalize-summary.json");
 }
 function writeFinalizeSummary(summary) {
   try {
@@ -11550,7 +11626,7 @@ init_config();
 
 // src/learner/roi.ts
 import fs43 from "fs";
-import path34 from "path";
+import path35 from "path";
 var DEFAULT_TOTALS = {
   totalWasteTokens: 0,
   totalWasteSeconds: 0,
@@ -11564,7 +11640,7 @@ var DEFAULT_TOTALS = {
   lastSessionTimestamp: ""
 };
 function roiFilePath() {
-  return path34.join(getLearningDir(), LEARNING_ROI_FILE);
+  return path35.join(getLearningDir(), LEARNING_ROI_FILE);
 }
 function readROIStats() {
   const filePath = roiFilePath();
@@ -11754,7 +11830,9 @@ Return a JSON object: {"matchedIndices": [0, 2]} or {"matchedIndices": []} if no
     const json = extractJson(raw);
     if (json) {
       const parsed = JSON.parse(json);
-      const indices = (parsed.matchedIndices || []).filter((i) => typeof i === "number" && i >= 0 && i < learnings.length);
+      const indices = (parsed.matchedIndices || []).filter(
+        (i) => typeof i === "number" && i >= 0 && i < learnings.length
+      );
       return { matchedIndices: indices, unmatchedFailures: failureEvents.length - indices.length };
     }
   } catch {
@@ -11792,7 +11870,7 @@ var AUTO_SETTLE_MS = 200;
 var INCREMENTAL_INTERVAL = 50;
 function writeFinalizeError(message) {
   try {
-    const errorPath = path35.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
+    const errorPath = path36.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
     if (!fs44.existsSync(getLearningDir())) fs44.mkdirSync(getLearningDir(), { recursive: true });
     fs44.writeFileSync(errorPath, JSON.stringify({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11804,7 +11882,7 @@ function writeFinalizeError(message) {
 }
 function readFinalizeError() {
   try {
-    const errorPath = path35.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
+    const errorPath = path36.join(getLearningDir(), LEARNING_LAST_ERROR_FILE);
     if (!fs44.existsSync(errorPath)) return null;
     return JSON.parse(fs44.readFileSync(errorPath, "utf-8"));
   } catch {
@@ -11853,7 +11931,7 @@ async function learnObserveCommand(options) {
         const { resolveCaliber: resolveCaliber2 } = await Promise.resolve().then(() => (init_resolve_caliber(), resolve_caliber_exports));
         const bin = resolveCaliber2();
         const { spawn: spawn4 } = await import("child_process");
-        const logPath = path35.join(getLearningDir(), LEARNING_FINALIZE_LOG);
+        const logPath = path36.join(getLearningDir(), LEARNING_FINALIZE_LOG);
         if (!fs44.existsSync(getLearningDir())) fs44.mkdirSync(getLearningDir(), { recursive: true });
         const logFd = fs44.openSync(logPath, "a");
         spawn4(bin, ["learn", "finalize", "--auto", "--incremental"], {
@@ -12143,7 +12221,7 @@ async function learnStatusCommand() {
   if (lastError) {
     console.log(`Last error: ${chalk23.red(lastError.error)}`);
     console.log(chalk23.dim(`  at ${lastError.timestamp}`));
-    const logPath = path35.join(getLearningDir(), LEARNING_FINALIZE_LOG);
+    const logPath = path36.join(getLearningDir(), LEARNING_FINALIZE_LOG);
     if (fs44.existsSync(logPath)) {
       console.log(chalk23.dim(`  Full log: ${logPath}`));
     }
@@ -12425,7 +12503,7 @@ async function insightsCommand(options) {
 
 // src/commands/sources.ts
 import fs45 from "fs";
-import path36 from "path";
+import path37 from "path";
 import chalk25 from "chalk";
 init_resolve_caliber();
 async function sourcesListCommand() {
@@ -12442,9 +12520,9 @@ async function sourcesListCommand() {
   if (configSources.length > 0) {
     for (const source of configSources) {
       const sourcePath = source.path || source.url || "";
-      const exists = source.path ? fs45.existsSync(path36.resolve(dir, source.path)) : false;
+      const exists = source.path ? fs45.existsSync(path37.resolve(dir, source.path)) : false;
       const status = exists ? chalk25.green("reachable") : chalk25.red("not found");
-      const hasSummary = source.path && fs45.existsSync(path36.join(path36.resolve(dir, source.path), ".caliber", "summary.json"));
+      const hasSummary = source.path && fs45.existsSync(path37.join(path37.resolve(dir, source.path), ".caliber", "summary.json"));
       console.log(`  ${chalk25.bold(source.role || source.type)}  ${chalk25.dim(sourcePath)}`);
       console.log(`    Type: ${source.type}  Status: ${status}${hasSummary ? "  " + chalk25.cyan("has summary.json") : ""}`);
       if (source.description) console.log(`    ${chalk25.dim(source.description)}`);
@@ -12454,7 +12532,7 @@ async function sourcesListCommand() {
   if (workspaces.length > 0) {
     console.log(chalk25.dim("  Auto-detected workspaces:"));
     for (const ws of workspaces) {
-      const exists = fs45.existsSync(path36.resolve(dir, ws));
+      const exists = fs45.existsSync(path37.resolve(dir, ws));
       console.log(`    ${exists ? chalk25.green("\u25CF") : chalk25.red("\u25CF")} ${ws}`);
     }
     console.log("");
@@ -12462,7 +12540,7 @@ async function sourcesListCommand() {
 }
 async function sourcesAddCommand(sourcePath) {
   const dir = process.cwd();
-  const absPath = path36.resolve(dir, sourcePath);
+  const absPath = path37.resolve(dir, sourcePath);
   if (!fs45.existsSync(absPath)) {
     console.log(chalk25.red(`
   Path not found: ${sourcePath}
@@ -12478,7 +12556,7 @@ async function sourcesAddCommand(sourcePath) {
   }
   const existing = loadSourcesConfig(dir);
   const alreadyConfigured = existing.some(
-    (s) => s.path && path36.resolve(dir, s.path) === absPath
+    (s) => s.path && path37.resolve(dir, s.path) === absPath
   );
   if (alreadyConfigured) {
     console.log(chalk25.yellow(`
@@ -12527,7 +12605,7 @@ async function sourcesRemoveCommand(name) {
 
 // src/commands/publish.ts
 import fs46 from "fs";
-import path37 from "path";
+import path38 from "path";
 import chalk26 from "chalk";
 import ora7 from "ora";
 init_config();
@@ -12542,10 +12620,10 @@ async function publishCommand() {
   const spinner = ora7("Generating project summary...").start();
   try {
     const fingerprint = await collectFingerprint(dir);
-    const claudeMd = readFileOrNull(path37.join(dir, "CLAUDE.md"));
+    const claudeMd = readFileOrNull(path38.join(dir, "CLAUDE.md"));
     const topLevelDirs = fingerprint.fileTree.filter((f) => f.endsWith("/") && !f.includes("/")).map((f) => f.replace(/\/$/, ""));
     const summary = {
-      name: fingerprint.packageName || path37.basename(dir),
+      name: fingerprint.packageName || path38.basename(dir),
       version: "1.0.0",
       description: fingerprint.description || "",
       languages: fingerprint.languages,
@@ -12557,7 +12635,7 @@ async function publishCommand() {
       summary.conventions = claudeMd.slice(0, 2e3);
     }
     try {
-      const pkgContent = readFileOrNull(path37.join(dir, "package.json"));
+      const pkgContent = readFileOrNull(path38.join(dir, "package.json"));
       if (pkgContent) {
         const pkg3 = JSON.parse(pkgContent);
         if (pkg3.scripts) {
@@ -12570,14 +12648,14 @@ async function publishCommand() {
       }
     } catch {
     }
-    const outputDir = path37.join(dir, ".caliber");
+    const outputDir = path38.join(dir, ".caliber");
     if (!fs46.existsSync(outputDir)) {
       fs46.mkdirSync(outputDir, { recursive: true });
     }
-    const outputPath = path37.join(outputDir, "summary.json");
+    const outputPath = path38.join(outputDir, "summary.json");
     fs46.writeFileSync(outputPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
     spinner.succeed("Project summary published");
-    console.log(`  ${chalk26.green("\u2713")} ${path37.relative(dir, outputPath)}`);
+    console.log(`  ${chalk26.green("\u2713")} ${path38.relative(dir, outputPath)}`);
     console.log(chalk26.dim("\n  Other projects can now reference this repo as a source."));
     console.log(chalk26.dim("  When they run `caliber init`, they'll read this summary automatically.\n"));
   } catch (err) {
@@ -12630,7 +12708,7 @@ async function bootstrapCommand() {
 
 // src/commands/uninstall.ts
 import fs48 from "fs";
-import path38 from "path";
+import path39 from "path";
 import chalk28 from "chalk";
 import confirm3 from "@inquirer/confirm";
 init_pre_commit_block();
@@ -12638,17 +12716,17 @@ init_builtin_skills();
 init_config();
 var MANAGED_DOC_FILES = [
   "CLAUDE.md",
-  path38.join(".github", "copilot-instructions.md"),
+  path39.join(".github", "copilot-instructions.md"),
   "AGENTS.md"
 ];
 var SKILL_DIRS = PLATFORM_CONFIGS.map((c) => c.skillsDir);
-var CURSOR_RULES_DIR = path38.join(".cursor", "rules");
+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 = path38.join(CURSOR_RULES_DIR, file);
+      const fullPath = path39.join(CURSOR_RULES_DIR, file);
       fs48.unlinkSync(fullPath);
       removed.push(fullPath);
     }
@@ -12660,7 +12738,7 @@ function removeBuiltinSkills() {
   for (const skillsDir of SKILL_DIRS) {
     if (!fs48.existsSync(skillsDir)) continue;
     for (const name of BUILTIN_SKILL_NAMES) {
-      const skillDir = path38.join(skillsDir, name);
+      const skillDir = path39.join(skillsDir, name);
       if (fs48.existsSync(skillDir)) {
         fs48.rmSync(skillDir, { recursive: true });
         removed.push(skillDir);
@@ -12764,7 +12842,7 @@ async function uninstallCommand(options) {
     if (removeConfig) {
       fs48.unlinkSync(configPath);
       console.log(`  ${chalk28.red("\u2717")} ${configPath}`);
-      const configDir = path38.dirname(configPath);
+      const configDir = path39.dirname(configPath);
       try {
         const remaining = fs48.readdirSync(configDir);
         if (remaining.length === 0) fs48.rmdirSync(configDir);
@@ -12778,9 +12856,9 @@ async function uninstallCommand(options) {
 }
 
 // src/cli.ts
-var __dirname = path39.dirname(fileURLToPath(import.meta.url));
+var __dirname = path40.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs49.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;
@@ -12872,16 +12950,14 @@ learn.command("add <content>").description("Add a learning directly (used by age
 
 // src/utils/version-check.ts
 import fs50 from "fs";
-import path40 from "path";
+import path41 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync16, execFileSync as execFileSync3 } from "child_process";
 import chalk29 from "chalk";
 import ora8 from "ora";
 import confirm4 from "@inquirer/confirm";
-var __dirname_vc = path40.dirname(fileURLToPath2(import.meta.url));
-var pkg2 = JSON.parse(
-  fs50.readFileSync(path40.resolve(__dirname_vc, "..", "package.json"), "utf-8")
-);
+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";
@@ -12904,8 +12980,11 @@ function isNewer(registry, current) {
 }
 function getInstalledVersion() {
   try {
-    const globalRoot = execSync16("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path40.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    const globalRoot = execSync16("npm root -g", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const pkgPath = path41.join(globalRoot, "@rely-ai", "caliber", "package.json");
     return JSON.parse(fs50.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
@@ -12940,17 +13019,18 @@ Run ${chalk29.bold(`npm install -g @rely-ai/caliber${installTag}`)} to upgrade.
       );
       return;
     }
-    console.log(
-      chalk29.yellow(`
-Update available: ${current} -> ${latest}`)
-    );
-    const shouldUpdate = await confirm4({ message: "Would you like to update now? (Y/n)", default: true });
+    console.log(chalk29.yellow(`
+Update available: ${current} -> ${latest}`));
+    const shouldUpdate = await confirm4({
+      message: "Would you like to update now? (Y/n)",
+      default: true
+    });
     if (!shouldUpdate) {
       console.log();
       return;
     }
     const tag = channel === "latest" ? latest : channel;
-    if (!/^[\w.\-]+$/.test(tag)) return;
+    if (!/^[\w.-]+$/.test(tag)) return;
     const spinner = ora8("Updating caliber...").start();
     try {
       execFileSync3("npm", ["install", "-g", `@rely-ai/caliber@${tag}`], {
@@ -12961,8 +13041,10 @@ Update available: ${current} -> ${latest}`)
       const installed = getInstalledVersion();
       if (installed !== latest) {
         spinner.fail(`Update incomplete \u2014 got ${installed ?? "unknown"}, expected ${latest}`);
-        console.log(chalk29.yellow(`Run ${chalk29.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
-`));
+        console.log(
+          chalk29.yellow(`Run ${chalk29.bold(`npm install -g @rely-ai/caliber@${tag}`)} manually.
+`)
+        );
         return;
       }
       spinner.succeed(chalk29.green(`Updated to ${latest}`));