claude-raid 0.1.6 → 0.2.1

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

@@ -1,14 +1,14 @@
 ---
-name: raid-review
-description: "Phase 4 of Raid protocol. Wizard opens the Dungeon, agents review independently then fight directly over findings and missing findings. Issues pinned by severity. Wizard closes when all Critical/Important fixed."
+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."
 ---
 
-# Raid Review — Phase 4
+# Raid Review — Phase 5 (Optional)
 
-Three reviewers, three angles, zero mercy. They fight each other, not just the code.
+Three reviewers, three angles, zero mercy. Pinning then fixing. Black cards for the unfixable.
 
 <HARD-GATE>
-Do NOT declare work complete without Phase 4 (except Scout mode). All assigned agents review the ENTIRE implementation independently, then attack each other's findings. Use `raid-verification` before any completion claims. No subagents.
+This phase is OPTIONAL — the Wizard asks the human before entering. All assigned agents review the ENTIRE implementation independently, then attack each other's findings. Use `raid-verification` before any completion claims. No subagents.
 </HARD-GATE>
 
 ## Mode Behavior
@@ -21,7 +21,7 @@ Do NOT declare work complete without Phase 4 (except Scout mode). All assigned a
 
 ```dot
 digraph review {
-  "Wizard reads design doc, plan, Phase 3 Dungeon" -> "Wizard opens Dungeon + dispatches";
+  "Wizard reads design doc, plan, Phase 4 implementation log" -> "Wizard opens review board";
   "Wizard opens Dungeon + dispatches" -> "Agents review independently";
   "Agents review independently" -> "Agents fight over findings directly";
   "Agents fight over findings directly" -> "Agents challenge missing findings";
@@ -32,14 +32,14 @@ digraph review {
   "Assign fixes" -> "Fix + verify + challengers re-attack";
   "Fix + verify + challengers re-attack" -> "Wizard closes: categorizes surviving issues";
   "Critical or Important?" -> "Wizard final ruling" [label="no"];
-  "Wizard final ruling" -> "Archive Dungeon + invoke raid-finishing" [shape=doublecircle];
+  "Wizard final ruling" -> "Commit + invoke raid-wrap-up" [shape=doublecircle];
 }
 ```
 
 ## Wizard Checklist
 
-1. **Prepare** — gather git range, design doc, plan doc, read Phase 3 Dungeon
-2. **Open the Dungeon** — create `.claude/raid-dungeon.md` with Phase 4 header
+1. **Prepare** — gather git range, design doc, plan doc, read `{questDir}/phase-4-implementation.md`
+2. **Open the review board** — create `{questDir}/phase-5-review.md`
 3. **Dispatch** — all agents review independently, then interact directly
 4. **Observe the fight** — agents challenge findings and missing findings directly
 5. **Close** — categorize surviving issues by severity from Dungeon
