@lifeaitools/rdc-skills 0.24.32 → 0.24.33

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.24.32",
+  "version": "0.24.33",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/commands/help.md

@@ -20,7 +20,9 @@ Resolve the manifest in this order and use the first existing file:
 2. `C:/Dev/rdc-skills/.claude-plugin/plugin.json`
 3. `~/.claude/plugins/cache/rdc-skills/rdc-skills/latest/.claude-plugin/plugin.json`
 
-Read `skills_meta` from the manifest. Group entries by `category` in this order:
+Read `skills_meta` from the manifest. Accept either the current object map shape
+(`skills_meta.<name>`) or an older array shape (`skills_meta[]`); normalize to
+entries before rendering. Group entries by `category` in this order:
 `planning`, `build`, `deploy`, `release`, `dev-loop`, `reporting`, `tooling`,
 `infra`.
 
@@ -38,7 +40,8 @@ static fallback table from `skills/help/SKILL.md`.
 ## Direct MCP / curl Access
 
 Show this block after the command table so non-Claude callers have the same
-entry point:
+entry point. Do not summarize, compress, relabel, or omit the curl examples;
+this block is the public direct-caller contract for MCP/API/curl users.
 
 ```text
 MCP endpoint: https://rdc-skills.regendevcorp.com/mcp
@@ -80,6 +83,8 @@ curl -s -X POST https://rdc-skills.regendevcorp.com/mcp \
   -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli","format":"json"}}}'
 ```
 
+Required exact token for tests and direct callers: `"format":"json"`
+
 ## Hard Rules
 
 - `cf: yes` skills must consult CodeFlow before acting.

package/commands/self-test.md

@@ -1,7 +1,7 @@
 ---
 name: rdc:self-test
 description: >-
-  Usage `rdc:self-test [--strict] [--skill <name>] [--json] [--fix] [--tier2] [--parallel <n>] [--quick]` — validates every rdc-*.md skill: frontmatter, Usage marker, name↔filename match, referenced guides/rules/hooks exist, output contract banner, plugin manifest, duplicate-name + collision checks. Tier 1 static lint; Tier 2 behavioral runs via headless claude in isolated worktrees + Supabase branch. Run before every release.
+  Usage `rdc:self-test [--strict] [--skill <name>] [--json] [--fix] [--tier2] [--parallel <n>] [--quick]` — validates every rdc-*.md skill: frontmatter, Usage marker, name↔filename match, referenced guides/rules/hooks exist, output contract banner, plugin manifest, duplicate-name + collision checks. Tier 1 static lint; Tier 2 behavioral runs via headless Claude or Codex in isolated worktrees + Supabase branch. Run before every release.
 ---
 
 > **⚠️ OUTPUT CONTRACT (READ FIRST):** `guides/output-contract.md`
@@ -22,7 +22,7 @@ description: >-
 | Tier | What it checks | Status |
 |------|----------------|--------|
 | Tier 1 | Static lint — frontmatter, Usage line, referenced files, name match | ✅ live |
-| Tier 2 | Behavioral — headless Claude runs each skill in sandbox, asserts artifacts | ✅ live, see `.rdc/plans/skill-self-test-tier-2.md` |
+| Tier 2 | Behavioral — headless Claude or Codex runs each skill in sandbox, asserts artifacts | ✅ live — 29 manifests; acceptance harness records transcripts, tool calls, artifacts, and lessons learned |
 | Tier 3 | Golden checklists — snapshot output format, regress on drift | 🔒 future |
 
 ## Procedure (Tier 1)
@@ -67,10 +67,11 @@ description: >-
 
 ## Procedure (Tier 2)
 
-Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed state (files touched, commits made, work items, exit code). Use it before shipping behavioral changes — Tier 1 alone can't catch runtime drift.
+Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed state (files touched, commits made, work items, exit code). Build acceptance additionally records all observable engine events/tool calls, assistant output, stdout/stderr artifacts, lessons learned, and next build optimizations. It supports `--engine claude` and `--engine codex`; both engines use the same manifests, worktree sandbox, JSONL evidence, and Markdown report. Use it before shipping behavioral changes — Tier 1 alone can't catch runtime drift.
 
 1. **Prerequisites:**
-   - `claude` CLI on PATH (headless mode: `claude --print`)
+   - `claude` CLI on PATH for Claude runs (headless mode: `claude --print`)
+   - `codex` CLI on PATH for Codex runs (headless mode: `codex exec --json`)
    - clauth daemon unlocked (`curl -s http://127.0.0.1:52437/ping`)
    - Supabase MCP reachable (runner creates a throwaway test branch)
    - Clean git tree in `rdc-skills` (worktrees are added under `.rdc/sandbox/<run-id>/`)
@@ -81,17 +82,21 @@ Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed
    node scripts/self-test.mjs --tier2 --skill rdc:build  # single skill
    node scripts/self-test.mjs --tier2 --parallel 3       # up to 3 skills in parallel
    node scripts/self-test.mjs --tier2 --quick            # skip long-running assertions
