---
name: bs-multi
description: >
  Use when the user invokes /bs-multi, or asks to brainstorm-then-build at lowest cost
  without compromising quality. Brainstorm → design → plan (contract-level) →
  multi-orchestrator. Same as /brainstorm but implementation runs via the cost-optimal
  risk-routed engine (sonnet orchestrator, cursor/composer implementer, opus only on
  money/auth/cross-file diffs) instead of plain Claude subagents, cursor-only, or
  north-only. Triggers on "brainstorm and build cheap-but-safe", "plan then
  multi-orchestrator", "risk-routed build".
---

# Brainstorm + Multi Orchestrator

audience: AI coding agents first. Imperative, BLUF.

Same as `/brainstorm`, except implementation runs via **multi-orchestrator** — the cost-optimal merge (sonnet coordinates, cursor/composer implements, a deterministic router sends only money/auth/cross-file diffs to opus, advisor gates composed-topology) instead of Claude subagents.

## IRON LAW — active every turn, survives compaction

**The orchestrator never writes implementation code. Not one line.** Applies after compaction, long gaps, any context event. About to write code, edit a file, run a build to "verify"? Stop. Dispatch the implementer. The full rule + its LOC≤LOP carve-out live in `cursor-orchestrator`; the cost-routed gate ladder lives in `multi-orchestrator` — re-read both after any compaction.

## What this skill does

1. **Run the `brainstorm` skill in full — every step, every rule, unchanged.** This is the opus-worthy work: spec + contract/seam authoring is the irreducible judgment.
2. After `plan` completes, **branch on plan shape FIRST, then model**:
   - **Multi-wave/multi-phase** (>1 wave/phase OR any wave has parallel tasks) → invoke `Skill("run-plan")` with the slug directly. Workflow is model-independent and runs in background — no handoff needed. Applies on both opus and sonnet.
   - **Single-wave + opus** → plan-only handoff. Finalize task JSONL, invoke `handoff`, STOP.
   - **Single-wave + sonnet / non-opus** → auto-invoke `multi-orchestrator`.

`plan` already emits **contract-level** tasks (bodies written by the implementer, not baked into the plan) — no override needed there.

## The only difference from /brainstorm

| Step | brainstorm | bs-multi (multi-wave) | bs-multi (SW+opus) | bs-multi (SW+sonnet) |
|------|-----------|----------------------|---------------------|---------------------|
| All steps up to plan | identical | identical | identical | identical |
| After plan completes | stop | `run-plan` Workflow | handoff + STOP | `multi-orchestrator` inline |

## Multi-wave → run-plan (any model)

When `plan` finishes and the plan is multi-wave/multi-phase:
1. Invoke `Skill("run-plan")` with the slug directly. The Workflow controller is model-independent — no handoff needed regardless of active model.
2. Tell the user: "Multi-wave plan detected. Launching run-plan Workflow in background — watch with `/workflows`."

## Single-wave + opus — the handoff branch

**Why:** opus is the right seat to AUTHOR the spec + contract/seam (irreducible judgment); it is the WRONG seat to COORDINATE inline execution (mechanical — the single biggest cost driver). So for single-wave plans on opus, offer handoff; **NEVER start inline orchestration on opus.**

When `plan` finishes, plan is single-wave, and active model = opus:
1. **Invoke `handoff`** with focus "execute this contract-level plan with multi-orchestrator on a sonnet session". `handoff` owns the session-state JSONL: it finalizes/creates `docs/plans/YYYY-MM-DD-<PLAN_SLUG>.jsonl` with the FULL contract-level task list (every task `PENDING`) and **sets `meta.exec_mode = "multi-orchestrator"`** so `run-plan` dispatches to the right executor — plus the OS-temp prose doc that points to the plan + spec. (If brainstorm already wrote the JSONL, `handoff` reconciles it; never fork a second file.)
2. **STOP and tell the user verbatim:**
   > "Planning complete on opus. Spec + contract-level plan + task JSONL written (slug: `<PLAN_SLUG>`). To execute cheaply: open a NEW session, run `/model sonnet`, then `/run-plan <PLAN_SLUG>` — it loads the plan and runs multi-orchestrator. Do not execute on opus."
3. **Do NOT auto-invoke `multi-orchestrator`.** The opus session ends at planning. (If the user explicitly wants to execute inline anyway, they switch to sonnet and run `/run-plan <slug>` themselves.)

## Single-wave + sonnet — start orchestration

When `plan` finishes, plan is single-wave, and active model = sonnet (or non-opus):
1. Tell the user: "Plan ready. Executing with multi-orchestrator (sonnet coordinator, cursor implementer, opus only on high-risk diffs)."
2. Load and follow `multi-orchestrator` from that point on.
3. No wait for confirmation — proceed immediately (same auto-proceed rule as brainstorm).

All gating/dispatch/routing is owned by `multi-orchestrator`: deterministic Gate 0, the `risk-router.sh` decision, the risk-routed single reviewer (opus on HIGH / composer-x1 on LOW), the `advisor()` process gate, implementer routing, cache discipline, and the quality floor.

## Relation to /bs-cursor and /bs-north

Same brainstorm→plan→orchestrate shape, with a smarter engine: `bs-cursor` reviews EVERY diff with opus (over-spends); `bs-north` puts a free-but-weak coder on the critical path (under-delivers). `bs-multi` keeps cursor on the critical path and spends opus ONLY on the risk-routed minority — the lowest cost that holds the quality floor.
