| name | ship-phase |
| description | Coordinate shipping a whole roadmap phase (multiple dependent issues) unattended — worker agents implement per-issue on one integration branch, small review per issue, one high-effort review + single PR at the end. Invoke as `/ship-phase <phase|issue-list>` (e.g. /ship-phase 7). The invoking session is the COORDINATOR and must be a capable model (Opus/Fable). |
/ship-phase — unattended multi-issue coordinator
You are the coordinator. You do not implement issues yourself — you plan waves, spawn
worker/reviewer agents, verify their output with your own commands, integrate commits, and
own everything git-remote-facing. Follow CLAUDE.md throughout; /ship's per-issue steps
1–5 are the worker contract referenced below.
Sandbox notes (same as /ship): grep is intercepted — rg PATTERN > "$TMPDIR/out" then
Read. Playwright e2e does NOT run locally — e2e signal comes from GitHub Actions on the
pushed branch. Capture long output to files.
0 — Unattended policy
- No approval gates. Where /ship says 🛑, do not stop the run: if an issue turns out
ambiguous or needs an unrecorded decision, skip it (leave its commits out), continue
the rest, and list it in the final report. Never invent architectural decisions.
- Never merge to
main, never force-push, never edit main's working tree directly.
- The coordinator alone touches:
git merge/push, gh pr *, issue comments, CHANGELOG.md
conflicts, memory writes.
1 — Orient
- Read roadmap #68 for the phase's build order, then
gh issue view every issue in the
phase. The issue bodies are the spec — they are deliberately self-contained; do not rely
on chat history.
- Derive the wave plan: sequence the dependency spine; parallelize only issues whose
planned file footprints are disjoint (judge from the issues' Files sections — when in
doubt, serialize; a merge conflict costs more than lost parallelism).
- Create the integration branch off the remote default branch:
git fetch origin && git checkout -b <type>/phase<N>-<slug> origin/main (see memory
[[ship-branch-off-diverged-main]]). Push it immediately so CI runs from the start.
2 — Per issue (repeat per wave)
Spawn a worker — a fresh agent (subagent_type: "general-purpose", never fork —
see [[ship-background-finalization]]), model: "sonnet" unless the wave plan marks the
issue high-risk (then omit model to inherit the coordinator's). Parallel workers get
isolation: "worktree"; a solo worker may work in the main tree on a
wip/<issue>-<slug> branch off the current integration HEAD.
Worker prompt must contain, explicitly:
- the issue number and instruction to
gh issue view it and treat Acceptance criteria as
the definition of done;
- the mutation boundary: Edit/Write + local
git commit on its branch only — no
push, no PR, no gh mutations, no issue edits, no memory writes, no CHANGELOG beyond its
own entry, no TaskCreate;
- follow
/ship steps 2–5 (plan → implement+tests to the 100/100/100/100 per-file gate →
npm test + npm run build green → self-review → CHANGELOG [Unreleased] entry);
commit message <type>: <summary> (#<ISSUE>) + the repo footer convention;
- return: plan summary, files touched, test/build output tail, acceptance-criteria
checklist with each item ticked or explained.
Verify yourself (never trust the self-report): git log/git diff the worker branch,
re-run npm test and npm run build in that tree.
Small review: spawn a read-only reviewer agent (model: "sonnet", explicit
boundary: no Edit/Write/git/gh/memory) on the issue's diff vs the integration base, prompted
with the issue's acceptance criteria + CLAUDE.md hard rules. Real findings → send back to
the worker (SendMessage) or a fix agent with the same worker boundary; re-verify.
Integrate: merge the worker branch into the integration branch (resolve conflicts
yourself — you are the only writer of the integration branch), re-run npm test, push.
Each push gives a CI e2e signal — check it before starting the next wave
(gh run list --branch <branch>); a red e2e stops the line until fixed.
3 — Finish
- Whole-branch high review: run
/code-review at high effort on the full branch
diff (and /security-review if anything touched auth/config). Apply real findings via a
fix agent; re-verify; push.
- Confirm CI fully green (unit + e2e, all engines).
- Reconcile: tick #68's phase checkboxes in one edit; CHANGELOG entries are already
per-issue — dedupe/merge conflicts only.
- One PR (
gh pr create --base main), body per the PR template, with one
Closes #<n> line per completed issue (skipped issues: Part of), a per-issue
summary table, and the repo PR footer.
- 🛑 Merge gate — the only stop. Report: PR URL, per-issue status (shipped / skipped +
why), review findings applied, CI status. Do not merge.
- Friction → memory (coordinator writes it, not a subagent).
