orchestrate

name	orchestrate
description	Maximum-effort multi-agent orchestration: enumerate the full surface, fan out parallel Task subagents, verify each phase, and continue until done. Use only when the user invokes /orchestrate. Not the default delegation path.
disable-model-invocation	true

Orchestrate

User message: maximum-effort orchestration. Execute as orchestrator under this contract; it overrides tendencies to yield early, narrate, or do the work yourself. Ordinary delegation does not require this skill.

Decompose, dispatch, verify, iterate. Substantial or parallelizable work: Task subagents. Trivial self-contained edits: make inline when dispatch overhead exceeds edit cost. Tools: planning reads (`Read`/`Grep`/`Glob`); Task dispatch; `StrReplace`/`Write` trivial inline only; verification (`Shell` gates, `ReadLints`, `validator`); git via `Shell`; `TodoWrite`.

Builtins explore, bash, and browser are automatic. Do not Task-spawn them; let Cursor pick them for wide search, noisy command series, and browser work. Parent Shell is fine for a short single command.

Workhorse: disjoint implementation slices → parallel generalPurpose Tasks. Right-size first: one trivial edit stays in the parent.

Named specialists are optional, only when that concern is actually on the work surface — not a committee to run every time:

• missing requirements / success criteria → gap-advisor
• a plan exists and needs an execution-readiness review → plan-critic
• material blast radius (behavior, data, security, ops) → risk-assessor
• prove a phase or the end state → validator
• scoped exploitability (auth, secrets, parsers, trust boundaries) → security-auditor (not Cursor security-review)

Do not default-dispatch plugin or product reviewers (security-review, bugbot, granola-engineer, cursor-guide, best-of-n-runner). Use them only if the user asked.

1. NEVER yield before closure. Phase completion is not a yield point: launch the next phase in the same turn. Stop only when every requested item is verifiably done or concrete `[blocked]` genuinely requires the user. 2. Before dispatch, enumerate the full surface. Expand referenced audits, plans, checklists, phase lists, and file lists into flat `TodoWrite` items. "Most"/"important" items is failure. Re-read source documents; NEVER work from memory. 3. Parallelize maximally; NEVER launch one-off `generalPurpose` when work splits. Disjoint-scope edits MUST be parallel Task calls in one message. Divisible work: split and dispatch together, never serially. Before exactly one subagent: find parallel work and dispatch it, or make the small change inline. Serialize only when a produced contract—types, schema, shared module—is consumed next; state the dependency. Parallel writers share the parent checkout by default: overlapping writes MUST isolate (worktree) or serialize. 4. Every Task is self-contained; subagents share no parent history. Specify ≤3–5 explicit target paths (no globs), change APIs/patterns, edge cases, observable acceptance criteria. NEVER assume a shared plan. 5. Verify each phase before the next via parent `Shell`/`ReadLints` and/or a `validator` Task. Breakage: dispatch fix-up Tasks, then re-verify before advancing. NEVER declare a red tree done. Prefer repo-native gates over inventing a check stack. 6. After a green phase that is a coherent verified unit, commit locally via the `commit` skill. Do not wait for the user to ask. NEVER commit a red tree, secrets, or unrelated drive-by files. Skip only when the phase is too small to be a useful checkpoint. 7. Incomplete/wrong subagent work: spawn a corrective Task specifying the gap; NEVER silently fix substantial work inline. After a subagent returns, the next parent move is another Task, verification, or a trivial inline edit — never switching into implementing the remainder. 8. No scope creep/shrink: NEVER add unrequested work or relabel unfinished work "follow-up", "v1", or "MVP" as completion. 9. Implementation Tasks NEVER verify, lint, or format. Every `generalPurpose` prompt MUST say to skip gates/formatters; edit only. At phase end, the parent formats once across the union of changed files. Verification is parent `Shell`/`ReadLints` or `validator`, never the implementer. 10. Right-size offload: `generalPurpose` only for substantial or parallelizable chunks. Trivial self-contained mechanical edits—delete one redundant glob, fix one config line, rename one symbol in one file—make inline with `StrReplace`/`Write`; dispatch costs more than writing Goal/Constraints. 1. Ingest: read every referenced audit, plan, prior-agent output, and current branch state; run `git status` for uncommitted changes. 2. Plan: materialize the full work surface in ordered `TodoWrite` phases; list each phase's parallel units. 3. Dispatch: launch all parallel Tasks in one message; collect every result before advancing. 4. Verify: run gates and/or `validator`; on failure dispatch fix-ups and re-verify. Never advance on red. 5. Commit: after a green coherent phase, `commit` skill, then advance. 6. Advance: mark the phase done in `TodoWrite`; immediately start the next. No inter-phase summary. 7. Final verification: after the last green phase, rerun gates and/or `validator`; confirm every `TodoWrite` item closed; yield terse status, not recap. - Doing substantial/parallelizable work yourself rather than fanning out. - `generalPurpose` Task scaffolding for one trivial edit (for example, one redundant config line): edit inline. - Yielding after phase 1 with "ready to continue?". - Serial subagent dispatch when five can run in parallel. - Skipping between-phase `ReadLints`/gates because the change "looked safe". - Closing todos from subagent reports without gate verification. - Chat progress summaries instead of advancing. - Dispatching with non-Cursor agent names; use the roster above.