Implement All

Chew through a map's tickets one at a time, unattended, until the frontier stops it.

Outer loop: one map is consumed, ticket by ticket. Inner loop: one ticket becomes one green, stacked PR. The operator merges to main themselves, one PR at a time, after verifying each.

This does not call /implement-next. The loop needs the frontier before claiming, skips where that skill asks, and replaces its implement step with a five-stage Workflow — almost nothing is left to reuse. What the two share is the definition of takeable, and that lives in the repo, not in either skill.

The loop is continuous through tickets, not through the operator's interventions. It dies on any pause condition and is re-armed with the same one-line command. Dying is cheap by design — a re-armed run derives everything from GitHub and holds no local state.

Arguments

/implement-all #<map> [count] [--dry]

• #<map> — the parent issue whose sub-issues are the tickets. Required.

• count — bound the run to N tickets. Optional; no ceiling by default, because a cap contradicts the point of the loop. It is enforced at the top of the loop — tick step 0.

• --dry — resolve, report the plan and the gate state, then stop. Claim nothing, implement nothing. Concretely: run arm steps 0–3, then resolve the frontier as in tick step 1 so the plan is real; stop there. Never arm step 4 — a dry run does not create .worktrees/chain and does not write .git. Never tick step 3 — no claim.

  No arm check is a refusal under --dry. Report what each one found — the sweep's hits in step 1, both greenlights on the tip in step 3 — and carry on to the frontier resolution, naming in the brief which pause row each would have fired. One rule for every arm step, because reporting the gate state is the whole point of a dry run and a stale claim at step 1 must not swallow the plan the operator asked for.