claude-raid 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-raid",
-  "version": "0.2.5",
+  "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. |