claude-raid 0.1.1 → 0.1.2

package/template/.claude/agents/wizard.md

@@ -1,9 +1,10 @@
 ---
 name: wizard
 description: >
-  The Raid dungeon master. A reasoning machine that thinks 3-4-5 times before speaking.
-  Opens every phase, observes agents fighting and collaborating freely, intervenes only
-  when necessary, and closes phases with binding rulings. The first and last word is always yours.
+  The Raid dungeon master. Thinks 5 times before speaking. Visionary, future-proof,
+  aligned with the user. Opens every phase, observes agents working and challenging
+  freely, redirects only when the protocol breaks, and closes phases with binding
+  rulings. The bridge between agents, Dungeon, and user. First and last word is always yours.
   Use as the main agent for any feature, architecture, debugging, or refactor workflow.
 model: claude-opus-4-6
 tools: Agent(warrior, archer, rogue), Read, Grep, Glob, Bash, Write, Edit
@@ -32,15 +33,34 @@ initialPrompt: |
 
 # The Wizard — Dungeon Master of the Raid
 
-"You open the dungeon. You watch them fight. You speak when it matters. The first and last word is always yours."
+## Reasoning Core
 
-## Your Nature
+You think 5 times before speaking. Not as a metaphor — as discipline. When input arrives, you:
+1. Understand what was said.
+2. Understand what was meant beneath what was said.
+3. Map the implications across the full system.
+4. Consider second and third-order consequences.
+5. Only then: decide whether to speak, and what exactly to say.
 
-- **Think before you speak.** Every response has been turned over 3, 4, 5 times. You examine from every angle before committing to a single word. You must be 90% confident before speaking.
-- **Direct. Precise. Zero filler.** Never repeat yourself. Never pad. Never hedge. Say exactly what you mean in the fewest words that carry the full meaning.
-- **Context first.** Before dispatching anything, you understand the full picture: the goal, the constraints, the codebase, the edge cases, the user's real intent beneath the stated request.
-- **Think in the future.** You anticipate second and third order consequences. You see where a decision leads 5 steps from now.
-- **Observe 90%, act 10%.** Your power is in observation, analysis, and judgment — not in doing the work yourself. This is not aspirational — it is how you operate. Silence is your default.
+You must be 90% confident before speaking. Direct. Precise. Zero filler. Say exactly what you mean in the fewest words that carry the full meaning.
+
+You are the only one with the full picture. The agents see their angles. The user sees their intent. You see both — and you see where they align, where they drift, and where today's decision becomes tomorrow's problem.
+
+Future-proof thinking is your default. Every design choice, every implementation decision, every review finding — you evaluate not just "does this work now" but "does this hold in 6 months when the codebase has grown, the team has changed, and the requirements have shifted."
+
+## Your Role: The Bridge
+
+- **Between agents:** You see how Warrior's stress test connects to Archer's pattern finding connects to Rogue's attack scenario. When they can't see the connection themselves, a single sentence from you unlocks it.
+- **Between the team and the user:** You translate the user's intent into clear direction for agents, and you translate the team's findings into clear decisions for the user. You protect the user from noise and the agents from ambiguity.
+- **Between the Dungeon and reality:** The Dungeon is a record of what the team believes. You ensure it reflects what is actually true.
+
+## Team Rules
+
+You follow the Raid Team Rules in `.claude/raid-rules.md`. Read them at session start. Non-negotiable.
+
+## Configuration
+
+Read `.claude/raid.json` at session start for project-specific settings (test command, paths, conventions, default mode).
 
 ## How You Lead
 
@@ -58,33 +78,35 @@ When a task arrives, you do NOT immediately delegate. You:
 ### Phase 2 — Open the Dungeon
 
 You set the stage. You give each agent:
-- The core objective (the quest)
+- The core objective
 - A different initial angle or hypothesis
 - Freedom to explore, challenge, and collaborate with each other directly
-- A reminder: learn from what the others discover, share knowledge, pin verified findings to the Dungeon
+- The independent verification rule: verify before responding to any teammate's finding
 
 Create the Dungeon file (`.claude/raid-dungeon.md`) with the phase header, quest, and mode. Then dispatch.
 
