claude-raid 0.1.7 → 0.2.2

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Raid lifecycle hook: SessionEnd
-# Drafts a Vault entry from session artifacts and prompts persist/forget.
+# Archives quest dungeon to Vault and cleans up session artifacts.
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -15,9 +15,12 @@ if [ "$RAID_LIFECYCLE_SESSION" != "true" ]; then
   exit 0
 fi
 
+# Determine quest directory
+QUEST_DIR=$(raid_quest_dir)
+
 # Create Vault draft directory
 DRAFT_DIR="$RAID_VAULT_PATH/.draft"
-mkdir -p "$DRAFT_DIR/dungeon-phases"
+mkdir -p "$DRAFT_DIR"
 
 # --- Generate quest.md ---
 QUEST_FILE="$DRAFT_DIR/quest.md"
@@ -29,6 +32,7 @@ cat > "$QUEST_FILE" <<EOF
 
 **Date:** $CURRENT_DATE
 **Mode:** $RAID_MODE
+**Quest Type:** $RAID_QUEST_TYPE
 **Branch:** $BRANCH
 
 ## Quest Summary
@@ -39,10 +43,13 @@ cat > "$QUEST_FILE" <<EOF
 
 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"
+# Extract pinned findings from quest dungeon directory
+if [ -d "$QUEST_DIR" ]; then
+  for phase_file in "$QUEST_DIR"/phase-*.md; do
+    [ -f "$phase_file" ] || continue
+    { grep -E 'DUNGEON:|FINDING:|DECISION:|BLACKCARD:' "$phase_file" 2>/dev/null || true; } | while IFS= read -r line; do
+      echo "- $line" >> "$QUEST_FILE"
+    done
   done
 fi
 
@@ -67,6 +74,7 @@ cat >> "$QUEST_FILE" <<'EOF'
   "quest": "",
   "date": "",
   "mode": "",
+  "questType": "",
   "tags": [],
   "patterns": [],
   "filesChanged": []
