@rely-ai/caliber 1.1.4 → 1.3.0

package/dist/bin.js

@@ -32,17 +32,17 @@ __export(constants_exports, {
   LEARNING_STATE_FILE: () => LEARNING_STATE_FILE,
   MANIFEST_FILE: () => MANIFEST_FILE
 });
-import path8 from "path";
+import path9 from "path";
 import os2 from "os";
 var AUTH_DIR, CALIBER_DIR, MANIFEST_FILE, BACKUPS_DIR, LEARNING_DIR, LEARNING_SESSION_FILE, LEARNING_STATE_FILE, LEARNING_MAX_EVENTS;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
-    AUTH_DIR = path8.join(os2.homedir(), ".caliber");
+    AUTH_DIR = path9.join(os2.homedir(), ".caliber");
     CALIBER_DIR = ".caliber";
-    MANIFEST_FILE = path8.join(CALIBER_DIR, "manifest.json");
-    BACKUPS_DIR = path8.join(CALIBER_DIR, "backups");
-    LEARNING_DIR = path8.join(CALIBER_DIR, "learning");
+    MANIFEST_FILE = path9.join(CALIBER_DIR, "manifest.json");
+    BACKUPS_DIR = path9.join(CALIBER_DIR, "backups");
+    LEARNING_DIR = path9.join(CALIBER_DIR, "learning");
     LEARNING_SESSION_FILE = "current-session.jsonl";
     LEARNING_STATE_FILE = "state.json";
     LEARNING_MAX_EVENTS = 500;
