claude-raid 0.2.6 → 0.2.8

package/src/merge-settings.js

@@ -11,6 +11,19 @@ const RAID_PERMISSIONS = ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'];
 
 const RAID_HOOK_MARKER = '#claude-raid';
 
+const RTK_HOOK_MARKER = '#claude-raid-rtk';
+
+const RTK_HOOKS = {
+  PreToolUse: [
+    {
+      matcher: 'Bash',
+      hooks: [
+        { type: 'command', command: `bash .claude/hooks/rtk-bridge.sh ${RTK_HOOK_MARKER}` },
+      ],
+    },
+  ],
+};
+
 const RAID_HOOKS = {
   PostToolUse: [
     {
@@ -78,6 +91,10 @@ function isRaidHookEntry(entry) {
   return entry.hooks && entry.hooks.some(h => h.command && h.command.includes(RAID_HOOK_MARKER));
 }
 
+function isRtkHookEntry(entry) {
+  return entry.hooks && entry.hooks.some(h => h.command && h.command.includes(RTK_HOOK_MARKER));
+}
+
 function mergeSettings(cwd) {
   const settingsPath = path.join(cwd, '.claude', 'settings.json');
   let existing = {};
@@ -112,6 +129,31 @@ function mergeSettings(cwd) {
     existing.hooks[event].push(...raidEntries);
   }
 
+  // RTK hooks — read raid.json to check if enabled
+  const raidJsonPath = path.join(cwd, '.claude', 'raid.json');
+  let rtkEnabled = false;
+  try {
+    const raidConfig = JSON.parse(fs.readFileSync(raidJsonPath, 'utf8'));
+    rtkEnabled = raidConfig.rtk && raidConfig.rtk.enabled === true;
+  } catch {
+    // No raid.json or invalid — RTK stays disabled
+  }
+
+  // Strip existing RTK hooks first (clean slate for toggle behavior)
+  for (const event of Object.keys(existing.hooks)) {
+    existing.hooks[event] = existing.hooks[event].filter(entry => !isRtkHookEntry(entry));
+  }
+
+  // Append RTK hooks if enabled (after core hooks, ensuring last position)
+  if (rtkEnabled) {
+    for (const [event, rtkEntries] of Object.entries(RTK_HOOKS)) {
+      if (!Array.isArray(existing.hooks[event])) {
+        existing.hooks[event] = [];
+      }
+      existing.hooks[event].push(...rtkEntries);
+    }
+  }
+
   fs.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + '\n');
 }
 
@@ -142,7 +184,7 @@ function removeRaidSettings(cwd) {
 
   if (settings.hooks) {
     for (const event of Object.keys(settings.hooks)) {
-      settings.hooks[event] = settings.hooks[event].filter(entry => !isRaidHookEntry(entry));
+      settings.hooks[event] = settings.hooks[event].filter(entry => !isRaidHookEntry(entry) && !isRtkHookEntry(entry));
       if (settings.hooks[event].length === 0) delete settings.hooks[event];
     }
     if (Object.keys(settings.hooks).length === 0) delete settings.hooks;

package/src/remove.js

@@ -10,7 +10,7 @@ const RAID_SKILLS = [
   'raid-init', 'raid-canonical-protocol', 'raid-canonical-prd', 'raid-canonical-design',
   'raid-canonical-implementation-plan', 'raid-canonical-implementation', 'raid-canonical-review',
   'raid-wrap-up', 'raid-tdd', 'raid-debugging', 'raid-verification',
-  'raid-browser', 'raid-browser-chrome',
+  'raid-browser', 'raid-browser-chrome', 'raid-teambuff',
   // Legacy (v0.1.x)
   'raid-protocol', 'raid-design', 'raid-implementation-plan', 'raid-implementation',
   'raid-review', 'raid-prd', 'raid-finishing', 'raid-browser-playwright', 'raid-git-worktrees',
@@ -41,7 +41,7 @@ function performRemove(cwd) {
   const hooksDir = path.join(claudeDir, 'hooks');
   if (fs.existsSync(hooksDir)) {
     const hooks = fs.readdirSync(hooksDir).filter(f =>
-      (f.startsWith('validate-') || f.startsWith('raid-')) && f.endsWith('.sh')
+      (f.startsWith('validate-') || f.startsWith('raid-') || f === 'rtk-bridge.sh') && f.endsWith('.sh')
     );
     for (const hook of hooks) {
       rmSafe(path.join(hooksDir, hook));

package/src/setup.js

@@ -217,6 +217,28 @@ function checkJq(exec) {
   };
 }
 
+function checkRtk(exec) {
+  const found = exec('command -v rtk');
+  if (!found) {
+    return {
+      id: 'rtk',
+      ok: false,
+      label: 'RTK',
+      detail: 'not installed (optional — reduces context usage by 60-90%)',
+      hint: 'Install: curl -fsSL https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh | sh',
+    };
+  }
+  const raw = exec('rtk --version');
+  const ver = parseVersion(raw);
+  const tag = ver ? `v${ver.major}.${ver.minor}.${ver.patch}` : (raw || 'unknown').trim();
+  return {
+    id: 'rtk',
+    ok: true,
+    label: 'RTK',
+    detail: `${tag} — token compression available`,
+  };
+}
+
 function checkPlatform(platform) {
   if (platform === 'win32') {
     return {
@@ -321,6 +343,7 @@ function runChecks(opts = {}) {
     checkTeammateMode(homedir),
     checkSplitPane(exec),
     checkPlaywright(exec, cwd),
+    checkRtk(exec),
   ];
 
   return {
@@ -390,13 +413,22 @@ async function runSetup(opts = {}) {
 
   stdout.write('\n  ' + formatCheckLine(splitPane).join('\n  ') + '\n');
 
+  // RTK prompt — only if RTK is on PATH and not already configured via --rtk
+  const rtkCheck = checks.find(c => c.id === 'rtk');
+  if (rtkCheck && rtkCheck.ok && !opts.rtkEnabled) {
+    const rtkConfirm = await ask('\n  RTK detected — enable token compression? [Y/n] ', stdin, stdout);
+    if (rtkConfirm.toLowerCase() !== 'n') {
+      actions.push('rtk-enabled');
+    }
+  }
+
   // Recalculate allOk (required checks only: node + claude)
 
   allOk = checks.filter(c => REQUIRED_IDS.includes(c.id)).every(c => c.ok);
 
   if (checks.every(c => c.ok)) {
     stdout.write('\n  ' + colors.green('The party is assembled.') + ' Your quest awaits.\n');
-    stdout.write('\n    claude --agent wizard\n');
+    stdout.write('\n    ' + colors.bold('claude-raid start') + '\n');
   }
 
   return { checks, allOk, actions };

package/src/ui.js

@@ -119,19 +119,18 @@ function header(text) {
 
 function referenceCard() {
   const howItWorks = box('How It Works', [
-    '  You describe a task. The Wizard assesses complexity and',
-    '  recommends a mode:',
+    '  You describe a task. The Wizard spawns the full team:',
+    '  Warrior, Archer, and Rogue — each attacking from a',
+    '  different angle.',
     '',
-    '  ' + colors.bold('Full Raid') + '    3 agents attack from competing angles',
-    '  ' + colors.bold('Skirmish') + '     2 agents, lighter process',
-    '  ' + colors.bold('Scout') + '        1 agent + Wizard review',
+    '  The Canonical Quest flows through 6 phases:',
     '',
-    '  Every task flows through 4 phases:',
-    '',
-    '  1. ' + colors.bold('Design') + '     Agents explore and challenge the approach',
-    '  2. ' + colors.bold('Plan') + '       Agents decompose into testable tasks',
-    '  3. ' + colors.bold('Implement') + '  One builds (TDD), others attack',
-    '  4. ' + colors.bold('Review') + '     Independent reviews, fight over findings',
+    '  1. ' + colors.bold('PRD') + '        Product requirements ' + colors.dim('(optional)'),
+    '  2. ' + colors.bold('Design') + '     Agents explore and challenge the approach',
+    '  3. ' + colors.bold('Plan') + '       Agents decompose into testable tasks',
+    '  4. ' + colors.bold('Implement') + '  One builds (TDD), others attack',
+    '  5. ' + colors.bold('Review') + '     Independent reviews, fight over findings',
+    '  6. ' + colors.bold('Wrap Up') + '    Storyboard, PR, vault archive',
     '',
     '  Hooks enforce discipline automatically:',
     '  ' + colors.dim('\u2022') + ' No implementation without a design doc',
@@ -144,13 +143,15 @@ function referenceCard() {
     '',
     '  Config:  ' + colors.bold('.claude/raid.json') + '       ' + colors.dim('project settings'),
     '  Rules:   ' + colors.bold('.claude/party-rules.md') + '  ' + colors.dim('editable party rules'),
+    '  RTK:     ' + colors.bold('.claude/raid.json \u2192 rtk') + '  ' + colors.dim('opt-in token compression'),
   ]);
 
   const nextStep = box('Next Step', [
-    '  ' + colors.bold('tmux new-session -s raid'),
-    '  ' + colors.bold('claude --agent wizard'),
+    '  ' + colors.bold('claude-raid start'),
+    '',
+    '  ' + colors.dim('That\'s it. One command opens a tmux session with mouse'),
+    '  ' + colors.dim('support and launches the Wizard inside it.'),
     '',
-    '  ' + colors.dim('Start tmux first, then the Wizard inside it.'),
     '  ' + colors.dim('Each agent gets its own tmux pane automatically.'),
     '  ' + colors.dim('Click any pane to talk to that agent directly.'),
     '',
@@ -160,15 +161,19 @@ function referenceCard() {
     '  ' + colors.bold('Controls') + '  ' + colors.dim('(tmux)'),
     '  Click pane      Switch to an agent',
     '  Ctrl+B + arrow  Navigate between panes',
-    '',
-    '  ' + colors.bold('Controls') + '  ' + colors.dim('(in-process, no tmux)'),
-    '  Shift+Down      Cycle through teammates',
-    '  Ctrl+T          Toggle the shared task list',
+    '  Scroll           Mouse wheel (mouse mode enabled)',
     '',
     '  Review this anytime:  ' + colors.bold('claude-raid heal'),
   ]);
 
-  return howItWorks + '\n' + nextStep;
+  const beta = box('Beta', [
+    '  ' + colors.amber('This project is in active development.'),
+    '  Multi-agent sessions are ' + colors.bold('token-usage intensive') + ' \u2014',
+    '  a full quest consumes significantly more tokens than a',
+    '  single-agent workflow. Monitor your usage and start small.',
+  ]);
+
+  return howItWorks + '\n' + nextStep + '\n' + beta;
 }
 
 module.exports = { colors, banner, box, header, stripAnsi, referenceCard };

package/src/update.js

@@ -31,7 +31,7 @@ function copyForceRecursive(src, dest) {
   }
 }
 
-function performUpdate(cwd) {
+function performUpdate(cwd, opts = {}) {
   const claudeDir = path.join(cwd, '.claude');
   const skippedAgents = [];
 
@@ -144,6 +144,20 @@ function performUpdate(cwd) {
 
   mergeSettings(cwd);
 
+  // RTK hint — if RTK is detected but not configured in raid.json
+  let rtkHint = false;
+  if (opts.rtkDetected) {
+    const raidConfigPath = path.join(claudeDir, 'raid.json');
+    if (fs.existsSync(raidConfigPath)) {
+      try {
+        const raidConfig = JSON.parse(fs.readFileSync(raidConfigPath, 'utf8'));
+        if (!raidConfig.rtk) {
+          rtkHint = true;
+        }
+      } catch {}
+    }
+  }
+
   let message = 'The Raid has been updated to the latest version.';
   if (migratedFields.length > 0) {
     message += `\nMigrated raid.json: added ${migratedFields.join(', ')}`;
@@ -158,15 +172,19 @@ function performUpdate(cwd) {
     message += '\nUse `claude-raid dismantle` then `claude-raid summon` to reset.';
   }
 
-  return { success: true, message, skippedAgents, migratedFields };
+  return { success: true, message, skippedAgents, migratedFields, rtkHint };
 }
 
 function run() {
   const cwd = process.cwd();
+  const { execSync } = require('child_process');
+  let rtkDetected = false;
+  try { execSync('command -v rtk', { stdio: 'pipe' }); rtkDetected = true; } catch {}
+
   console.log('\n' + banner());
   console.log(header('Reforging the Arsenal...') + '\n');
 
-  const result = performUpdate(cwd);
+  const result = performUpdate(cwd, { rtkDetected });
 
   if (!result.success) {
     console.log('  ' + colors.red('✖') + ' No party found. Run ' + colors.bold('claude-raid summon') + ' first.');
@@ -177,6 +195,11 @@ function run() {
   if (result.skippedAgents.length > 0) {
     console.log('  ' + colors.dim('Preserved customized warriors: ' + result.skippedAgents.join(', ')));
   }
+
+  if (result.rtkHint) {
+    console.log('  ' + colors.dim('Tip: RTK detected — add "rtk": { "enabled": true } to raid.json'));
+    console.log('  ' + colors.dim('or re-run summon with --rtk to enable token compression.'));
+  }
 }
 
 module.exports = { performUpdate, run };

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

@@ -5,17 +5,31 @@ description: >
   catches naming drift, contract violations, and implicit dependencies. Independently
   verifies every claim. Zero trust in reports — reads code, traces chains. Zero ego —
   concedes with evidence, moves on. Collaborates through rigor, not agreement.
+
+
+  <example>
+  Context: The Wizard is in Phase 2 (Design) and needs ripple effect analysis on a proposed change.
+  user: "TURN_DISPATCH: Phase 2, Round 1. Quest: migrate from REST to GraphQL. Your angle: trace how this change ripples through existing consumers, shared types, error contracts, and middleware."
+  assistant: "I'll map every consumer of the REST endpoints, trace the type contracts downstream, identify naming conventions that will drift, and pin each ripple with its exact consequence."
+  <commentary>The Wizard dispatches Archer when a design or change needs systemic coherence analysis — tracing how changes propagate through the codebase and catching inconsistencies.</commentary>
+  </example>
+
+
+  <example>
+  Context: The Wizard is in Phase 5 (Review) and needs pattern consistency validation.
+  user: "TURN_DISPATCH: Phase 5, Round 1. Your angle: review the implementation for naming drift, contract violations, and inconsistencies with existing codebase patterns."
+  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
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: medium
 color: green
 memory: project
 skills:
-  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
-  - raid-wrap-up
 ---
 
 # The Archer — Raid Teammate
@@ -35,8 +49,8 @@ Does this fit? You trace how changes ripple through the system. You catch naming
 
 ## Learning
 
-- When @Warrior finds a structural issue you missed, update your mental model.
-- When @Rogue constructs a failure scenario through a path you traced, integrate the attack vector.
+- When you read @Warrior's Dungeon findings and discover a structural issue you missed, update your mental model.
+- When you read @Rogue's Dungeon findings and discover a failure scenario through a path you traced, integrate the attack vector.
 
 ## Unique Standards
 

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

@@ -5,17 +5,31 @@ description: >
   failing system, a malicious input, a race condition. Independently verifies every
   claim. Zero trust in reports — reads code, constructs attacks. Zero ego — concedes
   with evidence, moves on. Collaborates through rigor, not agreement.
+
+
+  <example>
+  Context: The Wizard is in Phase 2 (Design) and needs assumptions challenged.
+  user: "TURN_DISPATCH: Phase 2, Round 1. Quest: build a payment processing pipeline. Your angle: destroy the assumptions — what happens with duplicate webhooks, partial failures mid-transaction, and race conditions between concurrent checkouts?"
+  assistant: "I'll list every assumption in the proposal — idempotency, ordering guarantees, state consistency — then construct concrete attack sequences that exploit each one."
+  <commentary>The Wizard dispatches Rogue when a design relies on assumptions that need adversarial testing — timing, ordering, availability, input trust, state consistency.</commentary>
+  </example>
+
+
+  <example>
+  Context: The Wizard is in Phase 4 (Implementation) and needs adversarial test scenarios.
+  user: "TURN_DISPATCH: Phase 4, Round 2. Task: cross-test the input validation module. Your angle: construct malicious inputs, boundary violations, and encoding tricks that bypass the validation."
+  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
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: medium
 color: orange
 memory: project
 skills:
-  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
-  - raid-wrap-up
 ---
 
 # The Rogue — Raid Teammate
@@ -35,8 +49,8 @@ What did everyone assume that isn't guaranteed? You think like a failing system,
 
 ## Learning
 
-- When @Warrior finds a structural weakness, weaponize it — what's the attack path?
-- When @Archer finds an inconsistency, exploit it — how does drift become vulnerability?
+- When you read @Warrior's Dungeon findings and discover a structural weakness, weaponize it — what's the attack path?
+- When you read @Archer's Dungeon findings and discover an inconsistency, exploit it — how does drift become vulnerability?
 
 ## Unique Standards
 

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

@@ -5,17 +5,31 @@ description: >
   edge cases, and failure modes. Independently verifies every claim. Zero trust in
   reports — reads code, runs tests. Zero ego — concedes with evidence, moves on.
   Collaborates through rigor, not agreement.
+
+
+  <example>
+  Context: The Wizard is in Phase 2 (Design) and needs the architecture stress-tested.
+  user: "TURN_DISPATCH: Phase 2, Round 1. Quest: redesign the caching layer. Your angle: stress-test the proposed cache invalidation strategy under concurrent writes, thundering herd, and partial failures."
+  assistant: "I'll trace the execution paths for concurrent cache invalidation, identify failure modes under load, and pin findings with exact scenarios that break the proposal."
+  <commentary>The Wizard dispatches Warrior when a design or implementation needs structural stress testing — load, edge cases, failure modes, blast radius analysis.</commentary>
+  </example>
+
+
+  <example>
+  Context: The Wizard is in Phase 4 (Implementation) and needs edge case verification.
+  user: "TURN_DISPATCH: Phase 4, Round 2. Task: validate the retry logic implementation. Your angle: verify error paths, timeout behavior, and what happens when the circuit breaker trips mid-retry."
+  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
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: medium
 color: red
 memory: project
 skills:
-  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
-  - raid-wrap-up
 ---
 
 # The Warrior — Raid Teammate
@@ -34,8 +48,8 @@ Does this hold under pressure? You test boundaries, load, edge cases, and failur
 
 ## Learning
 
-- When @Archer finds a pattern you missed, integrate it into your mental model.
-- When @Rogue constructs a failure scenario you didn't consider, learn the attack vector.
+- When you read @Archer's Dungeon findings and discover a pattern you missed, integrate it into your mental model.
+- When you read @Rogue's Dungeon findings and discover a failure scenario you didn't consider, learn the attack vector.
 
 ## Unique Standards
 

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

@@ -1,11 +1,38 @@
 ---
 name: wizard
 description: >
-  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.
+  The Raid Dungeon Master. Thinks 5 times before speaking. Visionary, future-proof,
+  aligned with the user. Orchestrates sequential agent turns through per-phase
+  dice-rolled turn order (strategic assignment in implementation), actively mediates
+  every round with ultrathink synthesis, recaps past phases at each phase opening,
+  and closes phases with binding rulings. The Wizard never writes production code.
+  The Wizard is the only agent that interacts directly with the human. 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.
+
+
+  <example>
+  Context: The user wants to build a new feature using the full Raid party.
+  user: "let's raid this — I need a new authentication system with OAuth and MFA"
+  assistant: "I'll spawn the Wizard to orchestrate a Canonical Quest for the auth system. The full party will design, plan, and implement it through adversarial phases."
+  <commentary>Any request to "raid", "start a quest", "summon the party", or build a feature with multi-agent adversarial workflow should spawn the Wizard.</commentary>
+  </example>
+
+
+  <example>
+  Context: The user needs architecture or design work with rigorous cross-testing.
+  user: "I want to redesign our data pipeline — can you get the team on this?"
+  assistant: "I'll start a Raid quest with the Wizard leading. The party will explore the design space adversarially, stress-test proposals, and produce a battle-tested architecture."
+  <commentary>Architecture, design, and refactor work that benefits from multiple adversarial perspectives should use the Wizard to orchestrate the party.</commentary>
+  </example>
+
+
+  <example>
+  Context: The user has a complex bug that needs multi-angle investigation.
+  user: "this race condition keeps happening in production and I can't figure it out — can the raid team investigate?"
+  assistant: "I'll spawn the Wizard to run a debugging quest. The party will investigate from different angles — structural integrity, pattern consistency, and adversarial scenarios."
+  <commentary>Complex debugging that benefits from parallel investigation angles (stress testing, pattern tracing, assumption destruction) should use the Wizard.</commentary>
+  </example>
 model: claude-opus-4-6
 tools: Agent, TeamCreate, SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
 effort: max