+   node scripts/acceptance.mjs --skill rdc:build         # build acceptance with JSONL/tool-call evidence
+   node scripts/acceptance.mjs --engine codex --skill rdc:build
    ```
 
 3. **What it does:**
    - Runs Tier 1 as a pre-gate (fails fast if static lint fails)
    - Creates one Supabase test branch for the run
-   - For each skill: `git worktree add` into `.rdc/sandbox/<run-id>/<skill>/`, sets `RDC_TEST=1`, invokes `claude --print` with the skill prompt, waits for exit
+   - For each skill: `git worktree add` into `.rdc/sandbox/<run-id>/<skill>/`, sets `RDC_TEST=1`, invokes the selected headless engine with the skill prompt, waits for exit
    - Asserts per the skill's manifest: exit code, files touched, commits made, stdout patterns
+   - Build acceptance writes JSONL evidence and extracts tool calls from the engine stream
    - Cleans up worktrees + deletes the Supabase branch at the end (even on failure)
 
 4. **Reports:**
    - `.rdc/reports/self-test-tier2-<iso>.json` — full per-skill result, findings, timings
+   - `.rdc/reports/acceptance-*.jsonl` and `.rdc/reports/acceptance-*.md` — build acceptance evidence, transcript artifact pointers, lessons learned, and next build optimizations
    - Exit codes: `0` pass, `1` fail (one or more skills failed assertions), `2` runner error (couldn't set up sandbox / branch)
 
 5. **Adding a new manifest:**
@@ -104,4 +109,5 @@ Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed
 - Run Tier 1 **before every `rdc:release rdc-skills`** — it catches the backtick-drift class of bugs that break the skill menu silently.
 - Use `--strict` in CI. Warnings matter in the release path.
 - Do NOT skip findings by relaxing the linter. Fix the skill.
-- Tier 2 is in planning — see epic `462b3e0a-37dd-4c9d-bed7-a1ad260b8bc1`.
+- Run Tier 2 before tagging a release. Gate the tag if any manifested skill fails.
+- Headless sessions must not steal focus. The runner uses hidden process launch options where supported; if windows flash or focus is grabbed, inspect `scripts/lib/runner.mjs` before changing skill behavior.

package/git-sha.json

@@ -1,3 +1,3 @@
 {
-  "sha": "6cdbc94b363ce35e08dad017896af45a10122ddb"
+  "sha": "5ed863d7f96c670f483e34fa89ea4a28ca0dc776"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.24.32",
+  "version": "0.24.33",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",

package/scripts/acceptance.mjs

@@ -132,6 +132,16 @@ function claudeToolCalls(stdout) {
 }
 
 function assistantText(engine, stdout) {
+  if (engine === 'codex') {
+    const chunks = [];
+    for (const event of parseJsonLines(stdout)) {
+      if (event?.type === 'item.completed' && event.item?.type === 'agent_message' && typeof event.item.text === 'string') {
+        chunks.push(event.item.text);
+      }
+      if (event?.type === 'message' && typeof event.text === 'string') chunks.push(event.text);
+    }
+    return chunks.join('\n\n').trim() || String(stdout || '').trim();
+  }
   if (engine !== 'claude') return String(stdout || '').trim();
   const resultEvents = parseJsonLines(stdout).filter((event) => event.type === 'result' && typeof event.result === 'string');
   if (resultEvents.length > 0) return resultEvents.at(-1).result.trim();
@@ -333,10 +343,6 @@ async function main() {
     console.error(`unsupported --engine ${ENGINE}; expected claude or codex`);
     process.exit(2);
   }
-  if (ENGINE === 'codex') {
-    console.error('codex acceptance adapter can parse Codex JSONL, but live Codex agent spawning is not wired in this repo yet.');
-    process.exit(2);
-  }
 
   mkdirSync(REPORTS_DIR, { recursive: true });
   const startedAt = new Date().toISOString();
@@ -379,6 +385,7 @@ async function main() {
     const result = await runManifest(manifest, {
       runId: RUN_ID,
       projectCwd: PROJECT_CWD,
+      engine: ENGINE,
     });
     const toolCalls = result.observed ? extractToolCalls(ENGINE, result.observed) : [];
     const safeSkill = manifest.skill.replace(/[^a-z0-9-]+/gi, '-').replace(/^-+|-+$/g, '');

package/scripts/lib/runner.mjs

@@ -1,14 +1,16 @@
 // runner.mjs — Tier 2 per-skill test orchestration.
 //
 // Public API:
-//   runManifest(manifest, { runId, supabaseBranchRef?, timeout?, claudeBin? })
+//   runManifest(manifest, { runId, supabaseBranchRef?, timeout?, engine?, claudeBin?, codexBin? })
 //     → { skill, pass, duration_ms, observed?, failures?, error? }
 //
 // Flow per manifest:
 //   1. Create a worktree at .rdc-sandbox/<runId>/<skill-slug>/
 //   2. Write precondition_files into the worktree
 //   3. Snapshot HEAD sha + work_items rowcount (via Supabase branch if given)
-//   4. Spawn `claude --print "<prompt>" --output-format stream-json`
+//   4. Spawn the selected engine in headless JSONL mode:
+//      - claude: `claude --print "<prompt>" --output-format stream-json`
+//      - codex:  `codex exec --json "<prompt>"`
 //      - cwd = worktree
 //      - env = { ...process.env, ...fixture.env, RDC_TEST: "1" }
 //      - timeout kills the child on overrun
@@ -85,25 +87,19 @@ function writePreconditionFiles(worktreePath, files) {
   }
 }
 
-/** Spawn `claude --print ...` with a hard timeout. Resolves to {exit, stdout, stderr, timedOut}. */
-function spawnClaude({ claudeBin, prompt, cwd, env, timeoutMs }) {
+function spawnHiddenShell(command, args, { cwd, env, timeoutMs }) {
   return new Promise((resolve) => {
     let settled = false;
     let stdout = "";
     let stderr = "";
     let child;
     try {
-      // shell: true is required on Windows so `.cmd`/`.bat` shims (npm global
+      // shell: true is required on Windows so `.cmd`/`.bat`/`.ps1` shims (npm global
       // wrappers like `claude`) resolve. On Unix shell: true routes through sh,
-      // which is harmless here. Because the shell interprets args, we wrap the
-      // prompt with JSON.stringify so spaces/quotes/metacharacters in the
-      // fixture prompt become a single shell-quoted token.
-      const safePrompt = JSON.stringify(prompt ?? "");
-      child = spawn(
-        claudeBin,
-        ["--print", safePrompt, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions"],
-        { cwd, env, shell: true, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] },
-      );
+      // which is harmless here. Quote each arg so the shell preserves prompts
+      // with spaces/metacharacters as single argv tokens.
+      const safeArgs = args.map((arg) => JSON.stringify(String(arg)));
+      child = spawn(command, safeArgs, { cwd, env, shell: true, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
     } catch (e) {
       resolve({ exit: -1, stdout: "", stderr: `spawn failed: ${e.message}`, timedOut: false });
       return;
@@ -131,6 +127,35 @@ function spawnClaude({ claudeBin, prompt, cwd, env, timeoutMs }) {
   });
 }
 
+/** Spawn `claude --print ...` with a hard timeout. Resolves to {exit, stdout, stderr, timedOut}. */
+function spawnClaude({ claudeBin, prompt, cwd, env, timeoutMs }) {
+  return spawnHiddenShell(
+    claudeBin,
+    ["--print", prompt ?? "", "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions"],
+    { cwd, env, timeoutMs },
+  );
+}
+
+/** Spawn `codex exec --json ...` with a hard timeout. Resolves to {exit, stdout, stderr, timedOut}. */
+function spawnCodex({ codexBin, prompt, cwd, env, timeoutMs }) {
+  return spawnHiddenShell(
+    codexBin,
+    [
+      "exec",
+      "--json",
+      "--cd",
+      cwd,
+      "--sandbox",
+      "danger-full-access",
+      "--dangerously-bypass-approvals-and-sandbox",
+      "--dangerously-bypass-hook-trust",
+      "--ephemeral",
+      prompt ?? "",
+    ],
+    { cwd, env, timeoutMs },
+  );
+}
+
 // ─── work_items fetch (live) ────────────────────────────────────────────────
 //
 // These helpers talk to the Supabase PostgREST endpoint on the branch created
@@ -237,7 +262,9 @@ export async function runManifest(manifest, opts = {}) {
     runId,
     supabaseBranchRef = null,
     timeout = manifest?.timeout_ms || DEFAULT_TIMEOUT_MS,
+    engine = process.env.RDC_ACCEPTANCE_ENGINE || "claude",
     claudeBin = process.env.CLAUDE_BIN || "claude",
+    codexBin = process.env.CODEX_BIN || "codex",
     // projectCwd: the repo claude --print will commit to (regen-root).
     // Worktrees are created FROM this repo so git state tracking is correct.
     // claude runs inside the worktree (not projectCwd directly) so each skill
@@ -283,33 +310,41 @@ export async function runManifest(manifest, opts = {}) {
   const headBefore = snapshotHead(worktree.path);
   const wiCountBefore = await fetchWorkItemsCount(supabaseBranchRef);
 
-  // Start from process.env but scrub any inherited CLAUDE_* vars — the child
-  // claude process should not see parent session context. Then set RDC_TEST
+  const selectedEngine = String(engine || "claude").toLowerCase();
+  if (!["claude", "codex"].includes(selectedEngine)) {
+    return { skill, pass: false, duration_ms: nowMs() - started, error: `unsupported engine: ${selectedEngine}` };
+  }
+
+  // Start from process.env but scrub inherited engine session vars — the child
+  // process should not see parent session context. Then set RDC_TEST
   // and overlay fixture env.
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
     if (key.startsWith("CLAUDE_")) delete env[key];
+    if (key.startsWith("CODEX_") && key !== "CODEX_HOME") delete env[key];
   }
   env.RDC_TEST = "1";
   Object.assign(env, manifest.fixture?.env || {});
 
-  // Run claude inside the worktree — commits land there, git tracking is correct,
+  // Run the agent inside the worktree — commits land there, git tracking is correct,
   // and parallel skills each get their own isolated branch with no file conflicts.
   let spawnRes;
   try {
-    spawnRes = await spawnClaude({
-      claudeBin,
+    const spawnArgs = {
       prompt: manifest.fixture?.prompt || "",
       cwd: worktree.path,
       env,
       timeoutMs: timeout,
-    });
+    };
+    spawnRes = selectedEngine === "codex"
+      ? await spawnCodex({ ...spawnArgs, codexBin })
+      : await spawnClaude({ ...spawnArgs, claudeBin });
   } catch (e) {
     return {
       skill,
       pass: false,
       duration_ms: nowMs() - started,
-      error: `spawn claude: ${e.message}`,
+      error: `spawn ${selectedEngine}: ${e.message}`,
     };
   }
 
@@ -321,6 +356,7 @@ export async function runManifest(manifest, opts = {}) {
     exit_code: spawnRes.exit,
     stdout: spawnRes.stdout,
     stderr: spawnRes.stderr,
+    engine: selectedEngine,
     files_modified,
     commits,
     work_items_delta,

package/skills/help/SKILL.md

@@ -17,11 +17,11 @@ description: "Usage `rdc:help` — Show all MCP skills with usage, requirements,
    - `{PLUGIN_ROOT}/.claude-plugin/plugin.json`  ← preferred when running from the published plugin
    - `C:/Dev/rdc-skills/.claude-plugin/plugin.json` ← source-checkout fallback
    - `~/.claude/plugins/cache/rdc-skills/rdc-skills/latest/.claude-plugin/plugin.json` ← installed cache
-2. Read it. Parse JSON. Read `skills_meta`.
+2. Read it. Parse JSON. Read `skills_meta`. Accept either the current object map shape (`skills_meta.<name>`) or an older array shape (`skills_meta[]`); normalize to entries before rendering.
 3. Group entries by `category` in this order: `planning, build, deploy, release, dev-loop, reporting, tooling, infra`.
 4. For each entry render one row: `{slash}  —  {usage}  —  needs: {requires.join(',')}  —  cf: {codeflow_required ? 'yes' : 'no'}`.
 5. Print a Decision Tree at the end that maps natural-language phrases to skills, derived from each entry's `triggers[]`.
-6. Print the Direct MCP / curl Access block so non-Claude callers have the same entry point.
+6. Print the Direct MCP / curl Access block exactly as shown in the required output format. Do not summarize, compress, relabel, or omit the curl examples. This block is the public direct-caller contract for MCP/API/curl users.
 7. Hard rules section at the bottom (see below — verbatim).
 
 ## Required output format
@@ -128,6 +128,8 @@ RDC SKILLS — manifest: .claude-plugin/plugin.json @ v{version}
     -H 'Accept: application/json, text/event-stream' \
     -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"rdc_skill_get","arguments":{"name":"rdc:build","variant":"cli","format":"json"}}}'
 
+  REQUIRED EXACT TOKEN: "format":"json"
+
 ## Hard rules
 
 - `cf: yes` skills MUST consult CodeFlow before acting. Hooks fail-closed on unreachable CodeFlow for these.

package/skills/self-test/SKILL.md

@@ -23,7 +23,7 @@ description: "Usage `rdc:self-test [--strict]` — Validate all rdc:* skills, pl
 | Tier | What it checks | Status |
 |------|----------------|--------|
 | Tier 1 | Static lint — frontmatter, Usage line, referenced files, name match | ✅ live |
-| Tier 2 | Behavioral — headless Claude runs each skill in sandbox, asserts artifacts | ✅ live — 29 manifests; acceptance harness records transcripts, tool calls, artifacts, and lessons learned |
+| Tier 2 | Behavioral — headless Claude or Codex runs each skill in sandbox, asserts artifacts | ✅ live — 29 manifests; acceptance harness records transcripts, tool calls, artifacts, and lessons learned |
 | Tier 3 | Golden checklists — snapshot output format, regress on drift | 🔒 future |
 
 ## Interactive UI
@@ -85,10 +85,11 @@ Test output streams live to the terminal. No server, no extra processes.
 
 ## Procedure (Tier 2)
 
-Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed state (files touched, commits made, work items, exit code). Build acceptance additionally records all observable engine events/tool calls, assistant output, stdout/stderr artifacts, lessons learned, and next build optimizations. Use it before shipping behavioral changes — Tier 1 alone can't catch runtime drift.
+Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed state (files touched, commits made, work items, exit code). Build acceptance additionally records all observable engine events/tool calls, assistant output, stdout/stderr artifacts, lessons learned, and next build optimizations. It supports `--engine claude` and `--engine codex`; both engines use the same manifests, worktree sandbox, JSONL evidence, and Markdown report. Use it before shipping behavioral changes — Tier 1 alone can't catch runtime drift.
 
 1. **Prerequisites:**
-   - `claude` CLI on PATH (headless mode: `claude --print`)
+   - `claude` CLI on PATH for Claude runs (headless mode: `claude --print`)
+   - `codex` CLI on PATH for Codex runs (headless mode: `codex exec --json`)
    - clauth daemon unlocked (`curl -s http://127.0.0.1:52437/ping`)
    - Supabase MCP reachable (runner creates a throwaway test branch)
    - Clean git tree in `rdc-skills` (worktrees are added under `.rdc/sandbox/<run-id>/`)
