# Wave Planner Acpx

> Plan and execute large multi-step, multi-stack changes with contract-first waves, parallel worker ownership, user approval gates, ordered integration, and final verification/docs updates through acpx. Use this when you explicitly want cross-CLI or cross-provider workers instead of Codex subagents.

- Skill: `asm3r96/wave-planner-acpx` (Agent Skill, multi-file: 6 files)
- Install (CLI): `npx skillmds@latest add asm3r96/wave-planner-acpx`
- Raw SKILL.md: https://api.skillmd.com/api/skills/asm3r96/wave-planner-acpx/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: asm3r96 (https://skillmd.com/u/asm3r96)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/asm3r96/wave-planner-acpx

---


# Wave Planner

Create and run a Wave-Driven Development plan for large, cross-stack tasks.

## Objective

Produce:
- Vision and scope boundaries
- Decision Log
- Wave 0 contracts
- Wave 1..N parallel implementation waves
- Integration wave
- Final verification wave
- Documentation update step
- Saved plan file
- Ready-to-send worker prompts and execution checklist

## Workflow

1. Decide whether to use this skill:
- Use only if work is large, multi-step, and touches multiple parts/stacks.
- If not large enough, do not use this skill.
- If the user is already in Codex and does not need external workers, recommend using `wave-planner` instead.
2. Ask for Gate 1 user approval before planning:
- Send a short reason: "I recommend Wave method because <short reason>. Do you agree?"
- Stop until user accepts or declines.
3. If accepted, draft the plan:
- Clarify done criteria and out-of-scope.
- Build Decision Log (naming, API shape, error model, logging, tests, style constraints).
- Define Wave 0 contracts first (types/interfaces/schemas, boundaries, API shapes, constants, flags/migrations).
- Save the plan by default inside `.planning/`; create the folder if it does not exist.
- Use a clear feature-based filename for the plan.
4. Choose wave and agent count with balancing rules:
- Use the minimum number of waves that still avoids conflicts.
- Group independent tasks into the same wave.
- Move dependency-bound tasks to later waves.
- Keep each worker task medium-sized (not tiny and not overloaded).
- Ensure each worker has explicit file/module ownership.
5. Produce a one-line execution preview before full detail:
- One line per wave.
- One line per worker with task summary.
6. Produce the full plan with complete shared context:
- Include full vision and all waves so each worker sees global intent.
- Include worker-specific goals, files, constraints, and verification.
- Include explicit wave order for execution (Wave 0, then Wave 1..N, then Integration, then Final Verification, then Docs).
- Make each worker prompt highly specific: exact ownership, exact files/modules, exact handoff format, exact verification steps, and any important non-goals.
- Save the full plan to the plan file by default; do not dump the full plan in chat unless the user explicitly asks.
7. Ask for Gate 2 user approval before execution:
- "Plan is ready. Execute now?"
- Stop until user accepts or declines.
8. If accepted, load and use `acpx` skill, then execute:
- Use `acpx` to create/run named sessions per worker in current wave.
- Use `--prompt-retries` when transient failures are likely or already observed.
- Use `--suppress-reads` when cleaner logs are helpful for orchestration.
- Run workers in parallel inside a wave, but execute waves sequentially.
- Wait for all workers in wave to finish and validate handoffs before next wave.
- Close worker sessions after completion.
9. After all waves:
- Main agent reviews merged result and runs verification tests.
- Main agent updates existing docs if needed, or adds new docs for new features.
- Follow existing documentation format and conventions.
- Main agent updates the original plan file status to `Completed` or `Blocked`.
- Main agent adds final verification notes to the original plan file.

## Global Rules

- Gating rule: planning and execution require explicit user approvals (Gate 1 and Gate 2).
- Ownership rule: workers edit only assigned files.
- Dependency rule: if outside scope is needed, return a Dependency Note instead of editing.
- Consistency rule: follow existing repo patterns; do not invent new architecture unless requested.
- Verifiability rule: each worker includes at least one concrete verification method.
- Ordering rule: wave order is strict; do not start next wave early.
- Session rule: one named session per worker; close finished sessions.
- Plan-location rule: save plans in `.planning/` by default and create the folder if needed.
- Worker-context rule: every worker must read the original plan file first for the full picture before editing.
- Verification-scope rule: run targeted checks first, then broader final checks; report unrelated pre-existing failures clearly as outside scope.
- Docs rule: docs update is mandatory in final step (update existing docs or add new).

## Model Routing Configuration

Read `templates/model-routing.md` before choosing models.

Rules:
- Classify each worker task as `hard`, `middle`, or `easy`.
- Select the first available model from that class's ordered list.
- If a model fails/unavailable, fallback to the next model in order.
- If placeholder guidance still exists in routing config, stop and tell user to edit routing first.

## Mandatory Worker Handoff Format

1. Summary (1-3 lines)
2. Files changed (exact list)
3. Patch/diffs (or exact edits)
4. How to test (commands + expected result)
5. Risks/TODOs/Dependency Notes
6. Main plan log entry (what to append to shared execution log)
7. Completion marker: `WAVE {WAVE_ID} / {AGENT_NAME} DONE`

## Output Contract

Always output the final plan using this section order:
- A) Vision
- B) Decision Log
- C) Contracts (Wave 0)
- D) Waves (1..N with agents)
- E) Integration + Final Verification + Docs
- F) Worker prompts
- G) Execution checklist (acpx sessions + wave order)

Use templates from `templates/` when helpful.