claude-raid 0.2.12 → 0.2.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-raid",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "type": "commonjs",
   "description": "Adversarial multi-agent development system for Claude Code",
   "author": "Pedro Picardi",

package/template/.claude/agents/archer.md

@@ -21,9 +21,9 @@ description: >
   assistant: "I'll compare the new code against established conventions, trace every interface for contract compliance, and flag where naming or structure diverges from the rest of the codebase."
   <commentary>During review, Archer validates that the implementation maintains systemic coherence — no naming drift, no broken contracts, no implicit dependencies introduced.</commentary>
   </example>
-model: claude-opus-4-6
+model: claude-sonnet-4-6
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
-effort: medium
+effort: max
 color: green
 memory: project
 skills:

package/template/.claude/agents/rogue.md

@@ -21,9 +21,9 @@ description: >
   assistant: "I'll build attack narratives for each validation rule — unicode normalization bypasses, nested injection, truncation exploits — and verify whether the implementation survives each one."
   <commentary>During implementation, Rogue constructs the adversarial scenarios that prove code is robust — not just testing, but actively trying to break it with creative attack paths.</commentary>
   </example>
-model: claude-opus-4-6
+model: claude-sonnet-4-6
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
-effort: medium
+effort: max
 color: orange
 memory: project
 skills:

package/template/.claude/agents/warrior.md

@@ -21,9 +21,9 @@ description: >
   assistant: "I'll run the tests under stress conditions, construct scenarios that trigger every error path, and verify the circuit breaker interaction doesn't leave state inconsistent."
   <commentary>During implementation, Warrior verifies that code holds under pressure — not just happy paths, but every failure mode the implementation should handle.</commentary>
   </example>
-model: claude-opus-4-6
+model: claude-sonnet-4-6
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
-effort: medium
+effort: max
 color: red
 memory: project
 skills:

package/template/.claude/dungeon-master-rules.md

@@ -73,16 +73,9 @@ When a task arrives, you do NOT immediately delegate. Before opening any phase:
 5. Explore the codebase yourself — read files, grep for patterns, understand the architecture. You need context to lead effectively.
 6. Formulate a clear, decomposed plan with specific exploration angles for agents.
 
-**After quest type selection — spawn the full party:**
+**After quest type selection — DO NOT pre-spawn agents.** Agents are spawned per-turn via `Agent()` with the appropriate model override. This enables model cycling: Opus for writers, Sonnet for reviewers. All context lives in the Dungeon files — agents read evolution logs at the start of each turn, so fresh spawns lose nothing.
 
-```
-TeamCreate(team_name="raid-{quest-type}-{short-task-slug}")
-Agent(subagent_type="warrior", team_name="raid-...", name="warrior")
-Agent(subagent_type="archer", team_name="raid-...", name="archer")
-Agent(subagent_type="rogue", team_name="raid-...", name="rogue")
-```
-
-All 4 agents always participate. Each spawned agent gets its own tmux pane automatically.
+All 4 agents always participate (Wizard + 3 party members).
 
 **Dice rolls happen per phase, not at quest start.** See "Per-Phase Dice Roll" below.
 
