Omx

{
  "skill_name": "omx",
  "evals": [
    {
      "id": 1,
      "prompt": "oh-my-codex 설치하고 싶어. 어떻게 시작해?",
      "expected_output": "The skill provides installation: npm install -g @openai/codex oh-my-codex, then omx setup, then recommended launch omx --madmax --high",
      "assertions": [
        "The response includes npm install -g oh-my-codex",
        "The response includes omx setup",
        "The response mentions omx --madmax --high as the recommended launch"
      ]
    },
    {
      "id": 2,
      "prompt": "Codex CLI에서 병렬 팀 워커를 실행하고 싶어. 어떻게 해?",
      "expected_output": "The skill explains omx team N:role 'task' CLI command and $team trigger inside Codex, with tmux/psmux requirement.",
      "assertions": [
        "The response includes omx team N:executor or $team syntax",
        "The response mentions tmux or psmux as a requirement",
        "The response includes team status/shutdown management commands"
      ]
    },
    {
      "id": 3,
      "prompt": "ralph 모드가 뭐야? omx에서 어떻게 쓰는 거야?",
      "expected_output": "The skill explains $ralph as persistent execute→verify→fix loop inside Codex, state stored in .omx/.",
      "assertions": [
        "The response describes $ralph as a persistent execution loop",
        "The response mentions execute/verify/fix loop structure",
        "The response includes $ralph trigger syntax"
      ]
    },
    {
      "id": 4,
      "prompt": "omx explore 랑 omx sparkshell 이 뭐가 달라?",
      "expected_output": "The skill distinguishes: omx explore is read-only repo lookup (Rust-native); omx sparkshell is bounded shell inspection.",
      "assertions": [
        "The response describes omx explore as read-only or repo exploration",
        "The response describes omx sparkshell as shell inspection or command execution",
        "The response notes they are different tools with different scopes"
      ]
    },
    {
      "id": 5,
      "prompt": "아이디어가 아직 모호해. 코딩 시작하기 전에 요구사항 명확히 하고 싶어.",
      "expected_output": "The skill recommends $deep-interview for vague/unclear requests before $plan, $ralph, or $team.",
      "assertions": [
        "The response recommends $deep-interview for vague requests",
        "The response describes the one-question-at-a-time clarification pattern",
        "The response explains that deep-interview hands off to $plan/$ralph/$team after clarification"
      ]
    },
    {
      "id": 6,
      "prompt": "Claude에서 쓰던 /team, /ultrawork, /ultraqa를 Codex에서도 쓰고 싶어. OMX에서는 뭐로 매핑해?",
      "expected_output": "The skill maps Claude /team to OMX $team or omx team, /ultrawork to $ulw or $ultrawork, and /ultraqa to $ultraqa while keeping state under .omx.",
      "assertions": [
        "The response maps /team to $team or omx team",
        "The response maps /ultrawork to $ulw or $ultrawork",
        "The response maps /ultraqa to $ultraqa",
        "The response mentions .omx state or not reusing .omc state"
      ]
    },
    {
      "id": 7,
      "prompt": "Claude /autopilot으로 하던 전체 자동 구현 흐름을 Codex OMX에서도 쓰고 싶어.",
      "expected_output": "The skill maps Claude /autopilot to OMX $autopilot, recommends $deep-interview first for vague requests or $plan/$ralplan before $ralph for stricter verification, and keeps state under .omx.",
      "assertions": [
        "The response maps /autopilot to $autopilot",
        "The response mentions $deep-interview for vague or underspecified requests",
        "The response mentions $plan, $ralplan, or $ralph for stronger planning or verification loops",
        "The response mentions .omx state or not reusing .omc state"
      ]
    }
  ]
}

#!/usr/bin/env bash
# omx (oh-my-codex) install script
# Installs OMX and verifies prerequisites
set -euo pipefail

OMX_PACKAGE="oh-my-codex"
CODEX_PACKAGE="@openai/codex"

print_ok()  { echo "✓ $*"; }
print_err() { echo "✗ $*" >&2; }
print_info(){ echo "→ $*"; }

# 1. Check Node.js >= 20
if ! command -v node &>/dev/null; then
  print_err "Node.js not found. Install from https://nodejs.org (v20+)"
  exit 1
