codex-implement

Files (8)

• SKILL.md
• brief-rescue-result.schema.json · assets/
• implement-result.schema.json · assets/
• luna_high_executor.config.toml · assets/
• luna_max_brief_rescuer.config.toml · assets/
• luna_max_executor.config.toml · assets/
• luna_xhigh_executor.config.toml · assets/
• plan-orchestration.md · references/

SKILL.md (first lines)

# Codex Implement

The parent designs, slices, verifies, integrates, and owns Git. Luna implements.
Astra reviews the integrated phase once; implementers never review their own work.

## Usage

```text
/codex-implement "<single task>"
/codex-implement <brief-path>
/codex-implement              # next unchecked plan task when a plan exists
/codex-implement phase        # current phase in parallel waves
/codex-implement all          # remaining phases in order
```

For a standalone task, treat that task as a one-slice phase. Read
`references/plan-orchestration.md` before creating temporary worktrees, slicing,
launching, integrating, reviewing, committing, or cleaning up. When
`implementation_plan.md` exists, also apply its plan-selection rules.
If no plan exists and the user supplied no task, ask what to implement; do not guess.

## Profiles

Install without overwriting existing profiles:

- `assets/luna_xhigh_executor.config.toml` -> `${CODEX_HOME:-$HOME/.codex}/luna_xhigh_executor.config.toml`
- `assets/luna_high_executor.config.toml` -> `${CODEX_HOME:-$HOME/.codex}/luna_high_executor.config.toml`
- `assets/luna_max_executor.config.toml` -> `${CODEX_HOME:-$HOME/.codex}/luna_max_executor.config.toml`
- `assets/luna_max_brief_rescuer.config.toml` -> `${CODEX_HOME:-$HOME/.codex}/luna_max_brief_rescuer.config.toml`

Preflight the installed file, not `codex ... --help` (help does not load the profile): require the exact `${CODEX_HOME:-$HOME/.codex}/<name>.config.toml`, parse it with a local TOML parser, and assert expected model, effort, network, and delegation pins. Launch with `--strict-config` for Codex's recognized-key check. The default executor pins `gpt-5.6-luna` max. Optional brief rescuer also uses Luna max with a read-only sandbox. Review stays `gpt-6-astra` high.

Max is the executor default. High and xhigh remain explicit lower-cost overrides; switch
profiles by name rather than editing one in place so the evidence records which tier ran.

Three executor profiles stay installed, differing ONLY in `model_reasoning_effort`: `luna_high_executor`, `luna_xhigh_executor`, `luna_max_executor`. Use another tier only when the user explicitly requests it or project policy sets it. Prefer `codex-review`'s Sol-max repair architect when the problem is diagnosis rather than transcription.

Profiles carry no `name` or `description` key. Codex rejects both as unknown configuration fields under `--strict-config`; the description lives in a leading `#` comment instead.

## Track work

Create one harness task per plan slice, in plan order. Keep it `pending` until launch, `in_progress` through fixes, and `completed` only after gate closure, plan update, and any accepted-risk disposition.

## Parallelize implementation safely

**Default to concurrent Luna lanes, not one large brief.** Cap active lanes at four
unless the user or project policy says otherwise. Parallelism applies only to
implementation; one reviewer must hold the whole integrated phase diff.

Batching everything into one brief has a specific failure mode: when the hardest item comes back BLOCKED or wrong, its fix round drags every other item's context along with it. One session, one report, one resume thread, one entangled retry.

### Split by risk, never by count

1. **Each cross-cutting or design-bearing item gets its own lane.** These are the ones that come back BLOCKED, need a clarification, or get the design subtly wrong. Isolate them so their fix round costs only themselves.
2. **Small mechanical items batch into one lane.** Four one-line guards do not need four sessions; the per-lane overhead would exceed the work.
3. **Items sharing a FILE stay in the same lane. Always.** Check file overlap before counting lanes — two findings in one file cannot be split apart, so a five-finding round may only afford three or four lanes.

### Isolation and ownership

- **Standards context multiplies per lane.** Every brief must name the rule files by absolute path (see "Standards reach Luna only through the brief"), so each lane re-reads them. Accept this — Luna is cheap and a style violation caught at the gate costs a whole round.
- **Every concurrent lane gets an isolated Git worktree.** Disjoint intended files do not make one shared worktree safe: Git state, caches, formatters, and output files still race.
- **Round-0 surface grows with lanes.** N lanes means N diffs to review and N reports whose claimed counts you must re-run independently. Budget for it.

### Rules that do not relax under parallelism

- One harness task per lane, so a later comparison knows what ran where.
- Every lane gets its own CLOSED editable file set. An implicit set plus concurrency produces conflicting edits to the same file.
- Luna never commits. After independent verification, the coordinator makes a temporary
  slice commit for deterministic integration into the phase worktree. Never push slice
  branches.
- Verify each lane independently. Never let one lane's green suite stand in for another's.
- Do not invoke Astra or `codex-review` for individual slices.

## Launch

```bash
OUT=<scratch>/codex-luna-<slice>.md
cd <worktree-or-repo-root>
rtk proxy codex exec -p luna_max_executor --strict-config \
  --add-dir "$HOME/.local/share/rtk" --skip-git-repo-check \
  --output-schema "<skill-dir>/assets/implement-result.schema.json" \
  -o "$OUT" '<BRIEF>' < /dev/null
```

Run in background; foreground harness calls can kill long runs. Profile enables workspace-write network access for all hosts. Required guards:

- Keep `rtk proxy` when available and `< /dev/null`. Launch through the caller's
  background-process mechanism; do not use a shell `timeout` wrapper.
- Missing/empty `$OUT` or nonzero exit = failed run. Inspect Git before judging whether edits landed.
- Never trust report paths or claimed checks without independent verification.

### Variables

Resolve all of these to absolute paths before the launch line runs. Nothing here is a literal.

| Placeholder | Meaning |
|---|---|
| `<scratch>` | Writable scratch directory OUTSIDE the repo, so run artifacts never appear in `git status`. |
| `<slice>` | Short slug for this slice or lane, unique per concurrent run, so two lanes never share an `$OUT`. |
| `$OUT` | Absolute path where the executor's final schema-conformant message is written. One per lane. |
| `$RESCUE_OUT` | Same, for a brief-rescue run. Keep it distinct from every `$OUT`. |
| `<worktree-or-repo-root>` | Absolute path to the repo root or the lane's dedicated worktree. Codex resolves relative paths against it. |
| `<skill-dir>` | Absolute path to this skill's directory, the one holding `assets/`. |
| `<codex-review-skill-dir>` | Absolute path to the installed `codex-review` skill directory, for its `assets/fix-architecture-result.schema.json`. |
| `<BRIEF>` | The full brief text from "Brief contract", passed as one single-quoted argument. |
| `<packet-path>` | Absolute path to the file holding the verified repair contract plus the current seam summary, for a brief rescue. |

## Preflight

1. Read repo rules and trace exact touched symbols/files with CodeGraph first when indexed; otherwise inspect source directly. Cite hook points and hazards in brief.
2. Check target lint config enables relevant rule classes.
3. For external tools, require mock tests plus real-tool end-to-end tests that skip only when tool is absent.
4. For heuristics, matching, resolution, or inference, define evidence required for every acceptance path. Missing evidence fails closed. Tests must cite the requirement they encode.

### Design gate

When any selected slice says `Design gate: yes`, or uses heuristic
resolution/inference, consolidate the affected slice contracts into one pre-phase
design gate:

From tcbuilds/nautilus, MIT.

More from tcbuilds/nautilus