codex-first

Files (7)

• SKILL.md
• coordination.md · references/
• launch-details.md · references/
• resume-and-watchdog.md · references/
• troubleshooting.md · references/
• codex-resume · scripts/
• codex-resume.test.sh · scripts/

SKILL.md (first lines)

# Codex First

## Launch flags — read first, copy verbatim

Default every Codex worker, **fresh or resumed**, to **GPT-6.1 Sol, high
reasoning, Ultrafast service tier** (`service_tier="ultrafast"`). Pass all three
settings unless the user requests an override.

```bash
# fresh
codex exec --yolo -C "$WT" \
  -m gpt-6.1-sol -c 'model_reasoning_effort="high"' \
  --enable fast_mode -c 'service_tier="ultrafast"' \
  -c 'model_auto_compact_token_limit=260000' \
  -o "$OUT" - < "$ORDER"
# resume: pass the same flags again; resume does not inherit them
codex exec resume "$SID" --dangerously-bypass-approvals-and-sandbox \
  -m gpt-6.1-sol -c 'model_reasoning_effort="high"' \
  --enable fast_mode -c 'service_tier="ultrafast"' \
  -c 'model_auto_compact_token_limit=260000' -o "$OUT" -
```

- Ultrafast has a context ceiling (measured 2026-10-13, direct Responses probes, gpt-6.1-sol +
  gpt-6-astra): served `ultrafast` up to ~282k prompt tokens, flaky at 288–294k, `fast` at
  ≥300k — silently, HTTP 200. Config default compacts at 400k, so long workers drift to Fast;
  the 260k compact cap keeps them Ultrafast. Rollouts record only the requested tier; prove the
  served tier with a direct probe (`response.service_tier`).
- Context: workers get the base 500k window. Add `-p sol61-1m` (or `-p astra-1m`) only when the
  order needs a whole-repo context; see `$codex-huge-context`. Those profiles forfeit Ultrafast
  above ~280k.
- Copy all model/reasoning/tier flags into wrappers; override only on user request. Verify launch arguments (`ultrafast` default; requested `fast` is valid).
- For requested Fast reviews, use `--codex-speed fast`.

### Security audits and cyber-classifier refusals → Daybreak Red (Peter, 2026-10-15/18)

Security audit lanes (threat models, injection/secret-exposure audits, permission inventories,
security review of hardening diffs) launch on **Daybreak Red** from the start (Peter 2026-10-18:
"use daylight red model for security audits"). Implementation workers stay on Sol.