@@ -100,12 +101,13 @@ Tier 2 runs each skill end-to-end in an isolated sandbox and asserts on observed
    node scripts/self-test.mjs --tier2 --parallel 3       # up to 3 skills in parallel
    node scripts/self-test.mjs --tier2 --quick            # skip long-running assertions
    node scripts/acceptance.mjs --skill rdc:build         # build acceptance with JSONL/tool-call evidence
+   node scripts/acceptance.mjs --engine codex --skill rdc:build
    ```
 
 3. **What it does:**
    - Runs Tier 1 as a pre-gate (fails fast if static lint fails)
    - Creates one Supabase test branch for the run
-   - For each skill: `git worktree add` into `.rdc/sandbox/<run-id>/<skill>/`, sets `RDC_TEST=1`, invokes `claude --print` with the skill prompt, waits for exit
+   - For each skill: `git worktree add` into `.rdc/sandbox/<run-id>/<skill>/`, sets `RDC_TEST=1`, invokes the selected headless engine with the skill prompt, waits for exit
    - Asserts per the skill's manifest: exit code, files touched, commits made, stdout patterns
    - Build acceptance writes JSONL evidence and extracts tool calls from the engine stream
    - Cleans up worktrees + deletes the Supabase branch at the end (even on failure)

package/skills/tests/MATRIX.md

@@ -2,7 +2,7 @@
 
 Current coverage: 29 manifests for 29 skill directories.
 
-The manifest layer verifies each skill can be started from a realistic caller prompt in an isolated `RDC_TEST=1` sandbox. The acceptance harness records the engine stream, extracted tool calls, stdout/stderr artifacts, rendered assistant output, failures, lessons learned, and next build optimizations under `.rdc/reports/`.
+The manifest layer verifies each skill can be started from a realistic caller prompt in an isolated `RDC_TEST=1` sandbox. The acceptance harness can run either Claude (`--engine claude`) or Codex (`--engine codex`) against the same manifests and records the engine stream, extracted tool calls, stdout/stderr artifacts, rendered assistant output, failures, lessons learned, and next build optimizations under `.rdc/reports/`.
 
 `rdc:channel-formatter` currently has the strongest content acceptance fixture: it asserts source-grounded social-pack output, forbidden-claim absence, and observable corpus or web-search tool routing. `rdc:help` asserts the public MCP/curl caller surface and structured `format:"json"` discovery path. `rdc:self-test` validates the test-tier/evidence language. Planning/reporting skills (`rdc:preplan`, `rdc:plan`, `rdc:handoff`, `rdc:prototype`, `rdc:review`, `rdc:report`) assert their required artifacts and safety boundaries. Operational/content skills (`rdc:brochure`, `rdc:convert`, `lifeai-brochure-author`, `rdc:build`, `rdc:fixit`, `rdc:fs-mcp`, `rdc:workitems`) assert artifact paths, dispatch gates, scoped commits, filesystem boundaries, and sandboxed work-item behavior. Coordination/design/maintenance skills (`rdc:co-develop`, `rdc:collab`, `rdc:design`, `rdc:extract-verifier-rules`, `rdc:housekeeping`, `rdc:overnight`, `rdc:rpms-filemap`) assert relay safety, token/reference use, verifier corpus safety, maintenance/reporting, unattended sentinel behavior, and canonical file-map rules. All manifests now include a deeper acceptance block beyond the basic executable smoke fixture.
 
@@ -48,6 +48,6 @@ The manifest layer verifies each skill can be started from a realistic caller pr
 
 ## Next Coverage Upgrades
 
-- Add tool-call assertions to read/research skills (`rdc:preplan`, `rdc:fs-mcp`, `rdc:co-develop`, `rdc:collab`).
-- Add artifact existence checks for output-producing skills (`rdc:brochure`, `rdc:convert`, `rdc:prototype`, `rdc:report`).
-- Add negative safety assertions for skills that open windows, launch terminals, deploy, release, or write commits.
+- Run full scheduled Claude and Codex sweeps regularly, not only changed-skill acceptance, so transcripts and lessons stay fresh.
+- Add richer artifact-content checks for output-producing skills (`rdc:brochure`, `rdc:convert`, `rdc:prototype`, `rdc:report`).
+- Promote recurring transcript review findings into manifest assertions instead of relying on human inspection.

package/skills/tests/README.md

@@ -2,7 +2,7 @@
 
 Each RDC skill directory has a colocated test manifest at `skills/tests/rdc-<name>.test.json`.
 There are currently 29 manifests for 29 skill directories. These drive the Tier 2
-behavioral runner and the build acceptance harness.
+behavioral runner and the build acceptance harness for both Claude and Codex.
 
 See `MATRIX.md` for the current skill-by-skill coverage table.
 
@@ -32,8 +32,9 @@ is the source of truth. Top-level fields:
 1. Start from an existing manifest in this dir
 2. Set `fixture.env.RDC_TEST = "1"` (required — sandbox contract)
 3. Write assertions tight enough to catch real regressions but not flaky
-4. Run `node scripts/acceptance.mjs --skill rdc:<name>` to capture the transcript, tool calls, and lessons learned
-5. Commit manifest + any skill changes together
+4. Run `node scripts/acceptance.mjs --skill rdc:<name>` to capture the Claude transcript, tool calls, and lessons learned
+5. When Codex behavior matters, also run `node scripts/acceptance.mjs --engine codex --skill rdc:<name>` against the same manifest
+6. Commit manifest + any skill changes together
 
 For content-producing skills, include both positive and negative output checks.
 Use `stdout_contains` for expected channel-native structure and source facts;

package/tests/acceptance.test.mjs

@@ -21,12 +21,13 @@ const missing = spawnSync(process.execPath, [script, '--skill', 'rdc:not-a-real-
 assert.equal(missing.status, 1);
 assert.match(missing.stderr, /missing acceptance manifest/);
 
-const codex = spawnSync(process.execPath, [script, '--engine', 'codex', '--skill', 'rdc:plan'], {
+const codex = spawnSync(process.execPath, [script, '--engine', 'codex', '--skill', 'rdc:not-a-real-skill'], {
   cwd: REPO_ROOT,
   encoding: 'utf8',
 });
-assert.equal(codex.status, 2);
-assert.match(codex.stderr, /Codex JSONL/);
+assert.equal(codex.status, 1);
+assert.doesNotMatch(codex.stderr, /not wired/i);
+assert.match(codex.stderr, /missing acceptance manifest/);
 
 const emptyProject = mkdtempSync(join(tmpdir(), 'rdc-acceptance-empty-'));
 try {