polyskill 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Penkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# polyskill
+
+Author your AI-coding-agent **skills and subagents once**, compile them to
+every harness. One Markdown source tree → Claude Code and Codex config trees,
+with **inline per-target macros** so a single file can say different things to
+different agents.
+
+```bash
+npx --yes polyskill --source ./src-agents --out .
+```
+
+## Why
+
+Most "sync my agent rules everywhere" tools broadcast the *same* body to every
+target and only vary the frontmatter. That breaks down the moment a skill needs
+to say something genuinely different per harness — e.g. Claude Code has
+`Explore` / `general-purpose` subagents and an `ExitPlanMode` tool that Codex
+does not. polyskill solves that with inline macros:
+
+```markdown
+<claude>On Claude Code, dispatch read-only checks with `subagent_type: "Explore"`.</claude>
+<codex>On Codex, use the default worker — there is no Explore / general-purpose split.</codex>
+```
+
+Everything outside a macro tag is shared verbatim. Tags are expanded only inside
+`.md` files; every other file is copied byte-for-byte.
+
+## Usage
+
+Zero install — run it with `npx`. Always pass `--yes` in scripts/CI so npx does
+not stall on its install prompt, and pin an exact version for reproducible
+builds:
+
+```bash
+npx --yes polyskill@0.1.0            # walk up for polyskill.config.json
+npx --yes polyskill --source ./a --out ./dist --target claude
+```
+
+Before publishing, you can run straight from GitHub:
+
+```bash
+npx --yes github:SSS135/polyskill --source ./a --out .
+```
+
+### Source layout
+
+```
+<source>/
+  skills/<name>/SKILL.md      # required; bundled files copy verbatim
+  skills/<name>/<other files>
+  agents/<name>.md            # single-file subagent
+  agents/<name>/<helpers>     # optional sibling folder
+```
+
+### Config
+
+With no flags, polyskill walks up from the current directory looking for
+`polyskill.config.json`:
+
+```json
+{
+  "source": "./src-agents",
+  "targets": {
+    "claude": { "kind": "claude", "out": "." },
+    "codex":  { "kind": "codex",  "out": "." }
+  }
+}
+```
+
+Relative paths in the config resolve against the config file's directory;
+relative paths passed as flags resolve against the current directory. Flags
+override config (`--source`, `--out`, `--target`). With no config file present,
+`--source` and `--out` are required and all built-in kinds are emitted.
+
+## Targets
+
+| Kind   | Skills                   | Subagents              |
+| ------ | ------------------------ | ---------------------- |
+| claude | `<out>/.claude/skills/`  | `<out>/.claude/agents/`|
+| codex  | `<out>/.agents/skills/`  | `<out>/.codex/agents/` |
+
+### Codex conversions
+
+- `SKILL.md` frontmatter is shrunk to `name` + `description`.
+- Subagent `.md` → TOML: the body becomes `developer_instructions`;
+  `mcpServers` → `mcp_servers`, `effort` → `model_reasoning_effort`.
+- `model` and other Claude-only fields (`tools`, `color`, `hooks`, …) are
+  dropped — a Claude model name is not a valid Codex model id. Set a
+  Codex-specific value in a `<codex>` frontmatter block if you need one.
+
+The build is overwrite-only: unchanged files are left untouched, and orphans
+from deleted sources are not auto-cleaned.
+
+## Development
+
+```bash
+npm install
+npm test          # node:test — golden byte-identical fixtures + unit tests
+npm run typecheck # tsc --noEmit over JSDoc-typed source (dev-only; runtime is zero-dep)
+```
+
+The runtime has **no dependencies** — it uses only Node built-ins and needs
+Node ≥ 20.
+
+## License
+
+MIT

package/examples/agents/example-reviewer/checklist.md

@@ -0,0 +1,8 @@
+# Review checklist
+
+A sibling file next to `example-reviewer.md`. Sibling folders are copied into
+the target's agent directory, with macros expanded in `.md` files.
+
+- Off-by-one and boundary conditions
+- Unhandled error paths
+- Resource leaks

package/examples/agents/example-reviewer.md

@@ -0,0 +1,17 @@
+---
+name: example-reviewer
+description: Reviews a diff for obvious mistakes.
+tools: Read, Grep, Bash
+model: sonnet
+mcpServers: my-server
+effort: high
+color: blue
+---
+
+You are a focused code reviewer. Read the diff and report only real issues —
+no style nits, no praise.
+
+<claude>Use the Read and Grep tools to inspect surrounding code.</claude>
+<codex>Use the available read/search capabilities to inspect surrounding code.</codex>
+
+See `checklist.md` for the review checklist.

package/examples/skills/hello-greeter/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: hello-greeter
+description: Demonstrates an author-once skill compiled to multiple harnesses.
+allowed-tools: Read, Grep
+model: inherit
+---
+
+# Hello Greeter
+
+A tiny example skill, authored once and emitted to every target. Everything
+outside a macro tag is shared verbatim.
+
+<claude>
+On Claude Code, dispatch read-only checks with `subagent_type: "Explore"`.
+</claude>
+<codex>
+On Codex, use the default worker — there is no Explore / general-purpose split.
+</codex>
+
+See `reference.md` for the canned greetings; `greeting.txt` ships verbatim.

package/examples/skills/hello-greeter/greeting.txt

@@ -0,0 +1 @@
+hello, world

package/examples/skills/hello-greeter/reference.md

@@ -0,0 +1,7 @@
+# Greetings reference
+
+A non-`SKILL.md` markdown file. Macros still expand here, but the Codex
+frontmatter shrink does not apply (it only touches `SKILL.md`).
+
+<claude>Claude users see this line.</claude>
+<codex>Codex users see this line.</codex>

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "polyskill",
+  "version": "0.1.0",
+  "description": "Compile author-once skills and subagents into per-harness agent configs (Claude Code, Codex), with inline per-target macros.",
+  "type": "module",
+  "bin": {
+    "polyskill": "src/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "src",
+    "examples",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "skills",
+    "subagents",
+    "agents",
+    "ai",
+    "cli",
+    "codegen"
+  ],
+  "license": "MIT",
+  "author": "SSS135 (https://github.com/SSS135)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SSS135/polyskill.git"
+  },
+  "homepage": "https://github.com/SSS135/polyskill#readme",
+  "bugs": {
+    "url": "https://github.com/SSS135/polyskill/issues"
+  },
+  "devDependencies": {
+    "@types/node": "^24",
+    "typescript": "^5"
+  }
+}

