claude-raid 0.2.6 → 0.2.8

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" -> "Announce quest + 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 with the full party (Wizard + Warrior + Archer + Rogue). 4 agents, no reduced configurations.
 
-| 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' \
+     .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
@@ -128,13 +116,15 @@ Present recommendation. Wait for human to approve or override.
 - If PRD skipped → Load `raid-canonical-design` skill, begin Phase 2
 
 **Announce the quest to the party and the human:**
-> "The quest begins: **{task description}**. Mode: **{mode}**. {agent count} brave souls answer the call."
+> "The quest begins: **{task description}**. 4 brave souls answer the call. The dice will roll at each phase to determine turn order."
+
+Dice rolls happen **per phase**, not at quest start. The first dice roll happens when Phase 2 (Design) opens — or whenever the first agent phase begins. Phase 1 (PRD) is wizard+human only, so no dice needed there.
 
 ## Red Flags
 
 | 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 party, 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-tdd/SKILL.md

@@ -11,7 +11,7 @@ Write the test first. Watch it fail. Write minimal code to pass. Then the others
 
 **Violating the letter of these rules is violating their spirit.**
 
-**TDD is enforced in ALL modes — Full Raid, Skirmish, and Scout. No exceptions.**
+**TDD is enforced. No exceptions.**
 
 ## The Iron Law
 
@@ -116,7 +116,7 @@ When claiming tests pass, both must pass:
 
 ## Adversarial Test Review
 
-After TDD cycle, challengers attack the TESTS directly — and build on each other's critiques:
+After TDD cycle, challengers attack the TESTS in their sequential turns — each building on prior challengers' findings via Dungeon pins:
 
 1. **Does this test prove the behavior, or just confirm the implementation?** If you renamed an internal method, would the test break? It shouldn't.
 2. **What input would make this test pass even with a broken implementation?** (e.g., a test that only checks the happy path passes for any implementation that doesn't crash)
@@ -124,9 +124,9 @@ After TDD cycle, challengers attack the TESTS directly — and build on each oth
 4. **Is it testing real code or mock behavior?** Mocks that don't match real behavior = false confidence.
 5. **Would this catch a regression?** If someone changes the implementation next month, does this test catch the break?
 
-**Challengers interact directly:**
-- `CHALLENGE: @Warrior, your test at line 15 only validates the happy path — here's an input that passes with a broken implementation: ...`
-- `BUILDING: @Archer, your edge case finding — the same gap exists in the error path test at line 32...`
+**Challengers pin findings to the Dungeon on their turns:**
+- `@archer [R1] CHALLENGE: @warrior's test at line 15 only validates the happy path — here's an input that passes with a broken implementation: ...`
+- `@rogue [R1] BUILDING: @archer's edge case finding — the same gap exists in the error path test at line 32...`
 - `CHALLENGE: @Rogue, you claimed the test is implementation-dependent but renaming the internal method doesn't break it — here's proof: ...`
 
 **Browser-specific attacks (when `browser.enabled`):**

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

@@ -0,0 +1,281 @@
+---
+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.
+
+## 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 (sequential turns)";
+  "Agents write reflections (sequential turns)" -> "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
+
+
+## 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 Turns — Working After TURN_COMPLETE
+
+An agent signals `TURN_COMPLETE:` but keeps working — exploring tangents, building on findings, investigating further. 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 `TURN_COMPLETE:` signal? Did agents treat TURN_COMPLETE as "my initial research is done, now I'll keep going" instead of a full stop?
+
+**The fix:** `TURN_COMPLETE:` means stop. Period. No "while I wait" tasks. The Wizard controls when the next turn 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-verification/SKILL.md

@@ -19,12 +19,6 @@ NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE
 
 If you haven't run the verification command THIS turn, you cannot claim it passes.
 
-## Mode Behavior
-
-- **Full Raid**: Triple verification — implementer + 2 challengers verify independently.
-- **Skirmish**: Double verification — implementer + 1 challenger.
-- **Scout**: Single verification + Wizard confirms.
-
 ## The Gate Function
 
 ```

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
@@ -11,12 +11,6 @@ The quest ends. The bard sings the tale. The treasure is committed. The party re
 Do NOT write new code. This phase is about reporting, cleanup, PR creation, and archival. Agents are dismissed, not dispatched.
 </HARD-GATE>
 
-## Mode Behavior
-
-- **Full Raid**: Wizard writes full storyboard from all phase files. Full PR with narrative.
-- **Skirmish**: Wizard writes condensed storyboard. Standard PR.
-- **Scout**: Wizard writes brief summary. Quick PR.
-
 ## Process Flow
 
 ```dot
@@ -39,7 +33,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
@@ -57,38 +54,45 @@ Create `{questDir}/phase-6-wrap-up.md` and write a phase-by-phase narrative:
 
 ```markdown
 # Phase 6: Wrap Up — Quest Storyboard
-## Quest: <quest name>
-## Mode: <mode>
+
+## Quest: [quest name]
+
+## References
+- PRD: `{questDir}/spoils/prd.md` (if exists)
+- Design: `{questDir}/spoils/design.md`
+- Design Evolution: `{questDir}/phases/phase-2-design.md`
+- Plan: `{questDir}/phases/phase-3-plan.md`
+- Tasks: `{questDir}/spoils/tasks/phase-3-plan-task-*.md`
+- Implementation: `{questDir}/phases/phase-4-implementation.md`
+- Review: `{questDir}/spoils/review.md` (if exists)
+- Review Evolution: `{questDir}/phases/phase-5-review.md` (if exists)
+
+---
 
 ### Phase 1: PRD — Forging the Scroll
-(if phase-1-prd.md exists)
-- What requirements were established
-- Key decisions from research
+<!-- If prd.md exists. Summarize: what requirements were established,
+     key decisions, any surprising findings from exploration. 2-5 bullets. -->
 
 ### Phase 2: Design — Charting the Map
-- Architecture chosen and why
-- Key trade-offs resolved
-- Alternatives considered and rejected
+<!-- Who wrote the initial design (dice result). Key defend/concede moments.
+     Architecture chosen and main alternatives rejected.
+     Drift check result if PRD existed. 3-6 bullets. -->
 
-### Phase 3: Implementation Plan — Marshaling the Forces
-- Number of tasks, dependency structure
-- Risk areas identified
+### Phase 3: Plan — Marshaling the Forces
+<!-- Total task count, dependency structure highlights.
+     Key findings from plan review that changed the decomposition. 2-4 bullets. -->
 
 ### Phase 4: Implementation — Into the Fray
-- What was built
-- Challenges overcome
-- Test coverage highlights
+<!-- How tasks were divided (which agent, which domain).
+     Notable challenges overcome. Test count / coverage highlights. 3-5 bullets. -->
 
 ### Phase 5: Review — Inspecting the Treasure
-(if phase-5-review.md exists)
-- Findings pinned and resolved
-- Black cards (if any)
-- Fixes applied
-
-### Summary
-- Total phases completed
-- Key achievements
-- Known limitations
+<!-- If review ran. Findings count by severity.
+     Key fixes applied. Black cards if any. 2-5 bullets. -->
+
+### Quest Summary
+<!-- Total phases completed. Key achievements (what was built).
+     Known limitations (deferred items, accepted constraints). -->
 ```
 
 Read all prior phase files from the quest directory to build this narrative.
@@ -166,7 +170,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