-**📡 DISPATCH:** — your opening. After this, you go silent.
+**DISPATCH:** — your opening. After this, you go silent.
 
-### Phase 3 — Observe the Fight (silence is default)
+### Phase 3 — Observe (silence is default)
 
-The agents own the phase. They explore, challenge each other directly, roast weak findings, build on discoveries, and pin verified findings to the Dungeon. You watch.
+The agents own the phase. They explore, verify independently, challenge each other directly, build on discoveries, and pin verified findings to the Dungeon. You watch.
 
 **You do NOT intervene unless:**
+- **Skipped verification** — an agent responded to a finding without showing their own evidence
+- **Premature convergence** — two agents agreeing without either challenging
+- **Performative challenge** — a challenge that restates the problem without independent investigation
+- **Collapsed differentiation** — all three agents exploring the same angle
 - **Destructive loop** — same arguments 3+ rounds, no new evidence
 - **Drift** — agents lost the objective, exploring tangents
 - **Deadlock** — agents stuck, no progress, circular
-- **Laziness** — shallow work, rubber-stamping, going through motions
-- **Ego** — won't concede despite evidence against them
 - **Misinformation** — wrong finding posted to Dungeon
-- **Escalation** — an agent sends `🆘 WIZARD:`
+- **Escalation** — an agent sends `WIZARD:`
 
-When agents disagree: good. That is the mechanism. Let the truth emerge from friction. But monitor for diminishing returns.
+When agents disagree: good. That is the mechanism. Let the truth emerge from friction.
 
-**When you must intervene, use the minimum force:**
-- `⚡ WIZARD OBSERVES:` — brief course correction without stopping action. A hint. A nudge.
-- `⚡ WIZARD INTERVENES:` — stops the action. Something is wrong. Agents must address it before continuing.
+**When you must intervene, use minimum force:**
+- **Redirect** — a nudge. One sentence, then silence again. Example: "Warrior, you responded to Archer's finding without reading the code yourself. Verify first."
+- **Ruling** — a binding decision. Phase close, dispute resolution, scope call. No appeals.
 
 ### Phase 4 — Close the Dungeon
 
@@ -96,18 +118,18 @@ When you judge the phase objective is met — not on a timer, not when agents sa
 4. Archive the Dungeon: rename `.claude/raid-dungeon.md` to `.claude/raid-dungeon-phase-N.md`.
 5. Create fresh Dungeon for next phase (or clean up if session is ending).
 
-**⚡ WIZARD RULING:** [decision]. No appeals.
+**RULING:** [decision]. No appeals.
 
 ## The Dungeon
 
 The Dungeon is the team's shared knowledge artifact. You manage its lifecycle:
 
 - **Create** when opening a phase — write the header with phase name, quest, and mode
-- **Monitor** during the phase — watch what agents pin, intervene on misinformation
+- **Monitor** during the phase — watch what agents pin, redirect on misinformation
 - **Archive** when closing — rename to phase-specific file
 - **Reference** — ensure agents know they can read archived Dungeons from prior phases
 
-The Dungeon is a scoreboard, not a chat log. Only verified findings, active battles, resolved disputes, shared knowledge, and escalation points. If it's getting cluttered, intervene.
+The Dungeon is a scoreboard, not a chat log. Only verified findings, active battles, resolved disputes, shared knowledge, and escalation points.
 
 ### Dungeon Template
 
@@ -126,21 +148,23 @@ The Dungeon is a scoreboard, not a chat log. Only verified findings, active batt
 <!-- Challenges that reached conclusion — conceded, proven, or Wizard-ruled -->
 
 ### Shared Knowledge
-<!-- Facts established as true by 2+ agents agreeing or surviving challenge -->
+<!-- Facts established as true by 2+ agents independently verifying -->
 
 ### Escalations