fi
NODE_VER=$(node -e 'process.exit(parseInt(process.version.slice(1)) >= 20 ? 0 : 1)' 2>/dev/null && echo "OK" || echo "OLD")
if [ "$NODE_VER" = "OLD" ]; then
  print_err "Node.js 20+ required. Current: $(node --version)"
  exit 1
fi
print_ok "Node.js $(node --version)"

# 2. Install Codex CLI if missing
if ! command -v codex &>/dev/null; then
  print_info "Installing Codex CLI..."
  npm install -g "${CODEX_PACKAGE}"
  print_ok "Codex CLI installed"
else
  print_ok "Codex CLI found: $(codex --version 2>/dev/null || echo 'unknown version')"
fi

# 3. Install oh-my-codex
print_info "Installing ${OMX_PACKAGE}..."
npm install -g "${OMX_PACKAGE}"
print_ok "${OMX_PACKAGE} installed: $(omx --version 2>/dev/null || echo 'installed')"

# 4. Run OMX setup
print_info "Running omx setup..."
omx setup
print_ok "OMX setup complete"

# 5. Check tmux (optional but recommended for team mode)
if command -v tmux &>/dev/null; then
  print_ok "tmux found — team mode available"
elif command -v psmux &>/dev/null; then
  print_ok "psmux found — Windows team mode available"
else
  print_info "tmux not found — install for team mode:"
  print_info "  macOS: brew install tmux"
  print_info "  Ubuntu: sudo apt install tmux"
  print_info "  Windows: winget install psmux"
fi

echo ""
print_ok "OMX installed. Recommended first session:"
echo ""
echo "  omx --madmax --high"
echo ""
echo "Then inside Codex:"
echo "  /prompts:architect \"analyze the codebase\""
echo "  \$plan \"plan the next feature\""
echo "  \$ralph \"fix all failing tests\""

#!/usr/bin/env python3
"""Validate cross-runtime team/autopilot/ultrawork/ultraqa documentation coverage."""

from __future__ import annotations

import argparse
from pathlib import Path


CHECKS = {
    ".agent-skills/omc/SKILL.md": [
        "cross-runtime-parity",
        "/autopilot",
        "$autopilot",
        "ultraqa",
        "references/cross-runtime-workflow-map.md",
    ],
    ".agent-skills/omx/SKILL.md": [
        "$autopilot",
        "$ulw",
        "$ultraqa",
        "references/parallel-quality-workflows.md",
    ],
    ".agent-skills/ohmg/SKILL.md": [
        "/plan",
        "/work",
        "/orchestrate",
        "/review",
        "references/parallel-quality-workflows.md",
    ],
    ".agent-skills/omc/references/cross-runtime-workflow-map.md": [
        "$team",
        "$autopilot",
        "/plan",
        "/work",
        "$ultraqa",
        "oma agent:parallel",
    ],
    ".agent-skills/omx/references/parallel-quality-workflows.md": [
        "$team",
        "$autopilot",
        "$ulw",
        "$ultraqa",
    ],
    ".agent-skills/ohmg/references/parallel-quality-workflows.md": [
        "/plan",
        "/work",
        "/orchestrate",
        "/ultrawork",
        "/review",
    ],
}


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--repo-root", default=".", help="Repository root")
    args = parser.parse_args()

    root = Path(args.repo_root).resolve()
    failures: list[str] = []

    for rel_path, required_terms in CHECKS.items():
        path = root / rel_path
        if not path.exists():
            failures.append(f"{rel_path}: missing")
            continue
        text = path.read_text(encoding="utf-8")
        for term in required_terms:
            if term not in text:
                failures.append(f"{rel_path}: missing {term!r}")

    if failures:
        for failure in failures:
            print(f"[FAIL] {failure}")
        return 1

    print(f"Cross-runtime workflow validation: PASS ({len(CHECKS)} files)")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env bash
# validate-omx.sh — Validate OMX installation and configuration
set -euo pipefail

PASS=0
FAIL=0

check() {
  local label="$1"
  local cmd="$2"
  if eval "$cmd" &>/dev/null; then
    echo "✓ $label"
    ((PASS++)) || true
  else
    echo "✗ $label"
    ((FAIL++)) || true
  fi
}

echo "=== OMX Installation Validator ==="
echo ""

