Dispatch

Dispatch

Workhorse phase. Picks up a task file from /hyperflow:scope and runs it through the orchestrator pattern with parallel worker dispatch and thinking-tier reviews.

This skill exercises Layer 3 (Orchestrator), Layer 5 (Quality Gates), Layer 6 (Project Memory), Layer 8 (Git Workflow), and Layer 9 (Security) from the doctrine. Multi-level review (L1–L5) is applied per the triage's flow profile.

Per-Step Agent Map (DOCTRINE rule 12)

Every substantive step dispatches at least one Agent.

Iron rule — thinking agents ≥ batches + 1 (per-batch reviewer + final integration). With per-step thinking-tier reviewers in Step 4, the floor rises to batches + 2.

Review Levels (scale by flow profile)

Every batch reviewer and the final integration reviewer uses the level set below. Profile comes from /hyperflow:spec triage and is propagated via the chain-mode args.

L1 syntax/format · L2 spec/naming/edges · L3 integration/security · L4 perf/scale · L5 a11y/UX. See review-levels.md for the full checklist.

Approval Gates

Inputs

• Task file — positional arg (slug or path). Default — most-recently-modified file in .hyperflow/tasks/.
• chain-mode=<auto|manual> — passed in by /hyperflow:scope. Controls whether to pause for confirmation after the final integration review. If absent, assume auto.
• --from-batch <n> — resume from a specific batch (skip prior batches).
• --final-only — skip batch dispatch, run only the final integration review.

Flow

Step 0 — Choose mode (only if invoked directly · STRUCTURAL GATE)

This is a structural gate per DOCTRINE rule 8. When dispatch is invoked directly (no chain-mode arg from scope), it MUST fire. "No clarifying questions" / "auto-pilot" / any autonomy directive does NOT skip it. Defaulting silently is a doctrine violation.

If a chain-mode arg was passed, skip this step — the chain-starter already asked.

Otherwise, ask via AskUserQuestion. Per DOCTRINE rule 8, the recommended option goes first with (Recommended):

How should I handle progress through the batches?

  Auto (Recommended)  — run all batches + final review and stop. Print next-step suggestions.
  Manual              — pause between batches and ask before continuing.

Wait for the user's answer. Do not proceed without it. If AskUserQuestion cannot be presented, print an error and stop — never silently default.

Step 1 — Load the task

Read .hyperflow/tasks/<slug>.md. If absent, stop and suggest /hyperflow:scope first.

Step 2 — For each batch

1. Print the batch header: Batch <n> — <one-line description>.
2. Dispatch all sub-tasks in the batch in a single message with parallel Agent calls (one per sub-task). Use the worker-prompt.md template. Inject Project Context (from .hyperflow/profile.md, architecture.md, conventions.md) plus accumulated Learnings from prior batches.
3. As each worker returns:
   • Print Implementer — completed <subtask> (or relevant role).
   • Immediately dispatch a thinking-tier reviewer per reviewer-prompt.md. Print **Reviewer** — reviewing <subtask> (L1–L<n>) where n is set by the flow-profile table above.
   • If verdict is NEEDS_FIX — re-dispatch worker with the fix list. Repeat until PASS (max 3 retries before escalating to a thinking-tier worker).
   • If verdict is SECURITY_VIOLATION — halt the chain immediately and surface the finding to the user (no auto-continue).
   • On PASS — commit this sub-task immediately per git-workflow.md rule 2 (per-sub-task commit cadence). Stage only the files this sub-task touched, write a conventional commit (feat(<scope>): <title> derived from the task file), commit. One sub-task = one commit. A batch of 3 parallel sub-tasks produces 3 commits.
4. After the full batch — synthesize learnings, check off the batch in the task file, run Layer 5 quality gates (lint / typecheck / tests on affected files) per quality-gates.md. If gates fix anything, those become small additional commits on top (never amend per-sub-task commits). If chain-mode=manual, pause and ask before starting the next batch.