aiblueprint-cli 1.4.60 → 1.4.62

package/dist/cli.js

@@ -32263,8 +32263,8 @@ var inquirer = {
 var lib_default = inquirer;
 
 // src/commands/setup.ts
-var import_fs_extra8 = __toESM(require_lib4(), 1);
-import path12 from "path";
+var import_fs_extra9 = __toESM(require_lib4(), 1);
+import path13 from "path";
 import os10 from "os";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -33481,6 +33481,7 @@ var TUI_STATUS_LINE_BLOCK = `status_line = [
 status_line_use_colors = true`;
 var TUI_SECTION = `[tui]
 ${TUI_STATUS_LINE_BLOCK}`;
+var COMMAND_DENY_HOOK_MARKER = "command-deny-list.ts";
 function hasTopLevelKey(content, key) {
   let inSection = false;
   for (const line of content.split(/\r?\n/)) {
@@ -33503,7 +33504,7 @@ function getTopLevelAssignments(defaultConfig) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
       continue;
-    if (/^\[[^\]]+\]$/.test(trimmed))
+    if (trimmed.startsWith("["))
       break;
     if (/^[A-Za-z0-9_-]+\s*=/.test(trimmed)) {
       assignments.push(line);
@@ -33553,6 +33554,45 @@ function appendBlock(content, block) {
 ${block}
 `;
 }
+function getDefaultHookBlocks(defaultConfig) {
+  const lines = defaultConfig.split(/\r?\n/);
+  const blocks = [];
+  let current = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const tableName = trimmed.startsWith("[[") && trimmed.endsWith("]]") ? trimmed.slice(2, -2) : trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : null;
+    if (tableName) {
+      const isHookTable = tableName.startsWith("hooks.");
+      if (!isHookTable) {
+        if (current) {
+          blocks.push(current.join(`
+`).trimEnd());
+          current = null;
+        }
+        continue;
+      }
+      current ??= [];
+    }
+    if (current) {
+      current.push(line);
+    }
+  }
+  if (current) {
+    blocks.push(current.join(`
+`).trimEnd());
+  }
+  return blocks.filter(Boolean);
+}
+function mergeDefaultHooks(existingConfig, defaultConfig) {
+  let merged = existingConfig;
+  for (const hookBlock of getDefaultHookBlocks(defaultConfig)) {
+    if (hookBlock.includes(COMMAND_DENY_HOOK_MARKER) && merged.includes(COMMAND_DENY_HOOK_MARKER)) {
+      continue;
+    }
+    merged = appendBlock(merged, hookBlock);
+  }
+  return merged;
+}
 function mergeCodexConfig(existingConfig, defaultConfig) {
   let merged = existingConfig.trimEnd();
   for (const assignment of getTopLevelAssignments(defaultConfig)) {
@@ -33561,6 +33601,7 @@ function mergeCodexConfig(existingConfig, defaultConfig) {
       merged = appendBlock(merged, assignment);
     }
   }
+  merged = mergeDefaultHooks(merged, defaultConfig).trimEnd();
   if (sectionHasKey(merged, "tui", "status_line")) {
     return `${merged}
 `;
@@ -33893,16 +33934,218 @@ async function listConfigBackups(options = {}) {
   return listSnapshots(paths.backupsDir, "backup");
 }
 
+// src/lib/codex-agents-renderer.ts
+var import_fs_extra8 = __toESM(require_lib4(), 1);
+import path12 from "path";
+var GENERATED_MARKER = "# Generated by aiblueprint-cli from Markdown agents.";
+var IGNORED_ENTRY_NAMES = new Set([".DS_Store", "node_modules"]);
+function parseFrontmatterValue(rawValue) {
+  const value = rawValue.trim();
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseMarkdownAgent(sourcePath, content) {
+  if (!content.startsWith(`---
+`))
+    return null;
+  const end = content.indexOf(`
+---`, 4);
+  if (end === -1)
+    return null;
+  const frontmatterText = content.slice(4, end);
+  const bodyStart = content.indexOf(`
+`, end + 4);
+  const body = bodyStart === -1 ? "" : content.slice(bodyStart + 1).trim();
+  const frontmatter = {};
+  const lines = frontmatterText.split(`
+`);
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index];
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match)
+      continue;
+    const key = match[1];
+    const rawValue = match[2];
+    if (rawValue === ">-" || rawValue === ">") {
+      const foldedLines = [];
+      while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+        index++;
+        foldedLines.push(lines[index].trim());
+      }
+      frontmatter[key] = foldedLines.join(" ");
+      continue;
+    }
+    if (rawValue === "|-" || rawValue === "|") {
+      const literalLines = [];
+      while (index + 1 < lines.length && /^\s+/.test(lines[index + 1])) {
+        index++;
+        literalLines.push(lines[index].replace(/^\s{2}/, ""));
+      }
+      frontmatter[key] = literalLines.join(`
+`);
+      continue;
+    }
+    frontmatter[key] = parseFrontmatterValue(rawValue);
+  }
+  return { sourcePath, frontmatter, body };
+}
+function normalizeCodexAgentName(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
+  if (!normalized)
+    return "agent";
+  if (/^[0-9]/.test(normalized))
+    return `agent_${normalized}`;
+  return normalized;
+}
+function mapModel(model) {
+  switch (model?.trim().toLowerCase()) {
+    case "haiku":
+      return "gpt-5.4-mini";
+    case "sonnet":
+      return "gpt-5.4";
+    case "opus":
+      return "gpt-5.5";
+    case "inherit":
+    case "":
+    case undefined:
+      return null;
+    default:
+      return model ?? null;
+  }
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlMultilineLiteral(value) {
+  if (value.includes("'''")) {
+    return tomlString(value);
+  }
+  return `'''
+${value}
+'''`;
+}
+function buildDeveloperInstructions(agent) {
+  const toolHints = agent.frontmatter.tools?.trim();
+  const color = agent.frontmatter.color?.trim();
+  const notes = [];
+  if (toolHints) {
+    notes.push(`Original tool hints from the Markdown agent: ${toolHints}.`);
+  }
+  if (color) {
+    notes.push(`Original display color metadata: ${color}.`);
+  }
+  const prefix = [
+    `Source Markdown agent: ${path12.basename(agent.sourcePath)}.`,
+    ...notes
+  ].join(`
+`);
+  return `${prefix}
+
+${agent.body}`.trim();
+}
+function renderToml(agent) {
+  const rawName = agent.frontmatter.name?.trim();
+  const description = agent.frontmatter.description?.trim();
+  if (!rawName || !description || !agent.body) {
+    return null;
+  }
+  const name = normalizeCodexAgentName(rawName);
+  const model = mapModel(agent.frontmatter.model);
+  const lines = [
+    GENERATED_MARKER,
+    `# Source: ${agent.sourcePath}`,
+    `name = ${tomlString(name)}`,
+    `description = ${tomlString(description)}`
+  ];
+  if (model) {
+    lines.push(`model = ${tomlString(model)}`);
+  }
+  lines.push(`developer_instructions = ${tomlMultilineLiteral(buildDeveloperInstructions(agent))}`);
+  lines.push("");
+  return {
+    name,
+    content: lines.join(`
+`)
+  };
+}
+async function canOverwriteTarget(targetPath, overwrite) {
+  if (overwrite)
+    return true;
+  const existing = await import_fs_extra8.default.readFile(targetPath, "utf-8").catch(() => null);
+  return existing?.startsWith(GENERATED_MARKER) ?? false;
+}
+async function ensureRealTargetDir(targetDir) {
+  const stat = await import_fs_extra8.default.lstat(targetDir).catch(() => null);
+  if (stat?.isSymbolicLink()) {
+    await import_fs_extra8.default.remove(targetDir);
+  }
+  await import_fs_extra8.default.ensureDir(targetDir);
+}
+async function renderCodexAgentsFromMarkdown(options = {}) {
+  const folders = resolveFolders(options);
+  const sourceDir = path12.join(folders.agentsDir, "agents");
+  const targetDir = path12.join(folders.codexDir, "agents");
+  const result = {
+    sourceDir,
+    targetDir,
+    rendered: [],
+    skipped: []
+  };
+  if (!await import_fs_extra8.default.pathExists(sourceDir)) {
+    return result;
+  }
+  await import_fs_extra8.default.ensureDir(folders.codexDir);
+  await ensureRealTargetDir(targetDir);
+  const entries = await import_fs_extra8.default.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_ENTRY_NAMES.has(entry.name))
+      continue;
+    if (!entry.isFile() || path12.extname(entry.name) !== ".md")
+      continue;
+    const sourcePath = path12.join(sourceDir, entry.name);
+    const parsed = parseMarkdownAgent(sourcePath, await import_fs_extra8.default.readFile(sourcePath, "utf-8"));
+    if (!parsed) {
+      result.skipped.push({ source: sourcePath, reason: "Missing YAML frontmatter" });
+      continue;
+    }
+    const rendered = renderToml(parsed);
+    if (!rendered) {
+      result.skipped.push({
+        source: sourcePath,
+        reason: "Missing name, description, or instruction body"
+      });
+      continue;
+    }
+    const targetPath = path12.join(targetDir, `${rendered.name}.toml`);
+    if (await import_fs_extra8.default.pathExists(targetPath) && !await canOverwriteTarget(targetPath, Boolean(options.overwrite))) {
+      result.skipped.push({
+        source: sourcePath,
+        reason: `Codex agent already exists at ${targetPath}`
+      });
+      continue;
+    }
+    await import_fs_extra8.default.writeFile(targetPath, rendered.content, "utf-8");
+    result.rendered.push({
+      source: sourcePath,
+      target: targetPath,
+      name: rendered.name
+    });
+  }
+  return result;
+}
+
 // src/commands/setup.ts
 var __filename2 = fileURLToPath2(import.meta.url);
 var __dirname2 = dirname2(__filename2);
 async function resolveClaudeAssetPath(sourceDir, name) {
   const candidates = [
-    path12.join(sourceDir, "claude-config", name),
-    path12.join(sourceDir, name)
+    path13.join(sourceDir, "claude-config", name),
+    path13.join(sourceDir, name)
   ];
   for (const candidate of candidates) {
-    if (await import_fs_extra8.default.pathExists(candidate))
+    if (await import_fs_extra9.default.pathExists(candidate))
       return candidate;
   }
   return null;
@@ -33990,8 +34233,8 @@ async function setupCommand(params = {}) {
     console.log(source_default.gray(`Claude:  ${claudeDir}`));
     console.log(source_default.gray(`Codex:   ${codexDir}`));
     console.log(source_default.gray(`Agents:  ${agentsDir}`));
-    await import_fs_extra8.default.ensureDir(claudeDir);
-    await import_fs_extra8.default.ensureDir(agentsDir);
+    await import_fs_extra9.default.ensureDir(claudeDir);
+    await import_fs_extra9.default.ensureDir(agentsDir);
     s.start("Creating backup of existing configuration");
     const backupPath = await createConfigBackup({ folder, claudeCodeFolder, codexFolder, agentsFolder }, "Before running aiblueprint setup", "setup", "aiblueprint-setup");
     if (backupPath) {
@@ -34019,11 +34262,11 @@ async function setupCommand(params = {}) {
       s.start("Setting up scripts");
       const scriptsSource = await resolveClaudeAssetPath(sourceDir, "scripts");
       if (scriptsSource) {
-        await import_fs_extra8.default.copy(scriptsSource, path12.join(claudeDir, "scripts"), {
+        await import_fs_extra9.default.copy(scriptsSource, path13.join(claudeDir, "scripts"), {
           overwrite: true
         });
-        await replacePathPlaceholdersInDir(path12.join(claudeDir, "scripts"), claudeDir);
-        await import_fs_extra8.default.ensureDir(path12.join(claudeDir, "scripts/statusline/data"));
+        await replacePathPlaceholdersInDir(path13.join(claudeDir, "scripts"), claudeDir);
+        await import_fs_extra9.default.ensureDir(path13.join(claudeDir, "scripts/statusline/data"));
         s.stop("Scripts installed");
       } else {
         s.stop("Scripts not available in repository");
@@ -34031,8 +34274,8 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintAgents) {
       s.start("Setting up AIBlueprint agents");
-      const agentsSource = path12.join(sourceDir, "agents");
-      if (await import_fs_extra8.default.pathExists(agentsSource)) {
+      const agentsSource = path13.join(sourceDir, "agents");
+      if (await import_fs_extra9.default.pathExists(agentsSource)) {
         const installResult = await installCategoryToAgents(agentsSource, "agents", agentsDir, claudeDir, { migrateClaudeDirs: true, silent: true });
         const summary = [
           installResult.copied.length && `${installResult.copied.length} copied`,
@@ -34047,8 +34290,8 @@ async function setupCommand(params = {}) {
     }
     if (options.aiblueprintSkills) {
       s.start("Setting up AIBlueprint Skills");
-      const skillsSourcePath = path12.join(sourceDir, "skills");
-      if (await import_fs_extra8.default.pathExists(skillsSourcePath)) {
+      const skillsSourcePath = path13.join(sourceDir, "skills");
+      if (await import_fs_extra9.default.pathExists(skillsSourcePath)) {
         const installResult = await installCategoryToAgents(skillsSourcePath, "skills", agentsDir, claudeDir, { migrateClaudeDirs: true, silent: true });
         const summary = [
           installResult.copied.length && `${installResult.copied.length} copied`,
@@ -34068,18 +34311,18 @@ async function setupCommand(params = {}) {
     }
     if (options.installCodex) {
       s.start("Setting up Codex");
-      await import_fs_extra8.default.ensureDir(codexDir);
-      const codexConfigSource = path12.join(sourceDir, "codex-config");
-      if (await import_fs_extra8.default.pathExists(codexConfigSource)) {
-        const codexConfigPath = path12.join(codexConfigSource, "config.toml");
-        if (await import_fs_extra8.default.pathExists(codexConfigPath)) {
+      await import_fs_extra9.default.ensureDir(codexDir);
+      const codexConfigSource = path13.join(sourceDir, "codex-config");
+      if (await import_fs_extra9.default.pathExists(codexConfigSource)) {
+        const codexConfigPath = path13.join(codexConfigSource, "config.toml");
+        if (await import_fs_extra9.default.pathExists(codexConfigPath)) {
           await mergeCodexConfigFile(codexConfigPath, codexDir);
         }
-        const entries = await import_fs_extra8.default.readdir(codexConfigSource);
+        const entries = await import_fs_extra9.default.readdir(codexConfigSource);
         for (const entry of entries) {
           if (entry === "config.toml")
             continue;
-          await import_fs_extra8.default.copy(path12.join(codexConfigSource, entry), path12.join(codexDir, entry), {
+          await import_fs_extra9.default.copy(path13.join(codexConfigSource, entry), path13.join(codexDir, entry), {
             overwrite: false
           });
         }
@@ -34088,7 +34331,12 @@ async function setupCommand(params = {}) {
         await syncCategorySymlinks("skills", agentsDir, codexDir, undefined, true);
       }
       if (options.aiblueprintAgents) {
-        await syncCategorySymlinks("agents", agentsDir, codexDir, undefined, true);
+        await renderCodexAgentsFromMarkdown({
+          folder,
+          claudeCodeFolder,
+          codexFolder,
+          agentsFolder
+        });
       }
       s.stop("Codex configured");
     }
@@ -34154,8 +34402,8 @@ Next steps:`));
 }
 
 // src/commands/setup-terminal.ts
-var import_fs_extra9 = __toESM(require_lib4(), 1);
-import path13 from "path";
+var import_fs_extra10 = __toESM(require_lib4(), 1);
+import path14 from "path";
 import os11 from "os";
 import { execSync as execSync3, exec as exec2 } from "child_process";
 var OHMYZSH_INSTALL_URL = "https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh";
@@ -34190,16 +34438,16 @@ function commandExists(cmd) {
   }
 }
 function isOhMyZshInstalled(homeDir) {
-  const ohMyZshDir = path13.join(homeDir, ".oh-my-zsh");
-  return import_fs_extra9.default.existsSync(ohMyZshDir);
+  const ohMyZshDir = path14.join(homeDir, ".oh-my-zsh");
+  return import_fs_extra10.default.existsSync(ohMyZshDir);
 }
 function backupFile(filePath) {
-  if (!import_fs_extra9.default.existsSync(filePath))
+  if (!import_fs_extra10.default.existsSync(filePath))
     return null;
   const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
   const backupPath = `${filePath}.backup-${timestamp2}`;
   try {
-    import_fs_extra9.default.copyFileSync(filePath, backupPath);
+    import_fs_extra10.default.copyFileSync(filePath, backupPath);
     return backupPath;
   } catch (error) {
     throw new Error(`Failed to create backup: ${error.message}`);
@@ -34238,7 +34486,7 @@ function installPrerequisiteSync(packageName, installCmd) {
 async function installOhMyZsh(homeDir) {
   return new Promise((resolve, reject) => {
     const installCmd = `sh -c "$(curl -fsSL ${OHMYZSH_INSTALL_URL})" "" --unattended`;
-    const env2 = { ...process.env, HOME: homeDir, ZSH: path13.join(homeDir, ".oh-my-zsh") };
+    const env2 = { ...process.env, HOME: homeDir, ZSH: path14.join(homeDir, ".oh-my-zsh") };
     exec2(installCmd, { timeout: INSTALL_TIMEOUT, env: env2 }, (error, stdout, stderr) => {
       if (error) {
         if ("killed" in error && error.killed) {
@@ -34259,8 +34507,8 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   if (!/^https:\/\/github\.com\/[\w-]+\/[\w-]+$/.test(repoUrl)) {
     throw new Error(`Invalid repository URL: ${repoUrl}`);
   }
-  const customPluginsDir = path13.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
-  if (import_fs_extra9.default.existsSync(customPluginsDir)) {
+  const customPluginsDir = path14.join(homeDir, ".oh-my-zsh/custom/plugins", pluginName);
+  if (import_fs_extra10.default.existsSync(customPluginsDir)) {
     return;
   }
   return new Promise((resolve, reject) => {
@@ -34278,20 +34526,20 @@ async function installPlugin(pluginName, repoUrl, homeDir) {
   });
 }
 function updateZshrcTheme(theme, homeDir) {
-  const zshrcPath = path13.join(homeDir, ".zshrc");
+  const zshrcPath = path14.join(homeDir, ".zshrc");
   const sanitizedTheme = sanitizeThemeName(theme);
-  if (!import_fs_extra9.default.existsSync(zshrcPath)) {
+  if (!import_fs_extra10.default.existsSync(zshrcPath)) {
     throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
   }
   try {
-    let content = import_fs_extra9.default.readFileSync(zshrcPath, "utf-8");
+    let content = import_fs_extra10.default.readFileSync(zshrcPath, "utf-8");
     if (content.match(/^ZSH_THEME=/m)) {
       content = content.replace(/^ZSH_THEME=.*/m, `ZSH_THEME="${sanitizedTheme}"`);
     } else {
       content = `ZSH_THEME="${sanitizedTheme}"
 ${content}`;
     }
-    import_fs_extra9.default.writeFileSync(zshrcPath, content);
+    import_fs_extra10.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -34300,12 +34548,12 @@ ${content}`;
   }
 }
 function updateZshrcPlugins(plugins, homeDir) {
-  const zshrcPath = path13.join(homeDir, ".zshrc");
-  if (!import_fs_extra9.default.existsSync(zshrcPath)) {
+  const zshrcPath = path14.join(homeDir, ".zshrc");
+  if (!import_fs_extra10.default.existsSync(zshrcPath)) {
     throw new Error(".zshrc file not found. Please ensure Oh My ZSH is installed correctly.");
   }
   try {
-    let content = import_fs_extra9.default.readFileSync(zshrcPath, "utf-8");
+    let content = import_fs_extra10.default.readFileSync(zshrcPath, "utf-8");
     const pluginsString = plugins.join(" ");
     if (content.match(/^plugins=\(/m)) {
       content = content.replace(/^plugins=\([^)]*\)/m, `plugins=(${pluginsString})`);
@@ -34313,7 +34561,7 @@ function updateZshrcPlugins(plugins, homeDir) {
       content = `${content}
 plugins=(${pluginsString})`;
     }
-    import_fs_extra9.default.writeFileSync(zshrcPath, content);
+    import_fs_extra10.default.writeFileSync(zshrcPath, content);
   } catch (error) {
     if (error.message.includes(".zshrc file not found")) {
       throw error;
@@ -34420,8 +34668,8 @@ Installing missing prerequisites: ${missingPrereqs.join(", ")}`));
         selectedTheme = themeAnswer.theme;
       }
     }
-    const zshrcPath = path13.join(homeDir, ".zshrc");
-    if (import_fs_extra9.default.existsSync(zshrcPath)) {
+    const zshrcPath = path14.join(homeDir, ".zshrc");
+    if (import_fs_extra10.default.existsSync(zshrcPath)) {
       s.start("Backing up .zshrc");
       const backupPath = backupFile(zshrcPath);
       if (backupPath) {
@@ -34471,37 +34719,37 @@ Next steps:`));
 }
 
 // src/commands/setup/symlinks.ts
-var import_fs_extra10 = __toESM(require_lib4(), 1);
-import path14 from "path";
+var import_fs_extra11 = __toESM(require_lib4(), 1);
+import path15 from "path";
 import os12 from "os";
 async function getToolPaths(tool, customFolder) {
   let baseDir;
   switch (tool) {
     case "claude-code":
-      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".claude");
+      baseDir = customFolder ? path15.resolve(customFolder) : path15.join(os12.homedir(), ".claude");
       return {
         baseDir,
-        commandsPath: path14.join(baseDir, "commands"),
-        agentsPath: path14.join(baseDir, "agents")
+        commandsPath: path15.join(baseDir, "commands"),
+        agentsPath: path15.join(baseDir, "agents")
       };
     case "codex":
-      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".codex");
+      baseDir = customFolder ? path15.resolve(customFolder) : path15.join(os12.homedir(), ".codex");
       return {
         baseDir,
-        agentsPath: path14.join(baseDir, "agents")
+        agentsPath: path15.join(baseDir, "agents")
       };
     case "opencode":
-      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".config", "opencode");
+      baseDir = customFolder ? path15.resolve(customFolder) : path15.join(os12.homedir(), ".config", "opencode");
       return {
         baseDir,
-        commandsPath: path14.join(baseDir, "command")
+        commandsPath: path15.join(baseDir, "command")
       };
     case "factoryai":
-      baseDir = customFolder ? path14.resolve(customFolder) : path14.join(os12.homedir(), ".factory");
+      baseDir = customFolder ? path15.resolve(customFolder) : path15.join(os12.homedir(), ".factory");
       return {
         baseDir,
-        commandsPath: path14.join(baseDir, "commands"),
-        agentsPath: path14.join(baseDir, "droids")
+        commandsPath: path15.join(baseDir, "commands"),
+        agentsPath: path15.join(baseDir, "droids")
       };
     default:
       throw new Error(`Unknown tool type: ${tool}`);
@@ -34509,18 +34757,18 @@ async function getToolPaths(tool, customFolder) {
 }
 async function createSymlink(sourcePath, targetPath, options = {}) {
   try {
-    const sourceExists = await import_fs_extra10.default.pathExists(sourcePath);
+    const sourceExists = await import_fs_extra11.default.pathExists(sourcePath);
     if (!sourceExists) {
       console.log(source_default.yellow(`  Source path ${sourcePath} does not exist. Skipping symlink creation...`));
       return false;
     }
-    const targetDir = path14.dirname(targetPath);
-    await import_fs_extra10.default.ensureDir(targetDir);
-    const targetExists = await import_fs_extra10.default.pathExists(targetPath);
+    const targetDir = path15.dirname(targetPath);
+    await import_fs_extra11.default.ensureDir(targetDir);
+    const targetExists = await import_fs_extra11.default.pathExists(targetPath);
     if (targetExists) {
-      const stat = await import_fs_extra10.default.lstat(targetPath);
+      const stat = await import_fs_extra11.default.lstat(targetPath);
       if (stat.isSymbolicLink()) {
-        await import_fs_extra10.default.remove(targetPath);
+        await import_fs_extra11.default.remove(targetPath);
       } else {
         console.log(source_default.yellow(options.skipMessage || `  ${targetPath} already exists and is not a symlink. Skipping...`));
         return false;
@@ -34528,9 +34776,9 @@ async function createSymlink(sourcePath, targetPath, options = {}) {
     }
     const isWindows2 = os12.platform() === "win32";
     if (isWindows2) {
-      await import_fs_extra10.default.symlink(sourcePath, targetPath, "junction");
+      await import_fs_extra11.default.symlink(sourcePath, targetPath, "junction");
     } else {
-      await import_fs_extra10.default.symlink(sourcePath, targetPath);
+      await import_fs_extra11.default.symlink(sourcePath, targetPath);
     }
     return true;
   } catch (error) {
@@ -34711,11 +34959,11 @@ async function symlinkCommand(params = {}) {
 }
 
 // src/lib/agents-unifier.ts
-var import_fs_extra11 = __toESM(require_lib4(), 1);
+var import_fs_extra12 = __toESM(require_lib4(), 1);
 import crypto from "crypto";
 import os13 from "os";
-import path15 from "path";
-var IGNORED_ENTRY_NAMES = new Set([
+import path16 from "path";
+var IGNORED_ENTRY_NAMES2 = new Set([
   ".DS_Store",
   ".git",
   "node_modules"
@@ -34724,7 +34972,7 @@ function uniqueByPath(candidates) {
   const seen = new Set;
   const unique = [];
   for (const candidate of candidates) {
-    const resolved = path15.resolve(candidate.path);
+    const resolved = path16.resolve(candidate.path);
     if (seen.has(resolved))
       continue;
     seen.add(resolved);
@@ -34734,109 +34982,123 @@ function uniqueByPath(candidates) {
 }
 function getContainerCandidates(options) {
   const folders = resolveFolders(options);
-  const cursorDir = path15.join(folders.rootDir, ".cursor");
-  const factoryDir = path15.join(folders.rootDir, ".factory");
-  const opencodeDir = path15.join(folders.rootDir, ".config", "opencode");
+  const cursorDir = path16.join(folders.rootDir, ".cursor");
+  const factoryDir = path16.join(folders.rootDir, ".factory");
+  const opencodeDir = path16.join(folders.rootDir, ".config", "opencode");
   return uniqueByPath([
     {
       category: "skills",
       label: "agents-skills",
-      path: path15.join(folders.agentsDir, "skills"),
+      path: path16.join(folders.agentsDir, "skills"),
       isDestination: true
     },
     {
       category: "skills",
       label: "claude-skills",
-      path: path15.join(folders.claudeDir, "skills"),
+      path: path16.join(folders.claudeDir, "skills"),
       linkWhenMissing: true
     },
     {
       category: "skills",
       label: "codex-skills",
-      path: path15.join(folders.codexDir, "skills"),
+      path: path16.join(folders.codexDir, "skills"),
       linkWhenMissing: true
     },
     {
       category: "skills",
       label: "cursor-skills",
-      path: path15.join(cursorDir, "skills"),
+      path: path16.join(cursorDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "cursor-skills-cursor",
-      path: path15.join(cursorDir, "skills-cursor"),
+      path: path16.join(cursorDir, "skills-cursor"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "factory-skills",
-      path: path15.join(factoryDir, "skills"),
+      path: path16.join(factoryDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "opencode-skill",
-      path: path15.join(opencodeDir, "skill"),
+      path: path16.join(opencodeDir, "skill"),
       linkWhenParentExists: true
     },
     {
       category: "skills",
       label: "opencode-skills",
-      path: path15.join(opencodeDir, "skills"),
+      path: path16.join(opencodeDir, "skills"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "agents-agents",
-      path: path15.join(folders.agentsDir, "agents"),
+      path: path16.join(folders.agentsDir, "agents"),
       isDestination: true
     },
     {
       category: "agents",
       label: "claude-agents",
-      path: path15.join(folders.claudeDir, "agents"),
+      path: path16.join(folders.claudeDir, "agents"),
       linkWhenMissing: true
     },
     {
       category: "agents",
       label: "claude-agnets",
-      path: path15.join(folders.claudeDir, "agnets")
-    },
-    {
-      category: "agents",
-      label: "codex-agents",
-      path: path15.join(folders.codexDir, "agents"),
-      linkWhenMissing: true
+      path: path16.join(folders.claudeDir, "agnets")
     },
     {
       category: "agents",
       label: "cursor-agents",
-      path: path15.join(cursorDir, "agents"),
+      path: path16.join(cursorDir, "agents"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "factory-droids",
-      path: path15.join(factoryDir, "droids"),
+      path: path16.join(factoryDir, "droids"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "opencode-agent",
-      path: path15.join(opencodeDir, "agent"),
+      path: path16.join(opencodeDir, "agent"),
       linkWhenParentExists: true
     },
     {
       category: "agents",
       label: "opencode-agents",
-      path: path15.join(opencodeDir, "agents"),
+      path: path16.join(opencodeDir, "agents"),
       linkWhenParentExists: true
     }
   ]);
 }
+function getInstructionFileCandidates(options) {
+  const folders = resolveFolders(options);
+  return uniqueByPath([
+    {
+      label: "agents-instructions",
+      path: path16.join(folders.agentsDir, "AGENTS.md"),
+      isDestination: true
+    },
+    {
+      label: "claude-instructions",
+      path: path16.join(folders.claudeDir, "CLAUDE.md"),
+      linkWhenMissing: true
+    },
+    {
+      label: "codex-instructions",
+      path: path16.join(folders.codexDir, "AGENTS.md"),
+      linkWhenMissing: true
+    }
+  ]);
+}
 function shouldCollectEntry(category, entry) {
-  if (IGNORED_ENTRY_NAMES.has(entry.name))
+  if (IGNORED_ENTRY_NAMES2.has(entry.name))
     return false;
   if (category === "skills" && entry.name === ".cursor-managed-skills-manifest.json") {
     return true;
@@ -34844,42 +35106,42 @@ function shouldCollectEntry(category, entry) {
   return entry.isFile() || entry.isDirectory() || entry.isSymbolicLink();
 }
 async function pathExistsOrSymlink(targetPath) {
-  const stat = await import_fs_extra11.default.lstat(targetPath).catch(() => null);
+  const stat = await import_fs_extra12.default.lstat(targetPath).catch(() => null);
   return Boolean(stat);
 }
 async function realPathIfPossible(targetPath) {
   try {
-    return await import_fs_extra11.default.realpath(targetPath);
+    return await import_fs_extra12.default.realpath(targetPath);
   } catch {
     return null;
   }
 }
 function samePath(a, b) {
-  return path15.resolve(a) === path15.resolve(b);
+  return path16.resolve(a) === path16.resolve(b);
 }
 function hashString(value) {
   return crypto.createHash("sha256").update(value).digest("hex");
 }
 async function hashPath(targetPath) {
-  const stat = await import_fs_extra11.default.lstat(targetPath);
+  const stat = await import_fs_extra12.default.lstat(targetPath);
   if (stat.isSymbolicLink()) {
-    const linkTarget = await import_fs_extra11.default.readlink(targetPath);
+    const linkTarget = await import_fs_extra12.default.readlink(targetPath);
     return hashString(`symlink:${linkTarget}`);
   }
   if (stat.isFile()) {
     const fileHash = crypto.createHash("sha256");
     fileHash.update("file:");
-    fileHash.update(await import_fs_extra11.default.readFile(targetPath));
+    fileHash.update(await import_fs_extra12.default.readFile(targetPath));
     return fileHash.digest("hex");
   }
   if (stat.isDirectory()) {
-    const entries = (await import_fs_extra11.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = (await import_fs_extra12.default.readdir(targetPath, { withFileTypes: true })).filter((entry) => !IGNORED_ENTRY_NAMES2.has(entry.name)).sort((a, b) => a.name.localeCompare(b.name));
     const dirHash = crypto.createHash("sha256");
     dirHash.update("dir:");
     for (const entry of entries) {
       dirHash.update(entry.name);
       dirHash.update("\x00");
-      dirHash.update(await hashPath(path15.join(targetPath, entry.name)));
+      dirHash.update(await hashPath(path16.join(targetPath, entry.name)));
       dirHash.update("\x00");
     }
     return dirHash.digest("hex");
@@ -34890,7 +35152,7 @@ function suffixFromLabel(label) {
   return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "source";
 }
 function nameWithSuffix(name, suffix, index) {
-  const parsed = path15.parse(name);
+  const parsed = path16.parse(name);
   const numberedSuffix = index === 1 ? suffix : `${suffix}-${index}`;
   if (parsed.ext && parsed.name) {
     return `${parsed.name}--${numberedSuffix}${parsed.ext}`;
@@ -34902,39 +35164,39 @@ async function findTargetName(destinationDir, originalName, label) {
   let index = 1;
   while (true) {
     const candidate = nameWithSuffix(originalName, suffix, index);
-    if (!await pathExistsOrSymlink(path15.join(destinationDir, candidate))) {
+    if (!await pathExistsOrSymlink(path16.join(destinationDir, candidate))) {
       return candidate;
     }
     index++;
   }
 }
 async function addExistingDestinationHashes(destinationDir, knownHashes) {
-  if (!await import_fs_extra11.default.pathExists(destinationDir))
+  if (!await import_fs_extra12.default.pathExists(destinationDir))
     return;
-  const entries = await import_fs_extra11.default.readdir(destinationDir, { withFileTypes: true });
+  const entries = await import_fs_extra12.default.readdir(destinationDir, { withFileTypes: true });
   for (const entry of entries) {
-    if (IGNORED_ENTRY_NAMES.has(entry.name))
+    if (IGNORED_ENTRY_NAMES2.has(entry.name))
       continue;
-    const entryPath = path15.join(destinationDir, entry.name);
+    const entryPath = path16.join(destinationDir, entry.name);
     knownHashes.set(await hashPath(entryPath), entry.name);
   }
 }
 async function importCategoryEntries(category, candidates, destinationDir, result) {
-  await import_fs_extra11.default.ensureDir(destinationDir);
+  await import_fs_extra12.default.ensureDir(destinationDir);
   const destinationRealPath = await realPathIfPossible(destinationDir);
   const knownHashes = new Map;
   await addExistingDestinationHashes(destinationDir, knownHashes);
   for (const candidate of candidates) {
     if (candidate.category !== category || candidate.isDestination)
       continue;
-    const candidateStat = await import_fs_extra11.default.lstat(candidate.path).catch(() => null);
+    const candidateStat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
     if (!candidateStat)
       continue;
     const candidateRealPath = await realPathIfPossible(candidate.path);
     if (destinationRealPath && candidateRealPath && samePath(destinationRealPath, candidateRealPath)) {
       continue;
     }
-    const entries = await import_fs_extra11.default.readdir(candidate.path, { withFileTypes: true }).catch(() => null);
+    const entries = await import_fs_extra12.default.readdir(candidate.path, { withFileTypes: true }).catch(() => null);
     if (!entries) {
       result.skipped.push({
         category,
@@ -34946,7 +35208,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
     for (const entry of entries) {
       if (!shouldCollectEntry(category, entry))
         continue;
-      const sourcePath = path15.join(candidate.path, entry.name);
+      const sourcePath = path16.join(candidate.path, entry.name);
       const sourceHash = await hashPath(sourcePath);
       const existingName = knownHashes.get(sourceHash);
       if (existingName) {
@@ -34954,15 +35216,15 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
           category,
           name: entry.name,
           from: sourcePath,
-          keptAs: path15.join(destinationDir, existingName)
+          keptAs: path16.join(destinationDir, existingName)
         });
         continue;
       }
       let targetName = entry.name;
-      let targetPath = path15.join(destinationDir, targetName);
+      let targetPath = path16.join(destinationDir, targetName);
       if (await pathExistsOrSymlink(targetPath)) {
         targetName = await findTargetName(destinationDir, entry.name, candidate.label);
-        targetPath = path15.join(destinationDir, targetName);
+        targetPath = path16.join(destinationDir, targetName);
         result.renamed.push({
           category,
           name: entry.name,
@@ -34971,7 +35233,7 @@ async function importCategoryEntries(category, candidates, destinationDir, resul
           reason: "Same name with different content"
         });
       }
-      await import_fs_extra11.default.copy(sourcePath, targetPath, {
+      await import_fs_extra12.default.copy(sourcePath, targetPath, {
         dereference: false,
         overwrite: false
       });
@@ -34989,43 +35251,51 @@ function timestamp2(date = new Date) {
   return date.toISOString().replace(/\.\d{3}Z$/, "").replace(/[:T]/g, "-");
 }
 function safeRelativePath(rootDir, targetPath) {
-  const relativePath = path15.relative(rootDir, targetPath);
-  if (!relativePath || relativePath.startsWith("..") || path15.isAbsolute(relativePath)) {
-    return path15.join("external", targetPath.replace(/[^a-zA-Z0-9._-]+/g, "-"));
+  const relativePath = path16.relative(rootDir, targetPath);
+  if (!relativePath || relativePath.startsWith("..") || path16.isAbsolute(relativePath)) {
+    return path16.join("external", targetPath.replace(/[^a-zA-Z0-9._-]+/g, "-"));
   }
   return relativePath;
 }
 function createBackupPath(rootDir) {
-  return path15.join(rootDir, ".aiblueprint", "backups", "agents-unify-sources", timestamp2());
+  return path16.join(rootDir, ".aiblueprint", "backups", "agents-unify-sources", timestamp2());
 }
 async function ensureBackupPath(result) {
   if (!result.backupPath) {
     result.backupPath = createBackupPath(result.rootDir);
-    await import_fs_extra11.default.ensureDir(result.backupPath);
+    await import_fs_extra12.default.ensureDir(result.backupPath);
   }
   return result.backupPath;
 }
 async function createDirectorySymlink(source, target) {
-  await import_fs_extra11.default.ensureDir(path15.dirname(target));
+  await import_fs_extra12.default.ensureDir(path16.dirname(target));
   if (os13.platform() === "win32") {
-    await import_fs_extra11.default.symlink(source, target, "junction");
+    await import_fs_extra12.default.symlink(source, target, "junction");
     return;
   }
-  await import_fs_extra11.default.symlink(source, target, "dir");
+  await import_fs_extra12.default.symlink(source, target, "dir");
+}
+async function createFileSymlink(source, target) {
+  await import_fs_extra12.default.ensureDir(path16.dirname(target));
+  if (os13.platform() === "win32") {
+    await import_fs_extra12.default.symlink(source, target, "file");
+    return;
+  }
+  await import_fs_extra12.default.symlink(source, target);
 }
 async function shouldLinkMissingContainer(candidate) {
   if (candidate.linkWhenMissing)
     return true;
   if (!candidate.linkWhenParentExists)
     return false;
-  return import_fs_extra11.default.pathExists(path15.dirname(candidate.path));
+  return import_fs_extra12.default.pathExists(path16.dirname(candidate.path));
 }
 async function linkContainer(candidate, destinationDir, result) {
   if (candidate.isDestination || samePath(candidate.path, destinationDir)) {
     return;
   }
   const destinationRealPath = await realPathIfPossible(destinationDir);
-  const stat = await import_fs_extra11.default.lstat(candidate.path).catch(() => null);
+  const stat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
   if (!stat) {
     if (!await shouldLinkMissingContainer(candidate))
       return;
@@ -35047,7 +35317,7 @@ async function linkContainer(candidate, destinationDir, result) {
       });
       return;
     }
-    await import_fs_extra11.default.remove(candidate.path);
+    await import_fs_extra12.default.remove(candidate.path);
     await createDirectorySymlink(destinationDir, candidate.path);
     result.linked.push({
       category: candidate.category,
@@ -35057,9 +35327,9 @@ async function linkContainer(candidate, destinationDir, result) {
     return;
   }
   const backupRoot = await ensureBackupPath(result);
-  const backupTarget = path15.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
-  await import_fs_extra11.default.ensureDir(path15.dirname(backupTarget));
-  await import_fs_extra11.default.move(candidate.path, backupTarget, { overwrite: false });
+  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
+  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
+  await import_fs_extra12.default.move(candidate.path, backupTarget, { overwrite: false });
   await createDirectorySymlink(destinationDir, candidate.path);
   result.linked.push({
     category: candidate.category,
@@ -35068,9 +35338,119 @@ async function linkContainer(candidate, destinationDir, result) {
     movedToBackup: backupTarget
   });
 }
+async function importInstructionFiles(candidates, destinationPath, result) {
+  await import_fs_extra12.default.ensureDir(path16.dirname(destinationPath));
+  const destinationRealPath = await realPathIfPossible(destinationPath);
+  let destinationHash = await pathExistsOrSymlink(destinationPath) ? await hashPath(destinationPath) : null;
+  for (const candidate of candidates) {
+    if (candidate.isDestination)
+      continue;
+    const sourceStat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+    if (!sourceStat)
+      continue;
+    const sourceRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && sourceRealPath && samePath(destinationRealPath, sourceRealPath)) {
+      continue;
+    }
+    const sourceHash = await hashPath(candidate.path);
+    if (!destinationHash) {
+      await import_fs_extra12.default.copy(candidate.path, destinationPath, {
+        dereference: false,
+        overwrite: false
+      });
+      destinationHash = sourceHash;
+      result.imported.push({
+        category: "instructions",
+        name: path16.basename(candidate.path),
+        from: candidate.path,
+        to: destinationPath
+      });
+      continue;
+    }
+    if (sourceHash === destinationHash) {
+      result.duplicates.push({
+        category: "instructions",
+        name: path16.basename(candidate.path),
+        from: candidate.path,
+        keptAs: destinationPath
+      });
+      continue;
+    }
+    const targetName = await findTargetName(path16.dirname(destinationPath), path16.basename(destinationPath), candidate.label);
+    const targetPath = path16.join(path16.dirname(destinationPath), targetName);
+    await import_fs_extra12.default.copy(candidate.path, targetPath, {
+      dereference: false,
+      overwrite: false
+    });
+    result.renamed.push({
+      category: "instructions",
+      name: path16.basename(candidate.path),
+      from: candidate.path,
+      to: targetPath,
+      reason: "Shared instruction file already exists with different content"
+    });
+  }
+}
+async function shouldLinkMissingInstruction(candidate) {
+  if (candidate.linkWhenMissing)
+    return true;
+  return false;
+}
+async function linkInstructionFile(candidate, destinationPath, result) {
+  if (candidate.isDestination || samePath(candidate.path, destinationPath)) {
+    return;
+  }
+  if (!await pathExistsOrSymlink(destinationPath)) {
+    return;
+  }
+  const destinationRealPath = await realPathIfPossible(destinationPath);
+  const stat = await import_fs_extra12.default.lstat(candidate.path).catch(() => null);
+  if (!stat) {
+    if (!await shouldLinkMissingInstruction(candidate))
+      return;
+    await createFileSymlink(destinationPath, candidate.path);
+    result.linked.push({
+      category: "instructions",
+      from: candidate.path,
+      to: destinationPath
+    });
+    return;
+  }
+  if (stat.isSymbolicLink()) {
+    const existingRealPath = await realPathIfPossible(candidate.path);
+    if (destinationRealPath && existingRealPath && samePath(destinationRealPath, existingRealPath)) {
+      result.alreadyLinked.push({
+        category: "instructions",
+        from: candidate.path,
+        to: destinationPath
+      });
+      return;
+    }
+    await import_fs_extra12.default.remove(candidate.path);
+    await createFileSymlink(destinationPath, candidate.path);
+    result.linked.push({
+      category: "instructions",
+      from: candidate.path,
+      to: destinationPath
+    });
+    return;
+  }
+  const backupRoot = await ensureBackupPath(result);
+  const backupTarget = path16.join(backupRoot, safeRelativePath(result.rootDir, candidate.path));
+  await import_fs_extra12.default.ensureDir(path16.dirname(backupTarget));
+  await import_fs_extra12.default.move(candidate.path, backupTarget, { overwrite: false });
+  await createFileSymlink(destinationPath, candidate.path);
+  result.linked.push({
+    category: "instructions",
+    from: candidate.path,
+    to: destinationPath,
+    movedToBackup: backupTarget
+  });
+}
 async function unifyAgentsConfiguration(options = {}) {
   const folders = resolveFolders(options);
   const candidates = getContainerCandidates(options);
+  const instructionCandidates = getInstructionFileCandidates(options);
   const result = {
     rootDir: folders.rootDir,
     agentsDir: folders.agentsDir,
@@ -35083,16 +35463,21 @@ async function unifyAgentsConfiguration(options = {}) {
     skipped: []
   };
   const destinationByCategory = {
-    skills: path15.join(folders.agentsDir, "skills"),
-    agents: path15.join(folders.agentsDir, "agents")
+    skills: path16.join(folders.agentsDir, "skills"),
+    agents: path16.join(folders.agentsDir, "agents"),
+    instructions: path16.join(folders.agentsDir, "AGENTS.md")
   };
-  await import_fs_extra11.default.ensureDir(folders.agentsDir);
+  await import_fs_extra12.default.ensureDir(folders.agentsDir);
+  await importInstructionFiles(instructionCandidates, destinationByCategory.instructions, result);
   for (const category of ["skills", "agents"]) {
     await importCategoryEntries(category, candidates, destinationByCategory[category], result);
   }
   for (const candidate of candidates) {
     await linkContainer(candidate, destinationByCategory[candidate.category], result);
   }
+  for (const candidate of instructionCandidates) {
+    await linkInstructionFile(candidate, destinationByCategory.instructions, result);
+  }
   return result;
 }
 
@@ -35113,13 +35498,16 @@ async function agentsUnifyCommand(params = {}) {
     console.log(source_default.blue.bold(`
 AIBlueprint agents unify ${source_default.gray(`v${getVersion()}`)}
 `));
-    console.log(source_default.gray("Centralizing reusable skills and agents into .agents"));
+    console.log(source_default.gray("Centralizing reusable skills and agents into .agents, then rendering Codex agents"));
     const result = await unifyAgentsConfiguration(params);
+    const codexResult = await renderCodexAgentsFromMarkdown(params);
     console.log(source_default.green(`
 Unify complete`));
     console.log(source_default.gray(`  Shared folder: ${result.agentsDir}`));
+    printCategorySummary(result, "instructions");
     printCategorySummary(result, "skills");
     printCategorySummary(result, "agents");
+    console.log(source_default.gray(`  codex agents: ${codexResult.rendered.length} rendered, ${codexResult.skipped.length} skipped`));
     if (result.backupPath) {
       console.log(source_default.gray(`  Source backups: ${result.backupPath}`));
     }
@@ -35137,6 +35525,34 @@ Agents unify failed:`), error);
   }
 }
 
+// src/commands/codex-agents.ts
+async function codexAgentsCommand(options = {}) {
+  try {
+    console.log(source_default.blue.bold(`
+AIBlueprint Codex agents ${source_default.gray(`v${getVersion()}`)}
+`));
+    console.log(source_default.gray("Rendering shared Markdown agents into Codex TOML custom agents"));
+    const result = await renderCodexAgentsFromMarkdown(options);
+    console.log(source_default.green(`
+Codex agents rendered`));
+    console.log(source_default.gray(`  Source: ${result.sourceDir}`));
+    console.log(source_default.gray(`  Target: ${result.targetDir}`));
+    console.log(source_default.gray(`  Rendered: ${result.rendered.length}`));
+    console.log(source_default.gray(`  Skipped: ${result.skipped.length}`));
+    if (result.skipped.length > 0) {
+      console.log(source_default.yellow(`
+Skipped agents:`));
+      for (const skipped of result.skipped) {
+        console.log(source_default.yellow(`  ${skipped.source}: ${skipped.reason}`));
+      }
+    }
+  } catch (error) {
+    console.error(source_default.red(`
+Codex agents render failed:`), error);
+    process.exit(1);
+  }
+}
+
 // node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -35853,12 +36269,12 @@ var Y2 = ({ indicator: t = "dots" } = {}) => {
 };
 
 // src/commands/pro.ts
-import path18 from "path";
+import path19 from "path";
 
 // src/lib/pro-installer.ts
-var import_fs_extra12 = __toESM(require_lib4(), 1);
+var import_fs_extra13 = __toESM(require_lib4(), 1);
 import os14 from "os";
-import path16 from "path";
+import path17 from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec3);
@@ -35866,9 +36282,9 @@ var PREMIUM_REPO = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH = "main";
 var CONFIG_FOLDER_CANDIDATES2 = ["agents-config", "ai-coding", "claude-code-config", "ai-config"];
 function routePath(relativePath) {
-  const segments = relativePath.split(path16.sep);
+  const segments = relativePath.split(path17.sep);
   const first = segments[0];
-  const rest = segments.slice(1).join(path16.sep);
+  const rest = segments.slice(1).join(path17.sep);
   if (first === "claude-config") {
     return { kind: "claude", relativePath: rest };
   }
@@ -35884,7 +36300,7 @@ function routePath(relativePath) {
   return { kind: "claude", relativePath };
 }
 function getCacheRepoDir() {
-  return path16.join(os14.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
+  return path17.join(os14.homedir(), ".config", "aiblueprint", "pro-repos", "aiblueprint-cli-premium");
 }
 async function execGitWithAuth(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -35898,21 +36314,21 @@ async function execGitWithAuth(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo(token) {
   const cacheDir = getCacheRepoDir();
   const repoUrl = `https://github.com/${PREMIUM_REPO}.git`;
-  if (await import_fs_extra12.default.pathExists(path16.join(cacheDir, ".git"))) {
+  if (await import_fs_extra13.default.pathExists(path17.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra12.default.remove(cacheDir);
-      await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+      await import_fs_extra13.default.remove(cacheDir);
+      await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
       await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra12.default.ensureDir(path16.dirname(cacheDir));
+    await import_fs_extra13.default.ensureDir(path17.dirname(cacheDir));
     await execGitWithAuth(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
   for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
-    const candidatePath = path16.join(cacheDir, candidate);
-    if (await import_fs_extra12.default.pathExists(candidatePath)) {
+    const candidatePath = path17.join(cacheDir, candidate);
+    if (await import_fs_extra13.default.pathExists(candidatePath)) {
       return candidatePath;
     }
   }
@@ -35920,38 +36336,38 @@ async function cloneOrUpdateRepo(token) {
 }
 async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra12.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra13.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name === ".DS_Store" || entry.name === "node_modules")
         continue;
-      const sourcePath = path16.join(dir, entry.name);
-      const relativePath = path16.relative(baseDir, sourcePath);
+      const sourcePath = path17.join(dir, entry.name);
+      const relativePath = path17.relative(baseDir, sourcePath);
       const route = routePath(relativePath);
       if (route.kind === "skip")
         continue;
       if (route.kind === "agents-category") {
-        if (relativePath.split(path16.sep).length === 1) {
+        if (relativePath.split(path17.sep).length === 1) {
           await copyAgentCategory(sourcePath, route.category, dest.agentsDir, dest.claudeDir, onProgress);
         }
         continue;
       }
       const targetBase = route.kind === "claude" ? dest.claudeDir : dest.codexDir;
-      const targetPath = path16.join(targetBase, route.relativePath);
+      const targetPath = path17.join(targetBase, route.relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra12.default.ensureDir(targetPath);
+        await import_fs_extra13.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else if (route.kind === "codex" && route.relativePath === "config.toml") {
         await mergeCodexConfigFile(sourcePath, dest.codexDir);
         onProgress?.(relativePath, "file");
       } else if (isTextFile(entry.name)) {
-        const content = await import_fs_extra12.default.readFile(sourcePath, "utf-8");
+        const content = await import_fs_extra13.default.readFile(sourcePath, "utf-8");
         const replaced = replaceClaudePathPlaceholder(content, dest.claudeDir);
-        await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
-        await import_fs_extra12.default.writeFile(targetPath, replaced, "utf-8");
+        await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
+        await import_fs_extra13.default.writeFile(targetPath, replaced, "utf-8");
         onProgress?.(relativePath, "file");
       } else {
-        await import_fs_extra12.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra13.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -35959,21 +36375,21 @@ async function copyConfigFromCache(cacheConfigDir, dest, onProgress) {
   await walk(cacheConfigDir);
 }
 async function copyAgentCategory(sourceCategoryDir, category, agentsDir, claudeDir, onProgress) {
-  const agentsCategoryDir = path16.join(agentsDir, category);
-  await import_fs_extra12.default.ensureDir(agentsCategoryDir);
-  const entries = await import_fs_extra12.default.readdir(sourceCategoryDir, { withFileTypes: true });
+  const agentsCategoryDir = path17.join(agentsDir, category);
+  await import_fs_extra13.default.ensureDir(agentsCategoryDir);
+  const entries = await import_fs_extra13.default.readdir(sourceCategoryDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".DS_Store")
       continue;
-    const src = path16.join(sourceCategoryDir, entry.name);
-    const dst = path16.join(agentsCategoryDir, entry.name);
-    const claudeTop = path16.join(claudeDir, category, entry.name);
-    const claudeStat = await import_fs_extra12.default.lstat(claudeTop).catch(() => null);
+    const src = path17.join(sourceCategoryDir, entry.name);
+    const dst = path17.join(agentsCategoryDir, entry.name);
+    const claudeTop = path17.join(claudeDir, category, entry.name);
+    const claudeStat = await import_fs_extra13.default.lstat(claudeTop).catch(() => null);
     if (claudeStat && !claudeStat.isSymbolicLink()) {
       onProgress?.(`${category}/${entry.name} (skipped - real dir in claude)`, "file");
       continue;
     }
-    await import_fs_extra12.default.copy(src, dst, { overwrite: true });
+    await import_fs_extra13.default.copy(src, dst, { overwrite: true });
     await applyPathPlaceholders(dst, claudeDir);
     onProgress?.(`${category}/${entry.name}`, entry.isDirectory() ? "directory" : "file");
   }
@@ -35992,8 +36408,8 @@ async function downloadFromPrivateGitHub(repo, branch, relativePath, targetPath,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra12.default.ensureDir(path16.dirname(targetPath));
-    await import_fs_extra12.default.writeFile(targetPath, Buffer.from(content));
+    await import_fs_extra13.default.ensureDir(path17.dirname(targetPath));
+    await import_fs_extra13.default.writeFile(targetPath, Buffer.from(content));
     return true;
   } catch (error) {
     console.error(`Error downloading ${relativePath}:`, error);
@@ -36018,10 +36434,10 @@ async function downloadDirectoryFromPrivateGitHub(repo, branch, dirPath, targetD
       console.error(`Unexpected response for directory ${dirPath}`);
       return false;
     }
-    await import_fs_extra12.default.ensureDir(targetDir);
+    await import_fs_extra13.default.ensureDir(targetDir);
     for (const file of files) {
       const relativePath = dirPath ? `${dirPath}/${file.name}` : file.name;
-      const targetPath = path16.join(targetDir, file.name);
+      const targetPath = path17.join(targetDir, file.name);
       const displayPath = relativePath.replace(/^(agents-config|ai-coding|claude-code-config|ai-config)\//, "");
       if (file.type === "file") {
         onProgress?.(displayPath, "file");
@@ -36044,8 +36460,8 @@ async function installProConfigs(options) {
     codexFolder,
     agentsFolder
   });
-  await import_fs_extra12.default.ensureDir(claudeDir);
-  await import_fs_extra12.default.ensureDir(agentsDir);
+  await import_fs_extra13.default.ensureDir(claudeDir);
+  await import_fs_extra13.default.ensureDir(agentsDir);
   const dest = { claudeDir, codexDir, agentsDir };
   try {
     const cacheConfigDir = await cloneOrUpdateRepo(githubToken);
@@ -36055,7 +36471,7 @@ async function installProConfigs(options) {
   } catch (error) {
     console.warn("Git caching failed, falling back to API download");
   }
-  const tempDir = path16.join(os14.tmpdir(), `aiblueprint-premium-${Date.now()}`);
+  const tempDir = path17.join(os14.tmpdir(), `aiblueprint-premium-${Date.now()}`);
   try {
     let success = false;
     for (const candidate of CONFIG_FOLDER_CANDIDATES2) {
@@ -36069,8 +36485,8 @@ async function installProConfigs(options) {
     await copyConfigFromCache(tempDir, dest, onProgress);
     await replacePathPlaceholdersInDir(claudeDir, claudeDir);
     for (const category of AGENT_CATEGORIES) {
-      const agentsCategoryDir = path16.join(agentsDir, category);
-      if (await import_fs_extra12.default.pathExists(agentsCategoryDir)) {
+      const agentsCategoryDir = path17.join(agentsDir, category);
+      if (await import_fs_extra13.default.pathExists(agentsCategoryDir)) {
         await replacePathPlaceholdersInDir(agentsCategoryDir, claudeDir);
       }
     }
@@ -36079,7 +36495,7 @@ async function installProConfigs(options) {
     throw new Error(`Failed to install premium configs: ${error instanceof Error ? error.message : "Unknown error"}`);
   } finally {
     try {
-      await import_fs_extra12.default.remove(tempDir);
+      await import_fs_extra13.default.remove(tempDir);
     } catch {}
   }
 }
@@ -36090,27 +36506,27 @@ async function syncAllAgentSymlinks(agentsDir, claudeDir) {
 }
 
 // src/lib/token-storage.ts
-var import_fs_extra13 = __toESM(require_lib4(), 1);
+var import_fs_extra14 = __toESM(require_lib4(), 1);
 import os15 from "os";
-import path17 from "path";
+import path18 from "path";
 function getConfigDir() {
   const platform = os15.platform();
   if (platform === "win32") {
-    const appData = process.env.APPDATA || path17.join(os15.homedir(), "AppData", "Roaming");
-    return path17.join(appData, "aiblueprint");
+    const appData = process.env.APPDATA || path18.join(os15.homedir(), "AppData", "Roaming");
+    return path18.join(appData, "aiblueprint");
   } else {
-    const configHome = process.env.XDG_CONFIG_HOME || path17.join(os15.homedir(), ".config");
-    return path17.join(configHome, "aiblueprint");
+    const configHome = process.env.XDG_CONFIG_HOME || path18.join(os15.homedir(), ".config");
+    return path18.join(configHome, "aiblueprint");
   }
 }
 function getTokenFilePath2() {
-  return path17.join(getConfigDir(), "token.txt");
+  return path18.join(getConfigDir(), "token.txt");
 }
 async function saveToken(githubToken) {
   const tokenFile = getTokenFilePath2();
-  const configDir = path17.dirname(tokenFile);
+  const configDir = path18.dirname(tokenFile);
   try {
-    await import_fs_extra13.default.ensureDir(configDir);
+    await import_fs_extra14.default.ensureDir(configDir);
   } catch (error) {
     if (error.code === "EACCES") {
       throw new Error(`Permission denied creating config directory: ${configDir}
@@ -36118,15 +36534,15 @@ async function saveToken(githubToken) {
     }
     throw error;
   }
-  await import_fs_extra13.default.writeFile(tokenFile, githubToken, { mode: 384 });
+  await import_fs_extra14.default.writeFile(tokenFile, githubToken, { mode: 384 });
 }
 async function getToken() {
   const tokenFile = getTokenFilePath2();
-  if (!await import_fs_extra13.default.pathExists(tokenFile)) {
+  if (!await import_fs_extra14.default.pathExists(tokenFile)) {
     return null;
   }
   try {
-    const token = await import_fs_extra13.default.readFile(tokenFile, "utf-8");
+    const token = await import_fs_extra14.default.readFile(tokenFile, "utf-8");
     return token.trim();
   } catch (error) {
     return null;
@@ -36140,7 +36556,7 @@ function getTokenInfo() {
 }
 
 // src/commands/pro.ts
-var import_fs_extra14 = __toESM(require_lib4(), 1);
+var import_fs_extra15 = __toESM(require_lib4(), 1);
 var API_URL = "https://codeline.app/api/products";
 var PRODUCT_IDS = ["prd_XJVgxVPbGG", "prd_NKabAkdOkw"];
 async function countInstalledItems(claudeDir) {
@@ -36149,20 +36565,20 @@ async function countInstalledItems(claudeDir) {
     skills: 0
   };
   try {
-    const agentsDir = path18.join(claudeDir, "agents");
-    if (await import_fs_extra14.default.pathExists(agentsDir)) {
-      const files = await import_fs_extra14.default.readdir(agentsDir);
+    const agentsDir = path19.join(claudeDir, "agents");
+    if (await import_fs_extra15.default.pathExists(agentsDir)) {
+      const files = await import_fs_extra15.default.readdir(agentsDir);
       counts.agents = files.filter((f) => f.endsWith(".md")).length;
     }
   } catch (error) {
     console.error("Failed to count agents:", error instanceof Error ? error.message : error);
   }
   try {
-    const skillsDir = path18.join(claudeDir, "skills");
-    if (await import_fs_extra14.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra14.default.readdir(skillsDir);
+    const skillsDir = path19.join(claudeDir, "skills");
+    if (await import_fs_extra15.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra15.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra14.default.stat(path18.join(skillsDir, item));
+        const stat = await import_fs_extra15.default.stat(path19.join(skillsDir, item));
         return stat.isDirectory();
       }));
       counts.skills = dirs.filter(Boolean).length;
@@ -36370,8 +36786,8 @@ async function proUpdateCommand(options = {}) {
 }
 
 // src/lib/sync-utils.ts
-var import_fs_extra15 = __toESM(require_lib4(), 1);
-import path19 from "path";
+var import_fs_extra16 = __toESM(require_lib4(), 1);
+import path20 from "path";
 import crypto2 from "crypto";
 var PREMIUM_REPO2 = "Melvynx/aiblueprint-cli-premium";
 var PREMIUM_BRANCH2 = "main";
@@ -36442,7 +36858,7 @@ async function listRemoteFilesRecursive(dirPath, githubToken, basePath = "") {
 }
 async function computeLocalFileSha(filePath) {
   try {
-    const content = await import_fs_extra15.default.readFile(filePath);
+    const content = await import_fs_extra16.default.readFile(filePath);
     return computeFileSha(content);
   } catch {
     return null;
@@ -36450,15 +36866,15 @@ async function computeLocalFileSha(filePath) {
 }
 async function listLocalFiles(dir) {
   const files = [];
-  if (!await import_fs_extra15.default.pathExists(dir)) {
+  if (!await import_fs_extra16.default.pathExists(dir)) {
     return files;
   }
-  const items = await import_fs_extra15.default.readdir(dir);
+  const items = await import_fs_extra16.default.readdir(dir);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path19.join(dir, item);
-    const stat = await import_fs_extra15.default.stat(fullPath).catch(() => null);
+    const fullPath = path20.join(dir, item);
+    const stat = await import_fs_extra16.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36473,13 +36889,13 @@ async function listLocalFiles(dir) {
 }
 async function listLocalFilesRecursive(dir, basePath) {
   const files = [];
-  const items = await import_fs_extra15.default.readdir(dir).catch(() => []);
+  const items = await import_fs_extra16.default.readdir(dir).catch(() => []);
   for (const item of items) {
     if (item === "node_modules" || item === ".DS_Store")
       continue;
-    const fullPath = path19.join(dir, item);
+    const fullPath = path20.join(dir, item);
     const relativePath = `${basePath}/${item}`;
-    const stat = await import_fs_extra15.default.stat(fullPath).catch(() => null);
+    const stat = await import_fs_extra16.default.stat(fullPath).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory()) {
@@ -36493,14 +36909,14 @@ async function listLocalFilesRecursive(dir, basePath) {
   return files;
 }
 async function listClaudeRealTopLevel(claudeCategoryDir) {
-  if (!await import_fs_extra15.default.pathExists(claudeCategoryDir))
+  if (!await import_fs_extra16.default.pathExists(claudeCategoryDir))
     return [];
-  const entries = await import_fs_extra15.default.readdir(claudeCategoryDir).catch(() => []);
+  const entries = await import_fs_extra16.default.readdir(claudeCategoryDir).catch(() => []);
   const real = [];
   for (const name of entries) {
     if (name === "node_modules" || name === ".DS_Store")
       continue;
-    const stat = await import_fs_extra15.default.lstat(path19.join(claudeCategoryDir, name)).catch(() => null);
+    const stat = await import_fs_extra16.default.lstat(path20.join(claudeCategoryDir, name)).catch(() => null);
     if (!stat)
       continue;
     if (stat.isDirectory())
@@ -36517,7 +36933,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   const items = [];
   const useAgents = isAgentCategory(category);
   const localBase = useAgents ? agentsDir : claudeDir;
-  const localDir = path19.join(localBase, category);
+  const localDir = path20.join(localBase, category);
   const remoteCategoryPath = getRemoteCategoryPath(category);
   const remoteFiles = await listRemoteFilesRecursive(remoteCategoryPath, githubToken);
   const localFiles = await listLocalFiles(localDir);
@@ -36531,7 +36947,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
   }
   const localSet = new Set(localFiles);
   for (const [remotePath, { sha, isFolder }] of remoteSet) {
-    const localPath = path19.join(localDir, remotePath);
+    const localPath = path20.join(localDir, remotePath);
     if (isFolder) {
       continue;
     }
@@ -36566,7 +36982,7 @@ async function analyzeCategory(category, claudeDir, agentsDir, githubToken) {
     for (const localPath of localSet) {
       agentsTopLevels.add(localPath.split("/")[0]);
     }
-    const claudeCategoryDir = path19.join(claudeDir, category);
+    const claudeCategoryDir = path20.join(claudeDir, category);
     const claudeRealEntries = await listClaudeRealTopLevel(claudeCategoryDir);
     for (const top of claudeRealEntries) {
       if (!remoteTopLevels.has(top))
@@ -36625,13 +37041,13 @@ async function downloadFromPrivateGitHub2(relativePath, targetPath, githubToken,
       return false;
     }
     const content = await response.arrayBuffer();
-    await import_fs_extra15.default.ensureDir(path19.dirname(targetPath));
+    await import_fs_extra16.default.ensureDir(path20.dirname(targetPath));
     if (isTextFile(relativePath)) {
       const textContent = Buffer.from(content).toString("utf-8");
       const transformedContent = transformFileContent(textContent, claudeDir);
-      await import_fs_extra15.default.writeFile(targetPath, transformedContent, "utf-8");
+      await import_fs_extra16.default.writeFile(targetPath, transformedContent, "utf-8");
     } else {
-      await import_fs_extra15.default.writeFile(targetPath, Buffer.from(content));
+      await import_fs_extra16.default.writeFile(targetPath, Buffer.from(content));
     }
     return true;
   } catch {
@@ -36647,27 +37063,27 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
   for (const item of items) {
     const useAgents = isAgentCategory(item.category);
     const baseDir = useAgents ? agentsDir : claudeDir;
-    const targetPath = path19.join(baseDir, item.relativePath);
+    const targetPath = path20.join(baseDir, item.relativePath);
     if (item.status === "migration" && useAgents) {
       const topName = item.name.split("/")[0];
-      const agentsTop = path19.join(agentsDir, item.category, topName);
-      const claudeTop = path19.join(claudeDir, item.category, topName);
+      const agentsTop = path20.join(agentsDir, item.category, topName);
+      const claudeTop = path20.join(claudeDir, item.category, topName);
       try {
-        const claudeStat = await import_fs_extra15.default.lstat(claudeTop).catch(() => null);
+        const claudeStat = await import_fs_extra16.default.lstat(claudeTop).catch(() => null);
         if (!claudeStat || claudeStat.isSymbolicLink()) {
           onProgress?.(item.relativePath, "skipping (no real dir to migrate)");
           failed++;
           continue;
         }
-        const agentsExists = await import_fs_extra15.default.pathExists(agentsTop);
+        const agentsExists = await import_fs_extra16.default.pathExists(agentsTop);
         if (agentsExists) {
           onProgress?.(item.relativePath, "skipping (already in .agents)");
           failed++;
           continue;
         }
         onProgress?.(item.relativePath, "moving to .agents");
-        await import_fs_extra15.default.ensureDir(path19.dirname(agentsTop));
-        await import_fs_extra15.default.move(claudeTop, agentsTop);
+        await import_fs_extra16.default.ensureDir(path20.dirname(agentsTop));
+        await import_fs_extra16.default.move(claudeTop, agentsTop);
         migrated++;
         touchedAgentCategories.add(item.category);
       } catch {
@@ -36677,8 +37093,8 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     }
     if (useAgents) {
       const topName = item.name.split("/")[0];
-      const claudeTop = path19.join(claudeDir, item.category, topName);
-      const claudeTopStat = await import_fs_extra15.default.lstat(claudeTop).catch(() => null);
+      const claudeTop = path20.join(claudeDir, item.category, topName);
+      const claudeTopStat = await import_fs_extra16.default.lstat(claudeTop).catch(() => null);
       if (claudeTopStat && !claudeTopStat.isSymbolicLink()) {
         onProgress?.(item.relativePath, "skipping (real dir in .claude)");
         failed++;
@@ -36688,7 +37104,7 @@ async function syncSelectedItems(claudeDir, items, githubToken, agentsDir, onPro
     if (item.status === "deleted") {
       onProgress?.(item.relativePath, "deleting");
       try {
-        await import_fs_extra15.default.remove(targetPath);
+        await import_fs_extra16.default.remove(targetPath);
         deleted++;
         if (useAgents)
           touchedAgentCategories.add(item.category);
@@ -37026,20 +37442,20 @@ async function proSyncCommand(options = {}) {
 }
 
 // src/lib/backup-utils.ts
-var import_fs_extra16 = __toESM(require_lib4(), 1);
-import path20 from "path";
+var import_fs_extra17 = __toESM(require_lib4(), 1);
+import path21 from "path";
 import os16 from "os";
-var BACKUP_BASE_DIR = path20.join(os16.homedir(), ".config", "aiblueprint", "backup");
+var BACKUP_BASE_DIR = path21.join(os16.homedir(), ".config", "aiblueprint", "backup");
 function formatDate(date) {
   const pad = (n) => n.toString().padStart(2, "0");
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}-${pad(date.getMinutes())}-${pad(date.getSeconds())}`;
 }
 async function listBackups() {
-  const exists = await import_fs_extra16.default.pathExists(BACKUP_BASE_DIR);
+  const exists = await import_fs_extra17.default.pathExists(BACKUP_BASE_DIR);
   if (!exists) {
     return [];
   }
-  const entries = await import_fs_extra16.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
+  const entries = await import_fs_extra17.default.readdir(BACKUP_BASE_DIR, { withFileTypes: true });
   const backups = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
@@ -37051,7 +37467,7 @@ async function listBackups() {
     const date = new Date(parseInt(year), parseInt(month) - 1, parseInt(day), parseInt(hour), parseInt(minute), parseInt(second));
     backups.push({
       name: entry.name,
-      path: path20.join(BACKUP_BASE_DIR, entry.name),
+      path: path21.join(BACKUP_BASE_DIR, entry.name),
       date
     });
   }
@@ -37060,12 +37476,12 @@ async function listBackups() {
 var AGENTS_BACKUP_SUBDIR = ".agents";
 var CLAUDE_ITEMS = ["commands", "agents", "skills", "scripts", "settings.json"];
 async function copyForBackup(sourcePath, destPath) {
-  await import_fs_extra16.default.copy(sourcePath, destPath, {
+  await import_fs_extra17.default.copy(sourcePath, destPath, {
     overwrite: true,
     dereference: false,
     filter: async (src) => {
       try {
-        const stat = await import_fs_extra16.default.lstat(src);
+        const stat = await import_fs_extra17.default.lstat(src);
         return !stat.isSymbolicLink();
       } catch {
         return true;
@@ -37074,28 +37490,28 @@ async function copyForBackup(sourcePath, destPath) {
   });
 }
 async function hasMeaningfulContent(dir) {
-  if (!await import_fs_extra16.default.pathExists(dir))
+  if (!await import_fs_extra17.default.pathExists(dir))
     return false;
-  const files = await import_fs_extra16.default.readdir(dir);
+  const files = await import_fs_extra17.default.readdir(dir);
   return files.some((f) => f !== ".DS_Store");
 }
 async function loadBackup(backupPath, claudeDir, agentsDir) {
-  const exists = await import_fs_extra16.default.pathExists(backupPath);
+  const exists = await import_fs_extra17.default.pathExists(backupPath);
   if (!exists) {
     throw new Error(`Backup not found: ${backupPath}`);
   }
-  await import_fs_extra16.default.ensureDir(claudeDir);
+  await import_fs_extra17.default.ensureDir(claudeDir);
   for (const item of CLAUDE_ITEMS) {
-    const sourcePath = path20.join(backupPath, item);
-    const destPath = path20.join(claudeDir, item);
-    if (await import_fs_extra16.default.pathExists(sourcePath)) {
+    const sourcePath = path21.join(backupPath, item);
+    const destPath = path21.join(claudeDir, item);
+    if (await import_fs_extra17.default.pathExists(sourcePath)) {
       await copyForBackup(sourcePath, destPath);
     }
   }
   if (agentsDir) {
-    const agentsBackupPath = path20.join(backupPath, AGENTS_BACKUP_SUBDIR);
-    if (await import_fs_extra16.default.pathExists(agentsBackupPath)) {
-      await import_fs_extra16.default.ensureDir(agentsDir);
+    const agentsBackupPath = path21.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    if (await import_fs_extra17.default.pathExists(agentsBackupPath)) {
+      await import_fs_extra17.default.ensureDir(agentsDir);
       await copyForBackup(agentsBackupPath, agentsDir);
     }
   }
@@ -37107,19 +37523,19 @@ async function createBackup(claudeDir, agentsDir) {
     return null;
   }
   const timestamp3 = formatDate(new Date);
-  const backupPath = path20.join(BACKUP_BASE_DIR, timestamp3);
-  await import_fs_extra16.default.ensureDir(backupPath);
+  const backupPath = path21.join(BACKUP_BASE_DIR, timestamp3);
+  await import_fs_extra17.default.ensureDir(backupPath);
   if (claudeHasContent) {
     for (const item of CLAUDE_ITEMS) {
-      const sourcePath = path20.join(claudeDir, item);
-      const destPath = path20.join(backupPath, item);
-      if (await import_fs_extra16.default.pathExists(sourcePath)) {
+      const sourcePath = path21.join(claudeDir, item);
+      const destPath = path21.join(backupPath, item);
+      if (await import_fs_extra17.default.pathExists(sourcePath)) {
         await copyForBackup(sourcePath, destPath);
       }
     }
   }
   if (agentsHasContent && agentsDir) {
-    const destPath = path20.join(backupPath, AGENTS_BACKUP_SUBDIR);
+    const destPath = path21.join(backupPath, AGENTS_BACKUP_SUBDIR);
     await copyForBackup(agentsDir, destPath);
   }
   return backupPath;
@@ -37303,18 +37719,18 @@ async function configsBackupsCreateCommand(reason, options = {}) {
 
 // src/commands/openclaw-pro.ts
 import os19 from "os";
-import path23 from "path";
+import path24 from "path";
 
 // src/lib/openclaw-installer.ts
-var import_fs_extra17 = __toESM(require_lib4(), 1);
+var import_fs_extra18 = __toESM(require_lib4(), 1);
 import os17 from "os";
-import path21 from "path";
+import path22 from "path";
 import { exec as exec4 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync3 = promisify3(exec4);
 var OPENCLAW_PRO_REPO = "Melvynx/openclawpro";
 function getCacheRepoDir2() {
-  return path21.join(os17.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
+  return path22.join(os17.homedir(), ".config", "openclaw", "pro-repos", "openclawpro");
 }
 async function execGitWithAuth2(command, token, repoUrl, cwd) {
   const authenticatedUrl = `https://x-access-token:${token}@${repoUrl.replace(/^https?:\/\//, "")}`;
@@ -37328,33 +37744,33 @@ async function execGitWithAuth2(command, token, repoUrl, cwd) {
 async function cloneOrUpdateRepo2(token) {
   const cacheDir = getCacheRepoDir2();
   const repoUrl = `https://github.com/${OPENCLAW_PRO_REPO}.git`;
-  if (await import_fs_extra17.default.pathExists(path21.join(cacheDir, ".git"))) {
+  if (await import_fs_extra18.default.pathExists(path22.join(cacheDir, ".git"))) {
     try {
       await execGitWithAuth2("pull", token, repoUrl, cacheDir);
     } catch (error) {
-      await import_fs_extra17.default.remove(cacheDir);
-      await import_fs_extra17.default.ensureDir(path21.dirname(cacheDir));
+      await import_fs_extra18.default.remove(cacheDir);
+      await import_fs_extra18.default.ensureDir(path22.dirname(cacheDir));
       await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
     }
   } else {
-    await import_fs_extra17.default.ensureDir(path21.dirname(cacheDir));
+    await import_fs_extra18.default.ensureDir(path22.dirname(cacheDir));
     await execGitWithAuth2(`clone ${repoUrl} ${cacheDir}`, token, repoUrl);
   }
-  return path21.join(cacheDir, "openclaw-config");
+  return path22.join(cacheDir, "openclaw-config");
 }
 async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
   const walk = async (dir, baseDir = dir) => {
-    const entries = await import_fs_extra17.default.readdir(dir, { withFileTypes: true });
+    const entries = await import_fs_extra18.default.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const sourcePath = path21.join(dir, entry.name);
-      const relativePath = path21.relative(baseDir, sourcePath);
-      const targetPath = path21.join(targetDir, relativePath);
+      const sourcePath = path22.join(dir, entry.name);
+      const relativePath = path22.relative(baseDir, sourcePath);
+      const targetPath = path22.join(targetDir, relativePath);
       if (entry.isDirectory()) {
-        await import_fs_extra17.default.ensureDir(targetPath);
+        await import_fs_extra18.default.ensureDir(targetPath);
         onProgress?.(relativePath, "directory");
         await walk(sourcePath, baseDir);
       } else {
-        await import_fs_extra17.default.copy(sourcePath, targetPath, { overwrite: true });
+        await import_fs_extra18.default.copy(sourcePath, targetPath, { overwrite: true });
         onProgress?.(relativePath, "file");
       }
     }
@@ -37363,7 +37779,7 @@ async function copyConfigFromCache2(cacheConfigDir, targetDir, onProgress) {
 }
 async function installOpenclawProConfigs(options) {
   const { githubToken, openclawFolder, onProgress } = options;
-  const targetFolder = openclawFolder || path21.join(os17.homedir(), ".openclaw");
+  const targetFolder = openclawFolder || path22.join(os17.homedir(), ".openclaw");
   try {
     const cacheConfigDir = await cloneOrUpdateRepo2(githubToken);
     await copyConfigFromCache2(cacheConfigDir, targetFolder, onProgress);
@@ -37374,28 +37790,28 @@ async function installOpenclawProConfigs(options) {
 }
 
 // src/lib/openclaw-token-storage.ts
-var import_fs_extra18 = __toESM(require_lib4(), 1);
+var import_fs_extra19 = __toESM(require_lib4(), 1);
 import os18 from "os";
-import path22 from "path";
+import path23 from "path";
 function getConfigDir2() {
   const platform = os18.platform();
   if (platform === "win32") {
-    return path22.join(process.env.APPDATA || os18.homedir(), "openclaw");
+    return path23.join(process.env.APPDATA || os18.homedir(), "openclaw");
   }
-  return path22.join(os18.homedir(), ".config", "openclaw");
+  return path23.join(os18.homedir(), ".config", "openclaw");
 }
 function getTokenPath() {
-  return path22.join(getConfigDir2(), "token.txt");
+  return path23.join(getConfigDir2(), "token.txt");
 }
 async function saveOpenclawToken(githubToken) {
   const configDir = getConfigDir2();
-  await import_fs_extra18.default.ensureDir(configDir);
-  await import_fs_extra18.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
+  await import_fs_extra19.default.ensureDir(configDir);
+  await import_fs_extra19.default.writeFile(getTokenPath(), githubToken, { mode: 384 });
 }
 async function getOpenclawToken() {
   const tokenPath = getTokenPath();
-  if (await import_fs_extra18.default.pathExists(tokenPath)) {
-    const token = await import_fs_extra18.default.readFile(tokenPath, "utf8");
+  if (await import_fs_extra19.default.pathExists(tokenPath)) {
+    const token = await import_fs_extra19.default.readFile(tokenPath, "utf8");
     return token.trim();
   }
   return null;
@@ -37408,7 +37824,7 @@ function getOpenclawTokenInfo() {
 }
 
 // src/commands/openclaw-pro.ts
-var import_fs_extra19 = __toESM(require_lib4(), 1);
+var import_fs_extra20 = __toESM(require_lib4(), 1);
 var API_URL2 = "https://codeline.app/api/products";
 var OPENCLAW_PRODUCT_ID = "prd_t2GRwX3aH1";
 var CLAUDE_CODE_TOOLS_INSTRUCTIONS = `
@@ -37515,7 +37931,7 @@ async function openclawProSetupCommand(options = {}) {
       Se(source_default.red("❌ Not activated"));
       process.exit(1);
     }
-    const openclawDir = options.folder ? path23.resolve(options.folder) : path23.join(os19.homedir(), ".openclaw");
+    const openclawDir = options.folder ? path24.resolve(options.folder) : path24.join(os19.homedir(), ".openclaw");
     const spinner = Y2();
     const onProgress = (file, type) => {
       spinner.message(`Installing: ${source_default.cyan(file)} ${source_default.gray(`(${type})`)}`);
@@ -37528,23 +37944,23 @@ async function openclawProSetupCommand(options = {}) {
     });
     spinner.stop("OpenClaw Pro configurations installed");
     let skillCount = 0;
-    const skillsDir = path23.join(openclawDir, "skills");
-    if (await import_fs_extra19.default.pathExists(skillsDir)) {
-      const items = await import_fs_extra19.default.readdir(skillsDir);
+    const skillsDir = path24.join(openclawDir, "skills");
+    if (await import_fs_extra20.default.pathExists(skillsDir)) {
+      const items = await import_fs_extra20.default.readdir(skillsDir);
       const dirs = await Promise.all(items.map(async (item) => {
-        const stat = await import_fs_extra19.default.stat(path23.join(skillsDir, item));
+        const stat = await import_fs_extra20.default.stat(path24.join(skillsDir, item));
         return stat.isDirectory();
       }));
       skillCount = dirs.filter(Boolean).length;
     }
     spinner.start("Setting up workspace TOOLS.md...");
-    const workspaceDir = path23.join(openclawDir, "workspace");
-    const toolsPath = path23.join(workspaceDir, "TOOLS.md");
-    await import_fs_extra19.default.ensureDir(workspaceDir);
-    if (await import_fs_extra19.default.pathExists(toolsPath)) {
-      const existingContent = await import_fs_extra19.default.readFile(toolsPath, "utf-8");
+    const workspaceDir = path24.join(openclawDir, "workspace");
+    const toolsPath = path24.join(workspaceDir, "TOOLS.md");
+    await import_fs_extra20.default.ensureDir(workspaceDir);
+    if (await import_fs_extra20.default.pathExists(toolsPath)) {
+      const existingContent = await import_fs_extra20.default.readFile(toolsPath, "utf-8");
       if (!existingContent.includes("Claude Code CLI")) {
-        await import_fs_extra19.default.appendFile(toolsPath, `
+        await import_fs_extra20.default.appendFile(toolsPath, `
 
 ` + CLAUDE_CODE_TOOLS_INSTRUCTIONS);
         spinner.stop("TOOLS.md updated with Claude Code instructions");
@@ -37558,7 +37974,7 @@ Skills define _how_ tools work. This file is for _your_ specifics — the stuff
 
 ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 `;
-      await import_fs_extra19.default.writeFile(toolsPath, defaultToolsMd);
+      await import_fs_extra20.default.writeFile(toolsPath, defaultToolsMd);
       spinner.stop("TOOLS.md created with Claude Code instructions");
     }
     spinner.start("Creating claude-run wrapper...");
@@ -37569,9 +37985,9 @@ ${CLAUDE_CODE_TOOLS_INSTRUCTIONS}
 script -q -c "claude $*" /dev/null
 `;
     const binDir = "/usr/local/bin";
-    const wrapperPath = path23.join(binDir, "claude-run");
+    const wrapperPath = path24.join(binDir, "claude-run");
     try {
-      await import_fs_extra19.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
+      await import_fs_extra20.default.writeFile(wrapperPath, claudeRunWrapper, { mode: 493 });
       spinner.stop("claude-run wrapper created");
     } catch {
       spinner.stop("claude-run wrapper skipped (no write access to /usr/local/bin)");
@@ -37620,12 +38036,12 @@ async function openclawProUpdateCommand(options = {}) {
 }
 
 // src/commands/dynamic-scripts.ts
-import path26 from "path";
+import path27 from "path";
 import { homedir } from "os";
 
 // src/lib/script-parser.ts
-var import_fs_extra20 = __toESM(require_lib4(), 1);
-import path24 from "path";
+var import_fs_extra21 = __toESM(require_lib4(), 1);
+import path25 from "path";
 var EXCLUDED_SCRIPTS = ["test", "lint", "format", "start"];
 var EXCLUDED_SUFFIXES = [":test", ":lint", ":test-fixtures", ":start"];
 function shouldIncludeScript(scriptName) {
@@ -37636,12 +38052,12 @@ function shouldIncludeScript(scriptName) {
   return true;
 }
 async function readScriptsPackageJson(claudeDir) {
-  const packageJsonPath = path24.join(claudeDir, "scripts", "package.json");
+  const packageJsonPath = path25.join(claudeDir, "scripts", "package.json");
   try {
-    if (!await import_fs_extra20.default.pathExists(packageJsonPath)) {
+    if (!await import_fs_extra21.default.pathExists(packageJsonPath)) {
       return null;
     }
-    const content = await import_fs_extra20.default.readFile(packageJsonPath, "utf-8");
+    const content = await import_fs_extra21.default.readFile(packageJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     return parsed.scripts || null;
   } catch (error) {
@@ -37685,10 +38101,10 @@ function groupScriptsByPrefix(commands) {
 }
 
 // src/commands/script-runner.ts
-var import_fs_extra21 = __toESM(require_lib4(), 1);
+var import_fs_extra22 = __toESM(require_lib4(), 1);
 import { spawn as spawn2 } from "child_process";
 import { execSync as execSync4 } from "child_process";
-import path25 from "path";
+import path26 from "path";
 import os20 from "os";
 function checkCommand2(cmd) {
   try {
@@ -37718,18 +38134,18 @@ async function executeScript(scriptName, claudeDir) {
     console.error(source_default.red("Bun is not installed. Install with: npm install -g bun"));
     return 1;
   }
-  const scriptsDir = path25.join(claudeDir, "scripts");
-  if (!await import_fs_extra21.default.pathExists(scriptsDir)) {
+  const scriptsDir = path26.join(claudeDir, "scripts");
+  if (!await import_fs_extra22.default.pathExists(scriptsDir)) {
     console.error(source_default.red(`Scripts directory not found at ${scriptsDir}`));
     console.log(source_default.gray("Run: aiblueprint agents setup"));
     return 1;
   }
-  const packageJsonPath = path25.join(scriptsDir, "package.json");
-  if (!await import_fs_extra21.default.pathExists(packageJsonPath)) {
+  const packageJsonPath = path26.join(scriptsDir, "package.json");
+  if (!await import_fs_extra22.default.pathExists(packageJsonPath)) {
     console.error(source_default.red(`package.json not found in ${scriptsDir}`));
     return 1;
   }
-  const packageJson = await import_fs_extra21.default.readJson(packageJsonPath);
+  const packageJson = await import_fs_extra22.default.readJson(packageJsonPath);
   if (!packageJson.scripts || !packageJson.scripts[scriptName]) {
     console.error(source_default.red(`Script "${scriptName}" not found in package.json`));
     return 1;
@@ -37752,7 +38168,7 @@ async function executeScript(scriptName, claudeDir) {
 
 // src/commands/dynamic-scripts.ts
 function getClaudeDir(parentOptions) {
-  return parentOptions.claudeCodeFolder || parentOptions.folder ? path26.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path26.join(homedir(), ".claude");
+  return parentOptions.claudeCodeFolder || parentOptions.folder ? path27.resolve(parentOptions.claudeCodeFolder || parentOptions.folder) : path27.join(homedir(), ".claude");
 }
 async function registerDynamicScriptCommands(claudeCodeCmd, claudeDir) {
   const scripts = await readScriptsPackageJson(claudeDir);
@@ -37814,7 +38230,7 @@ function registerAgentsCommands(cmd) {
       codexFolder: parentOptions.codexFolder
     });
   });
-  cmd.command("unify").description("Unify skills and agents into .agents and symlink tool folders back to it").action((options, command) => {
+  cmd.command("unify").description("Unify skills and agents into .agents, then render Codex TOML agents").action((options, command) => {
     const parentOptions = command.parent.opts();
     return agentsUnifyCommand({
       folder: parentOptions.folder,
@@ -37823,6 +38239,16 @@ function registerAgentsCommands(cmd) {
       agentsFolder: parentOptions.agentsFolder
     });
   });
+  cmd.command("codex-agents").description("Render shared Markdown agents from .agents/agents into Codex TOML custom agents").option("--overwrite", "Overwrite existing non-generated Codex agent files").action((options, command) => {
+    const parentOptions = command.parent.opts();
+    return codexAgentsCommand({
+      folder: parentOptions.folder,
+      claudeCodeFolder: parentOptions.claudeCodeFolder,
+      codexFolder: parentOptions.codexFolder,
+      agentsFolder: parentOptions.agentsFolder,
+      overwrite: options.overwrite
+    });
+  });
   const proCmd = cmd.command("pro").description("Manage AIBlueprint CLI Premium features");
   proCmd.command("activate [token]").description("Activate AIBlueprint CLI Premium with your access token").action((token) => {
     proActivateCommand(token);