---
name: bs-north
description: >
  Use when the user invokes /bs-north, or asks to brainstorm-then-build with the
  free north-mini-code model as the coding engine, or wants a plan executed by
  north-orchestrator instead of cursor-agent or Claude subagents. Triggers on
  "brainstorm and build with north", "plan then north-orchestrator", "cheap/free
  engine for this feature".
---

# Brainstorm + North Orchestrator

audience: AI coding agents first. Imperative, BLUF.

Same as `/brainstorm`, except implementation runs via **north-mini-code:free** (through the
Claude Code harness + ccr proxy) instead of Claude subagents — and the gate ladder is north-shaped.

## IRON LAW — active every turn, survives compaction

**Claude 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 north. north codes; Claude orchestrates and judges. The full
rule + its sole trivial-edit carve-out live in `north-orchestrator` — re-read it after any compaction.

## What this skill does

1. **Run the `brainstorm` skill in full — every step, every rule, unchanged.**
2. One override: at `brainstorm`'s terminal state, 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 `north-orchestrator`.

## The only difference from /brainstorm

| Step | brainstorm | bs-north (multi-wave) | bs-north (SW+opus) | bs-north (SW+sonnet) |
|------|-----------|----------------------|---------------------|---------------------|
| All steps up to plan | identical | identical | identical | identical |
| After plan completes | stop | `run-plan` Workflow | handoff + STOP | `north-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 — handoff branch

When `plan` finishes, plan is single-wave, and active model = opus:
1. **Invoke `handoff`** with focus "execute this plan with north-orchestrator on a sonnet session". `handoff` finalizes/creates `docs/plans/YYYY-MM-DD-<PLAN_SLUG>.jsonl` with full task list (every task `PENDING`) and **sets `meta.exec_mode = "north-orchestrator"`** so `run-plan` dispatches correctly. (If brainstorm already wrote JSONL, `handoff` reconciles it; never fork a second file.)
2. **STOP and tell user verbatim:**
   > "Planning complete on opus. Spec + plan + task JSONL written (slug: `<PLAN_SLUG>`). To execute: open a NEW session, run `/model sonnet`, then `/run-plan <PLAN_SLUG>`. Do not execute on opus."
3. **Do NOT auto-invoke `north-orchestrator`.**

## 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 north-orchestrator (free north-mini engine)."
2. Load and follow `north-orchestrator` from that point on.
3. No wait for confirmation — proceed immediately (same auto-proceed rule as brainstorm).

All gating/dispatch/routing owned by `north-orchestrator` — none lives here. That skill
owns: deterministic Gate 0, codex code-review gate every wave, process gate (`advisor()`),
task-class routing, north dispatch rig.

## Relation to /bs-cursor

Same brainstorm→plan→orchestrate shape as `bs-cursor`, with one swap: the engine is north (free)
under `north-orchestrator`, not cursor-agent under `cursor-orchestrator`.
