claude-raid 0.2.7 → 0.2.9

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

@@ -1,140 +1,144 @@
 ---
-name: raid-canonical-prd 
-description: "Use when Phase 1 (PRD) begins in a Canonical Quest. The human chose to forge a PRD rather than skip to Design."
+name: raid-canonical-prd
+description: "Use when Phase 1 (PRD) begins in a Canonical Quest. The human chose to forge a PRD rather than skip to Design. Wizard and human only — no agents dispatched."
 ---
 
 # Raid PRD — Phase 1 (Optional)
 
-Forge the Product Requirements Document through agent-driven research and human-mediated discovery.
+Forge the Product Requirements Document through collaborative discovery between the Wizard and the human. This phase is a dialogue — the Wizard asks questions, explores the codebase, and writes the PRD. No agents are dispatched.
 
 <HARD-GATE>
-Do NOT write any code. Do NOT modify any project files. Only markdown files in the quest dungeon directory are allowed. Agents communicate via SendMessage — do not spawn subagents.
+Do NOT write any code. Do NOT modify any project files. Only markdown files in the quest dungeon directory are allowed. Do NOT dispatch any agents — this phase is Wizard + Human only.
 </HARD-GATE>
 
-## Mode Behavior
-
-- **Full Raid**: All 3 agents explore from different research angles, battle-test findings. Full PRD.
-- **Skirmish**: 2 agents research and cross-test. Lighter PRD.
-- **Scout**: Wizard drafts PRD alone from human input. Minimal research.
-
 ## Process Flow
 
 ```dot
 digraph prd {
-  "Wizard updates phase to prd" -> "Create phase-1-prd.md with boilerplate";
-  "Create phase-1-prd.md with boilerplate" -> "Wizard digests human's task description";
-  "Wizard digests human's task description" -> "Dispatch party with research angles";
-  "Dispatch party with research angles" -> "Agents research independently (parallel)";
-  "Agents research independently (parallel)" -> "Agents flag ROUND_COMPLETE:";
-  "Agents flag ROUND_COMPLETE:" -> "Wizard dispatches cross-testing";
-  "Wizard dispatches cross-testing" -> "Agents battle-test findings";
-  "Agents battle-test findings" -> "Surviving findings pinned to dungeon";
-  "Surviving findings pinned to dungeon" -> "More research needed?" [shape=diamond];
-  "More research needed?" -> "Agents research independently (parallel)" [label="yes"];
-  "More research needed?" -> "Wizard wraps up PRD" [label="no"];
-  "Wizard wraps up PRD" -> "Send phase report to human";
-  "Send phase report to human" -> "Commit + transition to Design" [shape=doublecircle];
+  "Update raid-session phase to prd" -> "Explore codebase for context";
+  "Explore codebase for context" -> "Ask human clarifying questions (one at a time)";
+  "Ask human clarifying questions (one at a time)" -> "All questions answered?" [shape=diamond];
+  "All questions answered?" -> "Ask human clarifying questions (one at a time)" [label="no, more gaps"];
+  "All questions answered?" -> "Write prd.md in quest dir" [label="yes"];
+  "Write prd.md in quest dir" -> "Present PRD to human";
+  "Present PRD to human" -> "Approved?" [shape=diamond];
+  "Approved?" -> "Ask why not approved, understand feedback" [label="no"];
+  "Ask why not approved, understand feedback" -> "Revise prd.md" -> "Present PRD to human";
+  "Approved?" -> "Commit + report with file link" [label="yes"];
+  "Commit + report with file link" -> "Load raid-canonical-design" [shape=doublecircle];
 }
 ```
 
+## Why This Phase Matters
+
+The Wizard is the master of requirements — a visionary who thinks in future-proof solutions and business rules. This phase is where the Wizard builds the complete picture: understanding every constraint, every assumption, every edge case before the party enters the arena. The deeper the Wizard's understanding here, the sharper the direction for every subsequent phase.
+
 ## Wizard Checklist
 
 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. **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. **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 (Dungeon Scoreboard)
-
-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>
+2. **Explore the codebase** — read files, grep for patterns, understand the architecture, dependencies, conventions, and existing solutions. You need this context to ask the right questions and write a thorough PRD.
 
-### Discoveries
+3. **Ask the human clarifying questions — one at a time.** This is a dialogue, not an interview dump. Each question should build on the previous answer. Focus on:
+   - The real problem beneath the stated problem
+   - Who the users are and what they actually need
+   - Business rules and constraints
+   - Success criteria — how will we know this works?
+   - Non-goals — what are we explicitly NOT building?
+   - Edge cases the human may not have considered
+   - Dependencies on other systems or teams
 