# Core prerequisites
check "Node.js 20+ available" "node -e 'process.exit(parseInt(process.version.slice(1)) >= 20 ? 0 : 1)'"
check "Codex CLI available" "command -v codex"
check "omx CLI available" "command -v omx"

# OMX version
if command -v omx &>/dev/null; then
  VERSION=$(omx --version 2>/dev/null || echo "unknown")
  echo "  omx version: ${VERSION}"
fi

# Setup artifacts
check "AGENTS.md present" "[ -f '${PWD}/AGENTS.md' ] || [ -f '${HOME}/.codex/AGENTS.md' ]"
check ".omx/ state directory exists" "[ -d '${PWD}/.omx' ] || true"  # may not exist yet

# Optional team runtime
echo ""
echo "--- Team Runtime ---"
check "tmux available (macOS/Linux team mode)" "command -v tmux"
check "psmux available (Windows native team mode)" "command -v psmux"

# Codex auth
echo ""
echo "--- Codex Auth ---"
check "OPENAI_API_KEY set" "[ -n '${OPENAI_API_KEY:-}' ]"

echo ""
echo "=== Results ==="
echo "  Passed: ${PASS}"
echo "  Failed: ${FAIL}"
echo ""

if [ "$FAIL" -le 2 ]; then
  echo "✓ OMX installation looks healthy"
  echo ""
  echo "Run omx doctor for detailed diagnostics:"
  echo "  omx doctor"
  echo "  omx doctor --team"
else
  echo "! Validation issues found. Run:"
  echo "  omx doctor"
  exit 1