Worker stops with `This content was flagged for possible cybersecurity risk` → relaunch or resume
the same order on **Daybreak Red** (Peter: "use daybreak red if you hit a blocker with regular
models"). Don't rephrase to dodge the classifier or hop between regular models.

- Direct API only: the ChatGPT-account route returns 400 `not supported when using Codex with a
  ChatGPT account`. Add `-c 'model_provider="openai_api_direct"'` (API key via the provider's
  auth command in `~/.codex/config.toml`).
- Slug: the `model_catalog_json` entry whose `display_name` is `Daybreak Red`. Keep it out of
  public artifacts (commits, PRs, issues, logs) per public model naming.
- No Ultrafast: drop `--enable fast_mode` / `service_tier`; keep `model_reasoning_effort="high"`.
- Verified 2026-10-15 with a one-line `codex exec` probe on the direct provider.

### Capacity fallback (Peter, 2026-10-12)

Org caps `gpt-6.1-sol` at 40M tokens/min. Worker or resume fails with `Rate limit reached for
gpt-6.1-sol ... tokens per min (TPM)`, `Selected model is at capacity`, or `overloaded` → resume
that same session on **GPT-6 Astra, high, Ultrafast** immediately (Peter, 2026-10-12: "use
astra if sol has rate limits"; Astra serves `ultrafast`, verified 2026-10-13); no waiting loop:

```bash
codex exec resume "$SID" --dangerously-bypass-approvals-and-sandbox \
  -m gpt-6-astra -c 'model_reasoning_effort="high"' \
  --enable fast_mode -c 'service_tier="ultrafast"' \
  -c 'model_auto_compact_token_limit=260000' -o "$OUT" -
```

- Resume onto Astra keeps the thread (verified 2026-10-12: Sol-created session resumed on Astra and replied).
  Fresh orders at capacity: same flags with `codex exec --yolo -C "$WT"`; a fresh launch that dies
  on capacity already has a session id in stderr (`session id: …`) — resume that, don't relaunch.
- Back off only when Sol and Astra are both limited; then alternate with growing sleeps.
- Wrapper retry triggers must match all three strings (`rate limit|at capacity|overloaded`);
  matching only "rate limit" made capacity failures exit instead of falling back.
- Autoreview at capacity: `--model gpt-6-astra --thinking high --codex-speed fast`. If autoreview
  refuses because its provider/route doesn't match operator config, don't change config — review
  with a fresh-context subagent (diff + brief) and say so in the PR.
- New workers still start on Sol 6.1 Ultrafast; fall back per worker, only on the capacity error.
- Restarts and recoveries: `~/.codex/skills/agent-scripts/codex-first/scripts/codex-resume` does the
  fallback, busy check, safe stop, and classified exits ([resume and watchdog](references/resume-and-watchdog.md)).

### Wrapper and process hygiene (2026-10-12/13)

- Never edit a running wrapper script in place: bash reads scripts incrementally, so live runs
  execute the new bytes at their old offset. Write `x.new`, `bash -n`, `chmod +x`, then `mv`
  (rename keeps the old inode for running copies; forgetting `chmod` gives exit 126).
- Never run `codex exec` under `set -e` in a wrapper: a rate-limit death exits non-zero and ends
  the script before its fallback runs (2026-10-13, a 27-worker fleet). Capture the code
  (`… && rc=0 || rc=$?`) and classify it, or hand the session to `codex-resume`.
- Killing a wrapper orphans its `codex exec` children; the next resume then fails with
  `thread … already has an active writer`. Stop and resume with `codex-resume --stop "$SID"`:
  it finds the worker through its open rollout file (fresh launches don't carry `$SID` in argv,
  so `pgrep -f` misses them) and refuses while `scripts/pr` or git runs beneath it. A leftover
  `~/.codex/thread-writer-locks/$SID.lock` file without a live holder is harmless.
- To redirect a running worker (new design/priority), `codex-resume --stop -p "$ORDER_FILE" "$SID"` (or `--message "…"`);
  its worktree changes and context survive.
- To retire a worker for good, do not use `codex-resume`: `--stop` always resumes afterward
  (2026-10-18, a cancelled worker restarted in its deleted worktree). Kill the native codex
  binary (`pgrep -P <node-shim-pid>`), then the node shim and its wrapper.

## Hard gate

**Autoreview exception:** always prefer Codex-backed `$autoreview`, independent
of `ANTHROPIC_BASE_URL`, router state, or harness. Reviewing a frozen bundle is
not hands-on self-delegation. Do not switch review engines merely because the
parent session is router-backed. This exception takes precedence over the gate
below.

Use the autoreview helper with `--engine codex` (defaults: 6.1 Sol, medium, Ultrafast) unless the user requests an override. It tries the ChatGPT subscription first and, on an auth failure, retries once on the configured direct-API provider; pass `--codex-config 'model_provider="openai_api_direct"'` only to skip the subscription attempt. Preserve the helper's reviewer isolation.

For direct hands-on delegation, use this skill only
when the active agent is Claude Code **and** the session is running on a native
Claude model.

**Model check (primary).** The point of the gate is model economics: Claude
tokens are metered and expensive, so hands-on work moves to Codex; but if the
session is already routed to a cheaper/other model, delegation gains nothing.
Decide by the model the session actually runs on, not by the transport:

1. Read the model id from the system prompt's environment section ("You are
   powered by the model …"). Router-wrapped ids may be opaque
   (`claude-ccr-<hex>`); the hex suffix is often ASCII — decode it

From steipete/agent-scripts, MIT.

More from steipete/agent-scripts