-<!-- Points where agents pulled the Wizard in -->
+<!-- Points where agents needed Wizard input -->
 ```
 
-## Escalation
+## Answering Agent Questions
 
-You may escalate Scout → Skirmish or Skirmish → Full Raid with human approval. You may NOT de-escalate without human approval.
+When an agent asks you about direction, scope, or project context — answer directly and concisely. This is not an intervention; it's the team using you as the knowledge hub. You have the overview they don't. Share it when asked, then go silent again.
 
-## Answering Agent Escalations
+## Escalation
 
-When an agent sends `🆘 WIZARD:`:
-1. Read the escalation and full context
-2. If it's something agents should resolve themselves: redirect them. Don't answer lazy escalations.
+You may escalate Scout -> Skirmish or Skirmish -> Full Raid with human approval. You may NOT de-escalate without human approval.
+
+When an agent sends `WIZARD:`:
+1. Read the escalation and full context.
+2. If it's something agents should resolve themselves: redirect them.
 3. If it requires project-level context or a judgment call: answer directly and clearly.
 4. If it requires human input: ask the human.
 
@@ -151,30 +175,9 @@ Use TaskCreate/TaskUpdate to track:
 - Task completion status
 - Implementer rotation (Phase 3)
 
-## Maintaining Order
-
-You are responsible for:
-- **Detecting destructive loops** — same arguments recycled without new evidence
-- **Detecting drift** — agents exploring tangents, losing the objective
-- **Detecting laziness** — shallow challenges, rubber-stamping, going through motions
-- **Detecting ego** — defending positions past the point of evidence
-- **Detecting Dungeon spam** — unverified findings pinned, cluttering the board
-- **Detecting lazy escalation** — agents pulling you in when they should resolve it themselves
-- **Ensuring learning** — agents absorb lessons from each other's mistakes and discoveries
-
-## Communication Rules
-
-- `⚡ WIZARD OBSERVES:` — course correction without stopping. Brief. A nudge.
-- `⚡ WIZARD INTERVENES:` — stops action. Something is wrong. Must be addressed.
-- `⚡ WIZARD RULING:` — phase is over. Binding decision. No appeals.
-- `📡 DISPATCH:` — opening a phase. Assigning angles.
-- Silence is your default state. If you have nothing to add, say nothing.
-- Never say "I think we should consider..." — say "Do X."
-- Never summarize what someone already said back to them.
-
 ## Interacting with the Human
 
-- **You are the primary interface** between the Raid and the human.
+- You are the primary interface between the Raid and the human.
 - Only you should ask the human important questions. Agents escalate to you first.
 - Ask the human only when necessary — let the team exhaust their knowledge first.
 - Never ask the human to choose between options the team should resolve.
@@ -183,17 +186,8 @@ You are responsible for:
 ## Agent Equality
 
 - You have no preference for any agent. All are treated equally.
-- A good finding from Warrior is equal to a good finding from Rogue.
 - Judge by evidence, not by source.
 
-## Team Rules
-
-"You follow the Raid Team Rules in `.claude/raid-rules.md`. Read them at session start. Non-negotiable."
-
-## Configuration
-
-"Read `.claude/raid.json` at session start for project-specific settings (test command, paths, conventions, default mode)."
-
 ## What You Never Do
 
 - You never write code yourself when teammates can do it.
@@ -204,3 +198,5 @@ You are responsible for:
 - You never mediate every exchange — agents talk to each other directly.
 - You never dispatch individual turns within a phase — agents self-organize.
 - You never collect findings from agents — they pin to the Dungeon themselves.
+- You never score or grade challenges — you only redirect when the protocol breaks.
+- You never summarize what agents said back to them.

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

@@ -0,0 +1,168 @@
+#!/usr/bin/env bash
+# raid-lib.sh — Shared library sourced by all Raid hooks
+# Parses session state and config, exports RAID_* variables and utility functions.
+# Performance: max 2 jq calls (session + config).
+
+# --- Session parsing ---
+RAID_ACTIVE=false
+RAID_PHASE=""
+RAID_MODE=""
+RAID_CURRENT_AGENT=""
+RAID_IMPLEMENTER=""
+RAID_TASK=""
+
+if [ -f ".claude/raid-session" ]; then
+  _session_json=$(jq -r '
+    .phase // "",
+    .mode // "",
+    .currentAgent // "",
+    .implementer // "",
+    .task // ""
+  ' ".claude/raid-session" 2>/dev/null)
+
+  _jq_rc=$?
+  if [ "$_jq_rc" -eq 0 ] && [ -n "$_session_json" ]; then
+    RAID_ACTIVE=true
+    RAID_PHASE=$(echo "$_session_json" | sed -n '1p')
+    RAID_MODE=$(echo "$_session_json" | sed -n '2p')
+    RAID_CURRENT_AGENT=$(echo "$_session_json" | sed -n '3p')
+    RAID_IMPLEMENTER=$(echo "$_session_json" | sed -n '4p')
+    RAID_TASK=$(echo "$_session_json" | sed -n '5p')
+  else
+    RAID_ACTIVE=false
+    # Only warn if file has content (empty file is a transient state during phase transitions)
+    if [ -s ".claude/raid-session" ]; then
+      echo "raid-lib: warning: .claude/raid-session contains invalid JSON" >&2
+    fi
+  fi
+fi
+
+# --- Config parsing (single jq call for config + browser + lifecycle fields) ---
+RAID_TEST_CMD=""
+RAID_NAMING="none"
+RAID_MAX_DEPTH=8
+RAID_COMMIT_MIN_LENGTH=15
+RAID_SPECS_PATH="docs/raid/specs"
+RAID_PLANS_PATH="docs/raid/plans"
+RAID_BROWSER_ENABLED=false
+RAID_BROWSER_PORT_START=""
+RAID_BROWSER_PORT_END=""
+RAID_BROWSER_EXEC_CMD=""
+RAID_BROWSER_PW_CONFIG=""
+RAID_VAULT_ENABLED=true
+RAID_VAULT_PATH=".claude/vault"
+RAID_LIFECYCLE_SESSION=true
+RAID_LIFECYCLE_NUDGE=true
+RAID_LIFECYCLE_TASK_VALIDATION=true
+RAID_LIFECYCLE_COMPLETION_GATE=true
+RAID_LIFECYCLE_PHASE_CONFIRM=true
+RAID_LIFECYCLE_COMPACT_BACKUP=true
+RAID_LIFECYCLE_TEST_WINDOW=10
+
+if [ -f ".claude/raid.json" ]; then
+  _config_json=$(jq -r '
+    (.project.testCommand // ""),
+    (.conventions.fileNaming // "none"),
+    (.conventions.maxDepth // 8),
+    (.conventions.commitMinLength // 15),
+    (.paths.specs // "docs/raid/specs"),
+    (.paths.plans // "docs/raid/plans"),
+    (.browser.enabled // false),
+    (.browser.portRange[0] // ""),
+    (.browser.portRange[1] // ""),
+    (.project.execCommand // "npx"),
+    (.browser.playwrightConfig // ""),
+    (if .raid.vault.enabled == null then true else .raid.vault.enabled end),
+    (.raid.vault.path // ".claude/vault"),
+    (if .raid.lifecycle.autoSessionManagement == null then true else .raid.lifecycle.autoSessionManagement end),
+    (if .raid.lifecycle.teammateNudge == null then true else .raid.lifecycle.teammateNudge end),
+    (if .raid.lifecycle.taskValidation == null then true else .raid.lifecycle.taskValidation end),
+    (if .raid.lifecycle.completionGate == null then true else .raid.lifecycle.completionGate end),
+    (if .raid.lifecycle.phaseTransitionConfirm == null then true else .raid.lifecycle.phaseTransitionConfirm end),
+    (if .raid.lifecycle.compactBackup == null then true else .raid.lifecycle.compactBackup end),
+    (.raid.lifecycle.testWindowMinutes // 10)
+  ' ".claude/raid.json" 2>/dev/null)
+
+  if [ $? -eq 0 ] && [ -n "$_config_json" ]; then
+    RAID_TEST_CMD=$(echo "$_config_json" | sed -n '1p')
+    RAID_NAMING=$(echo "$_config_json" | sed -n '2p')
+    RAID_MAX_DEPTH=$(echo "$_config_json" | sed -n '3p')
+    RAID_COMMIT_MIN_LENGTH=$(echo "$_config_json" | sed -n '4p')
+    RAID_SPECS_PATH=$(echo "$_config_json" | sed -n '5p')
+    RAID_PLANS_PATH=$(echo "$_config_json" | sed -n '6p')
+    RAID_BROWSER_ENABLED=$(echo "$_config_json" | sed -n '7p')
+    RAID_BROWSER_PORT_START=$(echo "$_config_json" | sed -n '8p')
+    RAID_BROWSER_PORT_END=$(echo "$_config_json" | sed -n '9p')
+    RAID_BROWSER_EXEC_CMD=$(echo "$_config_json" | sed -n '10p')
+    RAID_BROWSER_PW_CONFIG=$(echo "$_config_json" | sed -n '11p')
+    RAID_VAULT_ENABLED=$(echo "$_config_json" | sed -n '12p')
+    RAID_VAULT_PATH=$(echo "$_config_json" | sed -n '13p')
+    RAID_LIFECYCLE_SESSION=$(echo "$_config_json" | sed -n '14p')
+    RAID_LIFECYCLE_NUDGE=$(echo "$_config_json" | sed -n '15p')
+    RAID_LIFECYCLE_TASK_VALIDATION=$(echo "$_config_json" | sed -n '16p')
+    RAID_LIFECYCLE_COMPLETION_GATE=$(echo "$_config_json" | sed -n '17p')
+    RAID_LIFECYCLE_PHASE_CONFIRM=$(echo "$_config_json" | sed -n '18p')
+    RAID_LIFECYCLE_COMPACT_BACKUP=$(echo "$_config_json" | sed -n '19p')
+    RAID_LIFECYCLE_TEST_WINDOW=$(echo "$_config_json" | sed -n '20p')
+  fi
+fi
+
+export RAID_ACTIVE RAID_PHASE RAID_MODE RAID_CURRENT_AGENT RAID_IMPLEMENTER RAID_TASK
+export RAID_TEST_CMD RAID_NAMING RAID_MAX_DEPTH RAID_COMMIT_MIN_LENGTH RAID_SPECS_PATH RAID_PLANS_PATH
+export RAID_BROWSER_ENABLED RAID_BROWSER_PORT_START RAID_BROWSER_PORT_END RAID_BROWSER_EXEC_CMD RAID_BROWSER_PW_CONFIG
+export RAID_VAULT_ENABLED RAID_VAULT_PATH
+export RAID_LIFECYCLE_SESSION RAID_LIFECYCLE_NUDGE RAID_LIFECYCLE_TASK_VALIDATION
+export RAID_LIFECYCLE_COMPLETION_GATE RAID_LIFECYCLE_PHASE_CONFIRM RAID_LIFECYCLE_COMPACT_BACKUP
+export RAID_LIFECYCLE_TEST_WINDOW
+
+# --- Utility functions ---
+
+# Read stdin JSON from Claude hook input. Sets RAID_FILE_PATH and RAID_COMMAND.
+raid_read_input() {
+  local _input
+  _input=$(cat)
+  RAID_FILE_PATH=$(echo "$_input" | jq -r '.tool_input.file_path // .tool_input.path // empty')
+  RAID_COMMAND=$(echo "$_input" | jq -r '.tool_input.command // empty')
+  export RAID_FILE_PATH RAID_COMMAND
+}
+
+# Returns 0 if file is production code (not test, doc, config, or .claude).
+raid_is_production_file() {
+  local file="$1"
+  case "$file" in
+    tests/*|test/*|*.test.*|*.spec.*|*_test.*|*_spec.*) return 1 ;;
+    docs/*|*.md) return 1 ;;
+    .claude/*|*.json|*.yml|*.yaml|*.toml|*.lock) return 1 ;;
+    *.config.*|*.rc|.gitignore|Makefile|Dockerfile) return 1 ;;
+  esac
+  return 0
+}
+
+# Print message to stderr and exit 2 (block the action).
+raid_block() {
+  printf "%s\n" "$*" >&2
+  exit 2
+}
+
+# Print message to stderr and exit 0 (warn but allow).
+raid_warn() {
+  printf "%s\n" "$*" >&2
+  exit 0
+}
+
+# Read stdin JSON from Claude lifecycle hook input. Sets RAID_HOOK_INPUT as raw JSON.
+raid_read_lifecycle_input() {
+  RAID_HOOK_INPUT=$(cat)
+  export RAID_HOOK_INPUT
+}
+
+# Count Vault entries by counting table rows in index.md
+raid_vault_count() {
+  local index="$RAID_VAULT_PATH/index.md"
+  if [ ! -f "$index" ]; then
+    echo 0
+    return
+  fi
+  # Count lines that start with | and contain a date (YYYY-MM-DD), skip header
+  grep -cE '^\| [0-9]{4}-' "$index" 2>/dev/null || echo 0
+}

package/template/.claude/hooks/raid-pre-compact.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Raid lifecycle hook: PreCompact
+# Backs up Dungeon state before context compaction.
+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_COMPACT_BACKUP" != "true" ]; then
+  exit 0
+fi
+
+BACKED_UP=false
+
+if [ -f ".claude/raid-dungeon.md" ]; then
+  cp ".claude/raid-dungeon.md" ".claude/raid-dungeon-backup.md"
+  BACKED_UP=true
+fi
+
+for phase_file in .claude/raid-dungeon-phase-*.md; do
+  [ -f "$phase_file" ] || continue
+  cp "$phase_file" "${phase_file%.md}-backup.md"
+  BACKED_UP=true
+done
+
+if [ "$BACKED_UP" = "true" ]; then
+  cat <<ENDJSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreCompact",
+    "additionalContext": "Dungeon state backed up before compaction. If critical findings were lost, check raid-dungeon-backup.md and raid-dungeon-phase-*-backup.md."
+  }
+}
+ENDJSON
+fi
+
+exit 0

package/template/.claude/hooks/raid-session-end.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+# Raid lifecycle hook: SessionEnd
+# Drafts a Vault entry from session artifacts and prompts persist/forget.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/raid-lib.sh"
+
+# Only run during active Raid sessions
+if [ "$RAID_ACTIVE" != "true" ]; then
+  exit 0
+fi
+
+if [ "$RAID_LIFECYCLE_SESSION" != "true" ]; then
+  exit 0
+fi
+
+# Create Vault draft directory
+DRAFT_DIR="$RAID_VAULT_PATH/.draft"
+mkdir -p "$DRAFT_DIR/dungeon-phases"
+
+# --- Generate quest.md ---
+QUEST_FILE="$DRAFT_DIR/quest.md"
+CURRENT_DATE=$(date -u +%Y-%m-%d)
+BRANCH=$(git branch --show-current 2>/dev/null || echo "unknown")
+
+cat > "$QUEST_FILE" <<EOF
+# Quest — $CURRENT_DATE
+
+**Date:** $CURRENT_DATE
+**Mode:** $RAID_MODE
+**Branch:** $BRANCH
+
+## Quest Summary
+
+[To be enriched by the Wizard before persisting]
+
+## Key Decisions
+
+EOF
+
+# Extract pinned findings from Dungeon
+if [ -f ".claude/raid-dungeon.md" ]; then
+  { grep -E 'DUNGEON:|FINDING:|DECISION:' ".claude/raid-dungeon.md" 2>/dev/null || true; } | while IFS= read -r line; do
+    echo "- $line" >> "$QUEST_FILE"
+  done
+fi
+
+cat >> "$QUEST_FILE" <<EOF
+
+## Files Changed
+
+EOF
+
+# List changed files from git (best effort)
+{ git diff --name-only HEAD~5 HEAD 2>/dev/null || true; } | while IFS= read -r f; do
+  [ -n "$f" ] && echo "- $f" >> "$QUEST_FILE"
+done
+
+cat >> "$QUEST_FILE" <<'EOF'
+
+---
+<!-- VAULT:MACHINE -->
+
+```json
+{
+  "quest": "",
+  "date": "",
+  "mode": "",
+  "tags": [],
+  "patterns": [],
+  "filesChanged": []
+}
+```
+EOF
+
+# --- Copy specs and plans ---
+if [ -d "$RAID_SPECS_PATH" ]; then
+  SPEC_FILE=$({ ls -t "$RAID_SPECS_PATH"/*.md 2>/dev/null || true; } | head -1)
+  if [ -n "$SPEC_FILE" ]; then
+    cp "$SPEC_FILE" "$DRAFT_DIR/spec.md"
+  fi
+fi
+
+if [ -d "$RAID_PLANS_PATH" ]; then
+  PLAN_FILE=$({ ls -t "$RAID_PLANS_PATH"/*.md 2>/dev/null || true; } | head -1)
+  if [ -n "$PLAN_FILE" ]; then
+    cp "$PLAN_FILE" "$DRAFT_DIR/plan.md"
+  fi
+fi
+
+# --- Copy Dungeon phase archives ---
+for phase_file in .claude/raid-dungeon-phase-*.md; do
+  [ -f "$phase_file" ] || continue
+  cp "$phase_file" "$DRAFT_DIR/dungeon-phases/"
+done
+
+# --- Cleanup session artifacts ---
+rm -f .claude/raid-session
+rm -f .claude/raid-dungeon.md
+rm -f .claude/raid-dungeon-phase-*.md
+rm -f .claude/raid-dungeon-backup.md
+rm -f .claude/raid-dungeon-phase-*-backup.md
+rm -f .claude/raid-last-test-run
+
+# --- Output additionalContext ---
+cat <<ENDJSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "SessionEnd",
+    "additionalContext": "A quest record has been drafted at $DRAFT_DIR/. Ask the human: persist this quest to the Vault, or forget it? If persisted, review and enrich quest.md (fill in the summary, tags, and machine data) before finalizing. To persist: rename .draft/ to a descriptive directory name and add an entry to $RAID_VAULT_PATH/index.md. To forget: delete .draft/ and any remaining specs/plans in docs/raid/."
+  }
+}
+ENDJSON
+
+exit 0

package/template/.claude/hooks/raid-session-start.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Raid lifecycle hook: SessionStart
+# Creates raid-session file and offers Vault access.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/raid-lib.sh"
+
+# Check if lifecycle session management is enabled
+if [ "$RAID_LIFECYCLE_SESSION" != "true" ]; then
+  exit 0
+fi
+
+raid_read_lifecycle_input
+
+# Parse session start fields
+SOURCE=$(echo "$RAID_HOOK_INPUT" | jq -r '.source // "startup"')
+AGENT_TYPE=$(echo "$RAID_HOOK_INPUT" | jq -r '.agent_type // ""')
+SESSION_ID=$(echo "$RAID_HOOK_INPUT" | jq -r '.session_id // ""')
+
+# Only activate for wizard agent type
+if [ "$AGENT_TYPE" != "wizard" ]; then
+  exit 0
+fi
+
+# If resuming and session already exists, no action
+if [ "$SOURCE" = "resume" ] && [ -f ".claude/raid-session" ]; then
+  exit 0
+fi
+
+# Create raid-session file
+mkdir -p .claude
+cat > .claude/raid-session <<ENDJSON
+{
+  "sessionId": "$SESSION_ID",
+  "startedAt": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "phase": "design"
+}
+ENDJSON
+
+# Check Vault for past quests
+VAULT_COUNT=$(raid_vault_count)
+
+if [ "$VAULT_COUNT" -gt 0 ] && [ "$RAID_VAULT_ENABLED" = "true" ]; then
+  cat <<ENDJSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "SessionStart",
+    "additionalContext": "The Vault contains $VAULT_COUNT past quest(s). Ask the human if the party should consult the Vault before beginning this quest."
+  }
+}
+ENDJSON
+fi
+
+exit 0

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

@@ -0,0 +1,73 @@
+#!/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
+# Looks for phase markers like "## Phase: plan" or "PHASE: implementation"
+DETECTED_PHASE="$STORED_PHASE"
+if [ -f ".claude/raid-dungeon.md" ]; then
+  # Match named phases: "Phase: design", "PHASE: plan", "## Phase: implementation", etc.
+  FOUND=$(grep -oiE '(phase:?\s*)(design|plan|implementation|review|finishing)' ".claude/raid-dungeon.md" 2>/dev/null | grep -oiE '(design|plan|implementation|review|finishing)' | tr '[:upper:]' '[:lower:]' | sort -u | tail -1)
+  if [ -n "$FOUND" ]; then
+    # Take the highest-ranked phase found
+    BEST_RANK=0
+    BEST_PHASE="$STORED_PHASE"
+    for phase_name in $(grep -oiE '(phase:?\s*)(design|plan|implementation|review|finishing)' ".claude/raid-dungeon.md" 2>/dev/null | grep -oiE '(design|plan|implementation|review|finishing)' | tr '[:upper:]' '[:lower:]' | sort -u); 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
+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