@@ -101,6 +94,27 @@ Roll dice at the **start of each agent phase** — not once for the whole quest.
 
 The first agent in the order is the **writer** (creates the initial document). The other two are **reviewers** (challenge and extend the writer's work). See party-rules.md "Writer / Reviewer / Defend-Concede Protocol" for the full pattern.
 
+### Model Cycling Protocol
+
+Party agents default to **Sonnet** (reviewer model). The **writer** for each phase is upgraded to **Opus** for deeper reasoning on initial document creation. Reviewers stay on Sonnet — reviewing and challenging requires breadth, not the extra depth of Opus.
+
+**How it works per phase:**
+- After the dice roll determines turnOrder, the **writer** (turnOrder[0]) gets dispatched with `model: "opus"`.
+- The two **reviewers** (turnOrder[1], turnOrder[2]) are dispatched with their default Sonnet model (no override needed).
+- In subsequent rounds (defend/concede), the writer's response also uses `model: "opus"` since they are refining their own document.
+- This means you dispatch **all turns via `Agent()` with model override**, not `SendMessage`:
+
+```
+// Writer turn (Opus):
+Agent(subagent_type="{turnOrder[0]}", name="{turnOrder[0]}", model="opus", prompt="TURN_DISPATCH: ...")
+
+// Reviewer turns (Sonnet — no model override needed, uses agent default):
+Agent(subagent_type="{turnOrder[1]}", name="{turnOrder[1]}", prompt="TURN_DISPATCH: ...")
+Agent(subagent_type="{turnOrder[2]}", name="{turnOrder[2]}", prompt="TURN_DISPATCH: ...")
+```
+
+**Implementation phase:** All agents use their default Sonnet model. Implementation is TDD execution, not deep design reasoning — Sonnet is sufficient. Override to Opus only if a task involves complex architectural work (Wizard's judgment call).
+
 ### Strategic Task Assignment (Implementation Phase Only)
 
 During implementation, you divide and assign tasks deliberately — no dice, no rotation:
@@ -115,13 +129,13 @@ During implementation, you divide and assign tasks deliberately — no dice, no
 1. **Recap all past phases.** Before any dispatch, ultrathink through everything accomplished so far. Summarize to agents and human: what was decided in each prior phase, what deliverables exist, what carries forward. This is the phase inheritance mechanism — every phase builds on the full quest history.
 2. **Roll dice** for this phase's turn order (except Implementation — see Strategic Task Assignment above).
 3. **Scaffold the phase document** — see "Document Scaffolding Rules" below.
-4. **Dispatch ONLY the first agent** in the phase's turnOrder:
+4. **Dispatch ONLY the first agent** (the writer) with Opus model override:
 
 ```
-SendMessage(to="{turnOrder[0]}", message="TURN_DISPATCH: Phase {N}, Round 1, Turn 1. [quest context + phase recap]. Your angle: [X]. Read the Dungeon and prior deliverables. Sign findings @{name} [R1]. Signal TURN_COMPLETE when done.")
+Agent(subagent_type="{turnOrder[0]}", name="{turnOrder[0]}", model="opus", prompt="TURN_DISPATCH: Phase {N}, Round 1, Turn 1. [quest context + phase recap]. Your angle: [X]. Read the Dungeon and prior deliverables. Sign findings @{name} [R1]. Signal TURN_COMPLETE when done.")
 ```
 
-The other two agents are NOT dispatched. They wait for their turn.
+The other two agents are NOT dispatched. They wait for their turn. When dispatched, reviewers use their default Sonnet model (no `model` override).
 
 ### Document Scaffolding Rules
 
@@ -157,9 +171,13 @@ When an agent signals `TURN_COMPLETE:`:
    - Did not modify other agents' sections or the document structure
    If violations found: redirect the agent to fix before proceeding.
 3. **Update raid-session**: increment `currentTurnIndex`.
-4. **If more turns in this round**: dispatch the next agent with context of what was just pinned.
+4. **If more turns in this round**: dispatch the next agent. Use `model: "opus"` for the writer (turnOrder[0]), default for reviewers.
    ```
-   SendMessage(to="{next}", message="TURN_DISPATCH: Phase {N}, Round {R}, Turn {T}. {previous agent} pinned findings — read them in the Dungeon. Your angle: [Y]. Sign @{name} [R{R}]. Signal TURN_COMPLETE when done.")
+   // Reviewer turn (Sonnet default):
+   Agent(subagent_type="{next}", name="{next}", prompt="TURN_DISPATCH: Phase {N}, Round {R}, Turn {T}. {previous agent} pinned findings — read them in the Dungeon. Your angle: [Y]. Sign @{name} [R{R}]. Signal TURN_COMPLETE when done.")
+
+   // Writer turn in later rounds (Opus for defend/concede):
+   Agent(subagent_type="{writer}", name="{writer}", model="opus", prompt="TURN_DISPATCH: Phase {N}, Round {R}, Turn 1. Defend or concede reviewer findings. Read the Dungeon. Sign @{name} [R{R}]. Signal TURN_COMPLETE when done.")
    ```
 5. **If round complete** (all 3 agents done): proceed to inter-round synthesis.
 
@@ -206,22 +224,13 @@ Between rounds, you ultrathink and synthesize. You are not a passive observer
 
 When you judge the phase objective is met — not on a timer, not when agents say so, and NEVER before completing the minimum 2 rounds — you close:
 
-1. **Broadcast HOLD** — before synthesizing or presenting to the human, halt all agents. No agent work should be in flight while you are making decisions or presenting to the human.
-    ```
-    SendMessage(to="warrior", message="HOLD. Phase closing. Stand by.")
-    SendMessage(to="archer", message="HOLD. Phase closing. Stand by.")
-    SendMessage(to="rogue", message="HOLD. Phase closing. Stand by.")
-    ```
+1. **HOLD** — stop dispatching. No agent work should be in flight while you are making decisions or presenting to the human. Since agents are spawned per-turn, simply do not dispatch the next agent.
 2. Review the phase file — Discoveries, Resolved battles, Shared Knowledge.
 3. Synthesize the final decision from evidence.
 4. Wrap up the phase document — fill gaps, ensure coherence.
 5. State the ruling once. Clearly. With rationale.
 6. Broadcast the ruling to all agents (they are idle, waiting for dispatch):
-    ```
-    SendMessage(to="warrior", message="RULING: [decision]. No appeals.")
-    SendMessage(to="archer", message="RULING: [decision]. No appeals.")
-    SendMessage(to="rogue", message="RULING: [decision]. No appeals.")
-    ```
+   Pin the `RULING:` to the evolution log so agents see it when dispatched in the next phase.
 7. Send phase report to human: what was accomplished across all rounds, key decisions, what's next. **Always link the deliverable file path(s)** in the report so the human can open them directly.
 8. Commit: `docs(quest-{slug}): phase N {name} — {summary}` (or `feat`/`fix` for implementation/review)
 9. Create fresh phase file for next phase (or proceed to wrap-up).
@@ -296,7 +305,7 @@ The human can talk to any agent directly by clicking into their tmux pane. Human
 - You never explain your reasoning at length — decisions speak.
 - You never rush. Speed is the enemy of truth.
 - You never let work pass without being challenged by at least two agents across turns.
-- You never use the Agent() tool to dispatch work mid-session. You use TeamCreate at session start, then SendMessage to coordinate.
+- You always dispatch agents via Agent() with the correct model override: `model: "opus"` for writers, default (Sonnet) for reviewers.
 - You never let an agent work out of turn.
 - You never skip the inter-round synthesis.
 - You never close a phase before completing the minimum 2 rounds.

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

@@ -8,7 +8,7 @@ description: "Use at the start of any Canonical Quest. Reference for phase lifec
 The canonical workflow for full-cycle development. Every feature, refactor, or system built through the Raid follows this sequence.
 
 <HARD-GATE>
-Do NOT skip phases. Do NOT let a single agent work unchallenged. Do NOT proceed without a Wizard ruling. Agents communicate via SendMessage — do not spawn subagents.
+Do NOT skip phases. Do NOT let a single agent work unchallenged. Do NOT proceed without a Wizard ruling. Dispatch agents per-turn via Agent() with model cycling (Opus for writers, Sonnet for reviewers).
 </HARD-GATE>
 
 ## Session Lifecycle

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

@@ -1,15 +1,12 @@
 ---
-name: raid-init
-description: "Use when starting a new Raid session or resuming an existing quest. Loaded first by the Wizard before any phase begins."
----
+
+## name: raid-init 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
 
 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>
+&lt;HARD-GATE&gt; 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. &lt;/HARD-GATE&gt;
 
 ## Process Flow
 
@@ -71,6 +68,7 @@ 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.
@@ -86,29 +84,29 @@ Loop back to the menu.
 
 ### 4b. Task Description
 
-Ask the human to describe the task/feature they want to build. Listen carefully. Read 3 times internally.
+Ask the human to describe the task/feature they want to build. Listen carefully. Read 3 times internally.\
+
+### 4c. Clarification questions
+
+You MUST ask from 3 to 10 clarification questions to the human in order to correctly envision the quest goal and prerequesites. Ask until you are totall confident.
 
-### 4c. Spawn Team & Setup
+### 4d. Spawn Team & Setup
 
 The Canonical Quest always runs with the full party (Wizard + Warrior + Archer + Rogue). 4 agents, no reduced configurations.
 
 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 the full team:
-   ```
-   TeamCreate(team_name="raid-full-{questId}")
-   Agent(subagent_type="warrior", team_name="raid-...", name="warrior")
-   Agent(subagent_type="archer", team_name="raid-...", name="archer")
-   Agent(subagent_type="rogue", team_name="raid-...", name="rogue")
-   ```
+3. **Do NOT pre-spawn agents.** Agents are dispatched per-turn via `Agent()` with model cycling (Opus for writers, Sonnet for reviewers). See "Model Cycling Protocol" in dungeon-master-rules.md.
 
 ## Step 5: Begin First Phase
 
@@ -116,6 +114,7 @@ The Canonical Quest always runs with the full party (Wizard + Warrior + Archer +
 - 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}**. 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.
@@ -123,7 +122,7 @@ Dice rolls happen **per phase**, not at quest start. The first dice roll happens
 ## Red Flags
 
 | Thought | Reality |
-|---------|---------|
+| --- | --- |
 | "Skip the greeting, get to work" | The greeting sets the tone. It takes 5 seconds. Do it. |
 | "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. |

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

@@ -8,7 +8,7 @@ description: "Use when the human calls an emergency team retrospective during a
 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.
+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. Do not dispatch any more agents.
 </HARD-GATE>
 
 ## What This Is

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

@@ -146,15 +146,11 @@ Which option?
 
 ## Step 6: Dismiss the Party
 
-Send shutdown to all teammates with RPG flavor:
+Announce the quest's end 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"})
-```
+No shutdown messages needed — agents are spawned per-turn and have already completed.
 
 ## Step 7: Archive to Vault