/claude-codex

name: claude-codex
description: "Bash wrapper around the local Codex CLI for non-interactive runs from inside Sutando (bridges, cron, scripts). For interactive code review or task hand-off from this Claude Code session, prefer the official `/codex:*` plugin commands; this skill is the file-bridge-compatible path that `discord-bridge.py` invokes for team-tier sandboxed delegation."
user-invocable: true

Claude Codex

Delegate work from Claude Code to the local `codex` CLI. This skill assumes Codex is already authenticated on this machine. It does not mint, extract, or transfer credentials.

**Usage**: `/claude-codex [prompt]`

ARGUMENTS: $ARGUMENTS

When to Use

• "Ask Codex to review this change"
• "Use my Codex subscription from Claude Code"
• Need a second model to inspect a bug, review a diff, or propose an implementation
• Need a Codex result saved or streamed from the current repo
• Spec-driven one-shot build of a self-contained artifact (HTML/CSS/JS prototype, single-file

demo) — use `--goal` to invoke Codex's `/goal` mode

When NOT to Use

• **Interactive review from this Claude Code session** → use `/codex:review`, `/codex:adversarial-review`, or `/codex:rescue` from the openai/codex-plugin-cc plugin. They're the discoverable, versioned path.
• **Anything that needs a Codex session ID / job tracking / status polling** → plugin's `/codex:status` is the right surface.

If you don't see `/codex:*` slash-commands available, install the plugin in this Claude Code session:

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

This skill stays as the **non-interactive bash-wrapper** path — invoked by `discord-bridge.py`'s team-tier `===SUTANDO SYSTEM INSTRUCTIONS===` block (codex exec --sandbox read-only on Discord tasks from non-owner senders), cron-fired jobs that need a one-shot codex call, and similar file-bridge workflows where a plugin slash-command can't reach.

Guardrails

• Prefer `codex review --uncommitted` for code review.
• Prefer `codex exec` for analysis, planning, or implementation prompts.
• Keep Codex pointed at the same repo with `-C "$PWD"` unless the user asked for another directory.
• Default to `workspace-write` sandbox or stricter. Do not use bypass flags unless the user explicitly asks.

Quick Checks

codex login status
bash "$SKILL_DIR/scripts/codex-run.sh" --check

Common Commands

# General delegation
bash "$SKILL_DIR/scripts/codex-run.sh" -- "Inspect src/task-bridge.ts for race conditions"

# Safer review of current uncommitted changes
bash "$SKILL_DIR/scripts/codex-run.sh" --review --uncommitted -- "Prioritize bugs and missing tests"

# Review against a base branch
bash "$SKILL_DIR/scripts/codex-run.sh" --review --base main -- "Focus on regressions and security"

# Save the last Codex message to a file
bash "$SKILL_DIR/scripts/codex-run.sh" --output-last-message results/codex-review.txt -- "Review the current workspace"

# Spec-driven one-shot build (Codex /goal mode)
bash "$SKILL_DIR/scripts/codex-run.sh" --goal -- "$(cat path/to/spec.md)"

PR review — `scripts/review-pr.sh <N>` (read-only, bounded)

The safe, read-only way to get a Codex review of a GitHub PR. Fetches the diff with `gh pr diff <N>` (READ-ONLY — no checkout, never mutates git state or fails on a dirty tree), inlines it into `codex exec --sandbox read-only`, and wraps the whole thing in `codex-bounded.sh` so a slow/wedged review can't grind unbounded.

bash "$SKILL_DIR/scripts/review-pr.sh" 1754            # default --max 240 --stall 60
bash "$SKILL_DIR/scripts/review-pr.sh" 1754 --max 300  # longer cap for a big diff

Prints Codex's verdict to stdout. Exit `0` = verdict produced; `124` = hit the `--max` cap; `125` = stalled (no output for `--stall` s); other non-zero = gh/codex error.

**Timing:** `codex exec` is agentic — even with the diff inlined it may explore related code, so a real review often takes 100s+ (147s observed on #1754). Keep `--max` ≥180; do NOT drop it near 120 or you'll kill legitimate reviews. This is the path the team-tier `===SUTANDO SYSTEM INSTRUCTIONS===` block runs to auto-review a non-owner PR-review request (owner-ping only on failure).

Bounded runner — `scripts/codex-bounded.sh`

Generic stall-watchdog + wall-clock cap for any (sandboxed) delegation. `--stall N` kills the process tree after N seconds of total output SILENCE (the "never going to finish" signal — a healthy codex streams as it works); `--max M` is the absolute backstop (`--max 0` disables it, stall-only). Exit `125` = stalled, `124` = max cap. Used by `review-pr.sh` and by the discord-bridge team/other-tier `codex exec` delegation so a sandboxed run can't grind forever.

bash "$SKILL_DIR/scripts/codex-bounded.sh" --stall 90 --max 240 -- <command...> < /dev/null

`/goal` mode (`--goal`)

Wraps Codex's interactive `/goal` slash-command for non-interactive use. The flag prepends `/goal ` to the prompt and forces `--full-auto` so Codex can write files unattended.

Reach for it when:

• The task is a self-contained artifact (single HTML file, one-off demo, isolated script).
• You have a tight written spec and want a one-shot build with a known cost ceiling.
• A second-model take on a prototype is useful (run `--goal` in parallel with Claude's own

build for cross-check).

Skip it when:

• The task touches in-repo code or needs memory/context Claude already has.
• You expect to iterate — `/goal` is one-shot and does not self-correct on failure.

If Invoked As A Slash Command

• If ARGUMENTS is empty, explain the available modes and suggest `--review --uncommitted` for diffs or a plain prompt for general delegation.
• If ARGUMENTS starts with `--goal ` (e.g., `/claude-codex --goal Build a self-playing demo`), strip the prefix and route the remaining text through `--goal` mode:

PROMPT="${ARGUMENTS#--goal }"
bash "$SKILL_DIR/scripts/codex-run.s