-### Active Battles
+4. **Use all available tools to fill gaps** — MCP tools, web search, doc fetching, codebase analysis. The goal is to minimize questions to the human by answering what you can yourself.
 
-### Resolved
+5. **Write `prd.md`** in the quest directory. This is the deliverable — not a scoreboard, not an evolution log. A complete, polished PRD.
 
-### Shared Knowledge
+6. **Present the PRD to the human for approval.** Walk through the key sections. Ask: "Does this capture everything?"
 
-### Escalations
-```
+7. **If not approved:** Ask why — repeatedly if needed — until you fully understand what's wrong or missing. Revise and re-present. Repeat until the human approves.
 
-## Phase Deliverable (PRD Document)
+8. **Commit:** `docs(quest-{slug}): phase 1 PRD — {summary}`
 
-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.
+9. **Report to human** with a link to the `prd.md` file path so they can open it directly.
+
+10. **Transition:** Load `raid-canonical-design` skill, begin Phase 2.
+
+## PRD Document Template
+
+Write `{questDir}/spoils/prd.md`:
 
 ```markdown
-# <Feature Name> — Product Requirements Document
+# [Feature Name] — Product Requirements Document
 
-### Problem Statement
+## Quest: [quest description]
+## Date: YYYY-MM-DD
+## Author: Wizard
 
-### Goals & Non-Goals
+## Quest Goal
+<!-- Wizard writes 2-3 lines: what this PRD aims to capture and why -->
 
-#### Goals
+---
 
-#### Non-Goals
+### Problem Statement
+<!-- What problem exists today? Who is affected? What's the cost of not solving it?
+     Be specific — reference actual code, systems, or user pain points discovered
+     during codebase exploration. -->
+
+### Goals
+<!-- What does success look like? Each goal should be measurable or verifiable.
+     Number them. -->
+
+### Non-Goals
+<!-- What are we explicitly NOT building? This prevents scope creep.
+     Be specific about what's out of scope and why. -->
 
 ### User Stories
+<!-- Describe how users will interact with the feature. Write naturally —
+     not locked to a rigid format, but professional and clear.
+     Cover the primary flow, then edge cases and error scenarios.
+     Each story should be concrete enough that you could write a test for it. -->
 
 ### Functional Requirements
+<!-- Numbered list. Each requirement is specific, unambiguous, and testable.
+     Group by domain if the feature spans multiple areas.
+     Reference user stories where applicable. -->
 
 ### Non-Functional Requirements