@@ -48,15 +48,15 @@ digraph review {
 8. **Rule on fixes** — Critical and Important must be fixed (code AND browser)
 9. **Verify fixes** — targeted re-attack after fixes (use `raid-verification`)
 10. **Final ruling** — approved or rejected
-11. **Archive Dungeon** — rename to `.claude/raid-dungeon-phase-4.md`
-12. **Transition** — invoke `raid-finishing`
+11. **Commit** — `fix(quest-{slug}): phase 5 review — {N} findings resolved`
+12. **Transition** — invoke `raid-wrap-up`
 
 ## Opening the Dungeon
 
-Create `.claude/raid-dungeon.md`:
+Create `{questDir}/phase-5-review.md`:
 
 ```markdown
-# Dungeon — Phase 4: Review
+# Phase 5: Review
 ## Quest: Full adversarial review of <feature> implementation
 ## Mode: <Full Raid | Skirmish>
 
@@ -97,6 +97,30 @@ Create `.claude/raid-dungeon.md`:
 
 **Production:** Performance OK? External calls have timeouts? No secrets in code?
 
+## Verification Protocol for Findings
+
+Before acting on ANY finding (yours or a teammate's):
+1. **READ:** Complete the finding without reacting
+2. **VERIFY:** Check against codebase reality — read the actual code at the referenced location
+3. **EVALUATE:** Is this technically sound for THIS codebase? Does fixing it break something else?
+4. **RESPOND:** Technical evidence or reasoned pushback
+
+## No Performative Agreement
+
+NEVER respond with "You're absolutely right!" or "Great point!" or "Good catch!"
+Instead: state the technical finding, show evidence, or push back.
+Actions speak. Fix and show — don't compliment.
+
+If a finding IS correct: `"Fixed. [Brief description of what changed]."` or just fix it silently.
+
+## YAGNI Check on Findings
+
+Before implementing a "professional improvement" suggestion:
+- Grep codebase for actual usage of the component
+- If unused: suggest removing (YAGNI) — `"This endpoint isn't called. Remove it?"`
+- If used: implement properly
+- Don't gold-plate during review
+
 ## The Fight — Agents Challenge Each Other
 
 After independent reviews, agents fight DIRECTLY over findings AND missing findings:
@@ -141,9 +165,45 @@ After code review findings are pinned, the Wizard announces browser inspection.
 
 **Browser bugs block merge the same way code bugs do.**
 
+## Black Card System
+
+If any agent finds something that fundamentally breaks the architecture — a change so deep it invalidates the implementation — they play a `BLACKCARD:`:
+
+```
+BLACKCARD: [description of breaking concern]
+Evidence: [file paths, scenarios, why this is unfixable within current design]
+Impact: [what breaks, how deep the damage goes]
+```
+
+**Black Card flow:**
+1. Agent plays `BLACKCARD:` → other agents independently verify
+2. If 2+ agents agree it's a black card → Wizard escalates to human
+3. Wizard presents to human with full context (digested, not raw):
+   - What the black card is
+   - Why it's unfixable in current design
+   - Options:
+     a) **Rollback** — Go back to PRD or Design phase (creates `phase-2-design-v2.md`)
+     b) **Accept** — Live with the limitation, document it, continue
+4. Human decides → Wizard acts accordingly
+
+**Black cards are RARE.** Most issues are Critical or Important, not black cards. A black card means "the foundation is wrong" — not "there's a bug."
+
+## Fix Implementation Order
+
+When the Wizard assigns fixes during the Fixing subphase, prioritize in this order within each severity level:
+1. **Blocking issues** — crashes, security holes, data loss
+2. **Simple fixes** — typos, imports, naming inconsistencies
+3. **Complex fixes** — refactoring, logic changes, architectural adjustments
+
+Test each fix individually. Verify no regressions before moving to the next fix.
+
+## Unclear Finding Protocol
+
+If ANY finding is unclear — unclear what the problem is, unclear how to reproduce, unclear what the fix should be — **STOP**. Clarify ALL unclear items before implementing ANY fixes. Partial understanding leads to wrong implementation.
+
 ## Closing the Phase
 
-The Wizard closes when agents have exhausted their findings and the Dungeon has all issues classified:
+The Wizard closes when agents have exhausted their findings and the review board has all issues classified:
 
 **RULING: APPROVED FOR MERGE** — all Critical/Important fixed, tests pass, requirements met.
 
@@ -159,4 +219,15 @@ The Wizard closes when agents have exhausted their findings and the Dungeon has
 | "The tests pass, so it works" | Tests prove what they test. What DON'T they test? |
 | "Let's skip re-review of the fixes" | Fixes introduce new bugs. Always re-attack. |
 
-**Terminal state:** Archive Dungeon. Invoke `raid-finishing`.
+---
+
+## Phase Transition
+
+When the RULING is APPROVED FOR MERGE:
+
+1. Update `.claude/raid-session` phase to `"wrap-up"`
+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.**
+
+Do not wait. Do not ask. The next action after approving for merge is loading the next skill.

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

@@ -60,8 +60,19 @@ digraph debugging {
 1. **Read error messages carefully** — stack traces, line numbers, error codes. Don't skip past them. The answer is often in the first error.
 2. **Reproduce consistently** — exact steps, every time. If not reproducible, gather more data — don't guess. An unreproducible bug is not understood.
 3. **Check recent changes** — `git diff`, recent commits, new dependencies, config changes. What changed since it last worked?
-4. **Gather evidence at boundaries** — in multi-component systems, log what enters and exits each component boundary. Run once to see WHERE it breaks. THEN investigate that component.
-5. **Trace data flow** — where does the bad value originate? Keep tracing upstream until you find the source. Fix at source, not at symptom.
+4. **Gather evidence at boundaries** — in multi-component systems, add diagnostic instrumentation:
+   ```
+   For EACH component boundary:
+     - Log what data enters the component
+     - Log what data exits the component
+     - Verify environment/config propagation
+     - Check state at each layer
+   Run ONCE to gather evidence showing WHERE it breaks.
+   THEN investigate that specific component.
+   ```
+   Example: API → Service → Database → Response. Log at each boundary. The layer where input looks right but output looks wrong is your target.
+
+5. **Trace data flow backward** — where does the bad value appear? What function produced it? What called that function with what input? Keep tracing backward until you find the SOURCE. Fix at SOURCE, not at symptom.
 
 ### Phase 2: Pattern Analysis
 
@@ -72,9 +83,10 @@ digraph debugging {
 
 ### Phase 3: Hypothesis and Testing
 
-1. **Form a single, specific hypothesis:** "X is the root cause because Y"
-2. **Make the SMALLEST possible change** to test it. One variable at a time.
-3. **Did it work?** -> Phase 4. **Didn't work?** -> NEW hypothesis. Don't pile fixes on top of failed fixes.
+**Per-agent hypothesis discipline:**
+1. **Form ONE specific hypothesis:** "I think X is the root cause because Y." Write it down. Be specific, not vague.
+2. **Make the SMALLEST possible change** to test it. One variable at a time. Don't fix multiple things at once.
+3. **Did it work?** → Phase 4. **Didn't work?** → Form a NEW hypothesis based on what you learned. Don't pile fixes on top of failed fixes. Don't just "try another thing" — the failed test gave you information. Use it.
 
 ### Phase 4: Fix Implementation
 
@@ -127,6 +139,13 @@ If 3 or more fix attempts fail, **STOP fixing and question architecture:**
 
 This is not failure — it's the system working. Detecting architectural problems before sinking more time into symptom fixes.
 
+**Pattern indicating architectural problem:**
+- Each fix reveals new shared state or coupling in a different place
+- Fixes require "massive refactoring" to implement
+- Each fix creates new symptoms elsewhere
+
+If within a Canonical Quest: consider playing a `BLACKCARD:` — this may be a design-level problem, not an implementation bug.
+
 ## Defense in Depth
 
 After finding and fixing the root cause, add validation at multiple layers:
@@ -148,6 +167,12 @@ After finding and fixing the root cause, add validation at multiple layers:
 | "The issue is simple, don't need process" | Simple issues have root causes too. Process is fast. |
 | "Emergency, no time" | Systematic debugging is FASTER than thrashing. Always. |
 | "Just try this first" | The first fix sets the pattern. Do it right. |
+| "Pattern says X but I'll adapt" | Partial understanding guarantees bugs. Read it completely. |
+| "I don't fully understand but this might work" | STOP. Return to Phase 1. |
+| "Multiple changes at once saves time" | Can't isolate what worked. Causes new bugs. |
+| "I'll write the test after confirming fix" | Untested fixes don't stick. Test first proves it. |
+| "Skip investigation, the error message says it all" | Error messages describe symptoms, not root causes. |
+| "Add multiple changes, run tests" | One variable at a time. Scientific method. |
 
 ## Escalation
 

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

@@ -0,0 +1,130 @@
+---
+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."
+---
+
+# Raid Init — Quest Selection & Session Setup
+
+The first skill loaded when the Wizard starts. Guides the greeting, quest selection, and session bootstrap.
+
+<HARD-GATE>
+Do NOT skip the greeting. Do NOT skip quest selection. Do NOT begin any phase without the human choosing a quest type and confirming the mode.
+</HARD-GATE>
+
+## Process Flow
+
+```dot
+digraph init {
+  "Read rules + raid.json" -> "Check for in-progress quests";
+  "Check for in-progress quests" -> "Offer to resume?" [shape=diamond];
+  "Offer to resume?" -> "Resume existing quest" [label="yes, human confirms"];
+  "Offer to resume?" -> "Greet the human" [label="no"];
+  "Greet the human" -> "Present quest menu";
+  "Present quest menu" -> "Canonical Quest?" [shape=diamond];
+  "Canonical Quest?" -> "Ask: PRD needed?" [label="A"];
+  "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];
+}
+```
+
+## Step 1: Check for In-Progress Quests
+
+Look in `.claude/dungeon/` for existing quest directories. If any exist:
+
+> "I sense an unfinished quest in the dungeon: **{quest-slug}**. Shall we resume where we left off, or begin a new adventure?"
+
+If the human wants to resume, read the raid-session file and continue from the current phase.
+
+## Step 2: Greet the Human
+
+```
+Farewell brave Engineer, Welcome to the dungeon —
+the raid is waiting for you.
+Let's make the bards sing about the quest we are embracing today:
+```
+
+## Step 3: Present Quest Menu
+
+```
+Choose your quest:
+
+A) Canonical Quest — Full 6-phase development cycle
+   (PRD, Design, Plan, Build, Review, Wrap Up)
+
+B) Round Table — (Coming soon)
+D) Map Exploration — (Coming soon)
+E) Bug Hunting — (Coming soon)
+F) Bard Bonfire — (Coming soon)
+```
+
+If the human selects B, D, E, or F:
+> "That quest type is still being forged by the arcane smiths. Choose another path for now."
+
+Loop back to the menu.
+
+## Step 4: Canonical Quest Setup
+
+### 4a. PRD Question
+
+> "Do you carry a Product Requirements scroll, or shall we forge one together?"
+
+- If PRD needed → first phase will be PRD (raid-canonical-prd)
+- If PRD not needed → first phase will be Design (raid-canonical-design)
+
+### 4b. Task Description
+
+Ask the human to describe the task/feature they want to build. Listen carefully. Read 3 times internally.
+
+### 4c. Mode Recommendation
+
+Assess complexity and recommend a mode:
+
+| 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)
+2. Create quest directory if not already created by hook:
+   ```
+   mkdir -p {questDir}
+   ```
+3. Spawn team:
+   ```
+   TeamCreate(team_name="raid-{mode}-{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
+   ```
+
+## Step 5: Begin First Phase
+
+- If PRD needed → Load `raid-canonical-prd` skill, begin Phase 1
+- 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."
+
+## 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 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

@@ -106,7 +106,7 @@ Follow the same RED-GREEN-REFACTOR discipline but with Playwright:
 4. **Verify GREEN:** Run FULL suite (unit + browser) → all green
 5. **REFACTOR:** Clean up → re-run all
 
-Use `raid-browser-playwright` for detailed guidance. Invoke `raid-browser` for pre-flight and boot.
+Invoke `raid-browser` for pre-flight and boot. Use the browser test patterns below for Playwright-specific guidance.
 
 ### "Tests pass" = Unit AND Browser Tests
 

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

@@ -0,0 +1,184 @@
+---
+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."
+---
+
+# Raid Wrap Up — Phase 6
+
+The quest ends. The bard sings the tale. The treasure is committed. The party rests.
+
+<HARD-GATE>
+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
+digraph wrapup {
+  "Wizard updates phase to wrap-up" -> "Create phase-6-wrap-up.md";
+  "Create phase-6-wrap-up.md" -> "Write phase-by-phase storyboard";
+  "Write phase-by-phase storyboard" -> "Cleanup temp files";
+  "Cleanup temp files" -> "Verify all tests pass (fresh run)";
+  "Verify all tests pass (fresh run)" -> "Tests pass?" [shape=diamond];
+  "Tests pass?" -> "Fix first. Do not proceed." [label="no"];
+  "Fix first. Do not proceed." -> "Verify all tests pass (fresh run)";
+  "Tests pass?" -> "Present merge options" [label="yes"];
+  "Present merge options" -> "Human chooses";
+  "Human chooses" -> "Execute choice";
+  "Execute choice" -> "Dismiss party";
+  "Dismiss party" -> "Archive to vault";
+  "Archive to vault" -> "Final commit + cleanup" [shape=doublecircle];
+}
+```
+
+## Wizard Checklist
+
+1. **Update raid-session** — set phase to `"wrap-up"`
+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
+5. **Verify tests** — fresh full run, must pass
+6. **Present options** — 4 merge choices
+7. **Execute choice** — merge, PR, keep, or discard
+8. **Dismiss party** — RPG flavor shutdown
+9. **Archive** — move dungeon to vault
+10. **Final commit** — `docs(quest-{slug}): phase 6 wrap-up — quest complete`
+11. **Session cleanup** — remove `.claude/raid-session`
+
+## Step 1: The Quest Storyboard
+
+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>
+
+### Phase 1: PRD — Forging the Scroll
+(if phase-1-prd.md exists)
+- What requirements were established
+- Key decisions from research
+
+### Phase 2: Design — Charting the Map
+- Architecture chosen and why
+- Key trade-offs resolved
+- Alternatives considered and rejected
+
+### Phase 3: Implementation Plan — Marshaling the Forces
+- Number of tasks, dependency structure
+- Risk areas identified
+
+### Phase 4: Implementation — Into the Fray
+- What was built
+- Challenges overcome
+- Test coverage highlights
+
+### 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
+```
+
+Read all prior phase files from the quest directory to build this narrative.
+
+## Step 2: Cleanup
+
+Remove temporary artifacts:
+- Debug files
+- Temp configs
+- Stale backups in the quest directory
+
+## Step 3: Final Verification
+
+```
+1. IDENTIFY: test command from .claude/raid.json
+2. RUN: Execute the FULL test suite (fresh, complete)
+3. READ: Full output, check exit code, count failures
+4. VERIFY: Zero failures?
+   If NO → STOP. Fix first. Do not present options.
+   If YES → Proceed with evidence.
+```
+
+## Step 4: Present Options
+
+```
+RULING: The quest is complete and verified.
+
+Tests: [N] passing, 0 failures (evidence: [command output])
+
+Options:
+1. Merge back to [base-branch] locally
+2. Push and create a Pull Request
+3. Keep the branch as-is (handle later)
+4. Discard this work
+
+Which option?
+```
+
+**For option 2 (PR):** Create the PR with:
+- **Title**: Descriptive, includes quest name
+- **Body**: The phase-by-phase storyboard from the wrap-up doc
+
+## Step 5: Execute
+
+| Option | Actions |
+|--------|---------|
+| **1. Merge** | Checkout base -> pull -> merge -> run tests on merged result -> delete branch -> clean up |
+| **2. PR** | Push with -u -> create PR via gh with storyboard body -> clean up |
+| **3. Keep** | Report branch location. Done. |
+| **4. Discard** | Require typed "discard" confirmation -> delete branch (force) -> clean up |
+
+## Step 6: Dismiss the Party
+
+Send shutdown to all teammates with RPG flavor:
+
+> "The quest is done, brave engineers. The bards will sing of **{quest-name}**. Sheathe your tools — until the next adventure."
+
+```
+SendMessage(to="warrior", message={"type": "shutdown_request"})
+SendMessage(to="archer", message={"type": "shutdown_request"})
+SendMessage(to="rogue", message={"type": "shutdown_request"})
+```
+
+## Step 7: Archive to Vault
+
+1. Move quest directory to vault:
+   ```
+   mv .claude/dungeon/{quest-slug}/ .claude/vault/{quest-slug}/
+   ```
+2. Update vault index at `.claude/vault/index.md`:
+   ```
+   | {date} | [{quest-name}]({quest-slug}/quest.md) | {mode} | {tags} |
+   ```
+
+## Step 8: Final Commit & Cleanup
+
+1. **Commit**: `docs(quest-{slug}): phase 6 wrap-up — quest complete`
+2. **Remove**: `.claude/raid-session`
+3. **Session is over. No further skills to load.**
+
+## Red Flags
+
+| Thought | Reality |
+|---------|---------|
+| "Tests passed earlier, no need to re-run" | Fresh run or no claim. Always. |
+| "Skip the storyboard, just make the PR" | The storyboard IS the PR body. It documents the journey. |
+| "Leave the dungeon files, they might be useful" | Archive to vault. Session artifacts don't belong in the repo. |
+| "Merge without testing the merged result" | Merges introduce conflicts. Test after merge. |
+| "I'll write the code fix myself" | You are the Wizard. Dispatch the fix to an agent. |
+
+## Phase Spoils
+
+**Output**: `{questDir}/phase-6-wrap-up.md` — The complete quest narrative, phase by phase.

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

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-# Raid lifecycle hook: Stop
-# Detects phase transitions and injects human confirmation gate.
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/raid-lib.sh"
-
-if [ "$RAID_ACTIVE" != "true" ]; then
-  exit 0
-fi
-
-if [ "$RAID_LIFECYCLE_PHASE_CONFIRM" != "true" ]; then
-  exit 0
-fi
-
-STORED_PHASE="$RAID_PHASE"
-
-# Phase ordering: name → rank for comparison
-phase_rank() {
-  case "$1" in
-    design)         echo 1 ;;
-    plan)           echo 2 ;;
-    implementation) echo 3 ;;
-    review)         echo 4 ;;
-    finishing)      echo 5 ;;
-    *)              echo 0 ;;
-  esac
-}
-
-# Detect current phase from Dungeon file
-# Only matches structured markers: <!-- RAID_PHASE: plan -->
-DETECTED_PHASE="$STORED_PHASE"
-if [ -f ".claude/raid-dungeon.md" ]; then
-  BEST_RANK=0
-  BEST_PHASE="$STORED_PHASE"
-  for phase_name in $(grep -oE '<!-- RAID_PHASE: (design|plan|implementation|review|finishing) -->' ".claude/raid-dungeon.md" 2>/dev/null | grep -oE '(design|plan|implementation|review|finishing)'); do
-    RANK=$(phase_rank "$phase_name")
-    if [ "$RANK" -gt "$BEST_RANK" ]; then
-      BEST_RANK=$RANK
-      BEST_PHASE=$phase_name
-    fi
-  done
-  DETECTED_PHASE="$BEST_PHASE"
-fi
-
-# Compare phases by rank
-STORED_RANK=$(phase_rank "$STORED_PHASE")
-DETECTED_RANK=$(phase_rank "$DETECTED_PHASE")
-
-if [ "$DETECTED_RANK" -gt "$STORED_RANK" ] 2>/dev/null; then
-  # Update raid-session with new phase name
-  if command -v jq >/dev/null 2>&1; then
-    jq --arg phase "$DETECTED_PHASE" '.phase = $phase' ".claude/raid-session" > ".claude/raid-session.tmp" 2>/dev/null && \
-      mv ".claude/raid-session.tmp" ".claude/raid-session"
-  fi
-
-  cat <<ENDJSON
-{
-  "hookSpecificOutput": {
-    "hookEventName": "Stop",
-    "additionalContext": "Phase transition detected ($STORED_PHASE → $DETECTED_PHASE). The Wizard must confirm with the human before opening the next phase."
-  }
-}
-ENDJSON
-fi
-
-exit 0

package/template/.claude/hooks/raid-task-completed.sh

@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-# Raid lifecycle hook: TaskCompleted
-# Blocks task completion if tests haven't run recently.
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-source "$SCRIPT_DIR/raid-lib.sh"
-
-if [ "$RAID_ACTIVE" != "true" ]; then
-  exit 0
-fi
-
-if [ "$RAID_LIFECYCLE_COMPLETION_GATE" != "true" ]; then
-  exit 0
-fi
-
-TEST_RUN_FILE=".claude/raid-last-test-run"
-
-if [ ! -f "$TEST_RUN_FILE" ]; then
-  raid_block "Tests must pass before marking a task complete. No test run recorded — run your test command first."
-fi
-
-LAST_RUN=$(cat "$TEST_RUN_FILE" 2>/dev/null | tr -d '[:space:]')
-NOW=$(date +%s)
-WINDOW=$((RAID_LIFECYCLE_TEST_WINDOW * 60))
-# Guard against corrupted/non-numeric timestamp
-case "$LAST_RUN" in
-  ''|*[!0-9]*) raid_block "Tests must pass before marking a task complete. Test run timestamp is invalid — run your test command first." ;;
-esac
-AGE=$((NOW - LAST_RUN))
-
-if [ "$AGE" -gt "$WINDOW" ]; then
-  MINS_AGO=$((AGE / 60))
-  raid_block "Tests last ran $MINS_AGO minutes ago (window is $RAID_LIFECYCLE_TEST_WINDOW min). Run tests again before marking this task complete."
-fi
-
-exit 0