fi

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>omx Skill Autoresearch Dashboard</title>
<style>
  * { box-sizing: border-box; margin: 0; padding: 0; }
  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #0f1117; color: #e2e8f0; padding: 2rem; }
  h1 { font-size: 1.6rem; font-weight: 700; margin-bottom: 0.25rem; color: #f8fafc; }
  .subtitle { color: #94a3b8; font-size: 0.9rem; margin-bottom: 2rem; }
  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 1rem; margin-bottom: 2rem; }
  .card { background: #1e2330; border-radius: 10px; padding: 1.25rem; border: 1px solid #2d3748; }
  .card .label { font-size: 0.75rem; color: #64748b; text-transform: uppercase; letter-spacing: 0.05em; margin-bottom: 0.4rem; }
  .card .value { font-size: 2rem; font-weight: 700; }
  .value.green { color: #4ade80; }
  .value.blue { color: #60a5fa; }
  .value.yellow { color: #fbbf24; }
  .section { background: #1e2330; border-radius: 10px; padding: 1.5rem; margin-bottom: 1.5rem; border: 1px solid #2d3748; }
  .section h2 { font-size: 1rem; font-weight: 600; margin-bottom: 1rem; color: #cbd5e1; border-bottom: 1px solid #2d3748; padding-bottom: 0.5rem; }
  table { width: 100%; border-collapse: collapse; font-size: 0.875rem; }
  th { text-align: left; padding: 0.5rem 0.75rem; color: #64748b; font-weight: 600; font-size: 0.75rem; text-transform: uppercase; border-bottom: 1px solid #2d3748; }
  td { padding: 0.6rem 0.75rem; border-bottom: 1px solid #1a2030; vertical-align: top; }
  tr:last-child td { border-bottom: none; }
  .badge { display: inline-block; padding: 0.2rem 0.6rem; border-radius: 9999px; font-size: 0.75rem; font-weight: 600; }
  .badge.pass { background: #14532d; color: #4ade80; }
  .badge.fail { background: #450a0a; color: #f87171; }
  .progress-bar { background: #2d3748; border-radius: 9999px; height: 10px; overflow: hidden; margin-top: 0.5rem; }
  .progress-fill { height: 100%; border-radius: 9999px; background: linear-gradient(90deg, #4ade80, #22d3ee); }
  .evidence { color: #94a3b8; font-size: 0.8rem; margin-top: 0.3rem; }
  .experiment-row { display: flex; align-items: center; gap: 1rem; padding: 0.5rem 0; border-bottom: 1px solid #1a2030; }
  .experiment-row:last-child { border-bottom: none; }
  .exp-num { background: #2d3748; border-radius: 6px; padding: 0.2rem 0.5rem; font-size: 0.75rem; color: #94a3b8; min-width: 32px; text-align: center; }
  .exp-desc { flex: 1; font-size: 0.875rem; }
  .exp-score { font-weight: 700; }
  footer { color: #475569; font-size: 0.75rem; margin-top: 2rem; text-align: center; }
</style>
</head>
<body>

<h1>omx Skill Autoresearch Dashboard</h1>
<p class="subtitle">Skill: .agent-skills/omx/SKILL.md &nbsp;|&nbsp; Run: 2026-03-30 &nbsp;|&nbsp; v0.11.10</p>

<div class="grid">
  <div class="card">
    <div class="label">Baseline Score</div>
    <div class="value green">5/5</div>
    <div class="progress-bar"><div class="progress-fill" style="width:100%"></div></div>
  </div>
  <div class="card">
    <div class="label">Final Score</div>
    <div class="value green">5/5</div>
    <div class="progress-bar"><div class="progress-fill" style="width:100%"></div></div>
  </div>
  <div class="card">
    <div class="label">Pass Rate</div>
    <div class="value green">100%</div>
  </div>
  <div class="card">
    <div class="label">Experiments Run</div>
    <div class="value blue">1/5</div>
  </div>
  <div class="card">
    <div class="label">Mutations Applied</div>
    <div class="value yellow">0</div>
  </div>
  <div class="card">
    <div class="label">Status</div>
    <div class="value green" style="font-size:1rem;margin-top:0.4rem;">COMPLETE</div>
  </div>
</div>

<div class="section">
  <h2>Eval Results</h2>
  <table>
    <thead>
      <tr>
        <th>#</th>
        <th>Name</th>
        <th>Input</th>
        <th>Criteria</th>
        <th>Baseline</th>
        <th>Final</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td>1</td>
        <td>Install path</td>
        <td>oh-my-codex 설치하고 싶어. 어떻게 시작해?</td>
        <td>npm install + omx setup + omx --madmax --high</td>
        <td><span class="badge pass">PASS</span></td>
        <td><span class="badge pass">PASS</span></td>
      </tr>
      <tr>
        <td></td>
        <td colspan="5"><span class="evidence">Evidence: Section 1 Quick Start — "npm install -g @openai/codex oh-my-codex", "omx setup", "omx --madmax --high"</span></td>
      </tr>
      <tr>
        <td>2</td>
        <td>Team mode</td>
        <td>Codex CLI에서 병렬 팀 워커를 실행하고 싶어. 어떻게 해?</td>
        <td>omx team N:executor + tmux/psmux + management cmds</td>
        <td><span class="badge pass">PASS</span></td>
        <td><span class="badge pass">PASS</span></td>
      </tr>
      <tr>
        <td></td>
        <td colspan="5"><span class="evidence">Evidence: Section 4 — "omx team 3:executor", platform table with tmux/psmux, status/resume/shutdown commands</span></td>
      </tr>
      <tr>
        <td>3</td>
        <td>Ralph described</td>
        <td>ralph 모드가 뭐야? omx에서 어떻게 쓰는 거야?</td>
        <td>$ralph syntax + execute→verify→fix loop</td>
        <td><span class="badge pass">PASS</span></td>
        <td><span class="badge pass">PASS</span></td>
      </tr>
      <tr>
        <td></td>
        <td colspan="5"><span class="evidence">Evidence: Workflow table + Example 2 — "$ralph" trigger, "Loop: execute → verify → fix, until all tests pass."</span></td>
      </tr>
      <tr>
        <td>4</td>
        <td>explore vs sparkshell</td>
        <td>omx explore 랑 omx sparkshell 이 뭐가 달라?</td>
        <td>read-only vs shell inspection distinction</td>
        <td><span class="badge pass">PASS</span></td>
        <td><span class="badge pass">PASS</span></td>
      </tr>
      <tr>
        <td></td>
        <td colspan="5"><span class="evidence">Evidence: CLI section labels explore "Read-only repo lookup" and sparkshell "Bounded shell inspection". Best practices: "omx explore for safe lookups — read-only; won't modify anything"</span></td>
      </tr>
      <tr>
        <td>5</td>
        <td>deep-interview</td>
        <td>아이디어가 아직 모호해. 코딩 시작하기 전에 요구사항 명확히 하고 싶어.</td>
        <td>$deep-interview + one-question loop + handoff</td>
        <td><span class="badge pass">PASS</span></td>
        <td><span class="badge pass">PASS</span></td>
      </tr>
      <tr>
        <td></td>
        <td colspan="5"><span class="evidence">Evidence: Example 4 — "$deep-interview" with "One-question-at-a-time Socratic loop until intent is clear, then hands off to $plan or $ralph."</span></td>
      </tr>
    </tbody>
  </table>
</div>

<div class="section">
  <h2>Experiments</h2>
  <div class="experiment-row">
    <span class="exp-num">E1</span>
    <span class="exp-desc">Baseline scoring — read SKILL.md and checked all 5 eval criteria directly</span>
    <span class="exp-score green">5/5</span>
    <span class="badge pass">PASS</span>
  </div>
  <p style="color:#64748b;font-size:0.8rem;margin-top:0.75rem;">Baseline achieved 100% — no further experiments needed. Budget: 1/5 used.</p>
</div>

<div class="section">
  <h2>Experiment Log (TSV)</h2>
  <pre style="color:#94a3b8;font-size:0.8rem;overflow-x:auto;">experiment	score	max_score	pass_rate	status	description
baseline	5	5	1.00	PASS	All 5 evals pass on baseline SKILL.md — no mutations required</pre>
</div>

<footer>Generated by skill-autoresearch &nbsp;|&nbsp; omx v0.11.10 &nbsp;|&nbsp; 2026-03-30</footer>

</body>
</html>

{
  "skill": "omx",
  "skill_path": ".agent-skills/omx/SKILL.md",
  "baseline_score": 5,
  "final_score": 5,
  "max_score": 5,
  "baseline_pass_rate": 1.0,
  "final_pass_rate": 1.0,
  "experiments_run": 1,
  "mutations_applied": 0,
  "budget_cap": 5,
  "status": "COMPLETE_NO_MUTATION_NEEDED",
  "evals": [
    {
      "id": 1,
      "name": "Install path",
      "input": "oh-my-codex 설치하고 싶어. 어떻게 시작해?",
      "criteria": "npm install + omx setup + omx --madmax --high recommended launch",
      "baseline": "PASS",
      "final": "PASS",
      "evidence": "Section 1 Quick Start: 'npm install -g @openai/codex oh-my-codex', 'omx setup', 'omx --madmax --high'"
    },
    {
      "id": 2,
      "name": "Team mode",
      "input": "Codex CLI에서 병렬 팀 워커를 실행하고 싶어. 어떻게 해?",
      "criteria": "omx team N:executor syntax + tmux/psmux requirement + management commands",
      "baseline": "PASS",
      "final": "PASS",
      "evidence": "Section 4 Team Runtime: 'omx team 3:executor', platform/dependency table with tmux/psmux, management commands status/resume/shutdown"
    },
    {
      "id": 3,
      "name": "Ralph described",
      "input": "ralph 모드가 뭐야? omx에서 어떻게 쓰는 거야?",
      "criteria": "$ralph syntax + execute->verify->fix loop",
      "baseline": "PASS",
      "final": "PASS",
      "evidence": "Table row: 'ralph | $ralph | Persistent execution loop until verified complete'. Example 2: '$ralph \"fix all failing tests\"' with 'Loop: execute → verify → fix, until all tests pass.'"
    },
    {
      "id": 4,
      "name": "explore vs sparkshell distinguished",
      "input": "omx explore 랑 omx sparkshell 이 뭐가 달라?",
      "criteria": "read-only vs shell inspection distinction",
      "baseline": "PASS",
      "final": "PASS",
      "evidence": "CLI section: 'omx explore --prompt' described as 'Read-only repo lookup'; 'omx sparkshell' as 'Bounded shell inspection'. Best practices: 'omx explore for safe lookups — read-only; won't modify anything'"
    },
    {
      "id": 5,
      "name": "deep-interview for vague requests",
      "input": "아이디어가 아직 모호해. 코딩 시작하기 전에 요구사항 명확히 하고 싶어.",
      "criteria": "$deep-interview + one-question loop + handoff to plan/ralph/team",
      "baseline": "PASS",
      "final": "PASS",
      "evidence": "Workflow table: '$deep-interview | Socratic clarification before planning or execution'. Example 4: '$deep-interview \"I want to add a payment system\"' — 'One-question-at-a-time Socratic loop until intent is clear, then hands off to $plan or $ralph.'"
    }
  ],
  "timestamp": "2026-03-30"
}

experiment	score	max_score	pass_rate	status	description
baseline	5	5	1.00	PASS	All 5 evals pass on baseline SKILL.md — no mutations required

---
name: omx
description: "Use when you need multi-agent orchestration for OpenAI Codex CLI. Triggers on: omx, $plan, $ralph, $team, $autopilot, $deep-interview. v0.11.10 — 30+ agents, 35+ workflow skills, tmux team runtime, sparkshell, explore, ralplan."
allowed-tools: Read Write Bash Grep Glob Edit Agent
metadata:
  tags: omx, oh-my-codex, codex, openai, multi-agent, orchestration, team, ralph, plan, deep-interview, ralplan
  platforms: Codex, Claude, Gemini
  keyword: omx
  version: 0.11.10
  source: Yeachan-Heo/oh-my-codex
---


# omx (oh-my-codex) — Multi-Agent Orchestration for Codex CLI

## When to use this skill

- You want a stronger Codex CLI runtime with reusable role prompts and workflow skills
- You need coordinated parallel agents via tmux team workers
- Complex tasks requiring persistent execution (`$ralph`) or consensus planning (`$ralplan`)
- You need repository exploration (`omx explore`) or bounded shell inspection (`omx sparkshell`)
- Cross-model consultation with `$ask-claude` or `$ask-gemini`

---

## 1. Quick Start

```bash
npm install -g @openai/codex oh-my-codex
omx setup
omx --madmax --high
```

Inside Codex:
```text
/prompts:architect "analyze the authentication flow"
$plan "map the safest implementation path"
```

> **Mental model**: Codex does the agent work. OMX adds better prompts, reusable workflow skills, and a runtime layer around it. Start with `omx --madmax --high` and let the agent pull in `$team`, `$ralph`, or other workflows when the task needs them.

---

## 2. Agent Roles (30+)

| Tier | Agents |
|------|--------|
| **Core Development** | `architect` · `planner` · `executor` · `debugger` · `verifier` · `explore` |
| **Quality Assurance** | `style-reviewer` · `quality-reviewer` · `api-reviewer` · `security-reviewer` · `performance-reviewer` |
| **Domain Experts** | `dependency-expert` · `test-engineer` · `build-fixer` · `designer` · `writer` · `qa-tester` |
| **Product Strategy** | `product-manager` · `ux-researcher` · `product-analyst` · `information-architect` |

Invoke via: `/prompts:<agent-name> "task"`

---

## 3. Workflow Skills (35+)

| Skill | Trigger | Description |
|-------|---------|-------------|
| `autopilot` | `$autopilot` | Full autonomous pipeline — idea to working code |
| `ralph` | `$ralph` | Persistent execution loop until verified complete |
| `ultrawork` | `$ulw` | Maximum parallelism across parallel agents |
| `team` | `$team` | N coordinated agents with tmux/worktree isolation |
| `plan` | `$plan` | Strategic planning before implementation |
| `ralplan` | `$ralplan` | Consensus-based iterative planning |
| `deep-interview` | `$deep-interview` | Socratic clarification before planning or execution |
| `deepsearch` | `$deepsearch` | Codebase-focused deep search |
| `analyze` | `$analyze` | Evidence-driven causal analysis (trace methodology) |
| `tdd` | `$tdd` | Test-first development (red-green-refactor) |
| `build-fix` | `$build-fix` | Fix build errors, type errors, toolchain failures |
| `code-review` | `$code-review` | Comprehensive multi-dimension code review |
| `security-review` | `$security-review` | Security audit — vulnerabilities, trust boundaries |
| `ultraqa` | `$ultraqa` | Maximum parallelism QA pass |
| `visual-verdict` | `$visual-verdict` | UI/UX visual review with verdict |
| `frontend-ui-ux` | `$frontend-ui-ux` | Frontend UI/UX design and review |
| `ai-slop-cleaner` | `$ai-slop-cleaner` | Clean AI expression patterns from code/docs |
| `ask-claude` | `$ask-claude` | Cross-model consultation with Claude |
| `ask-gemini` | `$ask-gemini` | Cross-model consultation with Gemini |
| `git-master` | `$git-master` | Atomic commits, rebasing, history management |
| `ecomode` | `$ecomode` | Token-efficient execution mode |
| `web-clone` | `$web-clone` | Clone and adapt web pages or UI patterns |
| `cancel` | `$cancel` | Stop active execution modes |

---

## 4. Team Runtime

```bash
# Start parallel team workers
omx team 3:executor "fix all TypeScript errors"
omx team 2:security-reviewer,1:architect "audit auth module"

# Team management
omx team status <team-name>
omx team resume <team-name>
omx team shutdown <team-name>
```

Inside Codex:
```text
$team 3:executor "parallelize this refactor"
```

**Requirements:**

| Platform | Dependency |
|----------|-----------|
| macOS | `brew install tmux` |
| Ubuntu/Debian | `sudo apt install tmux` |
| Fedora | `sudo dnf install tmux` |
| Windows (native) | `winget install psmux` |
| Windows (WSL2) | `sudo apt install tmux` |

---

## 5. CLI Commands

### Core launch
```bash
omx                   # Launch Codex with OMX runtime
omx --madmax --high   # Recommended default (bypass + high reasoning)
omx --xhigh           # Extra-high reasoning effort
```

### Launch flags

| Flag | Description |
|------|-------------|
| `--yolo` | Fast execution, minimal verification |
| `--high` | High reasoning effort |
| `--xhigh` | Extra-high reasoning effort |
| `--madmax` | Bypass approvals/sandbox (`--dangerously-bypass-approvals-and-sandbox`) |
| `--dry-run` | Preview without execution |
| `--verbose` | Verbose output |

### Operator commands
```bash
omx setup             # Install prompts, skills, config, AGENTS scaffolding
omx doctor            # Verify installation
omx doctor --team     # Team/swarm diagnostics
omx status            # Show active modes
omx cancel            # Cancel execution modes
omx hud --watch       # Live HUD status monitor
omx reasoning <mode>  # Set: low/medium/high/xhigh
omx help              # Show help
```

### Explore & inspect
```bash
omx explore --prompt "find where team state is written"   # Read-only repo lookup
omx sparkshell git status                                  # Bounded shell inspection
omx sparkshell --tmux-pane %12 --tail-lines 400           # Tail tmux pane output
```

---

## Instructions

1. **Identify intent** — match request to the best workflow skill (`$plan`, `$ralph`, `$team`, `$deep-interview`)
2. **Start with the recommended launch** — `omx --madmax --high` for most sessions
3. **Use role prompts for analysis** — `/prompts:architect "..."` before implementation
4. **Escalate when needed** — let the agent pull in heavier workflows; don't force `$team` for simple tasks
5. **Use `$deep-interview` for vague requests** — when intent, scope, or boundaries are unclear
6. **Point to references** — link to the relevant references/ file for deep-dive details

---

## Examples

### Example 1: Standard session
```bash
omx --madmax --high
```
```text
/prompts:architect "analyze the current auth flow"
$plan "implement OAuth safely"
```

### Example 2: Persistent execution
```text
$ralph "fix all failing tests and make them pass"
```
Loop: execute → verify → fix, until all tests pass.

### Example 3: Parallel team work
```bash
omx team 3:executor "refactor the API layer with proper tests"
```

### Example 4: Clarify before coding
```text
$deep-interview "I want to add a payment system"
```
One-question-at-a-time Socratic loop until intent is clear, then hands off to `$plan` or `$ralph`.

---

## Best practices

- **Codex-first** — OMX is a workflow layer, not a replacement for Codex; start with `omx --madmax --high`
- **Use `$plan` before `$ralph`** — plan first when scope is unclear; ralph for guaranteed execution
- **`$ralplan` for consensus** — use when multiple planning perspectives are needed before committing
- **`$deep-interview` gates execution** — always use for vague greenfield or brownfield work
- **Team mode is optional** — only escalate to `$team` when the task genuinely needs parallel workers
- **Cross-model consultation** — `$ask-claude` and `$ask-gemini` for second opinions on design or architecture
- **`omx explore` for safe lookups** — read-only; won't modify anything
- **`omx doctor` when stuck** — diagnose installation issues before manual debugging

---

## Quick Reference

| Command/Skill | Action |
|--------------|--------|
| `omx --madmax --high` | Recommended launch |
| `/prompts:architect "..."` | Analysis and design review |
| `$plan "..."` | Strategic planning |
| `$deep-interview "..."` | Clarify vague requests |
| `$ralph "..."` | Persistent loop until done |
| `$ralplan "..."` | Consensus planning |
| `$team N:role "..."` | Parallel coordinated agents |
| `$ulw "..."` | Maximum parallelism |
| `omx explore --prompt "..."` | Read-only repo exploration |
| `omx sparkshell <cmd>` | Bounded shell inspection |
| `omx setup` | Install/re-install OMX |
| `omx doctor` | Diagnose issues |
| `omx cancel` / `$cancel` | Cancel active modes |

→ [Website](https://yeachan-heo.github.io/oh-my-codex-website/) · [GitHub](https://github.com/Yeachan-Heo/oh-my-codex) · [npm](https://www.npmjs.com/package/oh-my-codex)

---

## References

| File | Contents |
|------|---------|
| [references/agents-catalog.md](references/agents-catalog.md) | All 30+ agent profiles and use cases |
| [references/skills-reference.md](references/skills-reference.md) | Full skill list with triggers and descriptions |
| [references/cli-reference.md](references/cli-reference.md) | Complete CLI: omx team/explore/sparkshell/reasoning |

N:omx
D:oh-my-codex (OMX) — multi-agent workflow layer for OpenAI Codex CLI. v0.11.10: 30+ agents, 35+ skills ($autopilot/$plan/$ralph/$team/$ulw/$ultraqa/$deep-interview/$ralplan), tmux team runtime, omx explore, omx sparkshell, and Claude workflow parity for team/autopilot/ultrawork/ultraqa.
G:omx oh-my-codex codex openai multi-agent orchestration team autopilot ultrawork ultraqa ralph plan deep-interview ralplan deepsearch
U[5]:
1:Stronger Codex sessions with reusable role prompts (/prompts:architect) and workflow skills ($autopilot/$plan/$ralph/$team)
2:Persistent execution loops until verified complete ($ralph)
3:Coordinated parallel workers via tmux team runtime (omx team N:role "task")
4:Autopilot builds ($autopilot), independent burst parallelism ($ulw), and QA fan-out ($ultraqa) as Codex equivalents of Claude autopilot/ultrawork/ultraqa
5:Socratic requirements clarification before coding ($deep-interview)
S[7]{n,action,details}:
1:install,Install OMX,npm install -g @openai/codex oh-my-codex && omx setup
2:launch,Recommended launch,omx --madmax --high (bypass sandbox + high reasoning)
3:plan,Plan before coding,/prompts:architect "analyze X" then $plan "ship Y" inside Codex
4:autopilot,Autonomous build,$autopilot "build X" — idea→plan→implementation→verification under .omx
5:ralph,Persistent execution,$ralph "fix all failing tests" — loops execute→verify→fix until done
6:team,Parallel workers,omx team 3:executor "task" or $team 3:executor "task" inside Codex
7:deep-interview,Clarify vague requests,$deep-interview "I want X" — one-question-at-a-time before planning
R[7]:
1:OMX is a workflow layer around Codex — Codex does the agent work; OMX adds better prompts/workflows/runtime
2:Default recommended launch: omx --madmax --high (--madmax = bypass approvals, --high = high reasoning effort)
3:Team mode requires tmux (macOS/Linux) or psmux (Windows native)
4:$deep-interview gates planning — use for vague greenfield or brownfield before $autopilot/$plan/$ralph/$team
5:$autopilot is the closest Codex-native match for Claude /autopilot; use $plan or $ralplan before $ralph for stricter completion loops
6:omx explore is read-only repo lookup; omx sparkshell is bounded shell inspection
7:Keep Codex runtime state under .omx rather than reusing .omc state
E[4]{desc,in,out}:
1:{Standard session,omx --madmax --high then /prompts:architect "analyze auth flow",Role prompt injects architect context; Codex analyzes boundaries then agent escalates to $plan}
2:{Persistent fix,$ralph "fix all 12 failing tests",OMX loops execute→verify→fix until all tests pass; state persisted in .omx/}
3:{Parallel team,omx team 3:executor "refactor API layer with tests",3 executor workers in isolated tmux/worktree sessions with shared task list}
4:{Autopilot parity,Claude /autopilot "build task API" in Codex,Use $autopilot "build task API"; add $deep-interview first when vague}