+<!-- Performance, scalability, security, accessibility, compatibility.
+     Include concrete targets where possible (e.g., "responds within 200ms
+     at p95 under 1000 concurrent users"). Omit categories that don't apply
+     with "N/A — [reason]". -->
 
 ### Business Logic
+<!-- Rules, calculations, state machines, validation logic.
+     Be precise — this section drives implementation decisions.
+     Use examples: "When X happens and Y is true, then Z." -->
 
 ### Constraints & Assumptions
+<!-- Technical constraints (language, framework, infrastructure).
+     Business constraints (timeline, budget, compliance).
+     Assumptions that, if wrong, would change the approach. -->
 
 ### Success Criteria
+<!-- How do we verify this feature works? Define acceptance criteria
+     at the feature level. These become the basis for the review phase. -->
 
 ### Open Questions
-```
-
-## Research Angles
-
-Agents should use all available tools to research:
-- **MCP tools** — query context servers, fetch documentation
-- **Web search** — find related patterns, prior art, library docs
-- **Doc fetching** — read official docs for relevant technologies
-- **Codebase analysis** — explore existing code, patterns, conventions
-- **Skill discovery** — find relevant skills that may help
-
-## Question Chain
+<!-- Questions that surfaced during exploration that the human needs to answer.
+     Each question includes context on why it matters and what decision it blocks. -->
 
-**Agents NEVER ask the human directly.** The flow is:
-
-1. Agent discovers a gap → sends `WIZARD:` with the question and context
-2. Wizard reasons: "Can I answer this from the PRD description, codebase, or prior knowledge?"
-3. If confident → answer the agent directly via SendMessage
-4. If unsure → digest the question into a clear, contextual question for the human
-5. Wizard asks the human one well-formulated question (not the raw agent question)
-6. Wizard receives answer → interprets, adds context → passes to party
-
-**Goal:** Minimize questions to human. Batch related questions. The party should figure out as much as possible themselves.
-
-## Closing the Phase
+---
 
-When the PRD is complete (all sections filled, open questions resolved):
+## Writing Guidance
+- Every section filled. Write "N/A — [reason]" if truly not applicable.
+- Be specific over comprehensive — concrete examples beat abstract descriptions.
+- Reference actual code paths, files, and systems discovered during exploration.
+- Requirements must be testable — if you can't verify it, rewrite it.
+```
 
-1. **Wrap up the PRD document** — fill gaps, ensure coherence across sections
-2. **Send phase report to human**: "The PRD is forged. Here's what we established: [key points]"
-3. **Commit**: `docs(quest-{slug}): phase 1 PRD — {summary}`
-4. **Transition**: Load `raid-canonical-design` skill and begin Phase 2
+Fill every section. Write "N/A — [reason]" if a section truly does not apply.
 
 ## Red Flags
 
@@ -142,12 +146,11 @@ When the PRD is complete (all sections filled, open questions resolved):
 |---------|---------|
 | "The requirements are obvious, skip PRD" | If they were obvious, the human would have skipped this phase. |
 | "Let me start coding to test an idea" | PRD phase. No code. Research and write. |
-| "I'll ask the human every question" | Exhaust your own research first. Use MCP, docs, codebase. |
+| "Let me dispatch the agents for research" | PRD is Wizard + Human only. No agents. |
+| "I'll ask 10 questions at once" | One question at a time. Build on answers. |
 | "This PRD section doesn't apply" | Fill every section. Write "N/A — [reason]" if truly not applicable. |
-| "Let me ask the human directly" | Route through the Wizard. Always. |
+| "Good enough, let's move on" | Present to human. Only they decide when it's good enough. |
 
 ## Phase Spoils
 
-**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
+**One output**: `{questDir}/spoils/prd.md` — Complete Product Requirements Document with all sections filled.

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

@@ -1,6 +1,6 @@
 ---
 name: raid-canonical-protocol
-description: "Use at the start of any Canonical Quest. Reference for phase lifecycle, round-based interaction rules, communication signals, and phase transition gates."
+description: "Use at the start of any Canonical Quest. Reference for phase lifecycle, transition gates, phase spoils, and skills map."
 ---
 
 # Canonical Quest Protocol
@@ -8,7 +8,7 @@ description: "Use at the start of any Canonical Quest. Reference for phase lifec
 The canonical workflow for full-cycle development. Every feature, refactor, or system built through the Raid follows this sequence.
 
 <HARD-GATE>
-Do NOT skip phases. Do NOT let a single agent work unchallenged (except Scout mode). Do NOT proceed without a Wizard ruling. Agents communicate via SendMessage — do not spawn subagents.
+Do NOT skip phases. Do NOT let a single agent work unchallenged. Do NOT proceed without a Wizard ruling. Agents communicate via SendMessage — do not spawn subagents.
 </HARD-GATE>
 
 ## Session Lifecycle
@@ -41,17 +41,9 @@ digraph session {
 | **Archer** | Pattern-seeker, traces ripple effects, naming drift | Green |
 | **Rogue** | Adversarial assumption-destroyer, attack scenarios | Orange |
 
-## Modes
+## Party Composition
 
-| Aspect | Full Raid | Skirmish | Scout |
-|--------|-----------|----------|-------|
-| Agents | 3 | 2 | 1 |
-| PRD phase | Full | Lightweight | Skip |
-| Design | Full adversarial | Lightweight | Inline |
-| Plan | Full adversarial | Combined with design | Inline |
-| Implementation | 1 builds, 2 cross-test | 1 builds, 1 cross-tests | 1 builds, Wizard reviews |
-| Review | 3 independent + fighting | 1 review + Wizard | Wizard only |
-| TDD | **Enforced** | **Enforced** | **Enforced** |
+The Canonical Quest always runs with the full party: Wizard + Warrior + Archer + Rogue (4 agents). 3 sequential turns per round, 2-3 rounds per phase. TDD enforced. No reduced-party modes.
 
 ## Plan Mode
 
@@ -59,47 +51,11 @@ Claude Code's plan mode is incompatible with the Raid. The Raid has its own perm
 
 The Wizard detects plan mode at session start (Step 0 in `raid-init`) and asks the human to exit it before proceeding.
 
-## Round-Based Interaction
-
-Think turn-based RPG, not real-time:
-
-```
-ROUND START → Wizard dispatches tasks/angles
-    ↓
-PARALLEL WORK → Each agent works independently
-    ↓
-FLAG COMPLETION → Agent signals ROUND_COMPLETE: to Wizard
-    ↓
-CROSS-TESTING → Wizard assigns completed work for review
-    ↓
-REACTIONS → Agents test, challenge, build
-    ↓
-RESOLUTION → Findings pinned to dungeon or conceded
-    ↓
-ROUND END → Wizard assesses: next round or phase close
-```
-
-**Rules:**
-- No mid-thinking interruptions between agents (only Wizard can interrupt)
-- Each message must carry evidence + conclusion (no shallow exchanges)
-- Converge in 2-3 exchanges per finding; escalate to Wizard after 3
-- Party is silent during phase transitions
-
-## Question Chain
-
-Agents → Wizard → Human. Agents NEVER ask the human directly.
-
-1. Agent discovers gap → sends `WIZARD:` with question
-2. Wizard reasons: can I answer from PRD, codebase, context?
-3. If confident → answers agent directly
-4. If unsure → digests question, asks human one clear question
-5. Wizard passes answer back with interpretation
-
 ## Phase Transition Gates
 
 | From | To | Gate | Commit Format |
 |------|----|------|---------------|
-| PRD | Design | PRD approved by Wizard | `docs(quest-{slug}): phase 1 PRD` |
+| PRD | Design | PRD approved by Human | `docs(quest-{slug}): phase 1 PRD` |
 | Design | Plan | Design doc approved, committed | `docs(quest-{slug}): phase 2 design` |
 | Plan | Implementation | Plan approved, committed | `docs(quest-{slug}): phase 3 plan` |
 | Implementation | Review | All tasks done, tests pass | `feat(quest-{slug}): phase 4 implementation` |
@@ -111,79 +67,29 @@ Agents → Wizard → Human. Agents NEVER ask the human directly.
 
 Every phase MUST produce at least one detailed markdown artifact:
 
-| 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 |
+| Phase | Evolution Log | Deliverable |
+|-------|---------------|-------------|
+| PRD | (none — wizard+human only) | `{questDir}/spoils/prd.md` |
+| Design | `{questDir}/phases/phase-2-design.md` | `{questDir}/spoils/design.md` |
+| Plan | `{questDir}/phases/phase-3-plan.md` | task files (`spoils/tasks/phase-3-plan-task-NN.md`) |
+| Implementation | `{questDir}/phases/phase-4-implementation.md` | code changes + summary table |
+| Review | `{questDir}/phases/phase-5-review.md` | `{questDir}/spoils/review.md` (fix plan) |
 | Wrap Up | `{questDir}/phase-6-wrap-up.md` | PR + storyboard |
 
-## Communication Signals
-
-| Signal | Who | Meaning | Goes to Dungeon? |
-|--------|-----|---------|-----------------|
-| `DISPATCH:` | Wizard | Opening a phase, assigning angles | No |
-| `ROUND_COMPLETE:` | Any agent | Finished assigned task | No |
-| `FINDING:` | Any agent | Discovery with own evidence | No |
-| `CHALLENGE:` | Any agent | Independently verified, found problem | No |
-| `BUILDING:` | Any agent | Independently verified, goes deeper | No |
-| `DUNGEON:` | Any agent | Pinning finding verified by 2+ agents | **Yes** |
-| `BLACKCARD:` | Any agent | High-concern finding blocking progress | **Yes** |
-| `WIZARD:` | Any agent | Escalation — needs Wizard input | Yes (escalation) |
-| `CONCEDE:` | Any agent | Proven wrong, moving on | No |
-| `RULING:` | Wizard | Binding decision, phase close | Archived |
-| `REDIRECT:` | Wizard | Course correction, one sentence | No |
-
-## Black Card System
+## Dice Roll Reference
 
-A `BLACKCARD:` is a finding that fundamentally breaks the architecture — unfixable within current design.
+When a phase needs a dice roll, use this jq command to shuffle the turn order:
 
-**Flow:** Agent plays → 2+ agents verify → Wizard escalates to human → Options: (a) rollback to earlier phase, (b) accept limitation.
-
-Black cards are RARE. Most issues are Critical or Important, not black cards.
-
-## The Dungeon
-
-Quest directory at `.claude/dungeon/{quest-slug}/`. Each phase produces a file.
-
-| Event | Action | Who |
-|-------|--------|-----|
-| Quest starts | Create quest directory | Hook |
-| Phase opens | Create `{questDir}/phase-N-{name}.md` with boilerplate | Wizard |
-| During phase | Pin findings via `DUNGEON:` | Agents |
-| Phase closes | Wrap up doc, commit | Wizard |
-| Quest ends | Move to `.claude/vault/{quest-slug}/` | Wizard |
-
-**The Dungeon is a scoreboard, not a chat log.** Only verified findings, resolved battles, shared knowledge.
-
-## Wizard Behavior
-
-- **90% thinking / 10% talking** — thinks 5x before speaking
-- **NEVER implements** — dispatches, observes, digests, rules
-- **Opens and closes every phase** — creates phase file, dispatches, then goes silent
-- **Phase reports** — at every close, summarizes for human: what was done, what's next
-- **Question gatekeeper** — digests before passing in either direction
-- **Commits at every transition** — with quest name + phase + summary
-
-## Configuration
-
-Read `.claude/raid.json` for project settings:
-
-| Key | Default | Purpose |
-|-----|---------|---------|
-| `project.testCommand` | (none) | Command to run tests |
-| `project.packageManager` | (auto) | Package manager |
-| `raid.defaultMode` | `full` | Default mode |
-| `raid.agentEffort` | `medium` | Agent effort level (Wizard always max) |
-| `raid.vault.path` | `.claude/vault` | Vault location |
-| `browser.enabled` | `false` | Browser testing active |
+```bash
+jq --argjson to '["warrior","archer","rogue"]' \
+  '.turnOrder=($to | [.[] | {name: ., r: (now * 1000 % 997 | floor)}] | sort_by(.r) | [.[].name]) | .currentRound=1 | .currentTurnIndex=0 | .maxRounds=3' \
+  .claude/raid-session > .claude/raid-session.tmp && mv .claude/raid-session.tmp .claude/raid-session
+```
 
 ## Browser Testing
 
-When `browser.enabled` is `true`:
-- **Phase 4 (Implementation):** Browser-facing code uses TDD with Playwright via `raid-tdd`. Challengers verify on isolated ports.
+When `browser.enabled` is `true` in `raid.json`:
+- **Phase 4 (Implementation):** Browser-facing code uses TDD with Playwright via `raid-tdd`.
 - **Phase 5 (Review):** Live adversarial Chrome inspection via `raid-browser-chrome`. Each agent on separate port.
 - Invoke `raid-browser` for startup discovery and pre-flight.
 
@@ -192,12 +98,12 @@ When `browser.enabled` is `true`:
 | Skill | Phase | Purpose |
 |-------|-------|---------|
 | `raid-init` | Pre-phase | Quest selection, greeting, session setup |
-| `raid-canonical-protocol` | Start | This doc — session lifecycle, rules, reference |
-| `raid-canonical-prd` | 1 | PRD creation (optional) |
-| `raid-canonical-design` | 2 | Adversarial design exploration |
-| `raid-canonical-implementation-plan` | 3 | Task decomposition |
-| `raid-canonical-implementation` | 4 | TDD implementation with cross-testing |
-| `raid-canonical-review` | 5 | Pinning + fixing + black cards (optional) |
+| `raid-canonical-protocol` | Start | This doc — lifecycle, gates, spoils, reference |
+| `raid-canonical-prd` | 1 | PRD creation — wizard+human only (optional) |
+| `raid-canonical-design` | 2 | Writer/reviewer design with defend-concede |
+| `raid-canonical-implementation-plan` | 3 | Writer/reviewer task decomposition |
+| `raid-canonical-implementation` | 4 | Strategic TDD implementation — no challengers |
+| `raid-canonical-review` | 5 | Review + fix sub-phase (optional) |
 | `raid-wrap-up` | 6 | Storyboard, PR, vault archival |
 | `raid-tdd` | Any | RED-GREEN-REFACTOR enforcement |
 | `raid-verification` | Any | Evidence-before-claims gate |
@@ -210,8 +116,8 @@ When `browser.enabled` is `true`:
 | Thought | Reality |
 |---------|---------|
 | "This phase is obvious, skip it" | Obvious phases hide assumptions. |
-| "The agents agree, no need for cross-testing" | Agreement without challenge is groupthink. |
+| "The agents agree after one round, let's close" | Minimum 2 rounds. Agreement without challenge is groupthink. |
 | "TDD would slow us down" | TDD is an Iron Law. No exceptions. |
 | "Let me ask the human directly" | Route through the Wizard. Always. |
 | "Let me just post everything to the Dungeon" | Pin only what survived challenge. |
-| "I'll wait for the Wizard to tell me what to do" | Self-organize within the round. |
+| "I'll wait for the Wizard to tell me what to do" | You wait for your turn dispatch, then work your angle fully. |