| name | planning |
| description | Use when running the full plan → review → execute pipeline — write the plan, review it, then implement it behind review and verify gates. The top-level entrypoint that orchestrates writing-plans, plan review, and executing-plans end to end. |
| use_when | Driving a body of work from a spec through to merged implementation. |
Planning
## Runbook-Orchestrated Skill
Load the execution protocol *before* starting, so you can handle step 1 (a
delegation) the moment it appears:
Skill(skill: "rundown:running-runbooks")Skill(skill: "rundown:delegating-runbooks") — step 1 delegates- Then start the runbook with exactly this command, no added flags:
rundown run rundown:planning
Capture the run claim from that command: rundown run emits it as runbook_started.claim_id. This pipeline delegates (step 1), so every orchestrator command you issue — collect, pass, goto — must carry --claim-id <claim_id>.
JSON is the agent-facing default; --text is for humans/debugging only — do not add it here.
Overview
Take a body of work from idea to implementation through three gated stages: write the plan, review the plan, then execute the plan. This skill is the entrypoint that orchestrates the whole pipeline; the planning runbook owns the sequence and the gates, and each stage's craft lives in its own sibling skill.
Rundown orchestrates workflow; it does not store craft. This skill names the pipeline and points at the stages — it does not duplicate them.
The Three Stages
- Write the plan — produce a clean, complete implementation plan (delegated). Craft lives in writing-plans; the leaf is the
write-plan runbook. The stage stops the pipeline on failure.
- Review the plan — run the plan through structural, technical, build/runtime, and risk/safety reviewers, then collate. This stage composes the
review-plan runbook inline. It stops the pipeline on failure.
- Execute the plan — implement the plan task-by-task behind review and verify gates. Craft lives in executing-plans; the stage composes the
execute-plan runbook inline and completes the pipeline on success.
Every stage stops the pipeline on failure (FAIL ANY STOP); the final stage completes it (PASS ALL COMPLETE).
When to Use
- Driving a body of work end to end: spec → plan → reviewed plan → implementation.
- When you want the review and verify gates between planning and merging, not just stage 1.
When NOT to Use
- Only writing a plan with no review/execute follow-through — use writing-plans directly.
- Only implementing an already-written, already-reviewed plan — use executing-plans.
Reference