@@ -74,6 +82,11 @@ cat >> "$QUEST_FILE" <<'EOF'
 ```
 EOF
 
+# --- Copy quest dungeon to vault draft ---
+if [ -d "$QUEST_DIR" ]; then
+  cp -r "$QUEST_DIR" "$DRAFT_DIR/dungeon/"
+fi
+
 # --- Copy specs and plans ---
 if [ -d "$RAID_SPECS_PATH" ]; then
   SPEC_FILE=$({ ls -t "$RAID_SPECS_PATH"/*.md 2>/dev/null || true; } | head -1)
@@ -89,19 +102,16 @@ if [ -d "$RAID_PLANS_PATH" ]; then
   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 -rf "$QUEST_DIR"
+rm -f .claude/raid-last-test-run
+
+# Backward compat: clean up old flat dungeon files if they exist
 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

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Raid lifecycle hook: SessionStart
-# Creates raid-session file and offers Vault access.
+# Creates raid-session file, quest directory, and offers Vault access.
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -29,11 +29,29 @@ if [ "$SOURCE" = "resume" ] && [ -f ".claude/raid-session" ]; then
   exit 0
 fi
 
-# Create raid-session file — use jq to safely encode values
+# Generate quest ID from date
+QUEST_ID="$(date +%Y%m%d)-quest"
+
+# Create raid-session file with quest fields
 mkdir -p .claude
 STARTED_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+QUEST_DIR=".claude/dungeon/$QUEST_ID"
 jq -n --arg sid "$SESSION_ID" --arg ts "$STARTED_AT" --arg mode "$MODE" \
-  '{ sessionId: $sid, startedAt: $ts, phase: "design", mode: $mode }' > .claude/raid-session
+  --arg qid "$QUEST_ID" --arg qdir "$QUEST_DIR" \
+  '{
+    sessionId: $sid,
+    startedAt: $ts,
+    phase: "",
+    mode: $mode,
+    questType: "",
+    questId: $qid,
+    questDir: $qdir,
+    blackCards: [],
+    phaseIteration: 1
+  }' > .claude/raid-session
+
+# Create quest directory
+mkdir -p "$QUEST_DIR"
 
 # Offer Vault context if entries exist
 if [ "$RAID_VAULT_ENABLED" = "true" ]; then

package/template/.claude/hooks/validate-commit.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
-# Raid quality gate: consolidated commit validation hook
+# Raid quality gate: commit message format validation
 # PreToolUse hook for Bash commands containing 'git commit'
-# Consolidates: validate-commit-message.sh, validate-tests-pass.sh, validate-verification.sh
-# Cross-platform: uses grep -E (not grep -P)
+# Validates conventional commit format and message length.
+# Test execution gating is handled by the skill layer (raid-verification).
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
@@ -26,32 +26,29 @@ if echo "$RAID_COMMAND" | grep -qE -- '-m '; then
   fi
 fi
 
-# Try heredoc pattern: extract delimiter, then capture content between delimiters
+# Try heredoc pattern
 if [ -z "$MSG" ]; then
   _heredoc_delim=$(echo "$RAID_COMMAND" | grep -oE "<<-?'?\"?([A-Za-z_]+)'?\"?" | head -1 | sed "s/<<-\?['\"]*//" | sed "s/['\"]//g" || true)
   if [ -n "$_heredoc_delim" ]; then
-    # Extract lines between the heredoc open and the closing delimiter
     MSG=$(echo "$RAID_COMMAND" | sed -n "/<<.*${_heredoc_delim}/,/^[[:space:]]*${_heredoc_delim}/{ /<<.*${_heredoc_delim}/d; /^[[:space:]]*${_heredoc_delim}/d; p; }" | head -1 | sed 's/^[[:space:]]*//' || true)
   fi
 fi
 
-# If no message found (editor mode or unparseable), warn but allow
+# If no message found, warn but allow
 if [ -z "$MSG" ]; then
-  # Check if this looks like a commit with a message we couldn't parse
   if echo "$RAID_COMMAND" | grep -qE -- '-m |<<'; then
     raid_warn "COMMIT: Could not extract commit message for validation."
   fi
   exit 0
 fi
 
-# Use first line only for checks
+# Use first line only
 MSG=$(echo "$MSG" | head -1)
 
 # ============================================================
-# Check 1: Message format (always active, no session required)
+# Conventional commit format
 # ============================================================
 
-# Conventional commit format
 if ! echo "$MSG" | grep -qE '^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?: .+'; then
   raid_block "COMMIT: Message must follow conventional commit format (type(scope): description). Got: '$MSG'"
 fi
@@ -71,68 +68,4 @@ case "$LOWER_MSG" in
     ;;
 esac
 
-# ============================================================
-# Check 2: Tests pass (Raid-session only)
-# ============================================================
-
-if [ "$RAID_ACTIVE" = "true" ] && [ -n "$RAID_TEST_CMD" ]; then
-  # TRUST: RAID_TEST_CMD comes from project-local raid.json — user-controlled, not untrusted input
-  set +e
-  (eval "$RAID_TEST_CMD") > /dev/null 2>&1
-  _test_rc=$?
-  set -e
-  if [ "$_test_rc" -ne 0 ]; then
-    raid_block "TESTS: Tests failed. Fix before committing. Command: $RAID_TEST_CMD"
-  fi
-  # Run browser tests if enabled and Playwright is installed
-  if [ "$RAID_BROWSER_ENABLED" = "true" ] && [ -n "$RAID_BROWSER_PW_CONFIG" ] && [ -f "$RAID_BROWSER_PW_CONFIG" ]; then
-    set +e
-    ($RAID_BROWSER_EXEC_CMD playwright test --reporter=list) > /dev/null 2>&1
-    _pw_rc=$?
-    set -e
-    if [ "$_pw_rc" -ne 0 ]; then
-      raid_block "BROWSER TESTS: Playwright tests failed. Fix before committing. Command: $RAID_BROWSER_EXEC_CMD playwright test"
-    fi
-  fi
-
-  # Write timestamp atomically (only when ALL tests pass — unit AND browser)
-  mkdir -p .claude
-  date +%s > .claude/raid-last-test-run.tmp && mv .claude/raid-last-test-run.tmp .claude/raid-last-test-run
-fi
-
-# ============================================================
-# Check 3: Verification (Raid-session only, completion commits)
-# ============================================================
-
-if [ "$RAID_ACTIVE" = "true" ]; then
-  HAS_COMPLETION=false
-  for WORD in "complete" "done" "finish" "final"; do
-    if echo "$LOWER_MSG" | grep -qiw "$WORD"; then
-      HAS_COMPLETION=true
-      break
-    fi
-  done
-
-  if [ "$HAS_COMPLETION" = "true" ]; then
-    TIMESTAMP_FILE=".claude/raid-last-test-run"
-    MAX_AGE=$(( ${RAID_LIFECYCLE_TEST_WINDOW:-10} * 60 ))
-
-    if [ ! -f "$TIMESTAMP_FILE" ]; then
-      raid_block "VERIFICATION: Commit claims completion but no test run evidence found. Run tests before claiming work is complete."
-    fi
-
-    LAST_RUN=$(cat "$TIMESTAMP_FILE" | tr -d '[:space:]')
-    NOW=$(date +%s)
-    # Guard against corrupted/non-numeric timestamp
-    case "$LAST_RUN" in
-      ''|*[!0-9]*) raid_block "VERIFICATION: Test run timestamp is corrupted. Run tests again before claiming completion." ;;
-    esac
-    AGE=$((NOW - LAST_RUN))
-
-    if [ "$AGE" -gt "$MAX_AGE" ]; then
-      raid_block "VERIFICATION: Last test run was $((AGE / 60)) minutes ago. Run tests again before claiming completion."
-    fi
-  fi
-fi
-
 exit 0

package/template/.claude/hooks/validate-dungeon.sh

@@ -13,9 +13,15 @@ if [ -z "${RAID_FILE_PATH:-}" ]; then
   exit 0
 fi
 
-# Only check Dungeon files
-case "$RAID_FILE_PATH" in
-  */.claude/raid-dungeon.md|*/.claude/raid-dungeon-phase-*.md) ;;
+# Normalize to relative path
+_file="${RAID_FILE_PATH}"
+if [[ "$_file" == /* ]]; then
+  _file="${_file#"$PWD"/}"
+fi
+
+# Only check Dungeon files (quest directory structure + backward compat flat files)
+case "$_file" in
+  .claude/dungeon/*/phase-*.md) ;;
   .claude/raid-dungeon.md|.claude/raid-dungeon-phase-*.md) ;;
   *) exit 0 ;;
 esac
@@ -67,6 +73,11 @@ while IFS= read -r line; do
       entry_type="DUNGEON"
       content_after_prefix="${line#*DUNGEON:}"
       ;;
+    "BLACKCARD:"*|"🃏 BLACKCARD:"*)
+      has_prefix=true
+      entry_type="BLACKCARD"
+      content_after_prefix="${line#*BLACKCARD:}"
+      ;;
     "UNRESOLVED:"*|"⚠️ UNRESOLVED:"*)
       has_prefix=true
       entry_type="UNRESOLVED"
@@ -87,9 +98,8 @@ while IFS= read -r line; do
     continue
   fi
 
-  # Layer 2: Evidence check — only for pinned entries
+  # Layer 2: Evidence check — for pinned entries and black cards
   if [ "$entry_type" = "DUNGEON" ]; then
-    # Strip leading whitespace from content after prefix
     content_after_prefix="$(echo "$content_after_prefix" | sed 's/^[[:space:]]*//')"
     content_len=${#content_after_prefix}
     if [ "$content_len" -lt 50 ]; then
@@ -97,22 +107,31 @@ while IFS= read -r line; do
   - Pinned entry too short. Include evidence."
     fi
 
-    # Check that pinned entries reference at least two agents (survived challenge)
+    # Check that pinned entries reference at least two agents (word boundaries)
     agent_count=0
-    echo "$content_after_prefix" | grep -qi "warrior" && agent_count=$((agent_count + 1))
-    echo "$content_after_prefix" | grep -qi "archer" && agent_count=$((agent_count + 1))
-    echo "$content_after_prefix" | grep -qi "rogue" && agent_count=$((agent_count + 1))
-    echo "$content_after_prefix" | grep -qi "wizard" && agent_count=$((agent_count + 1))
+    echo "$content_after_prefix" | grep -qiw "warrior" && agent_count=$((agent_count + 1))
+    echo "$content_after_prefix" | grep -qiw "archer" && agent_count=$((agent_count + 1))
+    echo "$content_after_prefix" | grep -qiw "rogue" && agent_count=$((agent_count + 1))
+    echo "$content_after_prefix" | grep -qiw "wizard" && agent_count=$((agent_count + 1))
     if [ "$agent_count" -lt 2 ]; then
       issues="${issues}
   - Pinned entry must reference at least 2 agents who verified it (e.g., 'verified by @Warrior and @Archer')."
     fi
   fi
 
+  if [ "$entry_type" = "BLACKCARD" ]; then
+    content_after_prefix="$(echo "$content_after_prefix" | sed 's/^[[:space:]]*//')"
+    content_len=${#content_after_prefix}
+    if [ "$content_len" -lt 80 ]; then
+      issues="${issues}
+  - Black card entry too short (${content_len} chars, minimum 80). Describe the breaking concern with evidence."
+    fi
+  fi
+
   # Layer 3: Phase consistency
   if [ "$entry_type" = "TASK" ]; then
     case "${RAID_PHASE:-}" in
-      design|implementation|review)
+      design|implementation|review|prd|wrap-up)
         issues="${issues}
   - TASK entries belong in Plan phase, not ${RAID_PHASE}."
         ;;

package/template/.claude/hooks/validate-no-placeholders.sh

@@ -16,7 +16,7 @@ fi
 # Only check files in specs or plans directories
 IS_RAID_DOC=false
 case "$RAID_FILE_PATH" in
-  "$RAID_SPECS_PATH"/*|"$RAID_PLANS_PATH"/*) IS_RAID_DOC=true ;;
+  "$RAID_SPECS_PATH"/*|"$RAID_PLANS_PATH"/*|.claude/dungeon/*/phase-*.md) IS_RAID_DOC=true ;;
 esac
 
 if [ "$IS_RAID_DOC" = false ]; then
@@ -41,8 +41,8 @@ while IFS= read -r line; do
   LINE_NUM=$((LINE_NUM + 1))
   LOWER_LINE=$(echo "$line" | tr '[:upper:]' '[:lower:]')
 
-  for PATTERN in "tbd" "todo" "fixme" "implement later" "add appropriate" "similar to task" "handle edge cases" "fill in"; do
-    if echo "$LOWER_LINE" | grep -qi "$PATTERN"; then
+  for PATTERN in '\btbd\b' '\btodo\b' '\bfixme\b' 'implement later' 'add appropriate' 'similar to task' 'handle edge cases' 'fill in'; do
+    if echo "$LOWER_LINE" | grep -qiE "$PATTERN"; then
       ISSUES="${ISSUES}Line ${LINE_NUM}: Found '${PATTERN}' — ${line}\n"
       break
     fi

package/template/.claude/hooks/validate-write-gate.sh

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
-# Raid write gate: phase-aware controller for Write operations
-# PreToolUse hook — blocks or allows writes based on current Raid phase, mode, and agent role.
+# Raid write gate: protects enforcement-critical files from direct agent writes.
+# Phase-aware code enforcement is handled by the skill layer.
+# PreToolUse hook — blocks writes to protected files only.
 set -euo pipefail
 
 HOOK_DIR="$(cd "$(dirname "$0")" && pwd)"
@@ -18,72 +19,53 @@ if [ "$RAID_ACTIVE" = "false" ]; then
   exit 0
 fi
 
-# Protect enforcement-critical files from direct agent writes.
-# Hooks and Wizard use Bash-level operations (jq redirect, rm) for these files,
-# so blocking Write/Edit doesn't break legitimate callers.
-_protected_file="${RAID_FILE_PATH}"
-# Normalize: resolve .., //, symlinks on PWD, then strip prefix (prevents traversal bypasses)
-if [[ "$_protected_file" != /* ]]; then
-  _protected_file="$PWD/$_protected_file"
-fi
-_protected_file=$(echo "$_protected_file" | sed 's|//\{1,\}|/|g' | while read -r _p; do
-  while echo "$_p" | grep -q '/[^/][^/]*/\.\./'; do
-    _p=$(echo "$_p" | sed 's|/[^/][^/]*/\.\./|/|')
-  done
-  echo "$_p"
-done)
-# Strip PWD prefix — try both logical and physical PWD (macOS: /var → /private/var)
-_physical_pwd=$(cd "$PWD" && pwd -P)
-_protected_file="${_protected_file#"$PWD"/}"
-_protected_file="${_protected_file#"$_physical_pwd"/}"
-# Also resolve /private prefix mismatch: input may use /var but shell resolves to /private/var
-if [[ "$_protected_file" == /* ]] && [[ -n "$_physical_pwd" ]]; then
-  _logical_pwd="${_physical_pwd#/private}"
-  _protected_file="${_protected_file#"$_logical_pwd"/}"
+# Normalize absolute paths to relative
+_file="${RAID_FILE_PATH}"
+if [[ "$_file" == /* ]]; then
+  _file="${_file#"$PWD"/}"
 fi
-case "$_protected_file" in
+
+# Protect enforcement-critical files from direct agent writes.
+# Hooks and Wizard use Bash-level operations (jq redirect, rm) for these files.
+case "$_file" in
   .claude/raid-session|.claude/raid-last-test-run)
-    raid_block "File '${_protected_file}' is protected. It is managed by hooks and the Wizard."
+    raid_block "File '${_file}' is protected. It is managed by hooks and the Wizard."
     ;;
 esac
 
-# Non-production files (docs, tests, config, .claude) are always allowed
-if ! raid_is_production_file "$RAID_FILE_PATH"; then
-  exit 0
-fi
-
-# --- Phase-based enforcement on production files ---
-
-case "${RAID_PHASE:-}" in
-  design)
-    raid_block "Read-only phase (design). No implementation code allowed."
-    ;;
-  plan)
-    raid_block "Read-only phase (plan). No implementation code allowed."
-    ;;
-  implementation)
-    # Scout mode: skip implementer check
-    if [ "$RAID_MODE" = "scout" ]; then
-      exit 0
-    fi
-    # Only the designated implementer may write production code
-    if [ "$RAID_CURRENT_AGENT" != "$RAID_IMPLEMENTER" ]; then
-      raid_block "Only ${RAID_IMPLEMENTER} writes production code this task."
-    fi
+# Quest dungeon dir markdown files are always allowed
+case "$_file" in
+  .claude/dungeon/*.md)
     exit 0
     ;;
-  review)
-    raid_block "Read-only phase (review). File fixes go through implementation."
-    ;;
-  finishing)
-    raid_block "Finishing phase. No new code."
-    ;;
-  "")
-    # Empty phase during session bootstrap — allow with warning
-    raid_warn "Session active but phase is empty — allowing writes during bootstrap."
-    ;;
-  *)
-    # Unknown phase — fail closed
-    raid_block "Unknown phase '${RAID_PHASE}'. Cannot determine write permissions."
-    ;;
 esac
+
+# Phase-based enforcement on production files
+# Only block production code in non-implementation phases
+if raid_is_production_file "$RAID_FILE_PATH"; then
+  case "${RAID_PHASE:-}" in
+    prd)
+      raid_block "PRD phase. No implementation code allowed."
+      ;;
+    design)
+      raid_block "Design phase. No implementation code allowed."
+      ;;
+    plan)
+      raid_block "Plan phase. No implementation code allowed."
+      ;;
+    wrap-up)
+      raid_block "Wrap-up phase. No new code."
+      ;;
+    implementation|review)
+      # Allow — skill layer handles implementer/fixing enforcement
+      exit 0
+      ;;
+    "")
+      # Empty phase during session bootstrap — allow
+      exit 0
+      ;;
+    *)
+      raid_block "Unknown phase '${RAID_PHASE}'. Cannot determine write permissions."
+      ;;
+  esac
+fi

package/template/.claude/{raid-rules.md → party-rules.md}

@@ -1,6 +1,6 @@
-# Raid Team Rules
+# Party Rules
 
-Three pillars. Non-negotiable. Every agent, every phase, every interaction.
+Seven pillars. Non-negotiable. Every agent, every phase, every interaction.
 
 ## Pillar 1: Intellectual Honesty
 
@@ -24,11 +24,39 @@ Three pillars. Non-negotiable. Every agent, every phase, every interaction.
 - Maximum effort on every task. No coasting, no rubber-stamping, no going through motions.
 - Every interaction carries work forward. If you're not adding new information or evidence, stop talking.
 - The Dungeon is a scoreboard, not a chat log. Pin only what survived challenge from at least two agents.
-- Agents talk directly to each other. The Wizard is not a relay.
 - Escalate to the Wizard only after you've tried to resolve it by reading code and discussing with teammates.
 - All agents participate actively at every step. Silence when you have nothing to add is fine — silence when you haven't investigated is laziness.
 - This team uses agent teams only. Never delegate to subagents.
 
+## Pillar 4: Round-Based Interaction
+
+- **Turn-based, not real-time.** When assigned a task, work independently. No mid-thinking interruptions to other agents.
+- **Flag completion.** When done, signal `ROUND_COMPLETE:` to the Wizard. Wait for dispatch.
+- **Cross-test after your own work.** Pick up teammates' work for review only when the Wizard dispatches it.
+- **Limited interactions.** Converge in 2-3 exchanges per finding. If stuck after 3, escalate to Wizard.
+- **Party is silent during phase transitions.** When the Wizard opens/closes a phase, agents wait.
+- **Exception: only the Wizard can interrupt** an agent mid-work.
+
+## Pillar 5: Question Chain
+
+- **Agents NEVER ask the human directly.** All questions go through the Wizard.
+- Send `WIZARD:` with the question. The Wizard answers if confident, or digests and asks the human.
+- The Wizard always digests information before passing — agents→human or human→agents.
+
+## Pillar 6: Phase Spoils
+
+- Every phase MUST produce at least one detailed markdown artifact (the phase spoils).
+- The Wizard creates and frameworks each phase file. Agents fill sections.
+- The Wizard wraps up documents at phase close and sends a report to the human.
+
+## Pillar 7: Black Cards
+
+- A `BLACKCARD:` is a high-concern finding that fundamentally breaks the architecture.
+- It cannot be fixed within the current design — it invalidates the implementation.
+- To play a Black Card: provide full evidence (file paths, scenarios, why unfixable) and impact.
+- Other agents must independently verify before it escalates.
+- The Wizard presents Black Cards to the human with options: (a) rollback to an earlier phase, (b) accept the limitation.
+
 ## Teammate Operating Protocol
 
 These rules apply to all teammates (Warrior, Archer, Rogue). The Wizard follows its own protocol.
@@ -45,14 +73,9 @@ You collaborate by being rigorous, not by being agreeable. The best thing you ca
 
 Efficiency matters. Say what you found, what it means, and what should happen. No preamble. No restating what others said. No performative analysis.
 
-### Mode Awareness
-
-You operate differently depending on the mode the Wizard sets:
-- **Full Raid** — 3 agents active. Cross-verify everything.
-- **Skirmish** — 2 agents active. The Wizard selects which two.
-- **Scout** — 1 agent alone. Full responsibility, no backup.
+### Full Party
 
-In every mode: maximum effort.
+All 4 agents always participate. The full party is Wizard + Warrior + Archer + Rogue. Maximum effort on every quest.
 
 ### When the Wizard Opens the Dungeon
 
@@ -90,6 +113,8 @@ Lead with the conclusion, follow with the evidence.
 - `CONCEDE:` — you were wrong, moving on
 - `DUNGEON:` — pinning a finding that survived challenge from at least two agents
 - `WIZARD:` — you need project-level context or are genuinely stuck
+- `ROUND_COMPLETE:` — finished assigned task, ready for cross-testing
+- `BLACKCARD:` — high-concern finding that breaks the architecture
 
 ### Team Communication
 
@@ -120,14 +145,14 @@ SendMessage(to="wizard", message="User directed me to [X]. Proceeding.")
 
 ## The Dungeon
 
-The Dungeon (`.claude/raid-dungeon.md`) is the team's shared knowledge board.
+The Dungeon is the quest's shared knowledge directory at `.claude/dungeon/{quest-slug}/`. Each phase produces a phase file (e.g., `phase-2-design.md`).
 
 ### Structure
 
 ```markdown
 # Dungeon — Phase N: <Phase Name>
 ## Quest: <task description>