@@ -51,8 +51,8 @@ var init_constants = __esm({
 
 // src/cli.ts
 import { Command } from "commander";
-import fs25 from "fs";
-import path21 from "path";
+import fs26 from "fs";
+import path22 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/onboard.ts
@@ -60,7 +60,8 @@ import chalk5 from "chalk";
 import ora2 from "ora";
 import readline4 from "readline";
 import select2 from "@inquirer/select";
-import fs18 from "fs";
+import checkbox from "@inquirer/checkbox";
+import fs19 from "fs";
 
 // src/fingerprint/index.ts
 import fs6 from "fs";
@@ -145,6 +146,10 @@ function readExistingConfigs(dir) {
   if (fs2.existsSync(readmeMdPath)) {
     configs.readmeMd = fs2.readFileSync(readmeMdPath, "utf-8");
   }
+  const agentsMdPath = path2.join(dir, "AGENTS.md");
+  if (fs2.existsSync(agentsMdPath)) {
+    configs.agentsMd = fs2.readFileSync(agentsMdPath, "utf-8");
+  }
   const claudeMdPath = path2.join(dir, "CLAUDE.md");
   if (fs2.existsSync(claudeMdPath)) {
     configs.claudeMd = fs2.readFileSync(claudeMdPath, "utf-8");
@@ -1172,7 +1177,7 @@ async function llmJsonCall(options) {
 }
 
 // src/ai/prompts.ts
-var GENERATION_SYSTEM_PROMPT = `You are an expert auditor for coding agent configurations (Claude Code and Cursor).
+var GENERATION_SYSTEM_PROMPT = `You are an expert auditor for coding agent configurations (Claude Code, Cursor, and Codex).
 
 Your job depends on context:
 - If no existing configs exist \u2192 generate an initial setup from scratch.
@@ -1180,7 +1185,9 @@ Your job depends on context:
 
 You understand these config files:
 - CLAUDE.md: Project context for Claude Code \u2014 build/test commands, architecture, conventions.
+- AGENTS.md: Primary instructions file for OpenAI Codex \u2014 same purpose as CLAUDE.md but for the Codex agent. Also serves as a cross-agent coordination file.
 - .claude/skills/{name}/SKILL.md: Skill files following the OpenSkills standard (agentskills.io). Each skill is a directory named after the skill, containing a SKILL.md with YAML frontmatter.
+- .agents/skills/{name}/SKILL.md: Same OpenSkills format for Codex skills (Codex scans .agents/skills/ for skills).
 - .cursorrules: Coding rules for Cursor (deprecated legacy format \u2014 do NOT generate this).
 - .cursor/rules/*.mdc: Modern Cursor rules with frontmatter (description, globs, alwaysApply).
 - .cursor/skills/{name}/SKILL.md: Same OpenSkills format as Claude skills.
@@ -1212,7 +1219,7 @@ Omit empty categories. Keep each reason punchy and specific. End with a blank li
 
 AgentSetup schema:
 {
-  "targetAgent": "claude" | "cursor" | "both",
+  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
   "fileDescriptions": {
     "<file-path>": "reason for this change (max 80 chars)"
   },
@@ -1223,6 +1230,10 @@ AgentSetup schema:
     "claudeMd": "string (markdown content for CLAUDE.md)",
     "skills": [{ "name": "string (kebab-case, matches directory name)", "description": "string (what this skill does and when to use it)", "content": "string (markdown body \u2014 NO frontmatter, it will be generated from name+description)" }]
   },
+  "codex": {
+    "agentsMd": "string (markdown content for AGENTS.md \u2014 the primary Codex instructions file, same quality/structure as CLAUDE.md)",
+    "skills": [{ "name": "string (kebab-case, matches directory name)", "description": "string (what this skill does and when to use it)", "content": "string (markdown body \u2014 NO frontmatter, it will be generated from name+description)" }]
+  },
   "cursor": {
     "skills": [{ "name": "string (kebab-case, matches directory name)", "description": "string (what this skill does and when to use it)", "content": "string (markdown body \u2014 NO frontmatter, it will be generated from name+description)" }],
     "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
@@ -1237,14 +1248,15 @@ All skills follow the OpenSkills standard (agentskills.io):
 - The "content" field is the markdown body only \u2014 do NOT include YAML frontmatter in the content, it will be generated from the name and description fields.
 - Keep skill content under 500 lines. Move detailed references to separate files if needed.
 
-The "fileDescriptions" object MUST include a one-liner for every file that will be created or modified. Use actual file paths as keys (e.g. "CLAUDE.md", ".claude/skills/my-skill/SKILL.md", ".cursor/skills/my-skill/SKILL.md", ".cursor/rules/my-rule.mdc"). Each description should explain why the change is needed, be concise and lowercase.
+The "fileDescriptions" object MUST include a one-liner for every file that will be created or modified. Use actual file paths as keys (e.g. "CLAUDE.md", "AGENTS.md", ".claude/skills/my-skill/SKILL.md", ".agents/skills/my-skill/SKILL.md", ".cursor/skills/my-skill/SKILL.md", ".cursor/rules/my-rule.mdc"). Each description should explain why the change is needed, be concise and lowercase.
 
 The "deletions" array should list files that should be removed (e.g. duplicate skills, stale configs). Include a reason for each. Omit the array or leave empty if nothing should be deleted.
 
 SCORING CRITERIA \u2014 your output is scored deterministically. Optimize for 100/100:
 
 Existence (25 pts):
-- CLAUDE.md exists (6 pts) \u2014 always generate
+- CLAUDE.md exists (6 pts) \u2014 always generate for claude/both targets
+- AGENTS.md exists (6 pts) \u2014 always generate for codex target (serves as primary instructions file)
 - Skills configured (8 pts) \u2014 generate exactly 3 focused skills for full points (6 base + 1 per extra, cap 2). Two skills = 7 pts, three = 8 pts.
 - MCP servers mentioned (3 pts) \u2014 reference detected MCP integrations
 - For "both" target: .cursorrules/.cursor/rules/ exist (3+3 pts), cross-platform parity (2 pts)
@@ -1278,12 +1290,12 @@ Bonus (5 pts):
 - Hooks configured (2 pts), AGENTS.md (1 pt), OpenSkills format (2 pts) \u2014 handled by caliber
 
 OUTPUT SIZE CONSTRAINTS \u2014 these are critical:
-- CLAUDE.md: MUST be under 100 lines for maximum score. Aim for 70-90 lines. Be extremely concise \u2014 only commands, architecture overview, and key conventions. Use bullet points and tables, not prose.
+- CLAUDE.md / AGENTS.md: MUST be under 100 lines for maximum score. Aim for 70-90 lines. Be extremely concise \u2014 only commands, architecture overview, and key conventions. Use bullet points and tables, not prose.
 - Skills: generate exactly 3 skills per target platform. Only go above 3 for large multi-framework projects.
 - Each skill content: max 150 lines. Focus on patterns and examples, not exhaustive docs.
 - Cursor rules: max 5 .mdc files.
 - If the project is large, prioritize depth on the 3-4 most critical tools over breadth across everything.`;
-var REFINE_SYSTEM_PROMPT = `You are an expert at modifying coding agent configurations (Claude Code and Cursor).
+var REFINE_SYSTEM_PROMPT = `You are an expert at modifying coding agent configurations (Claude Code, Cursor, and Codex).
 
 You will receive the current AgentSetup JSON and a user request describing what to change.
 
@@ -1291,7 +1303,7 @@ Apply the requested changes to the setup and return the complete updated AgentSe
 
 AgentSetup schema:
 {
-  "targetAgent": "claude" | "cursor" | "both",
+  "targetAgent": ["claude", "cursor", "codex"] (array of selected agents),
   "fileDescriptions": {
     "<file-path>": "reason for this change (max 80 chars)"
   },
@@ -1302,6 +1314,10 @@ AgentSetup schema:
     "claudeMd": "string (markdown content for CLAUDE.md)",
     "skills": [{ "name": "string (kebab-case)", "description": "string", "content": "string (markdown body, no frontmatter)" }]
   },
+  "codex": {
+    "agentsMd": "string (markdown content for AGENTS.md)",
+    "skills": [{ "name": "string (kebab-case)", "description": "string", "content": "string (markdown body, no frontmatter)" }]
+  },
   "cursor": {
     "skills": [{ "name": "string (kebab-case)", "description": "string", "content": "string (markdown body, no frontmatter)" }],
     "rules": [{ "filename": "string.mdc", "content": "string (with frontmatter)" }]
@@ -1318,7 +1334,7 @@ var REFRESH_SYSTEM_PROMPT = `You are an expert at maintaining coding project doc
 
 You will receive:
 1. Git diffs showing what code changed
-2. Current contents of documentation files (CLAUDE.md, README.md, skills, cursor skills, cursor rules)
+2. Current contents of documentation files (CLAUDE.md, AGENTS.md, README.md, skills, cursor skills, cursor rules)
 3. Project context (languages, frameworks)
 
 Rules:
@@ -1329,6 +1345,7 @@ Rules:
 - Keep managed blocks (<!-- caliber:managed --> ... <!-- /caliber:managed -->) intact
 - If a doc doesn't need updating, return null for it
 - For CLAUDE.md: update commands, architecture notes, conventions, key files if the diffs affect them
+- For AGENTS.md: same as CLAUDE.md \u2014 this is the primary instructions file for Codex users
 - For README.md: update setup instructions, API docs, or feature descriptions if affected
 - For cursor skills: update skill content if the diffs affect their domains
 
@@ -1336,13 +1353,14 @@ Return a JSON object with this exact shape:
 {
   "updatedDocs": {
     "claudeMd": "<updated content or null>",
+    "agentsMd": "<updated content or null>",
     "readmeMd": "<updated content or null>",
     "cursorRules": [{"filename": "name.mdc", "content": "..."}] or null,
     "cursorSkills": [{"slug": "string", "name": "string", "content": "..."}] or null,
     "claudeSkills": [{"filename": "name.md", "content": "..."}] or null
   },
   "changesSummary": "<1-2 sentence summary of what was updated and why>",
-  "docsUpdated": ["CLAUDE.md", "README.md"]
+  "docsUpdated": ["CLAUDE.md", "AGENTS.md", "README.md"]
 }
 
 Respond with ONLY the JSON object, no markdown fences or extra text.`;
@@ -1361,7 +1379,7 @@ Your job is to reason deeply about these events and identify:
 From these observations, produce:
 
 ### claudeMdLearnedSection
-A markdown section with concise, actionable bullet points that should be added to the project's CLAUDE.md file. Each bullet should be a concrete instruction that prevents a past mistake or encodes a discovered convention. Examples:
+A markdown section with concise, actionable bullet points that should be added to the project's primary instructions file (CLAUDE.md for Claude Code, AGENTS.md for Codex). Each bullet should be a concrete instruction that prevents a past mistake or encodes a discovered convention. Examples:
 - "Always run \`npm install\` before \`npm run build\` in this project"
 - "The test database requires \`DATABASE_URL\` to be set \u2014 use \`source .env.test\` first"
 - "TypeScript strict mode is enabled \u2014 never use \`any\`, use \`unknown\` with type guards"
@@ -1644,7 +1662,7 @@ function truncate(text, maxChars) {
 function buildGeneratePrompt(fingerprint, targetAgent, prompt, failingChecks, currentScore, passingChecks) {
   const parts = [];
   const existing = fingerprint.existingConfigs;
-  const hasExistingConfigs = !!(existing.claudeMd || existing.claudeSettings || existing.claudeSkills?.length || existing.readmeMd || existing.cursorrules || existing.cursorRules?.length);
+  const hasExistingConfigs = !!(existing.claudeMd || existing.claudeSettings || existing.claudeSkills?.length || existing.readmeMd || existing.agentsMd || existing.cursorrules || existing.cursorRules?.length);
   const isTargetedFix = failingChecks && failingChecks.length > 0 && currentScore !== void 0 && currentScore >= 95;
   if (isTargetedFix) {
     parts.push(`TARGETED FIX MODE \u2014 current score: ${currentScore}/100, target: ${targetAgent}`);
@@ -1682,6 +1700,9 @@ ${tree.join("\n")}`);
   if (existing.claudeMd) parts.push(`
 Existing CLAUDE.md:
 ${truncate(existing.claudeMd, LIMITS.EXISTING_CONFIG_CHARS)}`);
+  if (existing.agentsMd) parts.push(`
+Existing AGENTS.md:
+${truncate(existing.agentsMd, LIMITS.EXISTING_CONFIG_CHARS)}`);
   if (existing.readmeMd) parts.push(`
 Existing README.md:
 ${truncate(existing.readmeMd, LIMITS.EXISTING_CONFIG_CHARS)}`);
@@ -1817,7 +1838,7 @@ Return the complete updated AgentSetup JSON incorporating the user's changes. Re
 }
 
 // src/writers/index.ts
-import fs11 from "fs";
+import fs12 from "fs";
 
 // src/writers/claude/index.ts
 import fs7 from "fs";
@@ -1911,77 +1932,106 @@ function writeCursorConfig(config) {
   return written;
 }
 
+// src/writers/codex/index.ts
+import fs9 from "fs";
+import path8 from "path";
+function writeCodexConfig(config) {
+  const written = [];
+  fs9.writeFileSync("AGENTS.md", config.agentsMd);
+  written.push("AGENTS.md");
+  if (config.skills?.length) {
+    for (const skill of config.skills) {
+      const skillDir = path8.join(".agents", "skills", skill.name);
+      if (!fs9.existsSync(skillDir)) fs9.mkdirSync(skillDir, { recursive: true });
+      const skillPath = path8.join(skillDir, "SKILL.md");
+      const frontmatter = [
+        "---",
+        `name: ${skill.name}`,
+        `description: ${skill.description}`,
+        "---",
+        ""
+      ].join("\n");
+      fs9.writeFileSync(skillPath, frontmatter + skill.content);
+      written.push(skillPath);
+    }
+  }
+  return written;
+}
+
 // src/writers/backup.ts
 init_constants();
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 function createBackup(files) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const backupDir = path9.join(BACKUPS_DIR, timestamp);
+  const backupDir = path10.join(BACKUPS_DIR, timestamp);
   for (const file of files) {
-    if (!fs9.existsSync(file)) continue;
-    const dest = path9.join(backupDir, file);
-    const destDir = path9.dirname(dest);
-    if (!fs9.existsSync(destDir)) {
-      fs9.mkdirSync(destDir, { recursive: true });
+    if (!fs10.existsSync(file)) continue;
+    const dest = path10.join(backupDir, file);
+    const destDir = path10.dirname(dest);
+    if (!fs10.existsSync(destDir)) {
+      fs10.mkdirSync(destDir, { recursive: true });
     }
-    fs9.copyFileSync(file, dest);
+    fs10.copyFileSync(file, dest);
   }
   return backupDir;
 }
 function restoreBackup(backupDir, file) {
-  const backupFile = path9.join(backupDir, file);
-  if (!fs9.existsSync(backupFile)) return false;
-  const destDir = path9.dirname(file);
-  if (!fs9.existsSync(destDir)) {
-    fs9.mkdirSync(destDir, { recursive: true });
+  const backupFile = path10.join(backupDir, file);
+  if (!fs10.existsSync(backupFile)) return false;
+  const destDir = path10.dirname(file);
+  if (!fs10.existsSync(destDir)) {
+    fs10.mkdirSync(destDir, { recursive: true });
   }
-  fs9.copyFileSync(backupFile, file);
+  fs10.copyFileSync(backupFile, file);
   return true;
 }
 
 // src/writers/manifest.ts
 init_constants();
-import fs10 from "fs";
+import fs11 from "fs";
 import crypto from "crypto";
 function readManifest() {
   try {
-    if (!fs10.existsSync(MANIFEST_FILE)) return null;
-    return JSON.parse(fs10.readFileSync(MANIFEST_FILE, "utf-8"));
+    if (!fs11.existsSync(MANIFEST_FILE)) return null;
+    return JSON.parse(fs11.readFileSync(MANIFEST_FILE, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeManifest(manifest) {
-  if (!fs10.existsSync(CALIBER_DIR)) {
-    fs10.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs11.existsSync(CALIBER_DIR)) {
+    fs11.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs10.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
+  fs11.writeFileSync(MANIFEST_FILE, JSON.stringify(manifest, null, 2));
 }
 function fileChecksum(filePath) {
-  const content = fs10.readFileSync(filePath);
+  const content = fs11.readFileSync(filePath);
   return crypto.createHash("sha256").update(content).digest("hex");
 }
 
 // src/writers/index.ts
 function writeSetup(setup) {
   const filesToWrite = getFilesToWrite(setup);
-  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs11.existsSync(f));
+  const filesToDelete = (setup.deletions || []).map((d) => d.filePath).filter((f) => fs12.existsSync(f));
   const existingFiles = [
-    ...filesToWrite.filter((f) => fs11.existsSync(f)),
+    ...filesToWrite.filter((f) => fs12.existsSync(f)),
     ...filesToDelete
   ];
   const backupDir = existingFiles.length > 0 ? createBackup(existingFiles) : void 0;
   const written = [];
-  if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
+  if (setup.targetAgent.includes("claude") && setup.claude) {
     written.push(...writeClaudeConfig(setup.claude));
   }
-  if ((setup.targetAgent === "cursor" || setup.targetAgent === "both") && setup.cursor) {
+  if (setup.targetAgent.includes("cursor") && setup.cursor) {
     written.push(...writeCursorConfig(setup.cursor));
   }
+  if (setup.targetAgent.includes("codex") && setup.codex) {
+    written.push(...writeCodexConfig(setup.codex));
+  }
   const deleted = [];
   for (const filePath of filesToDelete) {
-    fs11.unlinkSync(filePath);
+    fs12.unlinkSync(filePath);
     deleted.push(filePath);
   }
   ensureGitignore();
@@ -2011,8 +2061,8 @@ function undoSetup() {
   const removed = [];
   for (const entry of manifest.entries) {
     if (entry.action === "created") {
-      if (fs11.existsSync(entry.path)) {
-        fs11.unlinkSync(entry.path);
+      if (fs12.existsSync(entry.path)) {
+        fs12.unlinkSync(entry.path);
         removed.push(entry.path);
       }
     } else if ((entry.action === "modified" || entry.action === "deleted") && manifest.backupDir) {
@@ -2022,14 +2072,14 @@ function undoSetup() {
     }
   }
   const { MANIFEST_FILE: MANIFEST_FILE2 } = (init_constants(), __toCommonJS(constants_exports));
-  if (fs11.existsSync(MANIFEST_FILE2)) {
-    fs11.unlinkSync(MANIFEST_FILE2);
+  if (fs12.existsSync(MANIFEST_FILE2)) {
+    fs12.unlinkSync(MANIFEST_FILE2);
   }
   return { restored, removed };
 }
 function getFilesToWrite(setup) {
   const files = [];
-  if ((setup.targetAgent === "claude" || setup.targetAgent === "both") && setup.claude) {
+  if (setup.targetAgent.includes("claude") && setup.claude) {
     files.push("CLAUDE.md");
     if (setup.claude.mcpServers) files.push(".mcp.json");
     if (setup.claude.skills) {
@@ -2038,7 +2088,7 @@ function getFilesToWrite(setup) {
       }
     }
   }
-  if ((setup.targetAgent === "cursor" || setup.targetAgent === "both") && setup.cursor) {
+  if (setup.targetAgent.includes("cursor") && setup.cursor) {
     if (setup.cursor.cursorrules) files.push(".cursorrules");
     if (setup.cursor.rules) {
       for (const r of setup.cursor.rules) files.push(`.cursor/rules/${r.filename}`);
@@ -2048,27 +2098,33 @@ function getFilesToWrite(setup) {
     }
     if (setup.cursor.mcpServers) files.push(".cursor/mcp.json");
   }
+  if (setup.targetAgent.includes("codex") && setup.codex) {
+    files.push("AGENTS.md");
+    if (setup.codex.skills) {
+      for (const s of setup.codex.skills) files.push(`.agents/skills/${s.name}/SKILL.md`);
+    }
+  }
   return files;
 }
 function ensureGitignore() {
   const gitignorePath = ".gitignore";
-  if (fs11.existsSync(gitignorePath)) {
-    const content = fs11.readFileSync(gitignorePath, "utf-8");
+  if (fs12.existsSync(gitignorePath)) {
+    const content = fs12.readFileSync(gitignorePath, "utf-8");
     if (!content.includes(".caliber/")) {
-      fs11.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
+      fs12.appendFileSync(gitignorePath, "\n# Caliber local state\n.caliber/\n");
     }
   } else {
-    fs11.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
+    fs12.writeFileSync(gitignorePath, "# Caliber local state\n.caliber/\n");
   }
 }
 
 // src/writers/staging.ts
 init_constants();
-import fs12 from "fs";
-import path10 from "path";
-var STAGED_DIR = path10.join(CALIBER_DIR, "staged");
-var PROPOSED_DIR = path10.join(STAGED_DIR, "proposed");
-var CURRENT_DIR = path10.join(STAGED_DIR, "current");
+import fs13 from "fs";
+import path11 from "path";
+var STAGED_DIR = path11.join(CALIBER_DIR, "staged");
+var PROPOSED_DIR = path11.join(STAGED_DIR, "proposed");
+var CURRENT_DIR = path11.join(STAGED_DIR, "current");
 function normalizeContent(content) {
   return content.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
@@ -2078,20 +2134,20 @@ function stageFiles(files, projectDir) {
   let modifiedFiles = 0;
   const stagedFiles = [];
   for (const file of files) {
-    const originalPath = path10.join(projectDir, file.path);
-    if (fs12.existsSync(originalPath)) {
-      const existing = fs12.readFileSync(originalPath, "utf-8");
+    const originalPath = path11.join(projectDir, file.path);
+    if (fs13.existsSync(originalPath)) {
+      const existing = fs13.readFileSync(originalPath, "utf-8");
       if (normalizeContent(existing) === normalizeContent(file.content)) {
         continue;
       }
     }
-    const proposedPath = path10.join(PROPOSED_DIR, file.path);
-    fs12.mkdirSync(path10.dirname(proposedPath), { recursive: true });
-    fs12.writeFileSync(proposedPath, file.content);
-    if (fs12.existsSync(originalPath)) {
-      const currentPath = path10.join(CURRENT_DIR, file.path);
-      fs12.mkdirSync(path10.dirname(currentPath), { recursive: true });
-      fs12.copyFileSync(originalPath, currentPath);
+    const proposedPath = path11.join(PROPOSED_DIR, file.path);
+    fs13.mkdirSync(path11.dirname(proposedPath), { recursive: true });
+    fs13.writeFileSync(proposedPath, file.content);
+    if (fs13.existsSync(originalPath)) {
+      const currentPath = path11.join(CURRENT_DIR, file.path);
+      fs13.mkdirSync(path11.dirname(currentPath), { recursive: true });
+      fs13.copyFileSync(originalPath, currentPath);
       modifiedFiles++;
       stagedFiles.push({ relativePath: file.path, proposedPath, currentPath, originalPath, isNew: false });
     } else {
@@ -2102,8 +2158,8 @@ function stageFiles(files, projectDir) {
   return { newFiles, modifiedFiles, stagedFiles };
 }
 function cleanupStaging() {
-  if (fs12.existsSync(STAGED_DIR)) {
-    fs12.rmSync(STAGED_DIR, { recursive: true, force: true });
+  if (fs13.existsSync(STAGED_DIR)) {
+    fs13.rmSync(STAGED_DIR, { recursive: true, force: true });
   }
 }
 
@@ -2149,24 +2205,24 @@ function openDiffsInEditor(editor, files) {
 import { createTwoFilesPatch } from "diff";
 
 // src/lib/hooks.ts
-import fs13 from "fs";
-import path11 from "path";
+import fs14 from "fs";
+import path12 from "path";
 import { execSync as execSync5 } from "child_process";
-var SETTINGS_PATH = path11.join(".claude", "settings.json");
+var SETTINGS_PATH = path12.join(".claude", "settings.json");
 var HOOK_COMMAND = "caliber refresh --quiet";
 var HOOK_DESCRIPTION = "Caliber: auto-refreshing docs based on code changes";
 function readSettings() {
-  if (!fs13.existsSync(SETTINGS_PATH)) return {};
+  if (!fs14.existsSync(SETTINGS_PATH)) return {};
   try {
-    return JSON.parse(fs13.readFileSync(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(fs14.readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings(settings) {
-  const dir = path11.dirname(SETTINGS_PATH);
-  if (!fs13.existsSync(dir)) fs13.mkdirSync(dir, { recursive: true });
-  fs13.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  const dir = path12.dirname(SETTINGS_PATH);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
 }
 function findHookIndex(sessionEnd) {
   return sessionEnd.findIndex(
@@ -2224,19 +2280,19 @@ ${PRECOMMIT_END}`;
 function getGitHooksDir() {
   try {
     const gitDir = execSync5("git rev-parse --git-dir", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    return path11.join(gitDir, "hooks");
+    return path12.join(gitDir, "hooks");
   } catch {
     return null;
   }
 }
 function getPreCommitPath() {
   const hooksDir = getGitHooksDir();
-  return hooksDir ? path11.join(hooksDir, "pre-commit") : null;
+  return hooksDir ? path12.join(hooksDir, "pre-commit") : null;
 }
 function isPreCommitHookInstalled() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs13.existsSync(hookPath)) return false;
-  const content = fs13.readFileSync(hookPath, "utf-8");
+  if (!hookPath || !fs14.existsSync(hookPath)) return false;
+  const content = fs14.readFileSync(hookPath, "utf-8");
   return content.includes(PRECOMMIT_START);
 }
 function installPreCommitHook() {
@@ -2245,43 +2301,43 @@ function installPreCommitHook() {
   }
   const hookPath = getPreCommitPath();
   if (!hookPath) return { installed: false, alreadyInstalled: false };
-  const hooksDir = path11.dirname(hookPath);
-  if (!fs13.existsSync(hooksDir)) fs13.mkdirSync(hooksDir, { recursive: true });
+  const hooksDir = path12.dirname(hookPath);
+  if (!fs14.existsSync(hooksDir)) fs14.mkdirSync(hooksDir, { recursive: true });
   let content = "";
-  if (fs13.existsSync(hookPath)) {
-    content = fs13.readFileSync(hookPath, "utf-8");
+  if (fs14.existsSync(hookPath)) {
+    content = fs14.readFileSync(hookPath, "utf-8");
     if (!content.endsWith("\n")) content += "\n";
     content += "\n" + PRECOMMIT_BLOCK + "\n";
   } else {
     content = "#!/bin/sh\n\n" + PRECOMMIT_BLOCK + "\n";
   }
-  fs13.writeFileSync(hookPath, content);
-  fs13.chmodSync(hookPath, 493);
+  fs14.writeFileSync(hookPath, content);
+  fs14.chmodSync(hookPath, 493);
   return { installed: true, alreadyInstalled: false };
 }
 function removePreCommitHook() {
   const hookPath = getPreCommitPath();
-  if (!hookPath || !fs13.existsSync(hookPath)) {
+  if (!hookPath || !fs14.existsSync(hookPath)) {
     return { removed: false, notFound: true };
   }
-  let content = fs13.readFileSync(hookPath, "utf-8");
+  let content = fs14.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() === "") {
-    fs13.unlinkSync(hookPath);
+    fs14.unlinkSync(hookPath);
   } else {
-    fs13.writeFileSync(hookPath, content);
+    fs14.writeFileSync(hookPath, content);
   }
   return { removed: true, notFound: false };
 }
 
 // src/lib/learning-hooks.ts
-import fs14 from "fs";
-import path12 from "path";
-var SETTINGS_PATH2 = path12.join(".claude", "settings.json");
+import fs15 from "fs";
+import path13 from "path";
+var SETTINGS_PATH2 = path13.join(".claude", "settings.json");
 var HOOK_CONFIGS = [
   {
     event: "PostToolUse",
@@ -2300,17 +2356,17 @@ var HOOK_CONFIGS = [
   }
 ];
 function readSettings2() {
-  if (!fs14.existsSync(SETTINGS_PATH2)) return {};
+  if (!fs15.existsSync(SETTINGS_PATH2)) return {};
   try {
-    return JSON.parse(fs14.readFileSync(SETTINGS_PATH2, "utf-8"));
+    return JSON.parse(fs15.readFileSync(SETTINGS_PATH2, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeSettings2(settings) {
-  const dir = path12.dirname(SETTINGS_PATH2);
-  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
-  fs14.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
+  const dir = path13.dirname(SETTINGS_PATH2);
+  if (!fs15.existsSync(dir)) fs15.mkdirSync(dir, { recursive: true });
+  fs15.writeFileSync(SETTINGS_PATH2, JSON.stringify(settings, null, 2));
 }
 function hasLearningHook(matchers, command) {
   return matchers.some((entry) => entry.hooks?.some((h) => h.command === command));
@@ -2367,23 +2423,33 @@ function removeLearningHooks() {
 
 // src/lib/state.ts
 init_constants();
-import fs15 from "fs";
-import path13 from "path";
+import fs16 from "fs";
+import path14 from "path";
 import { execSync as execSync6 } from "child_process";
-var STATE_FILE = path13.join(CALIBER_DIR, ".caliber-state.json");
+var STATE_FILE = path14.join(CALIBER_DIR, ".caliber-state.json");
+function normalizeTargetAgent(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    if (value === "both") return ["claude", "cursor"];
+    if (["claude", "cursor", "codex"].includes(value)) return [value];
+  }
+  return void 0;
+}
 function readState() {
   try {
-    if (!fs15.existsSync(STATE_FILE)) return null;
-    return JSON.parse(fs15.readFileSync(STATE_FILE, "utf-8"));
+    if (!fs16.existsSync(STATE_FILE)) return null;
+    const raw = JSON.parse(fs16.readFileSync(STATE_FILE, "utf-8"));
+    if (raw.targetAgent) raw.targetAgent = normalizeTargetAgent(raw.targetAgent);
+    return raw;
   } catch {
     return null;
   }
 }
 function writeState(state) {
-  if (!fs15.existsSync(CALIBER_DIR)) {
-    fs15.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs16.existsSync(CALIBER_DIR)) {
+    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs15.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  fs16.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
 }
 function getCurrentHeadSha() {
   try {
@@ -2649,6 +2715,9 @@ 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 GRADE_THRESHOLDS = [
   { minScore: 85, grade: "A" },
   { minScore: 70, grade: "B" },
@@ -2666,15 +2735,15 @@ function computeGrade(score) {
 // src/scoring/checks/coverage.ts
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
-function readFileOrNull(path23) {
+function readFileOrNull(path24) {
   try {
-    return readFileSync(path23, "utf-8");
+    return readFileSync(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull(path23) {
-  const content = readFileOrNull(path23);
+function readJsonOrNull(path24) {
+  const content = readFileOrNull(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -2970,8 +3039,20 @@ function checkExistence(dir) {
     detail: hasCursorrules ? ".cursorrules found" : cursorRulesDir ? ".cursor/rules/ found" : "No Cursor rules",
     suggestion: cursorRulesExist ? void 0 : "Add .cursor/rules/ for Cursor users on your team"
   });
+  const agentsMdExists = existsSync3(join2(dir, "AGENTS.md"));
+  checks.push({
+    id: "codex_agents_md_exists",
+    name: "AGENTS.md exists",
+    category: "existence",
+    maxPoints: POINTS_CLAUDE_MD_EXISTS,
+    earnedPoints: agentsMdExists ? POINTS_CLAUDE_MD_EXISTS : 0,
+    passed: agentsMdExists,
+    detail: agentsMdExists ? "Found at project root" : "Not found",
+    suggestion: agentsMdExists ? void 0 : "Create AGENTS.md with project context for Codex"
+  });
   const claudeSkills = countFiles(join2(dir, ".claude", "skills"), /\.(md|SKILL\.md)$/);
-  const skillCount = claudeSkills.length;
+  const codexSkills = countFiles(join2(dir, ".agents", "skills"), /SKILL\.md$/);
+  const skillCount = claudeSkills.length + codexSkills.length;
   const skillBase = skillCount >= 1 ? POINTS_SKILLS_EXIST : 0;
   const skillBonus = Math.min((skillCount - 1) * POINTS_SKILLS_BONUS_PER_EXTRA, POINTS_SKILLS_BONUS_CAP);
   const skillPoints = skillCount >= 1 ? skillBase + Math.max(0, skillBonus) : 0;
@@ -3030,9 +3111,9 @@ function checkExistence(dir) {
 // src/scoring/checks/quality.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { join as join3 } from "path";
-function readFileOrNull2(path23) {
+function readFileOrNull2(path24) {
   try {
-    return readFileSync3(path23, "utf-8");
+    return readFileSync3(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3044,11 +3125,13 @@ function checkQuality(dir) {
   const checks = [];
   const claudeMd = readFileOrNull2(join3(dir, "CLAUDE.md"));
   const cursorrules = readFileOrNull2(join3(dir, ".cursorrules"));
-  const allContent = [claudeMd, cursorrules].filter(Boolean);
+  const agentsMd = readFileOrNull2(join3(dir, "AGENTS.md"));
+  const allContent = [claudeMd, cursorrules, agentsMd].filter(Boolean);
   const combinedContent = allContent.join("\n");
-  const hasCommands = claudeMd ? COMMAND_PATTERNS.some((p) => p.test(claudeMd)) : false;
-  const matchedCommands = claudeMd ? COMMAND_PATTERNS.filter((p) => p.test(claudeMd)).map((p) => {
-    const m = claudeMd.match(p);
+  const primaryInstructions = claudeMd ?? agentsMd;
+  const hasCommands = primaryInstructions ? COMMAND_PATTERNS.some((p) => p.test(primaryInstructions)) : false;
+  const matchedCommands = primaryInstructions ? COMMAND_PATTERNS.filter((p) => p.test(primaryInstructions)).map((p) => {
+    const m = primaryInstructions.match(p);
     return m ? m[0] : "";
   }).filter(Boolean) : [];
   checks.push({
@@ -3058,11 +3141,11 @@ function checkQuality(dir) {
     maxPoints: POINTS_HAS_COMMANDS,
     earnedPoints: hasCommands ? POINTS_HAS_COMMANDS : 0,
     passed: hasCommands,
-    detail: hasCommands ? `Found: ${matchedCommands.slice(0, 3).join(", ")}` : claudeMd ? "No build/test/lint commands detected" : "No CLAUDE.md to check",
-    suggestion: hasCommands ? void 0 : "Add build, test, and lint commands to CLAUDE.md"
+    detail: hasCommands ? `Found: ${matchedCommands.slice(0, 3).join(", ")}` : primaryInstructions ? "No build/test/lint commands detected" : "No instructions file to check",
+    suggestion: hasCommands ? void 0 : "Add build, test, and lint commands to your instructions file"
   });
-  const primaryFile = claudeMd ?? cursorrules;
-  const primaryName = claudeMd ? "CLAUDE.md" : cursorrules ? ".cursorrules" : null;
+  const primaryFile = claudeMd ?? agentsMd ?? cursorrules;
+  const primaryName = claudeMd ? "CLAUDE.md" : agentsMd ? "AGENTS.md" : cursorrules ? ".cursorrules" : null;
   let bloatPoints = 0;
   let lineCount = 0;
   if (primaryFile) {
@@ -3183,15 +3266,15 @@ function checkQuality(dir) {
 // src/scoring/checks/accuracy.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import { join as join4 } from "path";
-function readFileOrNull3(path23) {
+function readFileOrNull3(path24) {
   try {
-    return readFileSync4(path23, "utf-8");
+    return readFileSync4(path24, "utf-8");
   } catch {
     return null;
   }
 }
-function readJsonOrNull2(path23) {
-  const content = readFileOrNull3(path23);
+function readJsonOrNull2(path24) {
+  const content = readFileOrNull3(path24);
   if (!content) return null;
   try {
     return JSON.parse(content);
@@ -3372,11 +3455,11 @@ function checkAccuracy(dir) {
 }
 
 // src/scoring/checks/freshness.ts
-import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { join as join5 } from "path";
-function readFileOrNull4(path23) {
+function readFileOrNull4(path24) {
   try {
-    return readFileSync5(path23, "utf-8");
+    return readFileSync5(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3394,11 +3477,14 @@ function daysSinceModified(filePath) {
 function checkFreshness(dir) {
   const checks = [];
   const claudeMdPath = join5(dir, "CLAUDE.md");
-  const daysOld = daysSinceModified(claudeMdPath);
+  const agentsMdPath = join5(dir, "AGENTS.md");
+  const primaryPath = existsSync6(claudeMdPath) ? claudeMdPath : agentsMdPath;
+  const primaryName = existsSync6(claudeMdPath) ? "CLAUDE.md" : "AGENTS.md";
+  const daysOld = daysSinceModified(primaryPath);
   let freshnessPoints = 0;
   let freshnessDetail = "";
   if (daysOld === null) {
-    freshnessDetail = "No CLAUDE.md to check";
+    freshnessDetail = "No instructions file to check";
   } else {
     const threshold = FRESHNESS_THRESHOLDS.find((t) => daysOld <= t.maxDaysOld);
     freshnessPoints = threshold ? threshold.points : 0;
@@ -3406,16 +3492,17 @@ function checkFreshness(dir) {
   }
   checks.push({
     id: "claude_md_freshness",
-    name: "CLAUDE.md freshness",
+    name: `${primaryName} freshness`,
     category: "freshness",
     maxPoints: POINTS_FRESHNESS,
     earnedPoints: freshnessPoints,
     passed: freshnessPoints >= 4,
     detail: freshnessDetail,
-    suggestion: daysOld !== null && freshnessPoints < 4 ? `CLAUDE.md is ${daysOld} days old \u2014 run \`caliber refresh\` to update it` : void 0
+    suggestion: daysOld !== null && freshnessPoints < 4 ? `${primaryName} is ${daysOld} days old \u2014 run \`caliber refresh\` to update it` : void 0
   });
   const filesToScan = [
     "CLAUDE.md",
+    "AGENTS.md",
     ".cursorrules",
     ".claude/settings.json",
     ".claude/settings.local.json",
@@ -3486,9 +3573,9 @@ function checkFreshness(dir) {
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "fs";
 import { execSync as execSync7 } from "child_process";
 import { join as join6 } from "path";
-function readFileOrNull5(path23) {
+function readFileOrNull5(path24) {
   try {
-    return readFileSync6(path23, "utf-8");
+    return readFileSync6(path24, "utf-8");
   } catch {
     return null;
   }
@@ -3583,22 +3670,22 @@ function checkBonus(dir) {
 
 // src/scoring/dismissed.ts
 init_constants();
-import fs16 from "fs";
-import path14 from "path";
-var DISMISSED_FILE = path14.join(CALIBER_DIR, "dismissed-checks.json");
+import fs17 from "fs";
+import path15 from "path";
+var DISMISSED_FILE = path15.join(CALIBER_DIR, "dismissed-checks.json");
 function readDismissedChecks() {
   try {
-    if (!fs16.existsSync(DISMISSED_FILE)) return [];
-    return JSON.parse(fs16.readFileSync(DISMISSED_FILE, "utf-8"));
+    if (!fs17.existsSync(DISMISSED_FILE)) return [];
+    return JSON.parse(fs17.readFileSync(DISMISSED_FILE, "utf-8"));
   } catch {
     return [];
   }
 }
 function writeDismissedChecks(checks) {
-  if (!fs16.existsSync(CALIBER_DIR)) {
-    fs16.mkdirSync(CALIBER_DIR, { recursive: true });
+  if (!fs17.existsSync(CALIBER_DIR)) {
+    fs17.mkdirSync(CALIBER_DIR, { recursive: true });
   }
-  fs16.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
+  fs17.writeFileSync(DISMISSED_FILE, JSON.stringify(checks, null, 2) + "\n");
 }
 function getDismissedIds() {
   return new Set(readDismissedChecks().map((c) => c.id));
@@ -3614,21 +3701,19 @@ function sumCategory(checks, category) {
 }
 function filterChecksForTarget(checks, target) {
   return checks.filter((c) => {
-    if (target === "claude") {
-      return !CURSOR_ONLY_CHECKS.has(c.id) && !BOTH_ONLY_CHECKS.has(c.id);
-    }
-    if (target === "cursor") {
-      return !CLAUDE_ONLY_CHECKS.has(c.id) && !BOTH_ONLY_CHECKS.has(c.id);
-    }
+    if (CLAUDE_ONLY_CHECKS.has(c.id)) return target.includes("claude");
+    if (CURSOR_ONLY_CHECKS.has(c.id)) return target.includes("cursor");
+    if (CODEX_ONLY_CHECKS.has(c.id)) return target.includes("codex");
+    if (BOTH_ONLY_CHECKS.has(c.id)) return target.includes("claude") && target.includes("cursor");
     return true;
   });
 }
 function detectTargetAgent(dir) {
-  const hasClaude = existsSync8(join7(dir, "CLAUDE.md")) || existsSync8(join7(dir, ".claude", "skills"));
-  const hasCursor = existsSync8(join7(dir, ".cursorrules")) || existsSync8(join7(dir, ".cursor", "rules"));
-  if (hasClaude && hasCursor) return "both";
-  if (hasCursor) return "cursor";
-  return "claude";
+  const agents = [];
+  if (existsSync8(join7(dir, "CLAUDE.md")) || existsSync8(join7(dir, ".claude", "skills"))) agents.push("claude");
+  if (existsSync8(join7(dir, ".cursorrules")) || existsSync8(join7(dir, ".cursor", "rules"))) agents.push("cursor");
+  if (existsSync8(join7(dir, ".codex")) || existsSync8(join7(dir, ".agents", "skills"))) agents.push("codex");
+  return agents.length > 0 ? agents : ["claude"];
 }
 function computeLocalScore(dir, targetAgent) {
   const target = targetAgent ?? detectTargetAgent(dir);
@@ -3665,6 +3750,11 @@ function computeLocalScore(dir, targetAgent) {
 
 // src/scoring/display.ts
 import chalk3 from "chalk";
+var AGENT_DISPLAY_NAMES = {
+  claude: "Claude Code",
+  cursor: "Cursor",
+  codex: "Codex"
+};
 var CATEGORY_LABELS = {
   existence: "FILES & SETUP",
   quality: "QUALITY",
@@ -3707,7 +3797,7 @@ function formatCheck(check) {
 }
 function displayScore(result) {
   const gc = gradeColor(result.grade);
-  const agentLabel = result.targetAgent === "both" ? "Claude Code + Cursor" : result.targetAgent === "claude" ? "Claude Code" : "Cursor";
+  const agentLabel = result.targetAgent.map((a) => AGENT_DISPLAY_NAMES[a] || a).join(" + ");
   console.log("");
   console.log(chalk3.gray("  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E"));
   console.log(chalk3.gray("  \u2502") + "                                                   " + chalk3.gray("\u2502"));
@@ -3733,7 +3823,7 @@ function displayScore(result) {
 }
 function displayScoreSummary(result) {
   const gc = gradeColor(result.grade);
-  const agentLabel = result.targetAgent === "both" ? "Claude Code + Cursor" : result.targetAgent === "claude" ? "Claude Code" : "Cursor";
+  const agentLabel = result.targetAgent.map((a) => AGENT_DISPLAY_NAMES[a] || a).join(" + ");
   console.log("");
   console.log(
     chalk3.gray("  ") + gc(`${result.score}/${result.maxScore}`) + chalk3.gray(` (Grade ${result.grade})`) + chalk3.gray(`  \xB7  ${agentLabel}`) + chalk3.gray(`  \xB7  ${progressBar(result.score, result.maxScore, 20)}`)
@@ -3799,8 +3889,8 @@ function displayScoreDelta(before, after) {
 import chalk4 from "chalk";
 import ora from "ora";
 import readline3 from "readline";
-import fs17 from "fs";
-import path15 from "path";
+import fs18 from "fs";
+import path16 from "path";
 
 // src/mcp/search.ts
 var AWESOME_MCP_URL = "https://raw.githubusercontent.com/punkpeye/awesome-mcp-servers/main/README.md";
@@ -4147,36 +4237,36 @@ async function discoverAndInstallMcps(targetAgent, fingerprint, dir) {
   if (installedNames.length === 0) {
     return { installed: 0, names: [] };
   }
-  if (targetAgent === "claude" || targetAgent === "both") {
-    writeMcpJson(path15.join(dir, ".mcp.json"), mcpServers);
+  if (targetAgent.includes("claude") || targetAgent.includes("codex")) {
+    writeMcpJson(path16.join(dir, ".mcp.json"), mcpServers);
   }
-  if (targetAgent === "cursor" || targetAgent === "both") {
-    const cursorDir = path15.join(dir, ".cursor");
-    if (!fs17.existsSync(cursorDir)) fs17.mkdirSync(cursorDir, { recursive: true });
-    writeMcpJson(path15.join(cursorDir, "mcp.json"), mcpServers);
+  if (targetAgent.includes("cursor")) {
+    const cursorDir = path16.join(dir, ".cursor");
+    if (!fs18.existsSync(cursorDir)) fs18.mkdirSync(cursorDir, { recursive: true });
+    writeMcpJson(path16.join(cursorDir, "mcp.json"), mcpServers);
   }
   return { installed: installedNames.length, names: installedNames };
 }
 function writeMcpJson(filePath, mcpServers) {
   let existing = {};
   try {
-    if (fs17.existsSync(filePath)) {
-      const parsed = JSON.parse(fs17.readFileSync(filePath, "utf-8"));
+    if (fs18.existsSync(filePath)) {
+      const parsed = JSON.parse(fs18.readFileSync(filePath, "utf-8"));
       if (parsed.mcpServers) existing = parsed.mcpServers;
     }
   } catch {
   }
   const merged = { ...existing, ...mcpServers };
-  fs17.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
+  fs18.writeFileSync(filePath, JSON.stringify({ mcpServers: merged }, null, 2) + "\n");
 }
 function getExistingMcpNames(fingerprint, targetAgent) {
   const names = [];
-  if (targetAgent === "claude" || targetAgent === "both") {
+  if (targetAgent.includes("claude")) {
     if (fingerprint.existingConfigs.claudeMcpServers) {
       names.push(...Object.keys(fingerprint.existingConfigs.claudeMcpServers).map((k) => k.toLowerCase()));
     }
   }
-  if (targetAgent === "cursor" || targetAgent === "both") {
+  if (targetAgent.includes("cursor")) {
     if (fingerprint.existingConfigs.cursorMcpServers) {
       names.push(...Object.keys(fingerprint.existingConfigs.cursorMcpServers).map((k) => k.toLowerCase()));
     }
@@ -4355,7 +4445,7 @@ async function initCommand(options) {
   }
   const baselineScore = computeLocalScore(process.cwd(), targetAgent);
   displayScoreSummary(baselineScore);
-  const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length);
+  const hasExistingConfig = !!(fingerprint.existingConfigs.claudeMd || fingerprint.existingConfigs.claudeSettings || fingerprint.existingConfigs.claudeSkills?.length || fingerprint.existingConfigs.cursorrules || fingerprint.existingConfigs.cursorRules?.length || fingerprint.existingConfigs.agentsMd);
   const NON_LLM_CHECKS = /* @__PURE__ */ new Set(["hooks_configured", "agents_md_exists", "permissions_configured", "mcp_servers"]);
   if (hasExistingConfig && baselineScore.score === 100) {
     console.log(chalk5.bold.green("  Your setup is already optimal \u2014 nothing to change.\n"));
@@ -4656,7 +4746,7 @@ async function refineLoop(currentSetup, _targetAgent, sessionHistory) {
 }
 function summarizeSetup(action, setup) {
   const descriptions = setup.fileDescriptions;
-  const files = descriptions ? Object.entries(descriptions).map(([path23, desc]) => `  ${path23}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
+  const files = descriptions ? Object.entries(descriptions).map(([path24, desc]) => `  ${path24}: ${desc}`).join("\n") : Object.keys(setup).filter((k) => k !== "targetAgent" && k !== "fileDescriptions").join(", ");
   return `${action}. Files:
 ${files}`;
 }
@@ -4717,22 +4807,28 @@ function promptInput3(question) {
   });
 }
 async function promptAgent() {
-  return select2({
-    message: "Which coding agent are you using?",
+  const selected = await checkbox({
+    message: "Which coding agents do you use? (toggle with space)",
     choices: [
       { name: "Claude Code", value: "claude" },
       { name: "Cursor", value: "cursor" },
-      { name: "Both", value: "both" }
-    ]
+      { name: "Codex (OpenAI)", value: "codex" }
+    ],
+    validate: (items) => {
+      if (items.length === 0) return "At least one agent must be selected";
+      return true;
+    }
   });
+  return selected;
 }
 async function promptHookType(targetAgent) {
   const choices = [];
-  if (targetAgent === "claude" || targetAgent === "both") {
+  const hasClaude = targetAgent.includes("claude");
+  if (hasClaude) {
     choices.push({ name: "Claude Code hook (auto-refresh on session end)", value: "claude" });
   }
   choices.push({ name: "Git pre-commit hook (refresh before each commit)", value: "precommit" });
-  if (targetAgent === "claude" || targetAgent === "both") {
+  if (hasClaude) {
     choices.push({ name: "Both (Claude Code + pre-commit)", value: "both" });
   }
   choices.push({ name: "Skip for now", value: "skip" });
@@ -4776,8 +4872,8 @@ async function openReview(method, stagedFiles) {
     return;
   }
   const fileInfos = stagedFiles.map((file) => {
-    const proposed = fs18.readFileSync(file.proposedPath, "utf-8");
-    const current = file.currentPath ? fs18.readFileSync(file.currentPath, "utf-8") : "";
+    const proposed = fs19.readFileSync(file.proposedPath, "utf-8");
+    const current = file.currentPath ? fs19.readFileSync(file.currentPath, "utf-8") : "";
     const patch = createTwoFilesPatch(
       file.isNew ? "/dev/null" : file.relativePath,
       file.relativePath,
@@ -4960,7 +5056,7 @@ function printSetupSummary(setup) {
   };
   if (claude) {
     if (claude.claudeMd) {
-      const icon = fs18.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
+      const icon = fs19.existsSync("CLAUDE.md") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription("CLAUDE.md");
       console.log(`  ${icon} ${chalk5.bold("CLAUDE.md")}`);
       if (desc) console.log(chalk5.dim(`    ${desc}`));
@@ -4970,7 +5066,28 @@ function printSetupSummary(setup) {
     if (Array.isArray(skills) && skills.length > 0) {
       for (const skill of skills) {
         const skillPath = `.claude/skills/${skill.name}/SKILL.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs19.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
+        const desc = getDescription(skillPath);
+        console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
+        console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
+        console.log("");
+      }
+    }
+  }
+  const codex = setup.codex;
+  if (codex) {
+    if (codex.agentsMd) {
+      const icon = fs19.existsSync("AGENTS.md") ? chalk5.yellow("~") : chalk5.green("+");
+      const desc = getDescription("AGENTS.md");
+      console.log(`  ${icon} ${chalk5.bold("AGENTS.md")}`);
+      if (desc) console.log(chalk5.dim(`    ${desc}`));
+      console.log("");
+    }
+    const codexSkills = codex.skills;
+    if (Array.isArray(codexSkills) && codexSkills.length > 0) {
+      for (const skill of codexSkills) {
+        const skillPath = `.agents/skills/${skill.name}/SKILL.md`;
+        const icon = fs19.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
         console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
@@ -4980,7 +5097,7 @@ function printSetupSummary(setup) {
   }
   if (cursor) {
     if (cursor.cursorrules) {
-      const icon = fs18.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
+      const icon = fs19.existsSync(".cursorrules") ? chalk5.yellow("~") : chalk5.green("+");
       const desc = getDescription(".cursorrules");
       console.log(`  ${icon} ${chalk5.bold(".cursorrules")}`);
       if (desc) console.log(chalk5.dim(`    ${desc}`));
@@ -4990,7 +5107,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(cursorSkills) && cursorSkills.length > 0) {
       for (const skill of cursorSkills) {
         const skillPath = `.cursor/skills/${skill.name}/SKILL.md`;
-        const icon = fs18.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs19.existsSync(skillPath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(skillPath);
         console.log(`  ${icon} ${chalk5.bold(skillPath)}`);
         console.log(chalk5.dim(`    ${desc || skill.description || skill.name}`));
@@ -5001,7 +5118,7 @@ function printSetupSummary(setup) {
     if (Array.isArray(rules) && rules.length > 0) {
       for (const rule of rules) {
         const rulePath = `.cursor/rules/${rule.filename}`;
-        const icon = fs18.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
+        const icon = fs19.existsSync(rulePath) ? chalk5.yellow("~") : chalk5.green("+");
         const desc = getDescription(rulePath);
         console.log(`  ${icon} ${chalk5.bold(rulePath)}`);
         if (desc) {
@@ -5014,7 +5131,7 @@ function printSetupSummary(setup) {
       }
     }
   }
-  if (!fs18.existsSync("AGENTS.md")) {
+  if (!codex && !fs19.existsSync("AGENTS.md")) {
     console.log(`  ${chalk5.green("+")} ${chalk5.bold("AGENTS.md")}`);
     console.log(chalk5.dim("    Cross-agent coordination file"));
     console.log("");
@@ -5042,8 +5159,8 @@ function ensurePermissions() {
   const settingsPath = ".claude/settings.json";
   let settings = {};
   try {
-    if (fs18.existsSync(settingsPath)) {
-      settings = JSON.parse(fs18.readFileSync(settingsPath, "utf-8"));
+    if (fs19.existsSync(settingsPath)) {
+      settings = JSON.parse(fs19.readFileSync(settingsPath, "utf-8"));
     }
   } catch {
   }
@@ -5057,13 +5174,14 @@ function ensurePermissions() {
     "Bash(git *)"
   ];
   settings.permissions = permissions;
-  if (!fs18.existsSync(".claude")) fs18.mkdirSync(".claude", { recursive: true });
-  fs18.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (!fs19.existsSync(".claude")) fs19.mkdirSync(".claude", { recursive: true });
+  fs19.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
 }
 function collectSetupFiles(setup) {
   const files = [];
   const claude = setup.claude;
   const cursor = setup.cursor;
+  const codex = setup.codex;
   if (claude) {
     if (claude.claudeMd) files.push({ path: "CLAUDE.md", content: claude.claudeMd });
     const skills = claude.skills;
@@ -5073,6 +5191,15 @@ function collectSetupFiles(setup) {
       }
     }
   }
+  if (codex) {
+    if (codex.agentsMd) files.push({ path: "AGENTS.md", content: codex.agentsMd });
+    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) });
+      }
+    }
+  }
   if (cursor) {
     if (cursor.cursorrules) files.push({ path: ".cursorrules", content: cursor.cursorrules });
     const cursorSkills = cursor.skills;
@@ -5088,7 +5215,8 @@ function collectSetupFiles(setup) {
       }
     }
   }
-  if (!fs18.existsSync("AGENTS.md")) {
+  const hasCodexAgentsMd = codex && codex.agentsMd;
+  if (!fs19.existsSync("AGENTS.md") && !hasCodexAgentsMd) {
     const agentRefs = [];
     if (claude) agentRefs.push("See `CLAUDE.md` for Claude Code configuration.");
     if (cursor) agentRefs.push("See `.cursor/rules/` for Cursor rules.");
@@ -5139,7 +5267,7 @@ function undoCommand() {
 
 // src/commands/status.ts
 import chalk7 from "chalk";
-import fs19 from "fs";
+import fs20 from "fs";
 async function statusCommand(options) {
   const config = loadConfig();
   const manifest = readManifest();
@@ -5165,7 +5293,7 @@ async function statusCommand(options) {
   }
   console.log(`  Files managed: ${chalk7.cyan(manifest.entries.length.toString())}`);
   for (const entry of manifest.entries) {
-    const exists = fs19.existsSync(entry.path);
+    const exists = fs20.existsSync(entry.path);
     const icon = exists ? chalk7.green("\u2713") : chalk7.red("\u2717");
     console.log(`    ${icon} ${entry.path} (${entry.action})`);
   }
@@ -5195,7 +5323,7 @@ async function regenerateCommand(options) {
   genMessages.start();
   let generatedSetup = null;
   try {
-    const targetAgent = readState()?.targetAgent ?? "both";
+    const targetAgent = readState()?.targetAgent ?? ["claude", "cursor"];
     const result2 = await generateSetup(
       fingerprint,
       targetAgent,
@@ -5252,13 +5380,13 @@ import { mkdirSync, readFileSync as readFileSync7, readdirSync as readdirSync5,
 import { join as join8, dirname as dirname2 } from "path";
 
 // src/scanner/index.ts
-import fs20 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path17 from "path";
 import crypto2 from "crypto";
 function scanLocalState(dir) {
   const items = [];
-  const claudeMdPath = path16.join(dir, "CLAUDE.md");
-  if (fs20.existsSync(claudeMdPath)) {
+  const claudeMdPath = path17.join(dir, "CLAUDE.md");
+  if (fs21.existsSync(claudeMdPath)) {
     items.push({
       type: "rule",
       platform: "claude",
@@ -5267,10 +5395,10 @@ function scanLocalState(dir) {
       path: claudeMdPath
     });
   }
-  const skillsDir = path16.join(dir, ".claude", "skills");
-  if (fs20.existsSync(skillsDir)) {
-    for (const file of fs20.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
-      const filePath = path16.join(skillsDir, file);
+  const skillsDir = path17.join(dir, ".claude", "skills");
+  if (fs21.existsSync(skillsDir)) {
+    for (const file of fs21.readdirSync(skillsDir).filter((f) => f.endsWith(".md"))) {
+      const filePath = path17.join(skillsDir, file);
       items.push({
         type: "skill",
         platform: "claude",
@@ -5280,10 +5408,10 @@ function scanLocalState(dir) {
       });
     }
   }
-  const mcpJsonPath = path16.join(dir, ".mcp.json");
-  if (fs20.existsSync(mcpJsonPath)) {
+  const mcpJsonPath = path17.join(dir, ".mcp.json");
+  if (fs21.existsSync(mcpJsonPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(mcpJsonPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(mcpJsonPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5298,8 +5426,36 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorrulesPath = path16.join(dir, ".cursorrules");
-  if (fs20.existsSync(cursorrulesPath)) {
+  const agentsMdPath = path17.join(dir, "AGENTS.md");
+  if (fs21.existsSync(agentsMdPath)) {
+    items.push({
+      type: "rule",
+      platform: "codex",
+      name: "AGENTS.md",
+      contentHash: hashFile(agentsMdPath),
+      path: agentsMdPath
+    });
+  }
+  const codexSkillsDir = path17.join(dir, ".agents", "skills");
+  if (fs21.existsSync(codexSkillsDir)) {
+    try {
+      for (const name of fs21.readdirSync(codexSkillsDir)) {
+        const skillFile = path17.join(codexSkillsDir, name, "SKILL.md");
+        if (fs21.existsSync(skillFile)) {
+          items.push({
+            type: "skill",
+            platform: "codex",
+            name: `${name}/SKILL.md`,
+            contentHash: hashFile(skillFile),
+            path: skillFile
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  const cursorrulesPath = path17.join(dir, ".cursorrules");
+  if (fs21.existsSync(cursorrulesPath)) {
     items.push({
       type: "rule",
       platform: "cursor",
@@ -5308,10 +5464,10 @@ function scanLocalState(dir) {
       path: cursorrulesPath
     });
   }
-  const cursorRulesDir = path16.join(dir, ".cursor", "rules");
-  if (fs20.existsSync(cursorRulesDir)) {
-    for (const file of fs20.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
-      const filePath = path16.join(cursorRulesDir, file);
+  const cursorRulesDir = path17.join(dir, ".cursor", "rules");
+  if (fs21.existsSync(cursorRulesDir)) {
+    for (const file of fs21.readdirSync(cursorRulesDir).filter((f) => f.endsWith(".mdc"))) {
+      const filePath = path17.join(cursorRulesDir, file);
       items.push({
         type: "rule",
         platform: "cursor",
@@ -5321,12 +5477,12 @@ function scanLocalState(dir) {
       });
     }
   }
-  const cursorSkillsDir = path16.join(dir, ".cursor", "skills");
-  if (fs20.existsSync(cursorSkillsDir)) {
+  const cursorSkillsDir = path17.join(dir, ".cursor", "skills");
+  if (fs21.existsSync(cursorSkillsDir)) {
     try {
-      for (const name of fs20.readdirSync(cursorSkillsDir)) {
-        const skillFile = path16.join(cursorSkillsDir, name, "SKILL.md");
-        if (fs20.existsSync(skillFile)) {
+      for (const name of fs21.readdirSync(cursorSkillsDir)) {
+        const skillFile = path17.join(cursorSkillsDir, name, "SKILL.md");
+        if (fs21.existsSync(skillFile)) {
           items.push({
             type: "skill",
             platform: "cursor",
@@ -5339,10 +5495,10 @@ function scanLocalState(dir) {
     } catch {
     }
   }
-  const cursorMcpPath = path16.join(dir, ".cursor", "mcp.json");
-  if (fs20.existsSync(cursorMcpPath)) {
+  const cursorMcpPath = path17.join(dir, ".cursor", "mcp.json");
+  if (fs21.existsSync(cursorMcpPath)) {
     try {
-      const mcpJson = JSON.parse(fs20.readFileSync(cursorMcpPath, "utf-8"));
+      const mcpJson = JSON.parse(fs21.readFileSync(cursorMcpPath, "utf-8"));
       if (mcpJson.mcpServers) {
         for (const name of Object.keys(mcpJson.mcpServers)) {
           items.push({
@@ -5360,7 +5516,7 @@ function scanLocalState(dir) {
   return items;
 }
 function hashFile(filePath) {
-  const text = fs20.readFileSync(filePath, "utf-8");
+  const text = fs21.readFileSync(filePath, "utf-8");
   return crypto2.createHash("sha256").update(JSON.stringify({ text })).digest("hex");
 }
 function hashJson(obj) {
@@ -5380,13 +5536,17 @@ function getSkillPath(platform, slug) {
   if (platform === "cursor") {
     return join8(".cursor", "skills", slug, "SKILL.md");
   }
+  if (platform === "codex") {
+    return join8(".agents", "skills", slug, "SKILL.md");
+  }
   return join8(".claude", "skills", slug, "SKILL.md");
 }
 function getInstalledSkills() {
   const installed = /* @__PURE__ */ new Set();
   const dirs = [
     join8(process.cwd(), ".claude", "skills"),
-    join8(process.cwd(), ".cursor", "skills")
+    join8(process.cwd(), ".cursor", "skills"),
+    join8(process.cwd(), ".agents", "skills")
   ];
   for (const dir of dirs) {
     try {
@@ -5834,7 +5994,8 @@ async function fetchSkillContent(rec) {
   const candidates = [
     `https://raw.githubusercontent.com/${repoPath}/HEAD/skills/${rec.slug}/SKILL.md`,
     `https://raw.githubusercontent.com/${repoPath}/HEAD/${rec.slug}/SKILL.md`,
-    `https://raw.githubusercontent.com/${repoPath}/HEAD/.claude/skills/${rec.slug}/SKILL.md`
+    `https://raw.githubusercontent.com/${repoPath}/HEAD/.claude/skills/${rec.slug}/SKILL.md`,
+    `https://raw.githubusercontent.com/${repoPath}/HEAD/.agents/skills/${rec.slug}/SKILL.md`
   ];
   for (const url of candidates) {
     try {
@@ -5936,8 +6097,8 @@ async function scoreCommand(options) {
 }
 
 // src/commands/refresh.ts
-import fs22 from "fs";
-import path18 from "path";
+import fs23 from "fs";
+import path19 from "path";
 import chalk11 from "chalk";
 import ora6 from "ora";
 
@@ -6014,37 +6175,37 @@ function collectDiff(lastSha) {
 }
 
 // src/writers/refresh.ts
-import fs21 from "fs";
-import path17 from "path";
+import fs22 from "fs";
+import path18 from "path";
 function writeRefreshDocs(docs) {
   const written = [];
   if (docs.claudeMd) {
-    fs21.writeFileSync("CLAUDE.md", docs.claudeMd);
+    fs22.writeFileSync("CLAUDE.md", docs.claudeMd);
     written.push("CLAUDE.md");
   }
   if (docs.readmeMd) {
-    fs21.writeFileSync("README.md", docs.readmeMd);
+    fs22.writeFileSync("README.md", docs.readmeMd);
     written.push("README.md");
   }
   if (docs.cursorrules) {
-    fs21.writeFileSync(".cursorrules", docs.cursorrules);
+    fs22.writeFileSync(".cursorrules", docs.cursorrules);
     written.push(".cursorrules");
   }
   if (docs.cursorRules) {
-    const rulesDir = path17.join(".cursor", "rules");
-    if (!fs21.existsSync(rulesDir)) fs21.mkdirSync(rulesDir, { recursive: true });
+    const rulesDir = path18.join(".cursor", "rules");
+    if (!fs22.existsSync(rulesDir)) fs22.mkdirSync(rulesDir, { recursive: true });
     for (const rule of docs.cursorRules) {
-      const filePath = path17.join(rulesDir, rule.filename);
-      fs21.writeFileSync(filePath, rule.content);
+      const filePath = path18.join(rulesDir, rule.filename);
+      fs22.writeFileSync(filePath, rule.content);
       written.push(filePath);
     }
   }
   if (docs.claudeSkills) {
-    const skillsDir = path17.join(".claude", "skills");
-    if (!fs21.existsSync(skillsDir)) fs21.mkdirSync(skillsDir, { recursive: true });
+    const skillsDir = path18.join(".claude", "skills");
+    if (!fs22.existsSync(skillsDir)) fs22.mkdirSync(skillsDir, { recursive: true });
     for (const skill of docs.claudeSkills) {
-      const filePath = path17.join(skillsDir, skill.filename);
-      fs21.writeFileSync(filePath, skill.content);
+      const filePath = path18.join(skillsDir, skill.filename);
+      fs22.writeFileSync(filePath, skill.content);
       written.push(filePath);
     }
   }
@@ -6119,11 +6280,11 @@ function log(quiet, ...args) {
 function discoverGitRepos(parentDir) {
   const repos = [];
   try {
-    const entries = fs22.readdirSync(parentDir, { withFileTypes: true });
+    const entries = fs23.readdirSync(parentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const childPath = path18.join(parentDir, entry.name);
-      if (fs22.existsSync(path18.join(childPath, ".git"))) {
+      const childPath = path19.join(parentDir, entry.name);
+      if (fs23.existsSync(path19.join(childPath, ".git"))) {
         repos.push(childPath);
       }
     }
@@ -6218,7 +6379,7 @@ async function refreshCommand(options) {
 `));
     const originalDir = process.cwd();
     for (const repo of repos) {
-      const repoName = path18.basename(repo);
+      const repoName = path19.basename(repo);
       try {
         process.chdir(repo);
         await refreshSingleRepo(repo, { ...options, label: repoName });
@@ -6465,8 +6626,8 @@ function readStdin() {
 
 // src/learner/storage.ts
 init_constants();
-import fs23 from "fs";
-import path19 from "path";
+import fs24 from "fs";
+import path20 from "path";
 var MAX_RESPONSE_LENGTH = 2e3;
 var DEFAULT_STATE = {
   sessionId: null,
@@ -6474,15 +6635,15 @@ var DEFAULT_STATE = {
   lastAnalysisTimestamp: null
 };
 function ensureLearningDir() {
-  if (!fs23.existsSync(LEARNING_DIR)) {
-    fs23.mkdirSync(LEARNING_DIR, { recursive: true });
+  if (!fs24.existsSync(LEARNING_DIR)) {
+    fs24.mkdirSync(LEARNING_DIR, { recursive: true });
   }
 }
 function sessionFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_SESSION_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_SESSION_FILE);
 }
 function stateFilePath() {
-  return path19.join(LEARNING_DIR, LEARNING_STATE_FILE);
+  return path20.join(LEARNING_DIR, LEARNING_STATE_FILE);
 }
 function truncateResponse(response) {
   const str = JSON.stringify(response);
@@ -6493,50 +6654,50 @@ function appendEvent(event) {
   ensureLearningDir();
   const truncated = { ...event, tool_response: truncateResponse(event.tool_response) };
   const filePath = sessionFilePath();
-  fs23.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
+  fs24.appendFileSync(filePath, JSON.stringify(truncated) + "\n");
   const count = getEventCount();
   if (count > LEARNING_MAX_EVENTS) {
-    const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+    const lines = fs24.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
     const kept = lines.slice(lines.length - LEARNING_MAX_EVENTS);
-    fs23.writeFileSync(filePath, kept.join("\n") + "\n");
+    fs24.writeFileSync(filePath, kept.join("\n") + "\n");
   }
 }
 function readAllEvents() {
   const filePath = sessionFilePath();
-  if (!fs23.existsSync(filePath)) return [];
-  const lines = fs23.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+  if (!fs24.existsSync(filePath)) return [];
+  const lines = fs24.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
   return lines.map((line) => JSON.parse(line));
 }
 function getEventCount() {
   const filePath = sessionFilePath();
-  if (!fs23.existsSync(filePath)) return 0;
-  const content = fs23.readFileSync(filePath, "utf-8");
+  if (!fs24.existsSync(filePath)) return 0;
+  const content = fs24.readFileSync(filePath, "utf-8");
   return content.split("\n").filter(Boolean).length;
 }
 function clearSession() {
   const filePath = sessionFilePath();
-  if (fs23.existsSync(filePath)) fs23.unlinkSync(filePath);
+  if (fs24.existsSync(filePath)) fs24.unlinkSync(filePath);
 }
 function readState2() {
   const filePath = stateFilePath();
-  if (!fs23.existsSync(filePath)) return { ...DEFAULT_STATE };
+  if (!fs24.existsSync(filePath)) return { ...DEFAULT_STATE };
   try {
-    return JSON.parse(fs23.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs24.readFileSync(filePath, "utf-8"));
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 function writeState2(state) {
   ensureLearningDir();
-  fs23.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
+  fs24.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2));
 }
 function resetState() {
   writeState2({ ...DEFAULT_STATE });
 }
 
 // src/learner/writer.ts
-import fs24 from "fs";
-import path20 from "path";
+import fs25 from "fs";
+import path21 from "path";
 var LEARNED_START = "<!-- caliber:learned -->";
 var LEARNED_END = "<!-- /caliber:learned -->";
 function writeLearnedContent(update) {
@@ -6556,8 +6717,8 @@ function writeLearnedContent(update) {
 function writeLearnedSection(content) {
   const claudeMdPath = "CLAUDE.md";
   let existing = "";
-  if (fs24.existsSync(claudeMdPath)) {
-    existing = fs24.readFileSync(claudeMdPath, "utf-8");
+  if (fs25.existsSync(claudeMdPath)) {
+    existing = fs25.readFileSync(claudeMdPath, "utf-8");
   }
   const section = `${LEARNED_START}
 ${content}
@@ -6571,15 +6732,15 @@ ${LEARNED_END}`;
     const separator = existing.endsWith("\n") || existing === "" ? "" : "\n";
     updated = existing + separator + "\n" + section + "\n";
   }
-  fs24.writeFileSync(claudeMdPath, updated);
+  fs25.writeFileSync(claudeMdPath, updated);
 }
 function writeLearnedSkill(skill) {
-  const skillDir = path20.join(".claude", "skills", skill.name);
-  if (!fs24.existsSync(skillDir)) fs24.mkdirSync(skillDir, { recursive: true });
-  const skillPath = path20.join(skillDir, "SKILL.md");
-  if (!skill.isNew && fs24.existsSync(skillPath)) {
-    const existing = fs24.readFileSync(skillPath, "utf-8");
-    fs24.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
+  const skillDir = path21.join(".claude", "skills", skill.name);
+  if (!fs25.existsSync(skillDir)) fs25.mkdirSync(skillDir, { recursive: true });
+  const skillPath = path21.join(skillDir, "SKILL.md");
+  if (!skill.isNew && fs25.existsSync(skillPath)) {
+    const existing = fs25.readFileSync(skillPath, "utf-8");
+    fs25.writeFileSync(skillPath, existing.trimEnd() + "\n\n" + skill.content);
   } else {
     const frontmatter = [
       "---",
@@ -6588,14 +6749,14 @@ function writeLearnedSkill(skill) {
       "---",
       ""
     ].join("\n");
-    fs24.writeFileSync(skillPath, frontmatter + skill.content);
+    fs25.writeFileSync(skillPath, frontmatter + skill.content);
   }
   return skillPath;
 }
 function readLearnedSection() {
   const claudeMdPath = "CLAUDE.md";
-  if (!fs24.existsSync(claudeMdPath)) return null;
-  const content = fs24.readFileSync(claudeMdPath, "utf-8");
+  if (!fs25.existsSync(claudeMdPath)) return null;
+  const content = fs25.readFileSync(claudeMdPath, "utf-8");
   const startIdx = content.indexOf(LEARNED_START);
   const endIdx = content.indexOf(LEARNED_END);
   if (startIdx === -1 || endIdx === -1) return null;
@@ -6779,20 +6940,31 @@ Learned items in CLAUDE.md: ${chalk14.cyan(String(lineCount))}`);
 }
 
 // src/cli.ts
-var __dirname = path21.dirname(fileURLToPath(import.meta.url));
+var __dirname = path22.dirname(fileURLToPath(import.meta.url));
 var pkg = JSON.parse(
-  fs25.readFileSync(path21.resolve(__dirname, "..", "package.json"), "utf-8")
+  fs26.readFileSync(path22.resolve(__dirname, "..", "package.json"), "utf-8")
 );
 var program = new Command();
 var displayVersion = process.env.CALIBER_LOCAL ? `${pkg.version}-local` : pkg.version;
 program.name(process.env.CALIBER_LOCAL ? "caloc" : "caliber").description("Configure your coding agent environment").version(displayVersion);
-program.command("onboard").alias("init").description("Onboard your project for AI-assisted development").option("--agent <type>", "Target agent: claude, cursor, or both").option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").action(initCommand);
+function parseAgentOption(value) {
+  if (value === "both") return ["claude", "cursor"];
+  if (value === "all") return ["claude", "cursor", "codex"];
+  const valid = ["claude", "cursor", "codex"];
+  const agents = [...new Set(value.split(",").map((s) => s.trim().toLowerCase()).filter((a) => valid.includes(a)))];
+  if (agents.length === 0) {
+    console.error(`Invalid agent "${value}". Choose from: claude, cursor, codex (comma-separated for multiple)`);
+    process.exit(1);
+  }
+  return agents;
+}
+program.command("onboard").alias("init").description("Onboard your project for AI-assisted development").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).option("--dry-run", "Preview changes without writing files").option("--force", "Overwrite existing setup without prompting").action(initCommand);
 program.command("undo").description("Revert all config changes made by Caliber").action(undoCommand);
 program.command("status").description("Show current Caliber setup status").option("--json", "Output as JSON").action(statusCommand);
 program.command("regenerate").alias("regen").alias("re").alias("update").description("Re-analyze project and regenerate setup").option("--dry-run", "Preview changes without writing files").action(regenerateCommand);
 program.command("config").description("Configure LLM provider, API key, and model").action(configCommand);
 program.command("recommend").description("Discover and install skill recommendations").option("--generate", "Force fresh recommendation search").action(recommendCommand);
-program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agent: claude, cursor, or both").action(scoreCommand);
+program.command("score").description("Score your current agent config setup (deterministic, no network)").option("--json", "Output as JSON").option("--quiet", "One-line output for scripts/hooks").option("--agent <type>", "Target agents (comma-separated): claude, cursor, codex", parseAgentOption).action(scoreCommand);
 program.command("refresh").description("Update docs based on recent code changes").option("--quiet", "Suppress output (for use in hooks)").option("--dry-run", "Preview changes without writing files").action(refreshCommand);
 program.command("hooks").description("Manage auto-refresh hooks (toggle interactively)").option("--install", "Enable all hooks non-interactively").option("--remove", "Disable all hooks non-interactively").action(hooksCommand);
 var learn = program.command("learn").description("Session learning \u2014 observe tool usage and extract reusable instructions");
@@ -6803,22 +6975,22 @@ learn.command("remove").description("Remove learning hooks from .claude/settings
 learn.command("status").description("Show learning system status").action(learnStatusCommand);
 
 // src/utils/version-check.ts
-import fs26 from "fs";
-import path22 from "path";
+import fs27 from "fs";
+import path23 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { execSync as execSync9 } from "child_process";
 import chalk15 from "chalk";
 import ora7 from "ora";
 import confirm2 from "@inquirer/confirm";
-var __dirname_vc = path22.dirname(fileURLToPath2(import.meta.url));
+var __dirname_vc = path23.dirname(fileURLToPath2(import.meta.url));
 var pkg2 = JSON.parse(
-  fs26.readFileSync(path22.resolve(__dirname_vc, "..", "package.json"), "utf-8")
+  fs27.readFileSync(path23.resolve(__dirname_vc, "..", "package.json"), "utf-8")
 );
 function getInstalledVersion() {
   try {
     const globalRoot = execSync9("npm root -g", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-    const pkgPath = path22.join(globalRoot, "@rely-ai", "caliber", "package.json");
-    return JSON.parse(fs26.readFileSync(pkgPath, "utf-8")).version;
+    const pkgPath = path23.join(globalRoot, "@rely-ai", "caliber", "package.json");
+    return JSON.parse(fs27.readFileSync(pkgPath, "utf-8")).version;
   } catch {
     return null;
   }