@nurix/etna 0.19.22 → 0.19.24

package/lib/codex/agents-md.mjs

@@ -1,9 +1,14 @@
 // packages/cli/lib/codex/agents-md.mjs
-// CLAUDE.md → AGENTS.md — an exact copy (Codex's confirmed CLAUDE.md analog).
-// Mirrors the installer's CLAUDE.md safety net: overwrite in place when git can
-// recover it, otherwise back up the existing file and warn.
+// CLAUDE.md → AGENTS.md — the authored policy copied byte-for-byte, then a small GENERATED
+// Codex runtime adapter appended. The policy is runtime-neutral; the adapter maps its
+// capability hooks to Codex's native locations and, crucially, routes Codex to the markdown
+// rules under .claude/rules/ that Codex does NOT auto-load. The adapter is derived from the
+// bundled harness inventory (rules/skills/agents actually shipped), carries no user state, and
+// is regenerated whole on every reinstall alongside the rest of the harness-owned AGENTS.md.
+// Mirrors the installer's CLAUDE.md safety net: overwrite in place when git can recover it,
+// otherwise back up the existing file and warn.
 
-import { existsSync, lstatSync, renameSync, cpSync } from 'node:fs';
+import { existsSync, lstatSync, renameSync, readdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 
 function isSymlink(path) {
@@ -14,7 +19,75 @@ function isSymlink(path) {
     }
 }
 
-export function projectAgentsMd({ targetDir, bundledClaudeMd, projectHasGit }) {
+// Sorted base names of *.<ext> files directly under dir (e.g. rules/*.md → rule names).
+function listByExt(dir, ext) {
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+        .filter((f) => f.endsWith(ext))
+        .map((f) => f.slice(0, -ext.length))
+        .sort();
+}
+
+// Sorted names of immediate subdirectories of dir (e.g. skills/<name>/).
+function listSubdirs(dir) {
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+        .filter((f) => {
+            try {
+                return statSync(join(dir, f)).isDirectory();
+            } catch {
+                return false;
+            }
+        })
+        .sort();
+}
+
+// Render an inventory list as inline code names, or a runtime-neutral fallback when empty.
+function nameList(names) {
+    return names.length ? names.map((n) => `\`${n}\``).join(', ') : '_(none installed)_';
+}
+
+// Compose the generated Codex runtime adapter from the bundled harness inventory. Returns "" when
+// the bundle carries no rules, skills, or codex agents — nothing to adapt, so nothing is appended.
+export function buildCodexAdapter(bundledHarnessDir) {
+    const rules = listByExt(join(bundledHarnessDir, 'rules'), '.md');
+    const skills = listSubdirs(join(bundledHarnessDir, 'skills'));
+    const agents = listByExt(join(bundledHarnessDir, 'codex', 'agents'), '.toml');
+    if (!rules.length && !skills.length && !agents.length) return '';
+
+    const lines = [
+        '---',
+        '',
+        '## Codex runtime adapter (generated)',
+        '',
+        'This project is also installed for OpenAI Codex. The runtime-neutral policy above applies unchanged;',
+        "this section maps its capability hooks to Codex's native locations. It is generated from the installed",
+        'harness inventory and replaced whole on every reinstall — do not hand-edit.',
+        '',
+    ];
+    if (skills.length) {
+        lines.push(
+            `- **Skills** — Codex scans \`.agents/skills/\` (a mirror of \`.claude/skills/\`); invoke a skill by its name. Installed: ${nameList(skills)}.`,
+        );
+    }
+    if (agents.length) {
+        lines.push(
+            `- **Custom agents** — Codex reads \`.codex/agents/*.toml\`; dispatch a subagent by its name. Installed: ${nameList(agents)}.`,
+        );
+    }
+    if (rules.length) {
+        lines.push(
+            `- **Project rules** — Codex does NOT auto-load the markdown rules the policy references. Read the relevant file under \`.claude/rules/\` before the work it governs: ${nameList(rules)}.`,
+        );
+    }
+    lines.push(
+        '- **Ownership index** — regenerated each session by the `.codex/hooks.json` SessionStart hook; if it is absent from context, derive it by scanning `docs/features/` frontmatter.',
+    );
+    lines.push('');
+    return lines.join('\n');
+}
+
+export function projectAgentsMd({ targetDir, bundledClaudeMd, bundledHarnessDir, projectHasGit }) {
     if (!existsSync(bundledClaudeMd)) return null;
     const dest = join(targetDir, 'AGENTS.md');
     const existed = existsSync(dest) || isSymlink(dest);
@@ -30,6 +103,12 @@ export function projectAgentsMd({ targetDir, bundledClaudeMd, projectHasGit }) {
             warning = `No .git here, so no version-control safety net — backed up existing AGENTS.md → ${backup}`;
         }
     }
-    cpSync(bundledClaudeMd, dest, { force: true });
+    // Policy copied byte-for-byte; the generated adapter appended after a blank-line separator.
+    // The policy prefix is left exactly as authored — only a separator + adapter follow it.
+    const policy = readFileSync(bundledClaudeMd, 'utf8');
+    const adapter = bundledHarnessDir ? buildCodexAdapter(bundledHarnessDir) : '';
+    const separator = policy.endsWith('\n') ? '\n' : '\n\n';
+    const body = adapter ? policy + separator + adapter : policy;
+    writeFileSync(dest, body);
     return { installed: 'AGENTS.md → ./', notice, warning };
 }

package/lib/codex/hooks.mjs

@@ -3,10 +3,32 @@
 // filtered to type:"command" (the only hook type Codex executes — "prompt"/"agent"
 // entries are parsed but skipped). A standalone file, not a config.toml [hooks]
 // table, since the settings/config surface is out of scope for Codex here.
+//
+// Command translation: the source command locates its script via $CLAUDE_PROJECT_DIR,
+// which Claude Code exports but Codex does not — under Codex the token expands empty
+// and `node "/.claude/hooks/…"` exits 1, failing SessionStart. So every command that
+// references the token is prefixed with a runtime-neutral root resolution: `git
+// rev-parse` (walks up from any nested working directory) with a `pwd` fallback for a
+// non-Git project root. The resolved root is exported back as CLAUDE_PROJECT_DIR so the
+// script's own project-dir read (generate-ownership-index.mjs resolveProjectDir) also
+// points at the project root, not the session's nested cwd. The Claude source hooks.json
+// is left untouched — it stays valid for the CLI-installed .claude/settings.json path.
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 
+const PROJECT_DIR_TOKEN = /\$\{?CLAUDE_PROJECT_DIR\}?/;
+
+// Prefix a $CLAUDE_PROJECT_DIR-dependent command with a Codex-safe root resolution.
+// Commands that don't reference the token pass through unchanged.
+export function toCodexCommand(command) {
+    if (typeof command !== 'string' || !PROJECT_DIR_TOKEN.test(command)) return command;
+    return (
+        'export CLAUDE_PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; ' +
+        command
+    );
+}
+
 export function projectHooks({ targetDir, bundledHarnessDir }) {
     const srcJson = join(bundledHarnessDir, 'hooks', 'hooks.json');
     if (!existsSync(srcJson)) return null;
@@ -20,7 +42,9 @@ export function projectHooks({ targetDir, bundledHarnessDir }) {
     for (const [event, groups] of Object.entries(parsed.hooks || {})) {
         const kept = [];
         for (const group of groups) {
-            const hooks = (group.hooks || []).filter((h) => h.type === 'command');
+            const hooks = (group.hooks || [])
+                .filter((h) => h.type === 'command')
+                .map((h) => ({ ...h, command: toCodexCommand(h.command) }));
             if (hooks.length) kept.push({ ...group, hooks });
         }
         if (kept.length) out[event] = kept;

package/lib/codex/index.mjs

@@ -39,11 +39,12 @@ export function projectCodexArtifacts({
         owned.push(ownedPath);
     };
 
-    // AGENTS.md — exact copy of CLAUDE.md, with the CLAUDE.md backup-if-no-git rule.
-    collect(projectAgentsMd({ targetDir, bundledClaudeMd, projectHasGit }), 'AGENTS.md');
+    // AGENTS.md — CLAUDE.md copied byte-for-byte + a generated Codex runtime adapter derived from
+    // the bundled harness inventory (see agents-md.mjs), with the CLAUDE.md backup-if-no-git rule.
+    collect(projectAgentsMd({ targetDir, bundledClaudeMd, bundledHarnessDir, projectHasGit }), 'AGENTS.md');
     // .agents/skills — full-rebuilt mirror of the installed (already ship-filtered) .claude/skills.
     collect(projectSkills({ targetDir, projectHasGit }), '.agents/skills');
-    // .codex/agents — copy the shipped, pre-generated *.toml (see gen-agents.mjs).
+    // .codex/agents — copy the shipped, pre-authored *.toml (see docs/architecture/harness/authoring-agents.md).
     collect(copyCodexAgents({ targetDir, bundledHarnessDir, projectHasGit }), '.codex/agents');
     // .codex/hooks.json — Claude hooks.json filtered to type:"command".
     collect(projectHooks({ targetDir, bundledHarnessDir }), '.codex/hooks.json');

package/lib/codex/plugin-manifest.mjs

@@ -19,8 +19,13 @@ export function buildCodexPluginJson(fm, { hasHooks = false } = {}) {
     return out;
 }
 
-// The repo marketplace catalog Codex reads at .agents/plugins/marketplace.json.
-// Each plugin is a local source; the first keyword (if any) seeds a category.
+// The repo marketplace catalog Codex reads at .agents/plugins/marketplace.json. Each plugin is a
+// LOCAL source (source.path relative to the catalog root) carrying an explicit install policy:
+//   · installation AVAILABLE — offered, not force-installed (INSTALLED_BY_DEFAULT / NOT_AVAILABLE
+//     are the other documented tokens; these plugins are opt-in).
+//   · authentication NONE — they bundle only skills + hooks, no credentials or external auth.
+// The first keyword (if any) seeds a category. (Enum tokens per codex-support.md → Open Questions;
+// AVAILABLE/NONE are the correct pair for an opt-in, no-auth plugin.)
 export function buildCodexMarketplace(plugins) {
     return {
         name: 'nurixlabs',
@@ -29,7 +34,8 @@ export function buildCodexMarketplace(plugins) {
             .sort((a, b) => a.name.localeCompare(b.name))
             .map((p) => ({
                 name: p.name,
-                source: `./plugins/${p.name}`,
+                source: { path: `./plugins/${p.name}` },
+                policy: { installation: 'AVAILABLE', authentication: 'NONE' },
                 ...(p.frontmatter?.keywords?.length ? { category: p.frontmatter.keywords[0] } : {}),
             })),
     };

package/lib/codex/subagents.mjs

@@ -1,6 +1,6 @@
 // packages/cli/lib/codex/subagents.mjs
-// Copy the harness's pre-generated Codex subagent TOML — bundle codex/agents/*.toml,
-// authored on a Codex-authenticated laptop by gen-agents.mjs — into the project's
+// Copy the harness's pre-authored Codex subagent TOML — bundle codex/agents/*.toml,
+// authored per docs/architecture/harness/authoring-agents.md — into the project's
 // .codex/agents/. Full rebuild each run. The consumer needs NO Codex CLI: the TOML
 // ships ready, so a missing local Codex never blocks an install.
 

package/lib/codex/validate-codex-agents.mjs

@@ -0,0 +1,126 @@
+// packages/cli/lib/codex/validate-codex-agents.mjs
+// The Codex-twin validation gate — decoupled from any generator. A `<name>.codex.toml`
+// twin is now authored by the AI following docs/architecture/harness/authoring-agents.md,
+// so this is the check that keeps a malformed or Claude-only twin from shipping: the twins
+// are copied UNPARSED into the bundle (build-data.js) and a consumer's .codex/agents/, so
+// nothing else catches a bad one before Codex fails to load it in that repo. Run it after
+// authoring/editing a twin (the authoring-agents.md checklist mandates it) and, ideally, as
+// a fail-loud publish gate.
+//
+// Checks each twin for: valid TOML (python3 tomllib when present), the required keys
+// (name/description/developer_instructions), and runtime-neutrality (no Claude-only dispatch
+// primitives or fixed model tiers). Also flags a source agent with NO twin (out of sync).
+//
+// Usage:
+//   node packages/cli/lib/codex/validate-codex-agents.mjs             # shared catalog + all harnesses
+//   node packages/cli/lib/codex/validate-codex-agents.mjs --quiet     # errors only
+// Exits 0 when every twin is valid, 1 otherwise.
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(__dirname, '..', '..', '..', '..');
+const quiet = process.argv.slice(2).includes('--quiet');
+
+// Every source agent .md and its expected twin path: the shared catalog plus every harness's
+// owned agents. The .md is the authoritative set — a listed agent with no twin is out of sync.
+function collectAgents() {
+    const out = [];
+    const push = (dir) => {
+        if (!existsSync(dir)) return;
+        for (const f of readdirSync(dir)) {
+            if (!f.endsWith('.md')) continue;
+            const name = basename(f, '.md');
+            out.push({ name, mdPath: join(dir, f), tomlPath: join(dir, `${name}.codex.toml`) });
+        }
+    };
+    push(join(repoRoot, 'agents'));
+    const harnessDir = join(repoRoot, 'harness');
+    if (existsSync(harnessDir)) {
+        for (const harness of readdirSync(harnessDir)) {
+            if (harness === 'common') continue; // not a harness — the shared root-files folder
+            push(join(harnessDir, harness, 'agents'));
+        }
+    }
+    return out.sort((a, b) => a.tomlPath.localeCompare(b.tomlPath));
+}
+
+// TOML parse via python3's tomllib when present; '' = valid, a message = invalid, null =
+// python3 unavailable (the key + runtime-neutral regex checks still run, so the gate degrades
+// gracefully rather than passing blind — but CI/macOS both ship python3, so parse runs there).
+function tomlError(toml) {
+    const res = spawnSync('python3', ['-c', 'import tomllib,sys; tomllib.loads(sys.stdin.read())'], {
+        input: toml,
+        encoding: 'utf8',
+    });
+    if (res.error && res.error.code === 'ENOENT') return null;
+    return res.status === 0 ? '' : (res.stderr || 'invalid TOML').trim();
+}
+
+// A Codex twin runs under Codex, which has neither the Task tool nor Claude model aliases. The
+// md body is copied verbatim into developer_instructions, so a hit here is a hit in the SOURCE
+// agent. The dropped-tools comment lists bare names (`Task`, `Skill`) which are fine — only the
+// prose forms (`Task tool`/`Skill tool`) and model-tier aliases are rejected.
+const CLAUDE_ONLY_PATTERNS = [
+    { re: /Task tool/i, label: '"Task tool" (name the runtime-neutral outcome, not the Claude tool)' },
+    { re: /Skill tool/i, label: '"Skill tool" (refer to the skill by name, not the Claude tool)' },
+    { re: /subagent_type/i, label: '`subagent_type` (a Claude Agent-tool parameter)' },
+    { re: /\bhaiku\b/i, label: '"haiku" (a fixed Claude model tier — say "cheapest capable tier")' },
+    { re: /\bopus\b/i, label: '"opus" (a fixed Claude model tier — say "strongest tier")' },
+    { re: /\bsonnet\b/i, label: '"sonnet" (a fixed Claude model tier)' },
+];
+
+const REQUIRED_KEYS = ['name', 'description', 'developer_instructions'];
+
+// Return the list of problems with one twin (empty ⇒ valid).
+function validateTwin(tomlPath) {
+    const problems = [];
+    const toml = readFileSync(tomlPath, 'utf8');
+    for (const key of REQUIRED_KEYS) {
+        if (!new RegExp(`^\\s*${key}\\s*=`, 'm').test(toml)) problems.push(`missing \`${key} =\` key`);
+    }
+    const err = tomlError(toml);
+    if (err) problems.push(`invalid TOML: ${err.split('\n').pop().slice(0, 160)}`);
+    for (const { re, label } of CLAUDE_ONLY_PATTERNS) {
+        if (re.test(toml)) problems.push(`Claude-only primitive: ${label}`);
+    }
+    return problems;
+}
+
+function main() {
+    const agents = collectAgents();
+    if (!agents.length) {
+        console.error('validate-codex-agents: no agents/*.md found.');
+        process.exit(1);
+    }
+    let ok = 0;
+    const failures = [];
+    for (const { name, tomlPath } of agents) {
+        if (!existsSync(tomlPath)) {
+            failures.push(`${name}: no twin at ${relPath(tomlPath)} (source .md has no .codex.toml — out of sync)`);
+            continue;
+        }
+        const problems = validateTwin(tomlPath);
+        if (problems.length) {
+            failures.push(`${relPath(tomlPath)}:\n${problems.map((p) => `    - ${p}`).join('\n')}`);
+        } else {
+            ok += 1;
+            if (!quiet) console.log(`  ok  ${relPath(tomlPath)}`);
+        }
+    }
+    if (failures.length) {
+        console.error(`\nvalidate-codex-agents: ${failures.length} invalid, ${ok} ok of ${agents.length} twin(s):\n`);
+        for (const f of failures) console.error(`  ✗ ${f}`);
+        process.exit(1);
+    }
+    console.log(`\nvalidate-codex-agents: all ${ok} twin(s) valid.`);
+}
+
+function relPath(p) {
+    return p.startsWith(repoRoot) ? p.slice(repoRoot.length + 1) : p;
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nurix/etna",
-    "version": "0.19.22",
+    "version": "0.19.24",
     "description": "Bootstrap a project with a Nurix harness — copies the harness's CLAUDE.md, skills, agents, rules, and hooks directly into the project from a bundled payload (no marketplace fetch, no network).",
     "type": "module",
     "bin": {
@@ -21,7 +21,7 @@
     "scripts": {
         "build:data": "node scripts/build-data.js",
         "prepack": "node scripts/build-data.js",
-        "gen:codex-agents": "node lib/codex/gen-agents.mjs"
+        "validate:codex-agents": "node lib/codex/validate-codex-agents.mjs"
     },
     "repository": {
         "type": "git",

package/lib/codex/gen-agents.mjs

@@ -1,157 +0,0 @@
-// packages/cli/lib/codex/gen-agents.mjs
-// AUTHORING-TIME generator — runs ON A LAPTOP with the Codex CLI installed and
-// authenticated, NEVER in CI. For each Claude subagent (agents/<name>.md in the
-// shared catalog, plus harness/*/agents/*.md with --include-harness) it runs
-// `codex exec` to translate the markdown into an OpenAI Codex subagent TOML and
-// writes a committed sibling agents/<name>.codex.toml. The shippers (build-data.js,
-// publish.mjs) then carry those committed files; the installer copies them into a
-// consumer's .codex/agents/ with no Codex CLI required downstream.
-//
-// Usage:
-//   node packages/cli/lib/codex/gen-agents.mjs            # shared catalog, only stale/missing
-//   node packages/cli/lib/codex/gen-agents.mjs --force    # regenerate all shared agents
-//   node packages/cli/lib/codex/gen-agents.mjs --include-harness  # + harness/*/agents/*.md
-
-import {
-    existsSync,
-    readdirSync,
-    readFileSync,
-    writeFileSync,
-    statSync,
-} from 'node:fs';
-import { dirname, join, resolve, basename } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { spawnSync } from 'node:child_process';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const repoRoot = resolve(__dirname, '..', '..', '..', '..');
-
-// Pinned conversion prompt — deterministic instructions so re-runs stay stable.
-// Codex does the semantic md→toml; the body is copied verbatim, tools are dropped
-// (no Codex equivalent) and recorded in a leading comment.
-const CONVERSION_PROMPT = [
-    'Convert the Claude Code subagent definition provided on stdin into an OpenAI Codex subagent TOML document.',
-    'Output ONLY the raw TOML — no prose, no markdown code fences, nothing before or after.',
-    'Set `name` from the frontmatter `name`.',
-    'Set `description` as a TOML basic string (double quotes) from the frontmatter `description`, escaping any interior double-quote as \\".',
-    'Put the ENTIRE markdown body (everything after the closing frontmatter ---) VERBATIM into a TOML multi-line',
-    "LITERAL string delimited by triple SINGLE quotes: developer_instructions = '''<body>'''.",
-    'A literal string is verbatim — do NOT escape anything inside it, and do NOT use triple double-quotes (backslashes like \\s in the body must survive unchanged).',
-    'If frontmatter `model` is a real model id, set `model`; if it is `inherit`, omit `model`.',
-    'If frontmatter has a `tools:` line, do NOT translate it — instead put a single comment line',
-    '`# dropped Claude tools: <the list>` as the first line of the file.',
-    'Emit no keys other than name, description, model (optional), developer_instructions.',
-].join(' ');
-
-const args = process.argv.slice(2);
-const force = args.includes('--force');
-const includeHarness = args.includes('--include-harness');
-
-function die(msg) {
-    console.error(`gen-codex-agents: ${msg}`);
-    process.exit(1);
-}
-
-// Codex must be present + authenticated — this step cannot run in CI.
-function assertCodexReady() {
-    const which = spawnSync('codex', ['--version'], { encoding: 'utf8' });
-    if (which.status !== 0) {
-        die('the `codex` CLI is not installed / not on PATH. This generator runs only on an authoring laptop.');
-    }
-}
-
-// Every agents/<name>.md to convert: the shared catalog, plus harness-owned agents on request.
-function collectAgentFiles() {
-    const files = [];
-    const shared = join(repoRoot, 'agents');
-    if (existsSync(shared)) {
-        for (const f of readdirSync(shared)) {
-            if (f.endsWith('.md')) files.push(join(shared, f));
-        }
-    }
-    if (includeHarness) {
-        const harnessDir = join(repoRoot, 'harness');
-        if (existsSync(harnessDir)) {
-            for (const harness of readdirSync(harnessDir)) {
-                if (harness === 'common') continue; // not a harness — the shared root-files folder
-                const agentsDir = join(harnessDir, harness, 'agents');
-                if (!existsSync(agentsDir)) continue;
-                for (const f of readdirSync(agentsDir)) {
-                    if (f.endsWith('.md')) files.push(join(agentsDir, f));
-                }
-            }
-        }
-    }
-    return files.sort();
-}
-
-// A regen is due when forced, the toml is missing, or the md is newer than the toml.
-function needsRegen(mdPath, tomlPath) {
-    if (force || !existsSync(tomlPath)) return true;
-    return statSync(mdPath).mtimeMs > statSync(tomlPath).mtimeMs;
-}
-
-// Strip an accidental ```toml fence if the model wrapped its output despite the prompt.
-function stripFences(text) {
-    const trimmed = text.trim();
-    const fence = trimmed.match(/^```(?:toml)?\n([\s\S]*?)\n```$/);
-    return (fence ? fence[1] : trimmed) + '\n';
-}
-
-// Validate that the produced TOML parses. Uses python3's tomllib when present
-// (returns true/error string); returns null when python3 is unavailable so the
-// caller proceeds best-effort rather than hard-failing on a missing dev tool.
-function tomlError(toml) {
-    const res = spawnSync('python3', ['-c', 'import tomllib,sys; tomllib.loads(sys.stdin.read())'], {
-        input: toml,
-        encoding: 'utf8',
-    });
-    if (res.error && res.error.code === 'ENOENT') return null;
-    return res.status === 0 ? '' : (res.stderr || 'invalid TOML').trim();
-}
-
-function convert(mdPath) {
-    const md = readFileSync(mdPath, 'utf8');
-    const res = spawnSync('codex', ['exec', '--sandbox', 'read-only', CONVERSION_PROMPT], {
-        input: md,
-        encoding: 'utf8',
-        maxBuffer: 32 * 1024 * 1024,
-    });
-    if (res.status !== 0) {
-        throw new Error(`codex exec failed for ${mdPath}: ${(res.stderr || '').slice(-400)}`);
-    }
-    const toml = stripFences(res.stdout || '');
-    if (!/^\s*name\s*=/m.test(toml)) {
-        throw new Error(`codex output for ${mdPath} has no \`name =\` key — refusing to write. Got:\n${toml.slice(0, 200)}`);
-    }
-    const err = tomlError(toml);
-    if (err) {
-        throw new Error(`codex output for ${mdPath} is not valid TOML — refusing to write:\n${err.slice(0, 300)}`);
-    }
-    return toml;
-}
-
-assertCodexReady();
-const files = collectAgentFiles();
-if (!files.length) die('no agents/*.md found to convert.');
-
-let wrote = 0;
-let skipped = 0;
-for (const mdPath of files) {
-    const name = basename(mdPath, '.md');
-    const tomlPath = join(dirname(mdPath), `${name}.codex.toml`);
-    if (!needsRegen(mdPath, tomlPath)) {
-        skipped += 1;
-        continue;
-    }
-    process.stdout.write(`converting ${name} … `);
-    try {
-        writeFileSync(tomlPath, convert(mdPath));
-        wrote += 1;
-        console.log('ok');
-    } catch (e) {
-        console.log('FAILED');
-        console.error(`  ${e.message}`);
-    }
-}
-console.log(`\ngen-codex-agents: wrote ${wrote}, skipped ${skipped} (up-to-date) of ${files.length} agent(s).`);