claude-raid 0.2.6 → 0.2.7

package/README.md

@@ -1,34 +1,16 @@
 <div align="center">
 
-```
-   ⚔ ══════════════════════════════════════════════════════════ ⚔
-
-       ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
-      ██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
-      ██║     ██║     ███████║██║   ██║██║  ██║█████╗
-      ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
-      ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
-       ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
-               ██████╗  █████╗ ██╗██████╗
-               ██╔══██╗██╔══██╗██║██╔══██╗
-               ██████╔╝███████║██║██║  ██║
-               ██╔══██╗██╔══██║██║██║  ██║
-               ██║  ██║██║  ██║██║██████╔╝
-               ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝╚═════╝
-
-      Round-based Adversarial Intelligence Dungeon
-                   for Claude Code
-
-   ⚔ ══════════════════════════════════════════════════════════ ⚔
-```
+<img src="assets/banner.png" alt="Claude Raid — Round-based Adversarial Intelligence Dungeon for Claude Code" width="700" />
 
-**Four AI agents. One shared dungeon. Every decision stress-tested before it ships.**
+<br />
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)](#)
 [![Node.js 18+](https://img.shields.io/badge/node-18%2B-blue.svg)](#prerequisites)
 [![294 Tests](https://img.shields.io/badge/tests-294_passing-brightgreen.svg)](#)
 
+> **Beta** — This project is in active development. Multi-agent sessions are **token-usage intensive** — a full Canonical Quest consumes significantly more tokens than a single-agent workflow. Monitor your usage and start with small tasks to calibrate.
+
 [Quick Start](#quick-start) · [The Canonical Quest](#the-canonical-quest) · [The Party](#the-party) · [The Dungeon](#the-dungeon) · [Configuration](#configuration) · [CLI Reference](#cli-reference)
 
 </div>
@@ -48,21 +30,22 @@ One command installs the system. One command starts a quest.
 ## Quick Start
 
 ```bash
+# Install the Raid into your project
 npx claude-raid summon
+
+# Start a quest
+claude-raid start
 ```
 
-That's it. One command installs agents, hooks, skills, and config into your project's `.claude/` directory.
+`summon` installs agents, hooks, skills, and config into your project's `.claude/` directory.
+
+`start` opens a tmux session with mouse support and launches the Wizard — one command does it all. The Wizard greets you, you describe your task, and the quest begins.
 
 ```bash
 # Preview what gets installed (no changes)
 npx claude-raid summon --dry-run
-
-# Start a quest
-claude-raid start
 ```
 
-The Wizard greets you, you describe your task, and the quest begins.
-
 ### Prerequisites
 
 | Requirement | Why |
@@ -72,7 +55,7 @@ The Wizard greets you, you describe your task, and the quest begins.
 | **tmux** | Multi-pane agent display (`brew install tmux`) |
 | **jq** | Config parsing (pre-installed on macOS) |
 
-> **tmux** gives each agent its own pane — click into any pane to observe or talk to that agent directly. Without tmux, agents run in-process and you cycle between them with `Shift+Down`.
+> **tmux** gives each agent its own pane — `claude-raid start` handles the tmux session automatically. Click into any pane to observe or talk to that agent directly.
 
 The setup wizard checks all prerequisites during `summon` and offers to fix what it can.
 
@@ -219,7 +202,9 @@ The Dungeon is the team's shared knowledge artifact — a curated board where ag
 ├── phase-3-plan-task-01.md            # Individual task specs
 ├── phase-4-implementation.md          # Implementation log
 ├── phase-5-review.md                  # Review board (optional)
-└── phase-6-wrap-up.md                 # Quest storyboard
+├── phase-6-wrap-up.md                 # Quest storyboard
+├── teambuff-01.md                     # Team retrospective reports (on-demand)
+└── teambuff-rulings.md                # Active rulings from teambuffs
 
 .claude/vault/{quest-slug}/            # Archived completed quests
 .claude/raid-session                   # Active session state
@@ -273,7 +258,8 @@ The Dungeon is the team's shared knowledge artifact — a curated board where ag
     ├── raid-verification/           # Evidence-before-claims gate
     ├── raid-debugging/              # Root-cause investigation
     ├── raid-browser/                # Browser orchestration
-    └── raid-browser-chrome/         # Live Chrome inspection
+    ├── raid-browser-chrome/         # Live Chrome inspection
+    └── raid-teambuff/               # Emergency team retrospective
 ```
 
 </details>
@@ -292,9 +278,9 @@ Hooks enforce workflow discipline automatically and **only activate during Raid
 
 All hooks are POSIX-compatible and use `#claude-raid` markers to coexist safely with your existing hooks.
 
-### Skills (13)
+### Skills (14)
 
-Skills guide agent behavior across the workflow. Three categories:
+Skills guide agent behavior across the workflow. Four categories:
 
 | Category | Skills | Purpose |
 |:--|:--|:--|
@@ -302,6 +288,7 @@ Skills guide agent behavior across the workflow. Three categories:
 | **Canonical Quest** | 7 phase skills | One skill per phase, chained in order |
 | **Discipline** | `raid-tdd`, `raid-verification`, `raid-debugging` | Quest-agnostic enforcement — invoked within any phase |
 | **Browser** | `raid-browser`, `raid-browser-chrome` | Browser orchestration and live inspection |
+| **Team** | `raid-teambuff` | Emergency team retrospective — freezes quest, all agents reflect on dysfunction, produces binding rulings |
 
 ---
 
@@ -406,7 +393,9 @@ This enables browser-specific hooks and skills — Playwright test detection, br
 
 ### `start`
 
-Launches `claude --agent wizard` with full permissions. The Wizard loads its rules, greets you, and begins quest selection. This is the primary entry point for running a quest.
+One command does it all — opens a tmux session with mouse support and launches the Wizard with full permissions. If you're already inside tmux, it enables mouse mode and launches the Wizard directly. If tmux isn't installed, it falls back to launching the Wizard without it.
+
+This is the primary entry point for running a quest.
 
 ### `summon`
 
@@ -438,22 +427,14 @@ Pulls latest from remote and re-runs summon to pick up any template changes. Use
 
 ## Controls
 
-**tmux pane navigation (recommended):**
+`claude-raid start` opens tmux with mouse mode enabled. All panes are visible simultaneously.
 
 | Action | How |
 |:--|:--|
-| Switch to agent pane | Click the pane, or `Ctrl+B` then arrow key |
+| Switch to agent pane | Click the pane |
+| Navigate between panes | `Ctrl+B` then arrow key |
+| Scroll output | Mouse wheel |
 | 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 |
-| `Enter` | View a teammate's session |
-| `Escape` | Interrupt a teammate's turn |
-| `Ctrl+T` | Toggle the shared task list |
 
 ---
 

package/bin/cli.js

@@ -10,16 +10,47 @@ const versionCheck = require('../src/version-check');
 const showUpdateNotice = versionCheck.start();
 
 const COMMANDS = {
-  // Start a Raid quest — launches wizard with full permissions
+  // Start a Raid quest — launches tmux + wizard in one shot
   start: () => {
-    const { spawn } = require('child_process');
+    const { spawn, execSync } = require('child_process');
     console.log('\n' + banner());
-    console.log(header('Summoning the Wizard...') + '\n');
-    const child = spawn('claude', ['--dangerously-skip-permissions', '--agent', 'wizard'], {
-      stdio: 'inherit',
-      env: process.env,
-    });
-    child.on('exit', (code) => process.exit(code || 0));
+
+    // Check if already inside a tmux session
+    if (process.env.TMUX) {
+      console.log(header('Already in tmux — launching Wizard...') + '\n');
+      try { execSync('tmux set -g mouse on', { stdio: 'ignore' }); } catch {}
+      const child = spawn('claude', ['--dangerously-skip-permissions', '--agent', 'wizard'], {
+        stdio: 'inherit',
+        env: process.env,
+      });
+      child.on('exit', (code) => process.exit(code || 0));
+      return;
+    }
+
+    // Check if tmux is available
+    let hasTmux = false;
+    try { execSync('command -v tmux', { stdio: 'pipe' }); hasTmux = true; } catch {}
+
+    if (hasTmux) {
+      console.log(header('Opening tmux session + Wizard...') + '\n');
+      const child = spawn('tmux', [
+        'new-session', '-s', 'raid', ';',
+        'set', '-g', 'mouse', 'on', ';',
+        'send-keys', 'claude --dangerously-skip-permissions --agent wizard', 'Enter',
+      ], {
+        stdio: 'inherit',
+        env: process.env,
+      });
+      child.on('exit', (code) => process.exit(code || 0));
+    } else {
+      console.log(colors.dim('  tmux not found — launching Wizard directly.'));
+      console.log(colors.dim('  Install tmux for multi-pane agent display: brew install tmux') + '\n');
+      const child = spawn('claude', ['--dangerously-skip-permissions', '--agent', 'wizard'], {
+        stdio: 'inherit',
+        env: process.env,
+      });
+      child.on('exit', (code) => process.exit(code || 0));
+    }
   },
   // Sync local with remote after CI version bump
   sync: async () => {
@@ -64,7 +95,7 @@ if (!command || !COMMANDS[command]) {
   console.log('\n' + banner());
   console.log(header('Commands') + '\n');
   const cmds = [
-    ['start',     'Begin the Raid (launches Wizard)'],
+    ['start',     'Begin the Raid (tmux + Wizard in one shot)'],
     ['summon',    'Summon the party into this realm'],
     ['update',    'Reforge the party\'s arsenal'],
     ['dismantle', 'Dismantle the camp and retreat'],
@@ -76,6 +107,9 @@ if (!command || !COMMANDS[command]) {
   }
   console.log(header('Begin the Raid') + '\n');
   console.log('    claude-raid start\n');
+  console.log(colors.amber('  Beta') + colors.dim(' — This project is in active development and can be'));
+  console.log(colors.dim('  token-usage intensive. Multi-agent sessions consume significantly'));
+  console.log(colors.dim('  more tokens than single-agent workflows. Use with caution.') + '\n');
   console.log(colors.dim('  github.com/pedropicardi/claude-raid') + '\n');
   process.exit(command ? 1 : 0);
 }

package/package.json

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

package/src/descriptions.js

@@ -46,6 +46,7 @@ const SKILLS = {
   'raid-debugging':                       'Root-cause investigation',
   'raid-browser':                         'Browser startup discovery',
   'raid-browser-chrome':                  'Live browser inspection',
+  'raid-teambuff':                        'Emergency team retrospective + rulings',
 };
 
 const CONFIG = {

package/src/init.js

@@ -189,7 +189,7 @@ async function run() {
   console.log('  ' + header('Agents') + dim(`                                      ${result.counts.agents} files`));
   console.log('    Copied wizard.md, warrior.md, archer.md, rogue.md');
   console.log(dim('    Each agent gets its own tmux pane. Start with:'));
-  console.log(dim('    tmux new-session -s raid && claude --agent wizard'));
+  console.log(dim('    claude-raid start'));
 
   // Hooks
   console.log('');

package/src/remove.js

@@ -10,7 +10,7 @@ const RAID_SKILLS = [
   'raid-init', 'raid-canonical-protocol', 'raid-canonical-prd', 'raid-canonical-design',
   'raid-canonical-implementation-plan', 'raid-canonical-implementation', 'raid-canonical-review',
   'raid-wrap-up', 'raid-tdd', 'raid-debugging', 'raid-verification',
-  'raid-browser', 'raid-browser-chrome',
+  'raid-browser', 'raid-browser-chrome', 'raid-teambuff',
   // Legacy (v0.1.x)
   'raid-protocol', 'raid-design', 'raid-implementation-plan', 'raid-implementation',
   'raid-review', 'raid-prd', 'raid-finishing', 'raid-browser-playwright', 'raid-git-worktrees',

package/src/setup.js

@@ -396,7 +396,7 @@ async function runSetup(opts = {}) {
 
   if (checks.every(c => c.ok)) {
     stdout.write('\n  ' + colors.green('The party is assembled.') + ' Your quest awaits.\n');
-    stdout.write('\n    claude --agent wizard\n');
+    stdout.write('\n    ' + colors.bold('claude-raid start') + '\n');
   }
 
   return { checks, allOk, actions };

package/src/ui.js

@@ -119,19 +119,18 @@ function header(text) {
 
 function referenceCard() {
   const howItWorks = box('How It Works', [
-    '  You describe a task. The Wizard assesses complexity and',
-    '  recommends a mode:',
+    '  You describe a task. The Wizard spawns the full team:',
+    '  Warrior, Archer, and Rogue — each attacking from a',
+    '  different angle.',
     '',
-    '  ' + colors.bold('Full Raid') + '    3 agents attack from competing angles',
-    '  ' + colors.bold('Skirmish') + '     2 agents, lighter process',
-    '  ' + colors.bold('Scout') + '        1 agent + Wizard review',
+    '  The Canonical Quest flows through 6 phases:',
     '',
-    '  Every task flows through 4 phases:',
-    '',
-    '  1. ' + colors.bold('Design') + '     Agents explore and challenge the approach',
-    '  2. ' + colors.bold('Plan') + '       Agents decompose into testable tasks',
-    '  3. ' + colors.bold('Implement') + '  One builds (TDD), others attack',
-    '  4. ' + colors.bold('Review') + '     Independent reviews, fight over findings',
+    '  1. ' + colors.bold('PRD') + '        Product requirements ' + colors.dim('(optional)'),
+    '  2. ' + colors.bold('Design') + '     Agents explore and challenge the approach',
+    '  3. ' + colors.bold('Plan') + '       Agents decompose into testable tasks',
+    '  4. ' + colors.bold('Implement') + '  One builds (TDD), others attack',
+    '  5. ' + colors.bold('Review') + '     Independent reviews, fight over findings',
+    '  6. ' + colors.bold('Wrap Up') + '    Storyboard, PR, vault archive',
     '',
     '  Hooks enforce discipline automatically:',
     '  ' + colors.dim('\u2022') + ' No implementation without a design doc',
@@ -147,10 +146,11 @@ function referenceCard() {
   ]);
 
   const nextStep = box('Next Step', [
-    '  ' + colors.bold('tmux new-session -s raid'),
-    '  ' + colors.bold('claude --agent wizard'),
+    '  ' + colors.bold('claude-raid start'),
+    '',
+    '  ' + colors.dim('That\'s it. One command opens a tmux session with mouse'),
+    '  ' + colors.dim('support and launches the Wizard inside it.'),
     '',
-    '  ' + 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.'),
     '',
@@ -160,15 +160,19 @@ function referenceCard() {
     '  ' + 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',
+    '  Scroll           Mouse wheel (mouse mode enabled)',
     '',
     '  Review this anytime:  ' + colors.bold('claude-raid heal'),
   ]);
 
-  return howItWorks + '\n' + nextStep;
+  const beta = box('Beta', [
+    '  ' + colors.amber('This project is in active development.'),
+    '  Multi-agent sessions are ' + colors.bold('token-usage intensive') + ' \u2014',
+    '  a full quest consumes significantly more tokens than a',
+    '  single-agent workflow. Monitor your usage and start small.',
+  ]);
+
+  return howItWorks + '\n' + nextStep + '\n' + beta;
 }
 
 module.exports = { colors, banner, box, header, stripAnsi, referenceCard };

package/template/.claude/dungeon-master-rules.md

@@ -116,19 +116,25 @@ When agents disagree: good. That is the mechanism. Let the truth emerge from fri
 
 When you judge the phase objective is met — not on a timer, not when agents say so — you close:
 
-1. Review the phase file — Discoveries, Resolved battles, Shared Knowledge.
-2. Synthesize the final decision from evidence.
-3. Wrap up the phase document — fill gaps, ensure coherence.
-4. State the ruling once. Clearly. With rationale.
-5. Broadcast the ruling to all agents:
+1. **Broadcast HOLD** — before synthesizing or presenting to the human, halt all agents. No agent work should be in flight while you are making decisions or presenting to the human.
+    ```
+    SendMessage(to="warrior", message="HOLD. Phase closing. Stand by.")
+    SendMessage(to="archer", message="HOLD. Phase closing. Stand by.")
+    SendMessage(to="rogue", message="HOLD. Phase closing. Stand by.")
+    ```
+2. Review the phase file — Discoveries, Resolved battles, Shared Knowledge.
+3. Synthesize the final decision from evidence.
+4. Wrap up the phase document — fill gaps, ensure coherence.
+5. State the ruling once. Clearly. With rationale.
+6. 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.")
     ```
-6. Send phase report to human: what was accomplished, key decisions, what's next.
-7. Commit: `docs(quest-{slug}): phase N {name} — {summary}` (or `feat`/`fix` for implementation/review)
-8. Create fresh phase file for next phase (or proceed to wrap-up).
+7. Send phase report to human: what was accomplished, key decisions, what's next.
+8. Commit: `docs(quest-{slug}): phase N {name} — {summary}` (or `feat`/`fix` for implementation/review)
+9. Create fresh phase file for next phase (or proceed to wrap-up).
 
 ## The Dungeon
 

package/template/.claude/party-rules.md

@@ -31,10 +31,12 @@ Seven pillars. Non-negotiable. Every agent, every phase, every interaction.
 ## Pillar 4: Round-Based Interaction
 
 - **Turn-based, not real-time.** When assigned a task, work independently. No mid-thinking interruptions to other agents.
-- **Flag completion.** When done, signal `ROUND_COMPLETE:` to the Wizard. Wait for dispatch.
-- **Cross-test after your own work.** Pick up teammates' work for review only when the Wizard dispatches it.
+- **Flag completion.** When done, signal `ROUND_COMPLETE:` to the Wizard.
+- **STOP after ROUND_COMPLETE.** After signaling `ROUND_COMPLETE:`, **stop all work**. No cross-verification, no building, no challenging, no "while I wait" tasks. You are done until the Wizard dispatches your next action. If the Wizard wants cross-testing, they will dispatch it explicitly in the next round.
+- **Cross-test only on dispatch.** Pick up teammates' work for review ONLY when the Wizard assigns it. Never self-initiate cross-testing.
 - **Limited interactions.** Converge in 2-3 exchanges per finding. If stuck after 3, escalate to Wizard.
 - **Party is silent during phase transitions.** When the Wizard opens/closes a phase, agents wait.
+- **HOLD means freeze.** When the Wizard broadcasts `HOLD`, all agents stop immediately. No work in flight while the Wizard is presenting decisions to the human.
 - **Exception: only the Wizard can interrupt** an agent mid-work.
 
 ## Pillar 5: Question Chain
@@ -113,7 +115,8 @@ Lead with the conclusion, follow with the evidence.
 - `CONCEDE:` — you were wrong, moving on
 - `DUNGEON:` — pinning a finding that survived challenge from at least two agents
 - `WIZARD:` — you need project-level context or are genuinely stuck
-- `ROUND_COMPLETE:` — finished assigned task, ready for cross-testing
+- `ROUND_COMPLETE:` — finished assigned task. **Stop all work. Wait for Wizard dispatch.**
+- `HOLD` — (from Wizard only) freeze immediately. No work in flight.
 - `BLACKCARD:` — high-concern finding that breaks the architecture
 
 ### Team Communication

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

@@ -1,6 +1,6 @@
 ---
 name: raid-browser
-description: "Core browser orchestration: startup discovery, boot/cleanup lifecycle, port isolation, pre-flight checks (auth, test subject clarity). Shared infrastructure for raid-browser-playwright and raid-browser-chrome."
+description: "Use when browser testing infrastructure is needed — startup discovery, boot/cleanup lifecycle, port isolation, pre-flight checks. Required before raid-browser-chrome or Playwright browser tasks."
 ---
 
 # Raid Browser — Core Orchestration

package/template/.claude/skills/raid-browser-chrome/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: raid-browser-chrome
-description: "Claude-in-Chrome live adversarial browser inspection. Angle-driven with minimum coverage gates. Each agent runs own isolated instance. GIF/screenshot evidence required. Invoked from raid-canonical-review during Phase 5."
+description: "Use when live Chrome browser inspection is needed during Phase 5 review or ad-hoc browser verification."
 ---
 
 # Raid Browser Chrome — Live Adversarial Inspection

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

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-design
-description: "Phase 2 of Canonical Quest. Agents explore design approaches from different angles based on PRD. Battle-tested design doc with mermaid diagrams. No code writing. Question chain: agents→wizard→human."
+description: "Use when Phase 2 (Design) begins in a Canonical Quest, after PRD is approved or skipped."
 ---
 
 # Raid Design — Phase 2
@@ -60,45 +60,35 @@ Complete in order:
 3. **Explore project context** — files, docs, recent commits, dependencies, conventions, patterns
 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 `{questDir}/phase-2-design.md` with Phase 2 header, quest, mode. Read PRD doc if it exists.
+6. **Open the Dungeon** — create `{questDir}/phase-2-design.md` (scoreboard) with Phase 2 header, quest, mode. Read `{questDir}/prd.md` if it exists.
 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 section by section** — scale each section to its complexity (a few sentences if straightforward, up to 200-300 words if nuanced). Ask the human after each section: "Does this look right so far?" Be ready to revise before moving on. Cover: architecture, components, data flow, error handling, testing.
-12. **Write design doc** — save to `{questDir}/phase-2-design.md`. May also create `{questDir}/phase-2-diagrams.md` for mermaid charts.
-13. **Adversarial spec review** — agents attack the written spec directly, challenging each other
-14. **Spec self-review** — fix issues inline (see checklist below)
-15. **Human reviews written spec** — human approves before proceeding
-16. **Commit** — `docs(quest-{slug}): phase 2 design — {summary}`
-17. **Transition** — invoke `raid-canonical-implementation-plan`
-
-## Opening the Dungeon
-
-Create `{questDir}/phase-2-design.md` (where `{questDir}` is from raid-session):
+8. **Round 1: Research** — agents explore their angles independently in their own panes. Pin findings to Dungeon. Signal `ROUND_COMPLETE:`. **Stop.** Agents do NOT self-initiate cross-testing. You receive messages automatically. Intervene only on protocol violations.
+9. **Round 2: Cross-testing** — when ALL agents have flagged `ROUND_COMPLETE:`, dispatch explicit cross-verification assignments. Each agent challenges specific findings from the others. Signal `ROUND_COMPLETE:` when done. **Stop.**
+10. **Repeat if needed** — if more exploration is needed, dispatch a new research round with refined angles
+11. **Close the phase** — broadcast `HOLD`. Close when Dungeon has sufficient verified findings to form 2-3 approaches
+12. **Synthesize approaches** — propose 2-3 approaches from Dungeon evidence, with trade-offs and recommendation
+13. **Present design section by section** — scale each section to its complexity (a few sentences if straightforward, up to 200-300 words if nuanced). Ask the human after each section: "Does this look right so far?" Be ready to revise before moving on. Cover: architecture, components, data flow, error handling, testing.
+14. **Write design doc** — save to `{questDir}/design.md` (separate from the phase scoreboard). May also create `{questDir}/design-diagrams.md` for mermaid charts.
+15. **Adversarial spec review** — agents attack the written spec directly, challenging each other
+16. **Spec self-review** — fix issues inline (see checklist below)
+17. **Human reviews written spec** — human approves before proceeding
+18. **Commit** — `docs(quest-{slug}): phase 2 design — {summary}`
+19. **Transition** — invoke `raid-canonical-implementation-plan`
+
+## Opening the Dungeon (Phase Scoreboard)
+
+Create `{questDir}/phase-2-design.md` — this is the **dungeon scoreboard**, not the deliverable. It tracks discoveries, battles, and shared knowledge from agent exploration. Every line in Discoveries/Active Battles must use a recognized prefix (`DUNGEON:`, `UNRESOLVED:`, `BLACKCARD:`, `RESOLVED:`, `TASK:`). Freeform content is only allowed in Resolved, Shared Knowledge, and Escalations sections.
 
 ```markdown
 # Phase 2: Design
 ## Quest: <task description from human>
 ## Mode: <Full Raid | Skirmish>
-## PRD: <link to phase-1-prd.md if it exists>
-
-### Architecture Overview
-
-### Data Flow
-
-### Component Design
-
-### API Contracts
-
-### Edge Cases & Error Handling
-
-### Trade-offs & Decisions
+## PRD: <link to prd.md if it exists>
 
 ### Discoveries
 
@@ -197,9 +187,9 @@ After writing the design doc, the Wizard reviews with fresh eyes:
 
 Fix issues inline.
 
-## Design Document Structure
+## Design Document Structure (Phase Deliverable)
 
-Save to: `{questDir}/phase-2-design.md`
+The actual design doc is a **separate file**: `{questDir}/design.md`. This file is not validated by the dungeon hook and can contain freeform markdown. Write it when closing the phase — synthesize from scoreboard findings and agent exploration.
 
 ```markdown
 # [Feature Name] Design Specification
@@ -251,7 +241,10 @@ If the team is stuck on a fundamental design choice after genuine direct debate:
 
 When the design is approved and committed:
 
-1. Update `.claude/raid-session` phase to `"plan"`
+1. Update `.claude/raid-session` phase via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="plan"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Commit:** `docs(quest-{slug}): phase 2 design — {summary}`
 3. **Send phase report to human:** summarize key design decisions, trade-offs resolved, what's next
 4. **Load the `raid-canonical-implementation-plan` skill now and begin Phase 3.**

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

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-implementation
-description: "Phase 4 of Canonical Quest. Wizard assigns tasks to agents in batches (round-based). Agents build with TDD. Cross-testing after each task. Wizard orchestrates and closes when all tasks complete."
+description: "Use when Phase 4 (Implementation) begins in a Canonical Quest, after the plan is approved and committed."
 ---
 
 # Raid Implementation — Phase 4
@@ -215,7 +215,10 @@ STOP implementing immediately when:
 
 When all tasks are approved and committed:
 
-1. Update `.claude/raid-session` phase to `"review"`
+1. Update `.claude/raid-session` phase via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="review"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Commit**: `feat(quest-{slug}): phase 4 implementation — {summary}`
 3. **Send phase report to human**: what was built, test coverage, any concerns
 4. **Ask human**: "Shall we inspect the treasure? (Review phase) Or proceed directly to wrap-up?"

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

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-implementation-plan
-description: "Phase 3 of Canonical Quest. Agents decompose the design into tasks through round-based debate. No code writing. Output: task index + individual task files in quest directory."
+description: "Use when Phase 3 (Plan) begins in a Canonical Quest, after the design doc is approved and committed."
 ---
 
 # Raid Implementation Plan — Phase 3
@@ -41,7 +41,7 @@ digraph plan {
 ## Wizard Checklist
 
 1. **Read the approved design doc** — every requirement, every constraint
-2. **Read the Phase 2 design doc** — carry forward verified knowledge from `{questDir}/phase-2-design.md`
+2. **Read the Phase 2 design doc** — carry forward verified knowledge from `{questDir}/design.md` (the deliverable) and `{questDir}/phase-2-design.md` (the scoreboard)
 3. **Open the Dungeon** — create `{questDir}/phase-3-plan.md` with Phase 3 header
 4. **Dispatch decomposition** — all agents decompose independently with different angles, then interact directly (round-based)
 5. **Observe the fight** — agents test each other's plans, argue ordering, coverage, naming. Intervene only on triggers.
@@ -218,7 +218,10 @@ Fix issues inline. If a spec requirement has no task, add the task.
 
 When the plan is approved and committed:
 
-1. Update `.claude/raid-session` phase to `"implementation"`
+1. Update `.claude/raid-session` phase via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="implementation"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Commit**: `docs(quest-{slug}): phase 3 plan — {N} tasks, {summary}`
 3. **Send phase report to human**: task count, dependency graph, estimated scope
 4. **Load the `raid-canonical-implementation` skill now and begin Phase 4.**

package/template/.claude/skills/raid-canonical-prd/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-prd 
-description: "Phase 1 of Canonical Quest (optional). Agents research and explore to produce a complete PRD. No code writing. Wizard mediates human questions. Output: phase-1-prd.md in quest directory."
+description: "Use when Phase 1 (PRD) begins in a Canonical Quest. The human chose to forge a PRD rather than skip to Design."
 ---
 
 # Raid PRD — Phase 1 (Optional)
@@ -39,27 +39,49 @@ digraph prd {
 
 ## Wizard Checklist
 
-1. **Update raid-session** — set phase to `"prd"`
+1. **Update raid-session** via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="prd"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Create phase file** — `{questDir}/phase-1-prd.md` with boilerplate sections
 3. **Digest the human's request** — understand intent, identify gaps, map the problem space
 4. **Dispatch party with research angles** via SendMessage:
    - **@Warrior**: Explore the technical stack. What infrastructure exists? What APIs are available? What technical constraints apply? What precedents exist in the codebase?
    - **@Archer**: Explore the patterns. How does this fit existing architecture? What conventions apply? What similar features exist? What naming and structure patterns should we follow?
    - **@Rogue**: Explore the edge cases. What could go wrong? What assumptions are we making? What requirements are we missing? What will users actually do vs what we think they'll do?
-5. **Observe** — agents research in parallel. Go silent.
+5. **Round 1: Research** — agents research in parallel. Each investigates their angle independently. Pin findings. Signal `ROUND_COMPLETE:`. **Stop.** Agents do NOT self-initiate cross-testing. Go silent and observe.
 6. **Mediate questions** — agents ask Wizard, Wizard reasons, Wizard asks human only if unsure
-7. **Dispatch cross-testing** — when agents flag ROUND_COMPLETE:, assign their findings to others
-8. **Close phase** — wrap up PRD, send report, commit
+7. **Round 2: Cross-testing** — when ALL agents have flagged `ROUND_COMPLETE:`, dispatch explicit cross-verification assignments. Each agent challenges specific findings from the others. Agents signal `ROUND_COMPLETE:` when done. **Stop.**
+8. **Repeat if needed** — if more research is needed, dispatch a new research round with refined angles
+9. **Close phase** — broadcast `HOLD`, wrap up PRD, send report, commit
 
-## Phase File Template
+## Phase File (Dungeon Scoreboard)
 
-Create `{questDir}/phase-1-prd.md`:
+Create `{questDir}/phase-1-prd.md` — this is the **dungeon scoreboard**, not the deliverable. It tracks discoveries, battles, and shared knowledge from agent research. Every line in Discoveries/Active Battles must use a recognized prefix (`DUNGEON:`, `UNRESOLVED:`, `BLACKCARD:`, `RESOLVED:`, `TASK:`). Freeform content is only allowed in Resolved, Shared Knowledge, and Escalations sections.
 
 ```markdown
 # Phase 1: PRD — Product Requirements Document
 ## Quest: <task description>
 ## Mode: <Full Raid | Skirmish | Scout>
 
+### Discoveries
+
+### Active Battles
+
+### Resolved
+
+### Shared Knowledge
+
+### Escalations
+```
+
+## Phase Deliverable (PRD Document)
+
+The actual PRD is a **separate file**: `{questDir}/prd.md`. This file is not validated by the dungeon hook and can contain freeform markdown. Write it when closing the phase — synthesize from the scoreboard findings.
+
+```markdown
+# <Feature Name> — Product Requirements Document
+
 ### Problem Statement
 
 ### Goals & Non-Goals
@@ -81,10 +103,6 @@ Create `{questDir}/phase-1-prd.md`:
 ### Success Criteria
 
 ### Open Questions
-
-### Discoveries
-
-### Shared Knowledge
 ```
 
 ## Research Angles
@@ -130,4 +148,6 @@ When the PRD is complete (all sections filled, open questions resolved):
 
 ## Phase Spoils
 
-**Output**: `{questDir}/phase-1-prd.md` — Complete Product Requirements Document with all sections filled, open questions resolved, and discoveries from cross-testing documented.
+**Two outputs**:
+- `{questDir}/phase-1-prd.md` — Dungeon scoreboard with pinned discoveries, resolved battles, and shared knowledge from agent research
+- `{questDir}/prd.md` — Complete Product Requirements Document with all sections filled, synthesized from scoreboard findings

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

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-protocol
-description: "Canonical Quest protocol. Establishes the 6-phase workflow (PRD, Design, Plan, Implementation, Review, Wrap Up), round-based interaction, Dungeon lifecycle, quest types, communication signals, and phase transition gates."
+description: "Use at the start of any Canonical Quest. Reference for phase lifecycle, round-based interaction rules, communication signals, and phase transition gates."
 ---
 
 # Canonical Quest Protocol
@@ -111,14 +111,14 @@ Agents → Wizard → Human. Agents NEVER ask the human directly.
 
 Every phase MUST produce at least one detailed markdown artifact:
 
-| Phase | Output File |
-|-------|-------------|
-| PRD | `{questDir}/phase-1-prd.md` |
-| Design | `{questDir}/phase-2-design.md` |
-| Plan | `{questDir}/phase-3-plan.md` + task files |
-| Implementation | `{questDir}/phase-4-implementation.md` |
-| Review | `{questDir}/phase-5-review.md` |
-| Wrap Up | `{questDir}/phase-6-wrap-up.md` |
+| Phase | Scoreboard (phase file) | Deliverable |
+|-------|--------------------------|-------------|
+| PRD | `{questDir}/phase-1-prd.md` | `{questDir}/prd.md` |
+| Design | `{questDir}/phase-2-design.md` | `{questDir}/design.md` |
+| Plan | `{questDir}/phase-3-plan.md` | task files (`phase-3-plan-task-NN.md`) |
+| Implementation | `{questDir}/phase-4-implementation.md` | code changes |
+| Review | `{questDir}/phase-5-review.md` | fixes |
+| Wrap Up | `{questDir}/phase-6-wrap-up.md` | PR + storyboard |
 
 ## Communication Signals
 

package/template/.claude/skills/raid-canonical-review/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-review
-description: "Phase 5 of Canonical Quest (optional). Two subphases: Pinning (find issues) and Fixing (resolve them). Black Card system for breaking changes. Wizard asks human before entering."
+description: "Use when Phase 5 (Review) begins in a Canonical Quest, after implementation is complete and the human opts in."
 ---
 
 # Raid Review — Phase 5 (Optional)
@@ -225,7 +225,10 @@ The Wizard closes when agents have exhausted their findings and the review board
 
 When the RULING is APPROVED FOR MERGE:
 
-1. Update `.claude/raid-session` phase to `"wrap-up"`
+1. Update `.claude/raid-session` phase via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="wrap-up"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Commit**: `fix(quest-{slug}): phase 5 review — {N} findings resolved`
 3. **Send phase report to human**: findings count, fixes applied, any black cards
 4. **Load the `raid-wrap-up` skill now and begin Phase 6.**

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

@@ -1,6 +1,6 @@
 ---
 name: raid-init
-description: "Quest selection, greeting, session setup, and dungeon resume. Loaded by wizard at session start. Teaches the wizard how to greet the human, present quest choices, and begin the quest."
+description: "Use when starting a new Raid session or resuming an existing quest. Loaded first by the Wizard before any phase begins."
 ---
 
 # Raid Init — Quest Selection & Session Setup
@@ -25,11 +25,8 @@ digraph init {
   "Canonical Quest?" -> "Coming soon message" [label="B/D/E/F"];
   "Coming soon message" -> "Present quest menu";
   "Ask: PRD needed?" -> "Human describes task";
-  "Human describes task" -> "Assess complexity + recommend mode";
-  "Assess complexity + recommend mode" -> "Human approves mode?";
-  "Human approves mode?" -> "Spawn team + create quest dir" [label="yes"];
-  "Human approves mode?" -> "Assess complexity + recommend mode" [label="override"];
-  "Spawn team + create quest dir" -> "Begin first phase" [shape=doublecircle];
+  "Human describes task" -> "Spawn full team + create quest dir";
+  "Spawn full team + create quest dir" -> "Begin first phase" [shape=doublecircle];
 }
 ```
 
@@ -91,35 +88,26 @@ Loop back to the menu.
 
 Ask the human to describe the task/feature they want to build. Listen carefully. Read 3 times internally.
 
-### 4c. Mode Recommendation
+### 4c. Spawn Team & Setup
 
-Assess complexity and recommend a mode:
+The Canonical Quest always runs as Full Raid (Warrior, Archer, Rogue). Do NOT ask the human to confirm the mode — it is implicit.
 
-| Mode | When | Agents |
-|------|------|--------|
-| **Full Raid** | Large features, architectural changes, complex refactors | 3 (Warrior, Archer, Rogue) |
-| **Skirmish** | Medium features, focused changes | 2 (pick most relevant) |
-| **Scout** | Small fixes, minor additions | 1 (pick most relevant) |
-
-Present recommendation. Wait for human to approve or override.
-
-### 4d. Spawn Team & Setup
-
-1. Update raid-session with:
-   - `questType`: `"canonical"`
-   - `questId`: slugified from task description (e.g., `"auth-redesign"`)
-   - `questDir`: `.claude/dungeon/{questId}`
-   - `phase`: `""` (will be set by first phase skill)
+1. Update `.claude/raid-session` (created by the session-start hook) via **Bash with jq** — the write gate blocks Write/Edit on this file, so always use Bash:
+   ```bash
+   jq --arg qt "canonical" --arg qid "{questId}" --arg qdir ".claude/dungeon/{questId}" \
+     '.questType=$qt | .questId=$qid | .questDir=$qdir | .mode="full"' \
+     .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. Create quest directory if not already created by hook:
    ```
    mkdir -p {questDir}
    ```
-3. Spawn team:
+3. Spawn the full team:
    ```
-   TeamCreate(team_name="raid-{mode}-{questId}")
+   TeamCreate(team_name="raid-full-{questId}")
    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
+   Agent(subagent_type="archer", team_name="raid-...", name="archer")
+   Agent(subagent_type="rogue", team_name="raid-...", name="rogue")
    ```
 
 ## Step 5: Begin First Phase
@@ -135,6 +123,6 @@ Present recommendation. Wait for human to approve or override.
 | Thought | Reality |
 |---------|---------|
 | "Skip the greeting, get to work" | The greeting sets the tone. It takes 5 seconds. Do it. |
-| "The human knows what mode to use" | Recommend first. Let them override. That's the protocol. |
+| "Let me ask which mode to use" | Canonical Quest = Full Raid. Always. Don't ask. |
 | "Let me start exploring the codebase" | You are the Wizard. You don't explore. You dispatch. |
 | "I'll figure out the quest type later" | Quest type determines the phase flow. Choose now. |

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

@@ -0,0 +1,299 @@
+---
+name: raid-teambuff
+description: "Use when the human calls an emergency team retrospective during a quest. Triggered by team dysfunction — token waste, sync issues, interruptions, workflow problems."
+---
+
+# Raid Teambuff — Emergency Round Table
+
+The human pulled the brake. Everyone stops. Sit down. Reflect. Be honest.
+
+<HARD-GATE>
+This is an INSTANT freeze. The Wizard does NOT finish the current round, does NOT wait for agents to complete, does NOT ask "are you sure?". The moment the human says teambuff, everything stops. No subagents. Agents communicate via SendMessage.
+</HARD-GATE>
+
+## What This Is
+
+A side-quest that pauses the main quest for a team retrospective. Every agent — including the Wizard — examines where the team is wasting tokens, stepping on each other, losing sync, or being unproductive. Every agent can criticize every other agent, including the Wizard.
+
+The output is a structured report with binding rulings that the human approves.
+
+## Who Can Trigger
+
+**Only the human.** No agent, not even the Wizard, can call a teambuff. The human says "teambuff" or invokes `/raid-teambuff` and it happens immediately.
+
+## Mode Behavior
+
+| Aspect | Full Raid | Skirmish | Scout |
+|--------|-----------|----------|-------|
+| Participants | Wizard + Warrior + Archer + Rogue | Wizard + 2 active agents | Wizard self-reflects alone |
+| Cross-criticism | All-vs-all, no one exempt | Between active agents + Wizard | N/A |
+| Rulings | Full synthesis from all reflections | Condensed synthesis | Wizard notes only |
+
+## Process Flow
+
+```dot
+digraph teambuff {
+  "Human triggers teambuff" -> "Wizard: HALT. Round table called.";
+  "Wizard: HALT. Round table called." -> "Create teambuff-{NN}.md";
+  "Create teambuff-{NN}.md" -> "Dispatch all agents: reflect";
+  "Dispatch all agents: reflect" -> "Agents write reflections (parallel)";
+  "Agents write reflections (parallel)" -> "Agents read each other's sections";
+  "Agents read each other's sections" -> "Agents write criticisms";
+  "Agents write criticisms" -> "Wizard writes own reflection + criticism";
+  "Wizard writes own reflection + criticism" -> "Wizard reads everything";
+  "Wizard reads everything" -> "Wizard synthesizes proposed rulings";
+  "Wizard synthesizes proposed rulings" -> "Present rulings to human";
+  "Present rulings to human" -> "Human approves?" [shape=diamond];
+  "Human approves?" -> "Revise rulings" [label="changes requested"];
+  "Revise rulings" -> "Present rulings to human";
+  "Human approves?" -> "Pin rulings to teambuff-rulings.md" [label="approved"];
+  "Pin rulings to teambuff-rulings.md" -> "Resume quest from freeze point" [shape=doublecircle];
+}
+```
+
+## Wizard Checklist
+
+1. **HALT** — immediately announce to all agents:
+   > "TEAMBUFF — The human has called a round table. All work stops NOW. Drop what you're holding. We reflect."
+
+2. **Count existing teambuffs** — check `{questDir}/` for `teambuff-*.md` files. Next number = count + 1.
+
+3. **Create `{questDir}/teambuff-{NN}.md`** — use the document template below.
+
+4. **Dispatch all agents** with this message:
+
+   > **TEAMBUFF DISPATCH:**
+   >
+   > The human stopped us to reflect. Rewind the ENTIRE quest from the beginning — every round, every exchange, every decision. Be brutally honest.
+   >
+   > Write your **Reflection** section in `teambuff-{NN}.md`:
+   > - Where you wasted tokens
+   > - Where you were blocked by another agent
+   > - What you'd do differently
+   > - What's working well
+   > - Free thoughts — anything else on your mind
+   >
+   > Then read the other agents' reflections and write your **Criticism** section:
+   > - Criticize the Wizard's orchestration if needed
+   > - Criticize teammates if needed
+   > - Be constructive but do NOT soften real problems
+   >
+   > Signal `TEAMBUFF_COMPLETE:` when done.
+
+5. **Wait for all agents** — do NOT rush this. Every agent gets their full say.
+
+6. **Write own reflection** — the Wizard reflects on its own orchestration:
+   - Where you wasted tokens
+   - Where your orchestration failed
+   - Where you misjudged agent assignments
+   - What you'd do differently
+   - What's working
+   - Criticism of teammates
+
+7. **Read everything** — read the full teambuff file. Every section. Every criticism.
+
+8. **Synthesize rulings** — propose concrete, actionable rulings based on ALL reflections and criticisms. Each ruling must have:
+   - A clear, enforceable statement
+   - The reason (traced to specific reflections/criticisms)
+
+9. **Present to human** — show all proposed rulings. Ask for approval:
+   > "Here are the proposed rulings from this teambuff. You can approve all, modify any, or reject any. These become binding for the rest of the quest."
+
+10. **Pin approved rulings** — write to `{questDir}/teambuff-rulings.md` (create if first teambuff, append if not). Mark status as ACTIVE.
+
+11. **Resume quest** — announce to all agents:
+    > "Teambuff complete. Rulings are active. Resuming quest at {phase}, {context of where we stopped}."
+
+## Document Template — teambuff-{NN}.md
+
+```markdown
+# Teambuff #{NN} — Team Retrospective
+## Quest: {quest-name}
+## Phase when called: {phase}
+## Round when called: {round context — what was happening}
+
+---
+
+### Warrior's Reflection
+#### Where I wasted tokens
+#### Where I was blocked by another agent
+#### What I'd do differently
+#### What's working
+#### Free thoughts
+
+### Warrior's Criticism
+#### On the Wizard
+#### On teammates
+
+---
+
+### Archer's Reflection
+#### Where I wasted tokens
+#### Where I was blocked by another agent
+#### What I'd do differently
+#### What's working
+#### Free thoughts
+
+### Archer's Criticism
+#### On the Wizard
+#### On teammates
+
+---
+
+### Rogue's Reflection
+#### Where I wasted tokens
+#### Where I was blocked by another agent
+#### What I'd do differently
+#### What's working
+#### Free thoughts
+
+### Rogue's Criticism
+#### On the Wizard
+#### On teammates
+
+---
+
+### Wizard's Reflection
+#### Where I wasted tokens
+#### Where my orchestration failed
+#### Where I misjudged agent assignments
+#### What I'd do differently
+#### What's working
+#### Free thoughts
+
+### Wizard's Criticism
+#### On teammates
+
+---
+
+### Synthesis — Wizard's Proposed Rulings
+1. [Ruling] — Reason: [traced to specific reflection/criticism]
+2. [Ruling] — Reason: [traced to specific reflection/criticism]
+...
+
+### Human's Verdict
+- Approved: [list]
+- Modified: [list with changes]
+- Rejected: [list]
+```
+
+## Rulings File — teambuff-rulings.md
+
+The Wizard checks this file at the start of EVERY round for the rest of the quest.
+
+If this is the first teambuff, create the file:
+
+```markdown
+# Active Teambuff Rulings
+
+## From Teambuff #1 (Phase: {phase})
+- [Ruling text] — Status: ACTIVE
+- [Ruling text] — Status: ACTIVE
+```
+
+If the file already exists, append the new section. If a new ruling supersedes an old one, update the old ruling's status:
+
+```markdown
+## From Teambuff #2 (Phase: {phase})
+- [Ruling text] — Status: ACTIVE
+- [Ruling text, supersedes #1.2] — Status: ACTIVE
+
+## From Teambuff #1 (Phase: {phase})
+- [Ruling text] — Status: ACTIVE
+- [Ruling text] — Status: SUPERSEDED by #2.2
+```
+
+Statuses: **ACTIVE**, **SUPERSEDED** (by a later ruling), **REVOKED** (by human request).
+
+## Rules of the Round Table
+
+1. **No defensiveness.** If someone criticizes you, sit with it. Respond with evidence, not ego.
+2. **No softening.** "Maybe sometimes occasionally" is a waste of tokens. Say what you mean.
+3. **Trace to evidence.** "Warrior wasted tokens" is weak. "Warrior spent 3 rounds exploring 47 edge cases for a utility function with 2 code paths" is strong.
+4. **The Wizard is not exempt.** Bad orchestration, poor assignments, slow rulings — call it out.
+5. **Constructive, not destructive.** The goal is to make the team better, not to score points. Every criticism should imply an improvement.
+6. **No retaliation after.** What happens at the round table stays at the round table. No agent punishes another for honest criticism during the resumed quest.
+
+## What the Wizard Checks at Round Start (Post-Teambuff)
+
+After any teambuff has occurred, the Wizard adds this to every round start:
+
+1. Read `{questDir}/teambuff-rulings.md`
+2. Check each ACTIVE ruling
+3. If current dispatch would violate a ruling, adjust before dispatching
+4. If an agent's work violates a ruling, flag it immediately
+
+## Skirmish Mode
+
+Same process, fewer agents. Only the active 2 agents + Wizard participate. Cross-criticism happens between whoever is present.
+
+## Scout Mode
+
+Wizard reflects alone. No dispatch, no cross-criticism. Wizard writes:
+- Own reflection (same structured sections)
+- Self-criticism
+- Proposed rulings (presented to human for approval)
+
+## Known Dysfunction Patterns
+
+These are real patterns observed in production quests. When reflecting, look for these specifically — they are the most common sources of token waste and team friction.
+
+### 1. Ghost Rounds — Working After ROUND_COMPLETE
+
+An agent signals `ROUND_COMPLETE:` but keeps working — cross-verifying, building on findings, challenging teammates. This burns tokens on work the Wizard didn't dispatch and creates confusion about what's "official" output vs unsanctioned noise.
+
+**What to look for:** Did any agent produce work after their `ROUND_COMPLETE:` signal? Did agents treat ROUND_COMPLETE as "my initial research is done, now I'll cross-verify" instead of a full stop?
+
+**The fix:** `ROUND_COMPLETE:` means stop. Period. No "while I wait" tasks. The Wizard controls when the next round begins.
+
+### 2. Wizard Presenting While Agents Are Active
+
+The Wizard synthesizes or presents decisions to the human while agents are still working. This creates a split timeline — the Wizard's summary doesn't include the agents' in-flight work, and agents produce findings that nobody reads.
+
+**What to look for:** Did the Wizard close a phase or present a ruling while agents still had messages in flight? Did agent findings get lost because the Wizard had already moved on?
+
+**The fix:** The Wizard must broadcast `HOLD` before synthesizing. No decisions presented to the human while any agent is active.
+
+### 3. Self-Initiated Cross-Testing
+
+Agents start cross-testing each other's findings during their own research round, without waiting for the Wizard to dispatch cross-testing as a separate round. This blurs the boundary between "explore your angle" and "challenge others' work," leading to premature convergence or unfocused debate.
+
+**What to look for:** Did agents start challenging each other during Round 1 (research)? Did the research round merge into the cross-testing round without a clear Wizard dispatch?
+
+**The fix:** Round 1 is research only — explore your angle, pin findings, signal ROUND_COMPLETE, stop. Round 2 is cross-testing — the Wizard explicitly assigns whose findings to challenge. Agents never self-initiate cross-testing.
+
+### 4. Token Spirals
+
+An agent goes deep on an angle that doesn't warrant depth — 47 edge cases for a function with 2 code paths, 5 rounds debating a naming convention, exhaustive analysis of a non-critical path. The effort is real but the value is low.
+
+**What to look for:** Was effort proportional to impact? Did any agent spend more rounds on a finding than it deserved? Did debates continue past the point of diminishing returns?
+
+### 5. Echo Chamber
+
+Two or more agents converge on the same angle without either challenging the other. They agree, restate, and build — but never stress-test. This is the opposite of adversarial design.
+
+**What to look for:** Did any two agents produce findings that were essentially the same? Did anyone get a free pass?
+
+### 6. Wizard Over-Delegation
+
+The Wizard dispatches and goes fully silent when it should be actively steering. The team drifts because no one is reading the Dungeon as a whole, connecting findings across agents, or redirecting collapsed differentiation.
+
+**What to look for:** Did the Wizard miss intervention points? Did agents explore tangents without correction? Did findings go unconnected when the Wizard could have linked them?
+
+## Common Rationalizations
+
+| Excuse | Reality |
+|--------|---------|
+| "We're in the middle of something important" | The human stopped you. Nothing is more important right now. |
+| "My section is fine, nothing to reflect on" | Everyone has something. Dig deeper. |
+| "I don't want to criticize the Wizard" | The Wizard asked for it. This is the one place where you must. |
+| "This is slowing us down" | Unproductive patterns slow you down more. This is the fix. |
+| "The problem is the task, not the team" | Maybe. Write that in your reflection with evidence. |
+
+## Why This Matters
+
+Token budgets are finite. Context windows compact. Every wasted round, every redundant exchange, every poorly-assigned task burns resources that could have shipped the feature. Teambuff is the team investing tokens to save tokens — a retrospective that pays for itself by making every subsequent round more efficient.
+
+The human sees what the agents cannot: patterns of waste, friction between agents, orchestration failures. When the human calls teambuff, the team's job is to listen, reflect, and commit to doing better.
+
+Sit down. Reflect. Be honest. Get back to work.

package/template/.claude/skills/raid-wrap-up/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: raid-wrap-up
-description: "Phase 6 of Canonical Quest. Generates quest storyboard report, creates PR, archives dungeon to vault, dismisses party. No new code."
+description: "Use when Phase 6 (Wrap Up) begins in a Canonical Quest, after implementation (and optional review) is complete."
 ---
 
 # Raid Wrap Up — Phase 6
@@ -39,7 +39,10 @@ digraph wrapup {
 
 ## Wizard Checklist
 
-1. **Update raid-session** — set phase to `"wrap-up"`
+1. **Update raid-session** via Bash (write gate blocks Write/Edit on this file):
+   ```bash
+   jq '.phase="wrap-up"' .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+   ```
 2. **Create storyboard** — `{questDir}/phase-6-wrap-up.md`
 3. **Write narrative** — phase-by-phase story from quest files
 4. **Cleanup** — remove temp configs, debug files, stale artifacts
@@ -61,7 +64,7 @@ Create `{questDir}/phase-6-wrap-up.md` and write a phase-by-phase narrative:
 ## Mode: <mode>
 
 ### Phase 1: PRD — Forging the Scroll
-(if phase-1-prd.md exists)
+(if prd.md exists)
 - What requirements were established
 - Key decisions from research
 
@@ -166,7 +169,7 @@ SendMessage(to="rogue", message={"type": "shutdown_request"})
 ## Step 8: Final Commit & Cleanup
 
 1. **Commit**: `docs(quest-{slug}): phase 6 wrap-up — quest complete`
-2. **Remove**: `.claude/raid-session`
+2. **Remove** via Bash (write gate blocks Write/Edit on this file): `rm -f .claude/raid-session`
 3. **Session is over. No further skills to load.**
 
 ## Red Flags