package/src/cli.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// @ts-check
+/**
+ * polyskill CLI.
+ *
+ * Compiles an "author-once" source tree (skills/ + agents/) into per-target
+ * agent-config trees. Driven by a JSON config, by flags, or both — flags
+ * override config, and the tool runs with no config file at all when given
+ * --source/--out directly.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { buildTarget, KNOWN_KINDS, Report } from './compile.js';
+
+const CONFIG_NAME = 'polyskill.config.json';
+
+const USAGE = `polyskill — compile author-once skills/subagents to per-harness config trees
+
+Usage:
+  polyskill [--config <path>] [--source <dir>] [--out <dir>] [--target <id> ...]
+
+Options:
+  --config <path>   JSON config file. If omitted, walk up from the cwd looking
+                    for ${CONFIG_NAME}; if none is found, run from flags alone.
+  --source <dir>    Source root holding skills/ and agents/. Overrides config.
+  --out <dir>       Output root. Overrides every target's configured out.
+  --target <id>     Target to build (repeatable). Defaults to every target in
+                    the config, or to all built-in kinds (${KNOWN_KINDS.join(', ')})
+                    in no-config mode.
+  -h, --help        Show this help.
+
+Config shape:
+  {
+    "source": "./.universal-agent",
+    "targets": {
+      "claude": { "kind": "claude", "out": "../.." },
+      "codex":  { "kind": "codex",  "out": "../.." }
+    }
+  }
+  Relative paths in the config resolve against the config file's directory;
+  relative paths passed as flags resolve against the current directory.
+`;
+
+/** @param {string} msg */
+function fail(msg) {
+    process.stderr.write(`${msg}\n`);
+    return 2;
+}
+
+/** @param {string} startDir @returns {string|null} */
+function findConfig(startDir) {
+    let dir = startDir;
+    for (;;) {
+        const candidate = path.join(dir, CONFIG_NAME);
+        if (existsSync(candidate)) return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+
+/**
+ * @param {string[]} argv
+ * @returns {number} process exit code
+ */
+export function main(argv) {
+    let values;
+    try {
+        ({ values } = parseArgs({
+            args: argv,
+            options: {
+                config: { type: 'string' },
+                source: { type: 'string' },
+                out: { type: 'string' },
+                target: { type: 'string', multiple: true },
+                help: { type: 'boolean', short: 'h' },
+            },
+            allowPositionals: false,
+        }));
+    } catch (err) {
+        return fail(`error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+
+    const cwd = process.cwd();
+    const flagTargets = /** @type {string[]} */ (values.target ?? []);
+
+    // Resolve the config path: explicit flag, else walk-up discovery, else none.
+    /** @type {string|null} */
+    let configPath = null;
+    if (values.config) {
+        configPath = path.resolve(cwd, values.config);
+        if (!existsSync(configPath)) return fail(`error: config not found: ${configPath}`);
+    } else {
+        configPath = findConfig(cwd);
+    }
+
+    /** @type {Array<{ id: string, kind: string, sourceRoot: string, outRoot: string }>} */
+    const plan = [];
+
+    if (configPath) {
+        let cfg;
+        try {
+            cfg = JSON.parse(readFileSync(configPath, 'utf-8'));
+        } catch (err) {
+            return fail(`error: invalid JSON in ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const base = path.dirname(configPath);
+        const targets = cfg.targets ?? {};
+        const ids = Object.keys(targets);
+        if (ids.length === 0) return fail(`error: no "targets" defined in ${configPath}`);
+
+        const sourceRoot = values.source
+            ? path.resolve(cwd, values.source)
+            : path.resolve(base, cfg.source ?? '.');
+
+        const selected = flagTargets.length ? flagTargets : ids;
+        for (const id of selected) {
+            if (!(id in targets)) return fail(`error: unknown target: ${id}`);
+            const t = targets[id];
+            if (!KNOWN_KINDS.includes(t.kind)) return fail(`error: target ${id}: unknown kind '${t.kind}'`);
+            const outRoot = values.out
+                ? path.resolve(cwd, values.out)
+                : path.resolve(base, t.out ?? '.');
+            plan.push({ id, kind: t.kind, sourceRoot, outRoot });
+        }
+    } else {
+        // No-config mode: everything comes from flags.
+        if (!values.source || !values.out) {
+            return fail(`error: no ${CONFIG_NAME} found; --source and --out are required.\n\n${USAGE}`);
+        }
+        const sourceRoot = path.resolve(cwd, values.source);
+        const outRoot = path.resolve(cwd, values.out);
+        const selected = flagTargets.length ? flagTargets : KNOWN_KINDS;
+        for (const id of selected) {
+            if (!KNOWN_KINDS.includes(id)) return fail(`error: unknown target kind: ${id} (expected one of ${KNOWN_KINDS.join(', ')})`);
+            plan.push({ id, kind: id, sourceRoot, outRoot });
+        }
+    }
+
+    const report = new Report();
+    for (const t of plan) {
+        process.stdout.write(`[${t.id}] kind=${t.kind} -> ${t.outRoot}\n`);
+        buildTarget(t.sourceRoot, t.kind, t.outRoot, report);
+    }
+    report.emit();
+    return 0;
+}
+
+process.exit(main(process.argv.slice(2)));

package/src/compile.js

@@ -0,0 +1,306 @@
+// @ts-check
+/**
+ * polyskill core compiler.
+ *
+ * Reads "author-once" Claude-flavored skills and subagents, expands per-kind
+ * macros (<claude>...</claude>, <codex>...</codex>), and emits one config tree
+ * per target. Behavior is a faithful port of the original Python build.py:
+ * same macro pass, same line-based frontmatter parse, same TOML escaping, and
+ * the same overwrite-only / no-orphan-cleanup contract.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+export const KNOWN_KINDS = ['claude', 'codex'];
+
+/** Frontmatter fields that survive the Codex skill shrinkage step. */
+const CODEX_SKILL_KEEP = ['name', 'description'];
+
+/**
+ * Claude subagent frontmatter -> Codex TOML field renames.
+ * @type {Record<string, string>}
+ */
+const TOML_RENAMES = { mcpServers: 'mcp_servers', effort: 'model_reasoning_effort' };
+
+/**
+ * Claude subagent frontmatter fields that never reach the Codex TOML.
+ * `model` is intentionally dropped — a Claude model name (opus/sonnet) is not a
+ * valid Codex model id, so passing it through would be wrong, not lossless. A
+ * Codex-specific model belongs in a <codex> frontmatter block.
+ */
+const TOML_DROP = new Set([
+    'model', 'tools', 'disallowedTools', 'permissionMode', 'hooks',
+    'memory', 'isolation', 'background', 'initialPrompt', 'color',
+]);
+
+const TAG_RE = /<(claude|codex)>([\s\S]*?)<\/\1>/g;
+const FRONT_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
+const YAML_LINE_RE = /^([A-Za-z_][\w-]*)\s*:\s?(.*)$/;
+
+export class Report {
+    constructor() {
+        /** @type {string[]} */ this.written = [];
+        /** @type {string[]} */ this.warnings = [];
+        /** @type {string[]} */ this.dropped = [];
+    }
+    emit() {
+        process.stdout.write(`wrote ${this.written.length} file(s)\n`);
+        for (const w of this.warnings) process.stdout.write(`WARN: ${w}\n`);
+        for (const d of this.dropped) process.stdout.write(`drop: ${d}\n`);
+    }
+}
+
+/**
+ * Keep the body of macro tags matching `kind`; drop the rest.
+ * @param {string} text
+ * @param {string} kind
+ * @returns {string}
+ */
+export function processMacros(text, kind) {
+    return text.replace(TAG_RE, (_m, tagKind, body) => (tagKind === kind ? body : ''));
+}
+
+/**
+ * Split a leading `---` frontmatter block from the body.
+ * @param {string} text
+ * @returns {{ fields: Record<string,string> | null, raw: string, body: string }}
+ */
+export function splitFrontmatter(text) {
+    const stripped = text.replace(/^[\r\n]+/, '');
+    const leadingWs = text.slice(0, text.length - stripped.length);
+    const m = FRONT_RE.exec(stripped);
+    if (!m) return { fields: null, raw: '', body: text };
+    const raw = stripped.slice(0, m[0].length);
+    const body = stripped.slice(m[0].length);
+    /** @type {Record<string,string>} */
+    const fields = {};
+    for (const line of m[1].split(/\r\n|\r|\n/)) {
+        if (!line.trim()) continue;
+        const fm = YAML_LINE_RE.exec(line);
+        if (fm) fields[fm[1]] = fm[2];
+    }
+    return { fields, raw: leadingWs + raw, body };
+}
+
+/**
+ * Render a frontmatter block from ordered key/value pairs.
+ * @param {Record<string,string>} fields
+ * @returns {string}
+ */
+export function emitFrontmatter(fields) {
+    const lines = ['---'];
+    for (const [k, v] of Object.entries(fields)) lines.push(v ? `${k}: ${v}` : `${k}:`);
+    lines.push('---');
+    return lines.join('\n') + '\n';
+}
+
+/** @param {string} s @returns {string} */
+export function tomlBasic(s) {
+    const escaped = s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    return `"${escaped}"`;
+}
+
+/** @param {string} s @returns {string} */
+export function tomlMultiline(s) {
+    let out = s.replace(/\\/g, '\\\\').replaceAll('"""', '\\"""');
+    if (!out.endsWith('\n')) out += '\n';
+    return `"""\n${out}"""`;
+}
+
+// ---------- fs helpers ----------
+
+/** @param {string} dir @returns {string[]} absolute file paths, recursive, sorted */
+function walkFiles(dir) {
+    /** @type {string[]} */
+    const out = [];
+    /** @param {string} d */
+    const rec = (d) => {
+        for (const name of readdirSync(d)) {
+            const full = path.join(d, name);
+            if (statSync(full).isDirectory()) rec(full);
+            else out.push(full);
+        }
+    };
+    rec(dir);
+    return out.sort();
+}
+
+/** @param {string} p @returns {boolean} */
+function isDir(p) {
+    return existsSync(p) && statSync(p).isDirectory();
+}
+
+/**
+ * Read a text file with universal-newline normalization (CRLF/CR -> LF), so
+ * output matches the Python tool, whose text-mode reads normalize newlines.
+ * Verbatim/binary copies deliberately do NOT go through here.
+ * @param {string} p @returns {string}
+ */
+function readText(p) {
+    return readFileSync(p, 'utf-8').replace(/\r\n?/g, '\n');
+}
+
+/** @param {string} dest @param {Buffer} data @param {Report} report */
+function writeBytesIfChanged(dest, data, report) {
+    mkdirSync(path.dirname(dest), { recursive: true });
+    if (existsSync(dest) && readFileSync(dest).equals(data)) return;
+    writeFileSync(dest, data);
+    report.written.push(dest);
+}
+
+/** @param {string} dest @param {string} text @param {Report} report */
+function writeIfChanged(dest, text, report) {
+    writeBytesIfChanged(dest, Buffer.from(text, 'utf-8'), report);
+}
+
+/** @param {string} src @param {string} dest @param {string} kind @param {Report} report */
+function copyMdWithMacros(src, dest, kind, report) {
+    writeIfChanged(dest, processMacros(readText(src), kind), report);
+}
+
+/** @param {string} src @param {string} dest @param {Report} report */
+function copyVerbatim(src, dest, report) {
+    writeBytesIfChanged(dest, readFileSync(src), report);
+}
+
+// ---------- claude target ----------
+
+/** @param {string} srcDir @param {string} outDir @param {Report} report */
+function emitClaudeSkill(srcDir, outDir, report) {
+    for (const f of walkFiles(srcDir)) {
+        const dest = path.join(outDir, path.relative(srcDir, f));
+        if (f.endsWith('.md')) copyMdWithMacros(f, dest, 'claude', report);
+        else copyVerbatim(f, dest, report);
+    }
+}
+
+/**
+ * @param {string} srcFile @param {string|null} siblingDir
+ * @param {string} outFile @param {string} outSibling @param {Report} report
+ */
+function emitClaudeAgent(srcFile, siblingDir, outFile, outSibling, report) {
+    copyMdWithMacros(srcFile, outFile, 'claude', report);
+    if (siblingDir && isDir(siblingDir)) {
+        for (const f of walkFiles(siblingDir)) {
+            const dest = path.join(outSibling, path.relative(siblingDir, f));
+            if (f.endsWith('.md')) copyMdWithMacros(f, dest, 'claude', report);
+            else copyVerbatim(f, dest, report);
+        }
+    }
+}
+
+// ---------- codex target ----------
+
+/** @param {string} srcDir @param {string} outDir @param {Report} report */
+function emitCodexSkill(srcDir, outDir, report) {
+    for (const f of walkFiles(srcDir)) {
+        const dest = path.join(outDir, path.relative(srcDir, f));
+        if (path.basename(f) === 'SKILL.md') {
+            const text = processMacros(readText(f), 'codex');
+            const { fields, body } = splitFrontmatter(text);
+            if (fields === null) {
+                report.warnings.push(`${f}: no frontmatter after macro pass`);
+                writeIfChanged(dest, text, report);
+                continue;
+            }
+            /** @type {Record<string,string>} */
+            const kept = {};
+            for (const k of CODEX_SKILL_KEEP) if (k in fields) kept[k] = fields[k];
+            for (const k of Object.keys(fields)) {
+                if (!CODEX_SKILL_KEEP.includes(k)) report.dropped.push(`${f}: frontmatter '${k}'`);
+            }
+            writeIfChanged(dest, emitFrontmatter(kept) + body, report);
+        } else if (f.endsWith('.md')) {
+            copyMdWithMacros(f, dest, 'codex', report);
+        } else {
+            copyVerbatim(f, dest, report);
+        }
+    }
+}
+
+/**
+ * @param {string} srcFile @param {string|null} siblingDir
+ * @param {string} outFile @param {string} outSibling @param {Report} report
+ */
+function emitCodexAgent(srcFile, siblingDir, outFile, outSibling, report) {
+    const text = processMacros(readText(srcFile), 'codex');
+    let { fields, body } = splitFrontmatter(text);
+    if (fields === null) {
+        report.warnings.push(`${srcFile}: no frontmatter after macro pass`);
+        fields = {};
+    }
+    const lines = [];
+    const nameVal = fields.name ?? path.basename(srcFile, '.md');
+    const descVal = fields.description ?? '';
+    lines.push(`name = ${tomlBasic(nameVal)}`);
+    lines.push(`description = ${tomlBasic(descVal)}`);
+    for (const [k, v] of Object.entries(fields)) {
+        if (k === 'name' || k === 'description') continue;
+        if (TOML_DROP.has(k)) {
+            report.dropped.push(`${srcFile}: frontmatter '${k}'`);
+            continue;
+        }
+        const outKey = TOML_RENAMES[k] ?? k;
+        lines.push(`${outKey} = ${tomlBasic(v)}`);
+    }
+    lines.push(`developer_instructions = ${tomlMultiline(body)}`);
+    writeIfChanged(outFile, lines.join('\n') + '\n', report);
+
+    if (siblingDir && isDir(siblingDir)) {
+        for (const f of walkFiles(siblingDir)) {
+            const dest = path.join(outSibling, path.relative(siblingDir, f));
+            if (f.endsWith('.md')) copyMdWithMacros(f, dest, 'codex', report);
+            else copyVerbatim(f, dest, report);
+        }
+    }
+}
+
+// ---------- driver ----------
+
+/**
+ * Compile one source tree into one target's output tree.
+ * @param {string} sourceRoot absolute path holding skills/ and agents/
+ * @param {string} kind 'claude' | 'codex'
+ * @param {string} outRoot absolute output root
+ * @param {Report} report
+ */
+export function buildTarget(sourceRoot, kind, outRoot, report) {
+    const skillsSrc = path.join(sourceRoot, 'skills');
+    const agentsSrc = path.join(sourceRoot, 'agents');
+
+    let skillsOut, agentsOut;
+    if (kind === 'claude') {
+        skillsOut = path.join(outRoot, '.claude', 'skills');
+        agentsOut = path.join(outRoot, '.claude', 'agents');
+    } else if (kind === 'codex') {
+        skillsOut = path.join(outRoot, '.agents', 'skills');
+        agentsOut = path.join(outRoot, '.codex', 'agents');
+    } else {
+        throw new Error(`unknown kind: ${kind}`);
+    }
+
+    if (isDir(skillsSrc)) {
+        for (const name of readdirSync(skillsSrc).sort()) {
+            const skillDir = path.join(skillsSrc, name);
+            if (!isDir(skillDir)) continue;
+            const dest = path.join(skillsOut, name);
+            if (kind === 'claude') emitClaudeSkill(skillDir, dest, report);
+            else emitCodexSkill(skillDir, dest, report);
+        }
+    }
+
+    if (isDir(agentsSrc)) {
+        for (const entry of readdirSync(agentsSrc).sort()) {
+            const full = path.join(agentsSrc, entry);
+            if (!entry.endsWith('.md') || isDir(full)) continue;
+            const name = path.basename(entry, '.md');
+            const sibling = path.join(agentsSrc, name);
+            const siblingArg = isDir(sibling) ? sibling : null;
+            if (kind === 'claude') {
+                emitClaudeAgent(full, siblingArg, path.join(agentsOut, `${name}.md`), path.join(agentsOut, name), report);
+            } else {
+                emitCodexAgent(full, siblingArg, path.join(agentsOut, `${name}.toml`), path.join(agentsOut, name), report);
+            }
+        }
+    }
+}