/codex-implement

name: codex-implement
description: "Implement features via Codex exec. Use when: writing new code from specs, implementing features, Codex-driven development. Not for: code review (use codex-code-review), architecture advice (use codex-architect). Output: implemented code + review loop."
allowed-tools: Bash(git:*), Read, Grep, Glob, Edit, Write, AskUserQuestion, Skill, Agent, Bash(node:*)

Codex Implement Skill

Trigger

• Keywords: codex implement, implement feature, codex write code, implement from spec

When NOT to Use

• Architecture advice only (use `/codex-architect`)
• Code review (use `/codex-review-fast`)
• Bug fix (use `/bug-fix`)
• Simple one-line change (edit directly)

Workflow

Parse args → Decompose → Collect context → Iterate items → Review loop → Done
                                              ↕
                                    codex → diff → confirm
                                              ↕
                                    reject/modify → § Resume

Step 0: Pre-check and precondition (before any repository read)

**The index must carry no `assume-unchanged` / `skip-worktree` path before anything is dispatched** — under the two grants this skill holds, `Bash(git:*)` and `Bash(node:*)`, and no others:

node -e '
  const { execSync } = require("child_process");
  // The REPOSITORY, not the invocation directory. `git ls-files` is path-limited to the cwd
  // subtree, so running this from `skills/` would inspect a fraction of the index and report a
  // clean tree while a flagged file sat elsewhere — and the dispatch runs Codex at the top level
  // regardless of where this skill was invoked.
  const root = execSync("git rev-parse --show-toplevel").toString().trim();
  // `git ls-files -v` tags every cached path. Measured on git 2.55.0: `H` is the ordinary cached
  // entry, `S` is skip-worktree, and `-v` LOWERCASES the tag of an assume-unchanged file — so `h`
  // is assume-unchanged and `s` is both bits. Hidden state is therefore "tag is `S`, or the tag is
  // lowercase"; testing only for lowercase misses plain skip-worktree, and testing for "not `H`"
  // over-triggers on `M`, an unmerged entry, whose remedy is finishing the merge and which neither
  // `--no-assume-unchanged` nor `--no-skip-worktree` would touch.
  const lines = execSync("git ls-files -v", { cwd: root, maxBuffer: 1 << 28 }).toString()
    .split("\n").filter(Boolean);
  const hidden = lines.filter((l) => /^[a-z] /.test(l) || l.startsWith("S "));
  const unmerged = lines.filter((l) => /^[Mm] /.test(l));
  console.log(hidden.length ? hidden.join("\n") : "(none)");
  if (unmerged.length) console.log("[UNMERGED — finish the merge first]\n" + unmerged.join("\n"));
'

A hidden-state tag is an `assume-unchanged` or `skip-worktree` bit, and such a path is invisible three times over: the precondition below cannot see a local edit to it, Step 3b cannot display one, and Step 3b's Reject would treat it as baseline-absent and run `git checkout -- <path>` — which restores the *index* version and destroys the edit for good. That is data loss with no recovery path, so it is a hard stop rather than an opt-out: list the flagged paths, ask the user to clear the bit (`git update-index --no-assume-unchanged <path>` / `--no-skip-worktree <path>`) or to commit or stash the work, and re-run this step. **Never auto-revert a tracked path whose prior contents were not captured** — the Reject row's "no state to lose" holds only for paths the baseline could actually see.

Then resolve the adapter through `@skills/codex-code-review/references/codex-transport.md` § Locator, and let any auto-install that section prescribes happen before the `git status` below — in a consuming repository its second step *writes* the adapter into the tree, and a write after the snapshot puts an untracked file there that the changeset this step captured does not contain. Same reason the rest of this step is ordered the way it is: a snapshot that goes stale while the work runs describes a tree nobody is looking at.

Then `git status --porcelain --untracked-files=all --ignored`, and satisfy the precondition in § Step 3a before Step 1 reads anything. Step 1 parses the spec, loads the feature intent and derives the items from files the precondition may ask the user to stash or remove; running it first leaves the plan — and later the dispatched prompt — describing a tree that no longer exists. Three review rounds moved this earlier twice: it began inside Step 3, then before Step 2, and neither was early enough because each time a reader still hit a repository read first. It is a numbered step so the order is executable rather than asserted from inside a later one.

If cleanup happens after this step for any other reason, repeat the Step 1 reads and plan confirmation, and rebind the Step 2 context, before dispatching.

**Then pin the redactor Step 3b will run, by digest, before Codex is dispatched.** Step 3b executes that module (`require`), and by then the tree has been through a write-capable child — so no check made *afterwards* can establish what the module was: a child that sets `assume-unchanged` on a tracked file and then overwrites it leaves `git status` empty, which is exactly the invisibility this step's own probe exists to catch, and a path swapped for a symlink resolves somewhere else entirely. Authenticating the **bytes now** and requiring the same bytes later is the only order that works.

node -e '
  const fs = require("fs"), path = require("path"), crypto = require("crypto");
  const { execSync, execFileSync } = require("child_process");
  const root = fs.realpathSync(execSync("git rev-parse --show-toplevel").toString().trim());
  const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
  const inside = (p) => p === root || p.startsWith(root + path.sep);
  const dirs = (d) => { try { return fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDire