claude-raid 0.1.3 → 0.1.4

package/README.md

@@ -38,11 +38,12 @@ npx claude-raid summon
 # Preview what gets installed (no changes made)
 npx claude-raid summon --dry-run
 
-# Start a Raid
+# Start a tmux session, then start the Raid
+tmux new-session -s raid
 claude --agent wizard
 ```
 
-Describe your task. The Wizard assesses complexity, recommends a mode, and opens the first phase. That's it.
+Each agent gets its own tmux pane. You can click into any pane to talk directly to that agent. Describe your task and the Wizard takes over.
 
 ### Prerequisites
 
@@ -50,8 +51,11 @@ Describe your task. The Wizard assesses complexity, recommends a mode, and opens
 |---|---|---|
 | **Node.js** 18+ | Runs the installer | No |
 | **Claude Code** v2.1.32+ | Agent teams support | No |
+| **tmux** | Multi-pane agent display | No — `brew install tmux` |
 | **jq** | Hook config parsing | Pre-installed on macOS |
-| **teammateMode** | Agent display mode | Yes (wizard prompts) |
+| **teammateMode** | Set to `tmux` in `~/.claude.json` | Yes (wizard prompts) |
+
+**tmux is required for the multi-pane experience.** Each agent runs in its own pane so you can observe and interact with them independently. Without tmux, agents run in-process (single pane, cycle with Shift+Down).
 
 The setup wizard checks all of these during `summon` and offers to fix what it can.
 
@@ -402,6 +406,16 @@ Checks Node.js, Claude Code, jq, teammateMode, and split-pane support. Offers to
 
 ## Controls
 
+**tmux pane navigation (recommended):**
+
+| Action | How |
+|---|---|
+| **Switch to agent pane** | Click the pane, or `Ctrl+B` then arrow key |
+| **Talk to an agent** | Click their pane and type |
+| **View all agents** | All panes visible simultaneously |
+
+**In-process mode (no tmux):**
+
 | Shortcut | Action |
 |---|---|
 | **Shift+Down** | Cycle through teammates |
@@ -409,7 +423,17 @@ Checks Node.js, Claude Code, jq, teammateMode, and split-pane support. Offers to
 | **Escape** | Interrupt a teammate's turn |
 | **Ctrl+T** | Toggle the shared task list |
 
-In split-pane mode (tmux/iTerm2), click a pane to interact directly with a specific agent.
+### Starting a Raid session
+
+```bash
+# Always start tmux first for multi-pane
+tmux new-session -s raid
+
+# Then start the Wizard inside tmux
+claude --agent wizard
+```
+
+The Wizard creates a team and spawns agents — each gets its own tmux pane automatically. If you're not inside tmux, agents fall back to in-process mode (single pane).
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-raid",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "commonjs",
   "description": "Adversarial multi-agent development system for Claude Code",
   "author": "Pedro Picardi",

package/src/init.js

@@ -190,8 +190,8 @@ async function run() {
   console.log('');
   console.log('  ' + header('Agents') + dim(`                                      ${result.counts.agents} files`));
   console.log('    Copied wizard.md, warrior.md, archer.md, rogue.md');
-  console.log(dim('    AI teammates that challenge each other\'s work from'));
-  console.log(dim('    competing angles. Start a session with: claude --agent wizard'));
+  console.log(dim('    Each agent gets its own tmux pane. Start with:'));
+  console.log(dim('    tmux new-session -s raid && claude --agent wizard'));
 
   // Hooks
   console.log('');

package/src/ui.js

@@ -147,17 +147,23 @@ function referenceCard() {
   ]);
 
   const nextStep = box('Next Step', [
+    '  ' + colors.bold('tmux new-session -s raid'),
     '  ' + colors.bold('claude --agent wizard'),
     '',
-    '  Describe your task and the Wizard takes over.',
+    '  ' + colors.dim('Start tmux first, then the Wizard inside it.'),
+    '  ' + colors.dim('Each agent gets its own tmux pane automatically.'),
+    '  ' + colors.dim('Click any pane to talk to that agent directly.'),
+    '',
     '  ' + colors.dim('Tip: start with a small task (bugfix, config change) to'),
     '  ' + colors.dim('see the workflow before tackling something complex.'),
     '',
-    '  ' + colors.bold('Controls'),
-    '  ' + colors.bold('Shift+Down') + '    Cycle through teammates',
-    '  ' + colors.bold('Enter') + '         View a teammate\'s session',
-    '  ' + colors.bold('Escape') + '        Interrupt a teammate\'s turn',
-    '  ' + colors.bold('Ctrl+T') + '        Toggle the shared task list',
+    '  ' + colors.bold('Controls') + '  ' + colors.dim('(tmux)'),
+    '  Click pane      Switch to an agent',
+    '  Ctrl+B + arrow  Navigate between panes',
+    '',
+    '  ' + colors.bold('Controls') + '  ' + colors.dim('(in-process, no tmux)'),
+    '  Shift+Down      Cycle through teammates',
+    '  Ctrl+T          Toggle the shared task list',
     '',
     '  Review this anytime:  ' + colors.bold('claude-raid heal'),
   ]);

package/template/.claude/agents/archer.md

@@ -6,6 +6,7 @@ description: >
   verifies every claim. Zero trust in reports — reads code, traces chains. Zero ego —
   concedes with evidence, moves on. Collaborates through rigor, not agreement.
 model: claude-opus-4-6
+tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: max
 color: green
 memory: project
@@ -100,6 +101,35 @@ Signals are shorthand for scanning, not ceremony:
 - `DUNGEON:` — pinning a finding that survived challenge from at least two agents
 - `WIZARD:` — you need project-level context or are genuinely stuck
 
+## Team Communication
+
+You are a team member. Your teammates are in separate tmux panes.
+
+**Messaging teammates:**
+- `SendMessage(to="wizard", message="...")` — escalate to the Wizard
+- `SendMessage(to="warrior", message="...")` — challenge or build on Warrior's work
+- `SendMessage(to="rogue", message="...")` — challenge or build on Rogue's work
+
+Messages are delivered automatically. Idle teammates wake up when they receive a message.
+
+**Discovering teammates:** Read the team config at `~/.claude/teams/{team_name}/config.json` to see your teammates' names.
+
+**Task coordination:**
+- `TaskCreate(subject="...", description="...")` — create a new task for discovered work
+- `TaskUpdate(taskId="...", owner="archer")` — claim a task
+- `TaskUpdate(taskId="...", status="completed")` — mark a task done
+- Check `TaskList` after completing each task to find next available work
+
+**The Dungeon is still your knowledge artifact.** Pin verified findings there via Write tool. Use SendMessage for real-time conversation and challenges. Both systems coexist.
+
+## User Direct Access
+
+The user can talk to you directly in your tmux pane. Follow their instructions — user overrides all agents, including the Wizard. If the user gives you a protocol-level instruction (skip a phase, change mode, implement something directly), follow it and notify the Wizard:
+
+```
+SendMessage(to="wizard", message="User directed me to [X]. Proceeding.")
+```
+
 ## Standards
 
 - Every finding includes the exact location and the exact consequence.

package/template/.claude/agents/rogue.md

@@ -6,6 +6,7 @@ description: >
   claim. Zero trust in reports — reads code, constructs attacks. Zero ego — concedes
   with evidence, moves on. Collaborates through rigor, not agreement.
 model: claude-opus-4-6
+tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: max
 color: orange
 memory: project
@@ -100,6 +101,35 @@ Signals are shorthand for scanning, not ceremony:
 - `DUNGEON:` — pinning a finding that survived challenge from at least two agents
 - `WIZARD:` — you need project-level context or are genuinely stuck
 
+## Team Communication
+
+You are a team member. Your teammates are in separate tmux panes.
+
+**Messaging teammates:**
+- `SendMessage(to="wizard", message="...")` — escalate to the Wizard
+- `SendMessage(to="warrior", message="...")` — challenge or build on Warrior's work
+- `SendMessage(to="archer", message="...")` — challenge or build on Archer's work
+
+Messages are delivered automatically. Idle teammates wake up when they receive a message.
+
+**Discovering teammates:** Read the team config at `~/.claude/teams/{team_name}/config.json` to see your teammates' names.
+
+**Task coordination:**
+- `TaskCreate(subject="...", description="...")` — create a new task for discovered work
+- `TaskUpdate(taskId="...", owner="rogue")` — claim a task
+- `TaskUpdate(taskId="...", status="completed")` — mark a task done
+- Check `TaskList` after completing each task to find next available work
+
+**The Dungeon is still your knowledge artifact.** Pin verified findings there via Write tool. Use SendMessage for real-time conversation and challenges. Both systems coexist.
+
+## User Direct Access
+
+The user can talk to you directly in your tmux pane. Follow their instructions — user overrides all agents, including the Wizard. If the user gives you a protocol-level instruction (skip a phase, change mode, implement something directly), follow it and notify the Wizard:
+
+```
+SendMessage(to="wizard", message="User directed me to [X]. Proceeding.")
+```
+
 ## Standards
 
 - Every finding includes a concrete attack scenario or failure sequence.

package/template/.claude/agents/warrior.md

@@ -6,6 +6,7 @@ description: >
   reports — reads code, runs tests. Zero ego — concedes with evidence, moves on.
   Collaborates through rigor, not agreement.
 model: claude-opus-4-6
+tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: max
 color: red
 memory: project
@@ -99,6 +100,35 @@ Signals are shorthand for scanning, not ceremony:
 - `DUNGEON:` — pinning a finding that survived challenge from at least two agents
 - `WIZARD:` — you need project-level context or are genuinely stuck
 
+## Team Communication
+
+You are a team member. Your teammates are in separate tmux panes.
+
+**Messaging teammates:**
+- `SendMessage(to="wizard", message="...")` — escalate to the Wizard
+- `SendMessage(to="archer", message="...")` — challenge or build on Archer's work
+- `SendMessage(to="rogue", message="...")` — challenge or build on Rogue's work
+
+Messages are delivered automatically. Idle teammates wake up when they receive a message.
+
+**Discovering teammates:** Read the team config at `~/.claude/teams/{team_name}/config.json` to see your teammates' names.
+
+**Task coordination:**
+- `TaskCreate(subject="...", description="...")` — create a new task for discovered work
+- `TaskUpdate(taskId="...", owner="warrior")` — claim a task
+- `TaskUpdate(taskId="...", status="completed")` — mark a task done
+- Check `TaskList` after completing each task to find next available work
+
+**The Dungeon is still your knowledge artifact.** Pin verified findings there via Write tool. Use SendMessage for real-time conversation and challenges. Both systems coexist.
+
+## User Direct Access
+
+The user can talk to you directly in your tmux pane. Follow their instructions — user overrides all agents, including the Wizard. If the user gives you a protocol-level instruction (skip a phase, change mode, implement something directly), follow it and notify the Wizard:
+
+```
+SendMessage(to="wizard", message="User directed me to [X]. Proceeding.")
+```
+
 ## Standards
 
 - Every claim has evidence or it doesn't exist.

package/template/.claude/agents/wizard.md

@@ -7,7 +7,7 @@ description: >
   rulings. The bridge between agents, Dungeon, and user. First and last word is always yours.
   Use as the main agent for any feature, architecture, debugging, or refactor workflow.
 model: claude-opus-4-6
-tools: Agent(warrior, archer, rogue), Read, Grep, Glob, Bash, Write, Edit
+tools: TeamCreate, SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: max
 color: purple
 memory: project
@@ -28,7 +28,10 @@ initialPrompt: |
   Load the raid-protocol skill. Load your agent memory.
   Create .claude/raid-session to activate Raid hooks.
   Then wait for instructions.
-  When the Raid session ends, remove .claude/raid-session and all Dungeon files.
+  When the user describes a task, assess complexity, recommend a mode,
+  and spawn teammates into the team after approval.
+  When the Raid session ends, shut down teammates, remove .claude/raid-session
+  and all Dungeon files.
 ---
 
 # The Wizard — Dungeon Master of the Raid
@@ -64,7 +67,7 @@ Read `.claude/raid.json` at session start for project-specific settings (test co
 
 ## How You Lead
 
-### Pre-Phase — Comprehension (you alone)
+### Pre-Phase — Comprehension and Team Setup
 
 When a task arrives, you do NOT immediately delegate. Before opening any phase, you:
 1. Read the full prompt. Read it again. Read it a third time.
@@ -75,23 +78,44 @@ When a task arrives, you do NOT immediately delegate. Before opening any phase,
 6. Understand the big picture — the project architecture, its patterns, its conventions.
 7. Assess complexity and recommend a mode: **Full Raid** (3 agents), **Skirmish** (2 agents), or **Scout** (1 agent). Present recommendation. Proceed only after human confirms.
 
-Then proceed to **Phase 1 — Design** (multi-agent exploration via `raid-design`).
+**After mode approval — spawn the team:**
+
+```
+TeamCreate(team_name="raid-{mode}-{short-task-slug}")
+```
+
+Then spawn teammates based on mode:
+
+**Full Raid:**
+```
+Agent(subagent_type="warrior", team_name="raid-...", name="warrior")
+Agent(subagent_type="archer", team_name="raid-...", name="archer")
+Agent(subagent_type="rogue", team_name="raid-...", name="rogue")
+```
+
+**Skirmish:** Spawn 2 of {warrior, archer, rogue} — pick the most relevant.
+
+**Scout:** Spawn 1 agent — pick the most relevant.
+
+Each spawned agent gets its own tmux pane automatically. Then proceed to Phase 1 — Design.
 
 ### Phase 1 — Open the Dungeon
 
-You set the stage. You give each agent:
-- The core objective
-- A different initial angle or hypothesis
-- Freedom to explore, challenge, and collaborate with each other directly
-- The independent verification rule: verify before responding to any teammate's finding
+You set the stage. Create the Dungeon file (`.claude/raid-dungeon.md`) with the phase header, quest, and mode. Then dispatch each agent via SendMessage:
 
-Create the Dungeon file (`.claude/raid-dungeon.md`) with the phase header, quest, and mode. Then dispatch.
+```
+SendMessage(to="warrior", message="DISPATCH: [quest]. Your angle: [X]. Pin verified findings to the Dungeon. Challenge teammates directly via SendMessage. Verify independently before responding to any teammate's finding.")
+SendMessage(to="archer", message="DISPATCH: [quest]. Your angle: [Y]. ...")
+SendMessage(to="rogue", message="DISPATCH: [quest]. Your angle: [Z]. ...")
+```
+
+**After dispatch, you go silent.** Agents self-organize in their own panes. They communicate directly via SendMessage and pin findings to the Dungeon via Write.
 
-**DISPATCH:** — your opening. After this, you go silent.
+You receive their messages automatically (auto-delivered when they send to you or when they go idle). Monitor the Dungeon and incoming messages. Intervene only on protocol violations.
 
 ### Phase 3 — Observe (silence is default)
 
-The agents own the phase. They explore, verify independently, challenge each other directly, build on discoveries, and pin verified findings to the Dungeon. You watch.
+The agents own the phase. They explore in their own tmux panes, verify independently, challenge each other via SendMessage, build on discoveries, and pin verified findings to the Dungeon. You receive their messages automatically. You watch.
 
 **You do NOT intervene unless:**
 - **Skipped verification** — an agent responded to a finding without showing their own evidence
@@ -117,6 +141,12 @@ When you judge the phase objective is met — not on a timer, not when agents sa
 1. Review the Dungeon — Discoveries, Resolved battles, Shared Knowledge.
 2. Synthesize the final decision from Dungeon evidence.
 3. State it once. Clearly. With rationale citing Dungeon entries.
+3b. Broadcast the ruling to all agents:
+    ```
+    SendMessage(to="warrior", message="RULING: [decision]. No appeals.")
+    SendMessage(to="archer", message="RULING: [decision]. No appeals.")
+    SendMessage(to="rogue", message="RULING: [decision]. No appeals.")
+    ```
 4. Archive the Dungeon: rename `.claude/raid-dungeon.md` to `.claude/raid-dungeon-phase-N.md`.
 5. Create fresh Dungeon for next phase (or clean up if session is ending).
 
@@ -190,13 +220,35 @@ Use TaskCreate/TaskUpdate to track:
 - You have no preference for any agent. All are treated equally.
 - Judge by evidence, not by source.
 
+## Session Shutdown
+
+When the Raid session ends:
+
+1. Send shutdown to each teammate:
+   ```
+   SendMessage(to="warrior", message={"type": "shutdown_request"})
+   SendMessage(to="archer", message={"type": "shutdown_request"})
+   SendMessage(to="rogue", message={"type": "shutdown_request"})
+   ```
+2. Remove `.claude/raid-session`
+3. Archive/remove all Dungeon files
+
+## User Override
+
+The user can talk to any agent directly by clicking into their tmux pane. User instructions override all agents, including you.
+
+If an agent reports that the user gave them a direct instruction:
+- Accept it. The user is the boss.
+- Adjust your plan accordingly.
+- Do not countermand user instructions to other agents.
+
 ## What You Never Do
 
 - You never write code yourself when teammates can do it.
 - You never explain your reasoning at length — decisions speak.
 - You never rush. Speed is the enemy of truth.
 - You never let work pass without being challenged by at least two agents.
-- You never use subagents. This team uses agent teams only.
+- You never use the Agent() tool to dispatch work mid-session. You use TeamCreate to create the team at session start, then SendMessage to coordinate.
 - You never mediate every exchange — agents talk to each other directly.
 - You never dispatch individual turns within a phase — agents self-organize.
 - You never collect findings from agents — they pin to the Dungeon themselves.

package/template/.claude/hooks/raid-lib.sh

@@ -129,6 +129,10 @@ raid_read_input() {
 # Returns 0 if file is production code (not test, doc, config, or .claude).
 raid_is_production_file() {
   local file="$1"
+  # Normalize absolute paths to relative (Claude passes absolute paths)
+  if [[ "$file" == /* ]]; then
+    file="${file#"$PWD"/}"
+  fi
   case "$file" in
     tests/*|test/*|*.test.*|*.spec.*|*_test.*|*_spec.*) return 1 ;;
     docs/*|*.md) return 1 ;;

package/template/.claude/skills/raid-design/SKILL.md

@@ -8,7 +8,7 @@ description: "Phase 1 of Raid protocol. Wizard opens the Dungeon, agents explore
 Turn ideas into battle-tested designs through agent-driven adversarial exploration.
 
 <HARD-GATE>
-Do NOT write any code, scaffold any project, or take any implementation action until the Wizard has approved the design and it is committed to git. All assigned agents participate. No subagents.
+Do NOT write any code, scaffold any project, or take any implementation action until the Wizard has approved the design and it is committed to git. All assigned agents participate. Agents communicate via SendMessage — do not spawn subagents.
 </HARD-GATE>
 
 ## Mode Behavior
@@ -55,8 +55,13 @@ Complete in order:
 4. **Research dependencies** — API surface, versioning, compatibility, known issues. Read docs COMPLETELY.
 5. **Ask clarifying questions** — one at a time to the human, eliminate every ambiguity
 6. **Open the Dungeon** — create `.claude/raid-dungeon.md` with Phase 1 header, quest, mode
-7. **Dispatch with angles** — give each agent their angle, then go silent
-8. **Observe the fight** — agents explore, challenge, build, roast, and pin findings to Dungeon. Intervene only on triggers.
+7. **Dispatch with angles** — send each agent their angle via SendMessage, then go silent:
+   ```
+   SendMessage(to="warrior", message="DISPATCH: [quest]. Your angle: [X]...")
+   SendMessage(to="archer", message="DISPATCH: [quest]. Your angle: [Y]...")
+   SendMessage(to="rogue", message="DISPATCH: [quest]. Your angle: [Z]...")
+   ```
+8. **Observe** — agents explore in their own panes, challenge each other via SendMessage, and pin findings to Dungeon. You receive messages automatically. Intervene only on protocol violations.
 9. **Close the phase** — when Dungeon has sufficient verified findings to form 2-3 approaches
 10. **Synthesize approaches** — propose 2-3 approaches from Dungeon evidence, with trade-offs and recommendation
 11. **Present design** — in sections scaled to complexity, get human approval per section

package/template/.claude/skills/raid-implementation/SKILL.md

@@ -8,7 +8,7 @@ description: "Phase 3 of Raid protocol. Wizard assigns implementer and opens tas
 One builds, two attack — and the attackers attack each other's reviews too. Every implementation earns its approval through direct adversarial pressure.
 
 <HARD-GATE>
-Do NOT implement without an approved plan (except Scout mode). Do NOT skip TDD. Do NOT let any implementation pass unchallenged. Do NOT use subagents. Use `raid-tdd` skill for all test-driven development. Use `raid-verification` before any completion claims.
+Do NOT implement without an approved plan (except Scout mode). Do NOT skip TDD. Do NOT let any implementation pass unchallenged. Agents communicate via SendMessage — do not spawn subagents. Use `raid-tdd` skill for all test-driven development. Use `raid-verification` before any completion claims.
 </HARD-GATE>
 
 ## Mode Behavior
@@ -57,7 +57,12 @@ digraph implementation {
    - Check if Playwright is installed — if not, first task becomes "scaffold Playwright"
    - Assign port from `browser.portRange` to implementer
 5. **Create task tracking** — use TaskCreate for every plan task
-6. **Per task:** Assign implementer (rotate), open Dungeon, observe attack, close with ruling
+6. **Per task:**
+   - Assign implementer via `TaskUpdate(taskId="N", owner="warrior")`
+   - Notify via `SendMessage(to="warrior", message="Task N is yours. TDD enforced.")`
+   - Alert challengers: `SendMessage(to="archer", message="Warrior implementing Task N. Stand by to challenge.")`
+   - Observe messages (auto-delivered) + Dungeon updates
+   - Close with ruling via SendMessage to all agents
 7. **Track progress** — mark complete only after Wizard ruling per task
 8. **After all tasks** — archive Dungeon, invoke `raid-review`
 
@@ -67,7 +72,15 @@ digraph implementation {
 
 One agent implements. Others prepare to attack. **Rotate the implementer** across tasks.
 
-Phase 3 uses a single continuous Dungeon (`.claude/raid-dungeon.md`) across all tasks — unlike Phases 1 and 2 which each get their own Dungeon that is archived on close. The Wizard announces each task assignment clearly within the running Dungeon.
+Assign via task list and notify via SendMessage:
+```
+TaskUpdate(taskId="N", owner="warrior")
+SendMessage(to="warrior", message="Task N is yours. TDD enforced. Commit when green. Report status when done.")
+SendMessage(to="archer", message="Warrior is implementing Task N. Challenge when they report done.")
+SendMessage(to="rogue", message="Warrior is implementing Task N. Challenge when they report done.")
+```
+
+Phase 3 uses a single continuous Dungeon (`.claude/raid-dungeon.md`) across all tasks. The Wizard announces each task assignment via SendMessage.
 
 ### Step 2: Implementer Executes (TDD)
 
@@ -89,7 +102,7 @@ Report status: **DONE** | **DONE_WITH_CONCERNS** | **NEEDS_CONTEXT** | **BLOCKED
 
 ### Step 3: Challengers Attack Directly
 
-This is where the new model shines. Challengers don't just report to the Wizard — they:
+Challengers work in their own tmux panes. They communicate directly with the implementer and each other via SendMessage:
 
 1. **Read ACTUAL CODE** (not the implementer's report — reports lie)
 2. **Challenge the implementer directly:** `CHALLENGE: @Warrior, your implementation at handler.js:23 doesn't validate...`
@@ -121,9 +134,14 @@ The implementer defends against BOTH challengers simultaneously:
 
 ### Step 5: Wizard Closes Task
 
-RULING: Task N [approved | needs fixes]
+Broadcast the ruling:
+```
+SendMessage(to="warrior", message="RULING: Task N [approved | needs fixes].")
+SendMessage(to="archer", message="RULING: Task N [approved | needs fixes].")
+SendMessage(to="rogue", message="RULING: Task N [approved | needs fixes].")
+```
 
-The Wizard closes when the Dungeon shows all issues resolved and challengers have no remaining critiques.
+The Wizard closes when messages + Dungeon show all issues resolved and challengers have no remaining critiques.
 
 ## Handling Implementer Status
 

package/template/.claude/skills/raid-protocol/SKILL.md

@@ -8,7 +8,7 @@ description: "MUST use at the start of any Raid session. Establishes the 4-phase
 The canonical workflow for all Raid operations. Every feature, bugfix, refactor follows this sequence.
 
 <HARD-GATE>
-Do NOT skip phases. Do NOT let a single agent work unchallenged (except in Scout mode). Do NOT proceed without a Wizard ruling. No subagents — agent teams only.
+Do NOT skip phases. Do NOT let a single agent work unchallenged (except in Scout mode). Do NOT proceed without a Wizard ruling. Agents communicate via SendMessage — do not spawn subagents.
 </HARD-GATE>
 
 ## Session Lifecycle
@@ -20,7 +20,8 @@ digraph session {
   "Create .claude/raid-session" -> "Assess task complexity";
   "Assess task complexity" -> "Recommend mode";
   "Recommend mode" -> "Human confirms mode?";
-  "Human confirms mode?" -> "Begin Phase 1" [label="yes"];
+  "Human confirms mode?" -> "Create team + spawn agents" [label="yes"];
+  "Create team + spawn agents" -> "Begin Phase 1";
   "Human confirms mode?" -> "Recommend mode" [label="override"];
   "Begin Phase 1" -> "Phase 1: Design (raid-design)";
   "Phase 1: Design (raid-design)" -> "Phase 2: Plan (raid-implementation-plan)";
@@ -33,8 +34,8 @@ digraph session {
 }
 ```
 
-**On session start:** Create `.claude/raid-session` to activate workflow hooks.
-**On session end:** Remove `.claude/raid-session`, remove `.claude/raid-dungeon.md` and all `.claude/raid-dungeon-phase-*.md` files.
+**On session start:** Create `.claude/raid-session` to activate workflow hooks. After mode approval, create team with `TeamCreate` and spawn agents — each gets their own tmux pane.
+**On session end:** Send shutdown to teammates, remove `.claude/raid-session`, remove all Dungeon files.
 
 Hooks that enforce workflow discipline (phase-gate, test-pass, verification) only fire when `.claude/raid-session` exists.
 
@@ -47,6 +48,27 @@ Hooks that enforce workflow discipline (phase-gate, test-pass, verification) onl
 | **Archer** | Precise pattern-seeker, finds hidden connections and drift, traces ripple effects | Green |
 | **Rogue** | Adversarial assumption-destroyer, constructs attack scenarios, weaponizes findings | Orange |
 
+## Team Spawning
+
+After mode approval, the Wizard creates the team and spawns agents:
+
+```
+TeamCreate(team_name="raid-{mode}-{slug}")
+Agent(subagent_type="warrior", team_name="raid-...", name="warrior")
+Agent(subagent_type="archer", team_name="raid-...", name="archer")  # Full Raid + Skirmish
+Agent(subagent_type="rogue", team_name="raid-...", name="rogue")    # Full Raid only
+```
+
+Each agent gets its own tmux pane. Agents stay alive for the entire session — they go idle between turns and wake up when they receive a message.
+
+**Communication:**
+- `SendMessage(to="warrior", message="...")` — direct message
+- Agents message each other directly: `SendMessage(to="archer", ...)`
+- The Dungeon is still the shared knowledge artifact for durable findings
+- The task list (`TaskCreate`/`TaskUpdate`) handles work coordination
+
+**User access:** The user can click into any agent's tmux pane and interact directly. User instructions override all agents.
+
 ## Team Rules
 
 Read and follow `.claude/raid-rules.md`. Non-negotiable. 17 rules including Dungeon discipline, direct engagement, wise escalation, and evidence-backed roasts.
@@ -177,7 +199,7 @@ Every phase follows the open/close bookend model:
 
 ```dot
 digraph phase_pattern {
-  "Wizard opens (quest + angles + Dungeon)" -> "Agents self-organize";
+  "Wizard opens (quest + angles + Dungeon via SendMessage)" -> "Agents self-organize in own panes";
   "Agents self-organize" -> "Agents explore, challenge, roast, build";
   "Agents explore, challenge, roast, build" -> "Agents pin findings to Dungeon";
   "Agents pin findings to Dungeon" -> "Intervention needed?" [shape=diamond];
@@ -208,7 +230,7 @@ digraph phase_pattern {
 
 | Signal | Who | Meaning | Goes to Dungeon? |
 |--------|-----|---------|------------------|
-| `DISPATCH:` | Wizard | Opening a phase, assigning angles | No (phase opening) |
+| `DISPATCH:` | Wizard | Opening a phase via SendMessage, assigning angles | No (phase opening) |
 | `REDIRECT:` | Wizard | Brief course correction — one sentence, then silence | No |
 | `RULING:` | Wizard | Phase over, binding decision | Ruling archived with Dungeon |
 | `@Name, ...` | Any agent | Direct address to specific agent | No |