Execute Plan

---
name: execute-plan
description: Use when you have a reviewed plan or task graph and are ready to implement it. Drives the deterministic ODW engine: each task is implemented, then verified by a panel of blind auditors run as fresh `codex exec` contexts, and re-implemented with the findings until it passes. Keywords: workflow, plan, execute, audit, task graph.
---

# Execute Plan (Open Dynamic Workflow — Codex)

You are the **orchestrator**. A deterministic engine holds the graph truth; you
implement tasks and dispatch blind auditors, and feed every result back to the
engine. **Never track the graph in your head.**

## Locate the engine (once)

The engine ships at `scripts/engine-cli.ts` under this plugin's install root.
Bind it to `$ENGINE`, and use one stable state dir for the whole run:

```bash
ENGINE_CLI="${CODEX_PLUGIN_ROOT:+$CODEX_PLUGIN_ROOT/scripts}/engine-cli.ts"
[ -f "$ENGINE_CLI" ] || ENGINE_CLI="$(find "$HOME/.agents" "$HOME/.codex" -path '*odw*/scripts/engine-cli.ts' 2>/dev/null | head -1)"
ENGINE="node \"$ENGINE_CLI\""
STATE="--state-dir $PWD/.odw/state"
```

Requires Node ≥ 23.6 (the engine is TypeScript run via native type-stripping).

## Step 1 — Compile the plan to a task graph

Transcribe the reviewed plan's task list into a graph JSON — a **faithful 1:1
transcription**. Each task: `{id, name, deps[], acceptanceCriteria[],
maxAttempts, impl?: {executor}, humanGate?}`; `version: 1`. Omit `audit` —
auditors are resolved at runtime. Write to a temp file, then:

```bash
eval "$ENGINE validate --graph <tmp.json>"
GID=$(eval "$ENGINE init --graph <tmp.json> $STATE")   # capture the GRAPH_ID
```

## Step 2 — Run the scheduling loop

Repeat until `eval "$ENGINE done --id $GID $STATE"` prints `true`:

1. **Ask what's ready:** `eval "$ENGINE ready --id $GID $STATE"` — each line is
   `<subnode-id>\t<role>\t<executor>`. Handle each ready subnode by its role.

2. **By role:**

   - **`impl` → implement.** Do the work directly in the repo (you are a coding
     agent), or delegate a bounded task to a fresh context with `codex exec`
     (`-s workspace-write`). Implement only what the task asks; self-check every
     acceptance criterion. If this is a retry, first read the task's prior
     **findings** (`$ENGINE show` / report) and fix exactly those. On success:
     `eval "$ENGINE complete --id $GID --node <id> $STATE"`. On a genuine blocker,
     **stop and tell the user**.

   - **`resolve` → design the audit panel.** Inspect the change (`git diff`) and
     compose a **MECE** panel of blind auditors over how it can fail (always
     include a *Technical Execution* auditor that runs the tests/build). Emit a
     JSON array of `{focus, executor, audit_prompt}` where each `audit_prompt` is
     a complete blind-audit body (states it is blind, lists the acceptance
     criteria, gives a verification method, demands `VERDICT: PASS|FAIL` +
     `FINDINGS`). Write it to a file and register it:
     `eval "$ENGINE resolve --id $GID --node <id> --panel @<panel.json> $STATE"`.

   - **`audit` → run a BLIND auditor in a fresh context.** Fetch its prompt:
     `eval "$ENGINE show --id $GID --node <id> $STATE"` → JSON with `auditPrompt`.
     Run it as a fresh, isolated `codex exec` so the auditor never sees your
     implementation reasoning:

     ```bash
     printf '%s' "$AUDIT_PROMPT" | codex exec --skip-git-repo-check \
       -s read-only -c approval_policy=never -C "$PWD" -
     ```

     Read its stdout. On `VERDICT: PASS` →
     `eval "$ENGINE complete --id $GID --node <id> $STATE"`. On `VERDICT: FAIL` →
     `eval "$ENGINE fail --id $GID --node <id> --reason \"<findings>\" $STATE"`.

3. **Apply, then continue.** Every `complete`/`resolve`/`fail` prints the
   newly-ready subnodes — handle those next. The engine settles each task's audit
   round: all pass → `done`, dependents unblock; any fail with attempts left →
   it **reopens the implementer with the findings** and re-resolves a fresh
   panel; attempts exhausted → `failed` (non-halting; successors still run).

## Step 3 — Human gates

For a task whose `humanGate` is true, after its auditors all pass, **stop before
its successors** and ask the user to verify before continuing.

## Step 4 — Finish

Run the plan's verification (its test suite / commands) as one end-to-end check,
then present `eval "$ENGINE report --id $GID $STATE"`. Call out any `failed` task.

## Rules

- Drive the engine with `ready`/`complete`/`resolve`/`fail`; never track the
  graph from memory.
- Every task is implement-and-audit — never skip the audit.
- Run each auditor in a **fresh `codex exec` context** with its `auditPrompt`
  verbatim, blind to your implementation reasoning.
- Stop and ask on a genuine blocker or a failing end-to-end check the per-task
  audits missed. Audit exhaustion is reported as `failed`, not a stop.