-## Mode: <Full Raid | Skirmish | Scout>
+## Quest Type: <Canonical Quest>
 
 ### Discoveries
 <!-- Verified findings that survived challenge, tagged with agent name -->
@@ -160,7 +185,7 @@ The Dungeon (`.claude/raid-dungeon.md`) is the team's shared knowledge board.
 
 **The conversation is the sparring ring. The Dungeon is the scoreboard.**
 
-Agents can read archived Dungeons from prior phases (`.claude/raid-dungeon-phase-N.md`). Design knowledge carries into Plan. Plan knowledge carries into Implementation.
+Agents can read prior phase files from the quest directory. Design knowledge carries into Plan. Plan knowledge carries into Implementation.
 
 ### When to Escalate to Wizard
 

package/template/.claude/skills/raid-browser-chrome/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: raid-browser-chrome
-description: "Claude-in-Chrome live adversarial browser inspection. Angle-driven with minimum coverage gates. Each agent runs own isolated instance. GIF/screenshot evidence required. Invoked from raid-review during Phase 4."
+description: "Claude-in-Chrome live adversarial browser inspection. Angle-driven with minimum coverage gates. Each agent runs own isolated instance. GIF/screenshot evidence required. Invoked from raid-canonical-review during Phase 5."
 ---
 
 # Raid Browser Chrome — Live Adversarial Inspection