Execute Plan

---
name: execute-plan
description: <EXTREMELY_IMPORTANT>Use execute-plan when you have a reviewed plan or task graph and are ready to implement it. It drives the deterministic ODW engine: each task is implemented, then verified by a panel of blind auditors, and re-implemented with the findings until it passes. Use it instead of writing code straight from a plan.</EXTREMELY_IMPORTANT>
---

# Execute Plan (Open Dynamic Workflow)

**Announce:** "I'm using the ODW execute-plan skill — implement-and-audit per task."

You are the **orchestrator**. A deterministic engine holds the graph truth; you
dispatch the subagents and feed results back to it. Drive the engine through its
CLI and **never track the graph in your head**:

```
ENGINE="node \"${CLAUDE_PLUGIN_ROOT}/scripts/engine-cli.ts\""
STATE="--state-dir ${CLAUDE_PROJECT_DIR:-.}/.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, not a creative rewrite**. Each task:

```jsonc
{ "version": 1, "nodes": [
  { "id": "build", "name": "…", "deps": [],
    "acceptanceCriteria": ["independently checkable", "…"],
    "maxAttempts": 2, "impl": { "executor": "subagent(general-purpose)" },
    "humanGate": false }
]}
```

`impl` is optional (defaults to `subagent(general-purpose)`); do **not** add an
`audit` field — auditors are resolved at runtime. Write it to a temp file, then:

```bash
$ENGINE validate --graph <tmp.json>          # fix the dump if this errors
GID=$($ENGINE init --graph <tmp.json> $STATE) # prints + capture the GRAPH_ID
```

## Step 2 — Run the scheduling loop

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

1. **Ask what's ready.** `$ENGINE ready --id $GID $STATE` — each line is
   `<subnode-id>\t<role>\t<executor>`. Dispatch every ready subnode (in the
   **background** when you can, reacting to each completion).

2. **Dispatch by role** (parse `subagent(NAME)` → the `NAME` is the Task
   `subagent_type`):

   - **`impl` → implementer.** Spawn the executor's subagent with: the task's
     name + **acceptance criteria**, and — if this is a retry — the prior round's
     **findings** (fetch the task's current findings from the diff/criteria; the
     engine carries them). Instruct it to do the work, self-check every
     criterion, and end with `STATUS: COMPLETE` (+ `SUMMARY`/`CHANGED_FILES`) or
     `STATUS: BLOCKED` (+ `BLOCKED_REASON`). On COMPLETE →
     `$ENGINE complete --id $GID --node <id> $STATE`. On BLOCKED → **stop and
     raise the human** (genuine blocker).

   - **`resolve` → audit panel.** Spawn the bundled **`odw:audit-resolver`**
     agent with the task id, acceptance criteria, and changed files. It returns a
     `PANEL:` JSON array of `{focus, executor, audit_prompt}`. Write the array to
     a temp file and register it:
     `$ENGINE resolve --id $GID --node <id> --panel @<panel.json> $STATE`.

   - **`audit` → blind auditor.** Fetch the auditor's prompt:
     `$ENGINE show --id $GID --node <id> $STATE` → JSON with `executor`,
     `focus`, `auditPrompt`. Spawn that executor with the **`auditPrompt`
     verbatim** (it is a complete blind-audit body — give it no other guideline).
     On `VERDICT: PASS` → `$ENGINE complete --id $GID --node <id> $STATE`. On
     `VERDICT: FAIL` → `$ENGINE fail --id $GID --node <id> --reason "<findings>" $STATE`.

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

## Step 3 — Human gates

For a task whose `humanGate` is true, after its auditors all pass (the task is
done) **stop before dispatching its successors** and confirm with the
**AskUserQuestion** tool. Continue only after the user verifies.

## Step 4 — Finish

1. Run the plan's verification (the test suite / commands it specifies) as one
   end-to-end check.
2. Emit the table and present it: `$ENGINE report --id $GID $STATE`. Call out any
   task whose status is `failed`.

## Rules

- **MUST** drive the engine with `ready`/`complete`/`resolve`/`fail`; **MUST
  NOT** track the graph from memory.
- **MUST** treat each task as implement-and-audit; never skip the resolver/audit.
- **MUST** spawn an auditor with its `auditPrompt` verbatim and keep it blind to
  the implementer's reasoning.
- **STOP and ask** on an implementer `BLOCKED`, a failing end-to-end check the
  per-task audits missed, or an instruction you don't understand. Audit
  exhaustion is **not** a stop condition — it is reported as `failed`.