/v-dispatch

description: Execute a Compound-V-ready plan, manifest, or run-id on Engine C — the native Workflow dispatch engine. Accepts a bare plan path (auto-materializes the manifest), or a manifest|run-id (dispatches directly). Validates with --require-triage, runs partition-reviewer, emits and launches the workflow, then gates integration on compound-v-integration-gate.py before any job commit lands.

You are about to execute **Phase 3** of Compound V on `{{args}}` — manifest-driven dispatch on **Engine C**, the native Workflow engine (`scripts/compound-v-emit-workflow.py`).

**You run this yourself, at the top level. Do not delegate the run to the `superpowers-v:parallel-dispatcher` subagent.** A subagent has no Workflow tool — probed live under both the public name `Workflow` and the internal `RunWorkflow` — so delegating would silently drop the run onto the residual path. It is also what kept `/v:epic` off Engine C: `/v:epic` invokes `/v:dispatch` as a *command*, executed by the top-level agent, so once dispatch stops delegating, the epic inherits Engine C along with everything else.

`{{args}}` is accepted in **three backward-compatible forms** — detect which:

| `{{args}}` is… | Action | |---|---| | a **plan path** (`docs/superpowers/plans/…md`) | **materialize the manifest first** (Phase 2 → `manifest.yaml` + `state.json` in a new run dir), then dispatch. *This is the 0.1.x contract the `plan-saved-nudge` hook and current users rely on — it still works.* | | a **manifest path** (`…/execution/<run-id>/manifest.yaml`) | dispatch it directly (already materialized). | | a **run-id** (a dir name under `docs/superpowers/execution/`) | resolve to that run's `manifest.yaml` and dispatch directly. |

Resolving the plugin root

The `scripts/` and `schemas/` this command calls ship with the plugin — they are not files in your own repository. Resolve the plugin root once per session before calling any of them:

CV="${CLAUDE_PLUGIN_ROOT:-$(ls -d "$HOME"/.claude/plugins/cache/*/superpowers-v/*/ 2>/dev/null | sort -V | tail -1)}"
CV="${CV:-$PWD}"; CV="${CV%/}"

`CLAUDE_PLUGIN_ROOT` is set for hooks but is not set in this Bash environment, so treat it as a hint, never the whole answer — the fallback line covers an installed plugin cache or a checkout of this repo. Paths under `docs/superpowers/` stay relative; only the plugin's own `scripts/` and `schemas/` get `$CV`.

Steps

1. **Resolve `{{args}}`.**

• If `{{args}}` is **empty**, list plans in `docs/superpowers/plans/` and runs in

`docs/superpowers/execution/`, and ask which to dispatch.

• If `{{args}}` is a **run-id** or a **manifest path**, load that run's `manifest.yaml`.

Skip to step 3.

• If `{{args}}` is a **plan path**, verify it exists, then **materialize** per

[`/v:orchestrate`](v-orchestrate.md): apply [`routing-policy.md`](../skills/compound-v/routing-policy.md), write `manifest.yaml` + initial `state.json` into `docs/superpowers/execution/<run-id>/` (schema: [`execution-manifest.md`](../skills/compound-v/execution-manifest.md); run-dir + state shape: [`state-machine.md`](../skills/compound-v/state-machine.md)), then continue.

2. **Validate the manifest — always with `--require-triage`, in EVERY mode.**

   # legacy manifest (no fast_path block):
   python3 "$CV/scripts/compound-v-validate-manifest.py" --require-triage \
     docs/superpowers/execution/<run-id>/manifest.yaml
   # fast_path manifest (v2.9 pre-eval-backed):
   python3 "$CV/scripts/compound-v-validate-manifest.py" --require-triage \
     docs/superpowers/execution/<run-id>/manifest.yaml --mode pre-dispatch --repo-root <repo>

**`--require-triage` is passed explicitly here, every time, in every mode. This is the whole closure.** The flag ships default-off in the validator on purpose — a mode-scoped default creates a circular dependency, because turning it on for `--mode pre-dispatch` reds the e2e suite inside the very task that adds the flag, and the task that emits the block cannot reach the validator to flip it later. So the closure lives at the caller: `/v:dispatch` demands a `triage` block, and **that is the mechanism that stops a future run repeating 3.0's own bootstrap exemption.** Do not drop the flag to "get a run started".

The flag also carries the SCOPED+ rule: a manifest with `triage.flavor: scoped_plus` is rejected unless it declares a `type: review` job with `tier: deep` and `backend: claude`. That half is checkable here because the reviewer is *declared*; the cross-model half is evidence that does not exist yet, and step 9 checks it after the fact.

Pick the mode by manifest kind (CR5-1): a `fast_path` block ⇒ `--mode pre-dispatch`; a legacy plan-based manifest carries no such block and is validated mode-lessly, as before — a mode-less `fast_path` manifest is fail-closed rejected. Non-zero exit ⇒ fix the manifest and re-run.

3. **Run the partition reviewer** (Iron Rule #4: no execution without a verified Partition Map):

• Dispatch [`superpowers-v:partition-reviewer`](../agents/partition-reviewer.md) with the plan

**and** the manifest (it runs `compound-v-validate-manifest.py` as its deterministic backing gate, then verifies disjointness + invariants).

• `FAIL` → **STOP.** Surface the failure. Do not dispatch implementers.
• `PASS` → continue.

4. **Select the engine by PROBE, not by version.**

> ### Engine C is enabled again as of 3.0.2 — what was wrong, and what closed it > > 3.0.1 disabled it. A cross-model review had found three CRITICAL defects, every one firing on > first real use, in a path 3.0 had made the default **without ever executing it end to end**. > All three are fixed and each is now pinned by a test that was **observed red** against 3.0.1: > > 1. **A `direct` job's patch landed in the wrong repository.** `record` branched on whether the > agent-reported worktree was empty, and