do-whole-phase

name	do-whole-phase
description	Finish the active phase end-to-end, including the review and any fix slices.
allowed-tools	Bash(python3 scripts/workflow.py:*), Read, Edit, Write, Glob, Grep, Bash, Agent, EnterPlanMode, ExitPlanMode
disable-model-invocation	true

do-whole-phase

Read CLAUDE.md and the phase's phase.md — the bounded phase notebook (## Slices generated from slice.json, ## Decisions, ## Doc impact, ## Operator Questions, ## Notes for later slices, ## Now) — run python3 scripts/workflow.py next for the pointer, then finish every remaining slice in the current phase only. Read docs/current/ sections just in time, as the slices reach them, never the whole doc set up front. If you are ever unsure of the operator's intent, consult intent.md — the confirmed record of what was asked. next reports the current stream's active phase: on the default stream it skips phases opted into parallel mode (printing parallel_phases_elsewhere=<P>:<branch>), and in a phase-branch worktree it sees only that phase (printing a stream= line); python3 scripts/workflow.py parallel-status shows every stream. If next prints a hint: line offering python3 scripts/workflow.py parallel-start <P> for a planned phase waiting behind this one, relay it to the operator as a suggestion, never a default, and carry on with this phase unless they opt in (see the parallel-phase skill).

You are the ORCHESTRATOR (main thread): you plan each slice, verify, commit, move workflow state, and talk to the operator. Every slice — decomposition, implementation, fix, and the phase review — is delegated to a slice-executor tier subagent (slice-executor-mid or slice-executor-high), one at a time and sequentially. One exception, and it is narrower than it used to be: a co-work (design) slice runs inline → dispatched → inline. The DesignSync work is never dispatched — the read-back and the SIGNOFF regroup stay on the main thread, because DesignSync is main-thread only and no executor has it — but the mockup build is the one dispatched span inside it (slice-executor-high, no DesignSync, built from the round's build-prompt.md). See the design-cowork skill; either way the slice ends the run at a pending stop. Same contract as do-next-slice, looped over the phase.

Rules:

• If a slice or the phase is pending (shown [~]; next prints WAITING ON OPERATOR), STOP the loop: it needs operator co-work (validation or an operator-run action). Report what you need and do not start, finish, or advance past it. Resume only after the operator clears pending back to in_progress. When the phase is pending because its operator acceptance gate is open (next also prints acceptance_gate=open and the walkthrough), relay that walkthrough as-is: it clears with python3 scripts/workflow.py accept-gate <P> --clear [--note "..."], not with set-phase-status. If you hit such a point mid-slice, set it pending with set-slice-status <slice_id> pending and STOP. A co-work design slice stops pending twice and the engine cannot tell the two windows apart — both are status: pending on the same slice and both print the same line — so the difference lives entirely in what you report; say which one this is (the co-work rule below). (In parallel mode a pending item halts only its own stream.)

• After each slice, re-read the phase's phase.md and the executor's returned verdict — that pair is the handoff, and the notebook was rewritten, not appended to, so the previous read is stale. Drop the per-slice re-read of works/backlog.md (and works/state.json): next prints the pointer, and the dashboards are generated from the same state.

• Default is auto — plan inline → executor, straight through, no approval pause. With no mode word (an explicit auto, or "run unattended", means the same), do not enter plan mode (no EnterPlanMode / ExitPlanMode): for each slice, plan inline → Write plan.md verbatim and in full (no harness plan file exists to copy, since plan mode is never entered — the default persistence path is Write, not cp) → dispatch the executor → validate (state integrity) → finish → commit → next, to the end of the phase. Free-form, no template; pull context from phase.md, let the plan incorporate any operator note, and never pre-fill another slice's (the operator's verbatim intent lives in the phase's , not duplicated per slice). The default waives only the plan-approval pause — the safety halts still apply: a slice/phase, any / return, or a failed/empty return, STOPS the loop. An (or a failed/empty return from ) does not stop the loop: revise the plan and re-dispatch the slice to without a pause. For a slice already (), skip the inline planning too — its operator-approved already exists; dispatch from it directly.