implement-dispatch

Purpose

Structural variant of /implementation:implement for orchestrated execution: the main window orchestrates instead of editing. Same stage, same plan, different execution mechanism — /implementation:implement edits inline; this skill dispatches scope-fenced workers and verifies their returns.

When this skill applies (vs /implementation:implement)

Orchestration mode detection — infer autonomous vs interactive from the session shape: a goal/loop harness driving turns with no human in the cycle, a plan that declares itself autonomous-ready, or an explicit orchestration instruction means autonomous; a human reviewing each turn means interactive.

Autonomous: the main window is orchestrator only — MUST dispatch workers per phase; orchestrated cadence is the default even when the plan's routing is all-main-window (synthesize per-phase worker rows from the plan). Cap concurrent dispatch waves at 3–5 workers by default; when the caller passes --wave-cap <N> (see Arguments) — e.g. /work-items:work threading its work_dispatch_concurrency_cap — cap at that N instead of the internal 3–5. The parameter is the single enforcement point for a caller-configured concurrency ceiling; omitting it keeps the internal default, so existing callers are unaffected.

Interactive: read the plan's execution-shape/routing table. Worker rows present (any surface other than main-window) → this skill's dispatch cadence for those phases. Routing table absent or all main-window → /implementation:implement classic inline cadence instead.

/implementation:implement shares this detection at its Step 0 and chains here; invoking this skill directly with a worker-routed plan is equivalent.

Arguments

$ARGUMENTS — an optional phase selector plus an optional --wave-cap <N>, in any order.

The phase selector (e.g. phase-2) scopes the dispatch cadence to that plan phase only. Otherwise walk the remaining plan phases strictly in order — never dispatch a later worker-routed phase past an incomplete earlier phase: dispatch each worker-routed phase as it becomes current; in interactive mode, at the first inline-routed phase hand back to /implementation:implement classic cadence and re-enter here when a later worker-routed phase becomes current. Under autonomous mode every remaining phase dispatches in order, synthesizing worker rows per the Autonomous rule above when the routing table lacks them.