claude-raid 0.2.7 → 0.2.9

package/README.md

@@ -7,7 +7,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)](#)
 [![Node.js 18+](https://img.shields.io/badge/node-18%2B-blue.svg)](#prerequisites)
-[![294 Tests](https://img.shields.io/badge/tests-294_passing-brightgreen.svg)](#)
+[![325 Tests](https://img.shields.io/badge/tests-325_passing-brightgreen.svg)](#)
 
 > **Beta** — This project is in active development. Multi-agent sessions are **token-usage intensive** — a full Canonical Quest consumes significantly more tokens than a single-agent workflow. Monitor your usage and start with small tasks to calibrate.
 
@@ -44,6 +44,9 @@ claude-raid start
 ```bash
 # Preview what gets installed (no changes)
 npx claude-raid summon --dry-run
+
+# Install with RTK token compression (optional)
+npx claude-raid summon --rtk
 ```
 
 ### Prerequisites
@@ -93,31 +96,31 @@ flowchart LR
 
 Agents research the problem space and produce a complete Product Requirements Document. No code. The Wizard mediates questions between agents and the human.
 
-**Output:** `phase-1-prd.md`
+**Output:** `spoils/prd.md`
 
 ### Phase 2 — Design
 
 Agents explore design approaches from competing angles. Each brings their lens — the Warrior stress-tests architecture choices, the Archer traces ripple effects, the Rogue attacks assumptions. The design survives only if it withstands all three.
 
-**Output:** `phase-2-design.md` with mermaid diagrams and battle-tested decisions
+**Output:** `phases/phase-2-design.md` (evolution log) + `spoils/design.md` (polished deliverable)
 
 ### Phase 3 — Plan
 
 Agents decompose the approved design into discrete, testable tasks. They fight over ordering, scope boundaries, naming, and test coverage until the plan earns consensus.
 
-**Output:** `phase-3-plan.md` + individual task files (`phase-3-plan-task-01.md`, etc.)
+**Output:** `phases/phase-3-plan.md` + `spoils/tasks/phase-3-plan-task-NN.md`
 
 ### Phase 4 — Implementation
 
 The Wizard assigns tasks in batches. One agent builds each task using strict **TDD** (RED-GREEN-REFACTOR). The others cross-test the implementation — reading code, running tests, and challenging decisions. Every task earns approval before the next batch starts.
 
-**Output:** `phase-4-implementation.md` + committed, tested code
+**Output:** `phases/phase-4-implementation.md` + committed, tested code
 
 ### Phase 5 — Review *(optional)*
 
 Two sub-phases: **Pinning** (find issues) and **Fixing** (resolve them). Agents review independently, then fight over findings *and* missing findings. Critical and Important issues must be fixed. The **Black Card** system handles breaking architectural concerns.
 
-**Output:** `phase-5-review.md`
+**Output:** `phases/phase-5-review.md` + `spoils/review.md`
 
 ### Phase 6 — Wrap Up
 
@@ -146,6 +149,8 @@ Four agents, each with a distinct lens. They collaborate through rigor, not agre
 </tr>
 </table>
 
+All agents run on Claude Opus 4.6.
+
 ### How They Work Together
 
 ```mermaid
@@ -196,14 +201,21 @@ The Dungeon is the team's shared knowledge artifact — a curated board where ag
 
 ```
 .claude/dungeon/{quest-slug}/          # Active quest artifacts
-├── phase-1-prd.md                     # PRD (optional)
-├── phase-2-design.md                  # Battle-tested design
-├── phase-3-plan.md                    # Task index
-├── phase-3-plan-task-01.md            # Individual task specs
-├── phase-4-implementation.md          # Implementation log
-├── phase-5-review.md                  # Review board (optional)
+├── phases/                            # Evolution logs (scoreboards)
+│   ├── phase-2-design.md
+│   ├── phase-3-plan.md
+│   ├── phase-4-implementation.md
+│   └── phase-5-review.md
+├── spoils/                            # Polished deliverables
+│   ├── prd.md
+│   ├── design.md
+│   ├── review.md
+│   └── tasks/
+│       └── phase-3-plan-task-NN.md
+├── backups/                           # Pre-compact safety copies
+│   └── phase-N-{name}-backup.md
 ├── phase-6-wrap-up.md                 # Quest storyboard
-├── teambuff-01.md                     # Team retrospective reports (on-demand)
+├── teambuff-NN.md                     # Team retrospective reports (on-demand)
 └── teambuff-rulings.md                # Active rulings from teambuffs
 
 .claude/vault/{quest-slug}/            # Archived completed quests
@@ -244,7 +256,8 @@ The Dungeon is the team's shared knowledge artifact — a curated board where ag
 │   ├── validate-no-placeholders.sh  # No TBD/TODO in specs
 │   ├── validate-dungeon.sh          # Multi-agent verification on pins
 │   ├── validate-browser-tests-exist.sh  # Playwright test detection
-│   └── validate-browser-cleanup.sh  # Browser process cleanup
+│   ├── validate-browser-cleanup.sh  # Browser process cleanup
+│   └── rtk-bridge.sh               # Token compression via RTK (opt-in)
 └── skills/
     ├── raid-init/                   # Quest selection and session setup
     ├── raid-canonical-protocol/     # Canonical Quest rules and signals
@@ -268,24 +281,27 @@ The Dungeon is the team's shared knowledge artifact — a curated board where ag
 
 The Wizard orchestrates. Warrior, Archer, and Rogue each bring a specialized lens. All agents run on Claude Opus 4.6.
 
-### Hooks (12)
+### Hooks (13)
 
 Hooks enforce workflow discipline automatically and **only activate during Raid sessions** — they never interfere with normal coding.
 
-**Lifecycle hooks** manage session start/end, quest directory creation, vault archival, and context compaction backup.
+**Lifecycle hooks** (5) manage session start/end, quest directory creation, vault archival, context compaction backup, and task validation. All source `raid-lib.sh` for shared config.
 
-**Quality gate hooks** enforce conventional commits, phase-based write protection, naming conventions, placeholder blocking, multi-agent verification on dungeon pins, and browser test detection.
+**Quality gate hooks** (7) enforce conventional commits, phase-based write protection, naming conventions, placeholder blocking, multi-agent verification on dungeon pins, browser test detection, and browser process cleanup.
+
+**Optional hooks** (1): `rtk-bridge.sh` provides token compression via RTK — enabled with `--rtk` during summon.
 
 All hooks are POSIX-compatible and use `#claude-raid` markers to coexist safely with your existing hooks.
 
 ### Skills (14)
 
-Skills guide agent behavior across the workflow. Four categories:
+Skills guide agent behavior across the workflow. Five categories:
 
 | Category | Skills | Purpose |
 |:--|:--|:--|
 | **Core** | `raid-init` | Quest selection, greeting, session bootstrap |
-| **Canonical Quest** | 7 phase skills | One skill per phase, chained in order |
+| **Protocol** | `raid-canonical-protocol` | Phase lifecycle rules, transition gates, signals |
+| **Canonical Quest** | 6 phase skills | One skill per phase, chained in order |
 | **Discipline** | `raid-tdd`, `raid-verification`, `raid-debugging` | Quest-agnostic enforcement — invoked within any phase |
 | **Browser** | `raid-browser`, `raid-browser-chrome` | Browser orchestration and live inspection |
 | **Team** | `raid-teambuff` | Emergency team retrospective — freezes quest, all agents reflect on dysfunction, produces binding rulings |
@@ -301,6 +317,10 @@ Skills guide agent behavior across the workflow. Four categories:
   "project": {
     "name": "my-project",
     "language": "typescript",
+    "packageManager": "npm",
+    "runCommand": "npm run",
+    "execCommand": "npx",
+    "installCommand": "npm add",
     "testCommand": "npm test",
     "lintCommand": "npm run lint",
     "buildCommand": "npm run build"
@@ -311,14 +331,20 @@ Skills guide agent behavior across the workflow. Four categories:
     "worktrees": ".worktrees"
   },
   "conventions": {
-    "fileNaming": "kebab-case",
+    "fileNaming": "none",
     "commits": "conventional"
   },
   "raid": {
     "defaultMode": "full",
+    "agentEffort": "medium",
     "vault": { "path": ".claude/vault", "enabled": true },
     "lifecycle": {
       "autoSessionManagement": true,
+      "teammateNudge": true,
+      "taskValidation": true,
+      "completionGate": true,
+      "phaseTransitionConfirm": true,
+      "compactBackup": true,
       "testWindowMinutes": 10
     }
   }
@@ -342,6 +368,9 @@ Package manager is auto-detected (npm, pnpm, yarn, bun, uv, poetry). Commands ar
 
 | Key | Default | Description |
 |:--|:--|:--|
+| `project.name` | auto-detected | Project name |
+| `project.language` | auto-detected | Primary language |
+| `project.packageManager` | auto-detected | npm, pnpm, yarn, bun, uv, or poetry |
 | `project.testCommand` | auto-detected | Command to run tests |
 | `project.lintCommand` | auto-detected | Command to run linting |
 | `project.buildCommand` | auto-detected | Command to build |
@@ -350,8 +379,18 @@ Package manager is auto-detected (npm, pnpm, yarn, bun, uv, poetry). Commands ar
 | `paths.worktrees` | `.worktrees` | Git worktree directory |
 | `conventions.fileNaming` | `none` | `kebab-case`, `snake_case`, `camelCase`, or `none` |
 | `conventions.commits` | `conventional` | Commit message format |
-| `conventions.commitMinLength` | `15` | Minimum commit message length |
-| `conventions.maxDepth` | `8` | Maximum file nesting depth |
+| `conventions.commitMinLength` | `15` | Minimum commit message length (set manually) |
+| `conventions.maxDepth` | `8` | Maximum file nesting depth (set manually) |
+| `raid.defaultMode` | `full` | Default quest mode |
+| `raid.agentEffort` | `medium` | Agent reasoning effort level |
+| `raid.vault.enabled` | `true` | Archive completed quests to vault |
+| `raid.vault.path` | `.claude/vault` | Vault directory path |
+| `raid.lifecycle.autoSessionManagement` | `true` | Auto-manage session start/end |
+| `raid.lifecycle.teammateNudge` | `true` | Nudge agents to use teammate mode |
+| `raid.lifecycle.taskValidation` | `true` | Validate task subjects are meaningful |
+| `raid.lifecycle.completionGate` | `true` | Require verification before completion claims |
+| `raid.lifecycle.phaseTransitionConfirm` | `true` | Confirm before phase transitions |
+| `raid.lifecycle.compactBackup` | `true` | Back up dungeon before context compaction |
 | `raid.lifecycle.testWindowMinutes` | `10` | Max age (minutes) of test run for verification |
 
 </details>
@@ -368,13 +407,34 @@ When a browser framework is detected (Next.js, Vite, Angular, etc.), a `browser`
     "devCommand": "npm run dev",
     "baseUrl": "http://localhost:3000",
     "defaultPort": 3000,
-    "playwrightConfig": "playwright.config.ts"
+    "portRange": [3001, 3005],
+    "playwrightConfig": "playwright.config.ts",
+    "auth": null,
+    "startup": null
   }
 }
 ```
 
 This enables browser-specific hooks and skills — Playwright test detection, browser process cleanup, and live Chrome inspection during reviews.
 
+### RTK Token Compression
+
+When installed with `--rtk`, an `rtk` section is added to `raid.json`:
+
+```json
+{
+  "rtk": {
+    "enabled": true,
+    "bypass": {
+      "phases": [],
+      "commands": []
+    }
+  }
+}
+```
+
+RTK compresses token usage via a fail-open bridge hook. Bypass specific phases or command prefixes by editing the arrays. Requires the `rtk` binary to be installed separately.
+
 ---
 
 ## CLI Reference
@@ -404,6 +464,7 @@ Installs the full Raid system. Auto-detects project type, copies agents/hooks/sk
 - Never overwrites existing files — customized agents are preserved
 - Idempotent — safe to run multiple times
 - `--dry-run` shows exactly what would be created without touching disk
+- `--rtk` enables RTK token compression bridge
 
 ### `update`
 

package/bin/cli.js

@@ -73,7 +73,8 @@ const COMMANDS = {
       console.log(require('../src/init').dryRun(process.cwd()));
       return;
     }
-    return require('../src/init').run();
+    const rtkFlag = process.argv.includes('--rtk');
+    return require('../src/init').run({ rtkEnabled: rtkFlag });
   },
   update: () => require('../src/update').run(),
   dismantle: () => require('../src/remove').run(),
@@ -85,7 +86,8 @@ const COMMANDS = {
       console.log(require('../src/init').dryRun(process.cwd()));
       return;
     }
-    return require('../src/init').run();
+    const rtkFlag = process.argv.includes('--rtk');
+    return require('../src/init').run({ rtkEnabled: rtkFlag });
   },
   remove: () => require('../src/remove').run(),
   doctor: () => require('../src/doctor').run(),

package/package.json

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

package/src/descriptions.js

@@ -4,15 +4,15 @@
 // Keep descriptions under 80 chars — they appear in terminal columns.
 
 const AGENTS = {
-  'wizard.md':  'Dungeon master — opens phases, dispatches team, closes with rulings',
-  'warrior.md': 'Stress-tester — breaks things under load, edge cases, pressure',
-  'archer.md':  'Pattern-seeker — traces ripple effects, naming drift, contract violations',
-  'rogue.md':   'Assumption-destroyer — thinks like a failing system, malicious input',
+  'wizard.md':  'Dungeon Master — opens phases, dispatches team, closes with rulings',
+  'warrior.md': 'Stress-tester — tests boundaries, load, edge cases, failure modes',
+  'archer.md':  'Pattern-seeker — ripple effects, naming drift, contract violations, dependencies',
+  'rogue.md':   'Assumption-destroyer — failing systems, malicious input, race conditions',
 };
 
 const HOOKS = {
   lifecycle: [
-    { name: 'raid-lib.sh',            desc: 'Shared config — reads raid.json, exports session state' },
+    { name: 'raid-lib.sh',            desc: 'Shared config — reads raid.json, exports quest state' },
     { name: 'raid-session-start.sh',   desc: 'Activates Raid workflow, creates quest directory' },
     { name: 'raid-session-end.sh',     desc: 'Archives quest dungeon to vault, cleans up' },
     { name: 'raid-pre-compact.sh',    desc: 'Backs up Dungeon before message compaction' },
@@ -20,18 +20,21 @@ const HOOKS = {
   ],
   gates: [
     { name: 'validate-commit.sh',              desc: 'Enforces conventional commit format' },
-    { name: 'validate-write-gate.sh',          desc: 'Protects session files, allows quest dir writes' },
+    { name: 'validate-write-gate.sh',          desc: 'Protects raid-session file, allows quest dir writes' },
     { name: 'validate-file-naming.sh',         desc: 'Enforces naming convention (kebab-case, etc.)' },
     { name: 'validate-no-placeholders.sh',     desc: 'Blocks TBD/TODO in specs, plans, and quest docs' },
     { name: 'validate-dungeon.sh',             desc: 'Validates dungeon entries and black cards' },
     { name: 'validate-browser-tests-exist.sh', desc: 'Checks Playwright tests exist before commits' },
     { name: 'validate-browser-cleanup.sh',     desc: 'Verifies browser processes cleaned up properly' },
   ],
+  optional: [
+    { name: 'rtk-bridge.sh', desc: 'Token compression via RTK (optional, opt-in)' },
+  ],
 };
 
 const SKILLS = {
   // Core
-  'raid-init':                            'Quest selection, greeting, session setup',
+  'raid-init':                            'Quest selection, greeting, raid initialization',
   // Canonical Quest chain
   'raid-canonical-protocol':              'Canonical Quest protocol and rules',
   'raid-canonical-prd':                   'Phase 1: PRD creation (optional)',

package/src/init.js

@@ -32,7 +32,7 @@ function copyRecursive(src, dest, skipped) {
   }
 }
 
-function install(cwd) {
+function install(cwd, opts = {}) {
   const claudeDir = path.join(cwd, '.claude');
   const result = { skipped: [], alreadyInstalled: false, detected: null };
 
@@ -131,6 +131,15 @@ function install(cwd) {
         startup: null,
       };
     }
+    if (opts.rtkEnabled) {
+      raidConfig.rtk = {
+        enabled: true,
+        bypass: {
+          phases: [],
+          commands: [],
+        },
+      };
+    }
     fs.writeFileSync(raidConfigPath, JSON.stringify(raidConfig, null, 2) + '\n');
   }
 
@@ -161,14 +170,14 @@ function install(cwd) {
   return result;
 }
 
-async function run() {
+async function run(opts = {}) {
   const cwd = process.cwd();
   const { bold, dim } = colors;
 
   console.log('\n' + banner());
   console.log(header('Summoning the Party...') + '\n');
 
-  const result = install(cwd);
+  const result = install(cwd, opts);
 
   if (result.alreadyInstalled) {
     console.log('  The party is already here. Use ' + bold('claude-raid update') + ' to reforge.');
@@ -222,7 +231,20 @@ async function run() {
   }
 
   // Setup wizard
-  await runSetup();
+  const setupResult = await runSetup(opts);
+
+  // Apply RTK config if enabled interactively
+  if (setupResult.actions.includes('rtk-enabled')) {
+    const raidConfigPath = path.join(cwd, '.claude', 'raid.json');
+    if (fs.existsSync(raidConfigPath)) {
+      const config = JSON.parse(fs.readFileSync(raidConfigPath, 'utf8'));
+      if (!config.rtk) {
+        config.rtk = { enabled: true, bypass: { phases: [], commands: [] } };
+        fs.writeFileSync(raidConfigPath, JSON.stringify(config, null, 2) + '\n');
+        mergeSettings(cwd);
+      }
+    }
+  }
 
   // Reference card
   const { referenceCard } = require('./ui');
@@ -273,6 +295,15 @@ function dryRun(cwd) {
   }
   lines.push('');
 
+  // Hooks — Optional
+  if (HOOKS.optional && HOOKS.optional.length > 0) {
+    lines.push(header('Hooks \u2014 Optional') + '\n');
+    for (const h of HOOKS.optional) {
+      lines.push('  ' + colors.bold(h.name.padEnd(28)) + h.desc + tag('hooks/' + h.name));
+    }
+    lines.push('');
+  }
+
   // Skills
   lines.push(header('Skills') + '\n');
   for (const [folder, desc] of Object.entries(SKILLS)) {
@@ -301,7 +332,7 @@ function dryRun(cwd) {
   }
   lines.push('');
 
-  lines.push('  Run without --dry-run to install.');
+  lines.push('  Run without --dry-run to summon.');
 
   return lines.join('\n');
 }

package/src/merge-settings.js

@@ -7,10 +7,32 @@ const RAID_ENV = {
   CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS: '1',
 };
 
-const RAID_PERMISSIONS = ['Read', 'Glob', 'Grep', 'Bash', 'Write', 'Edit'];
+const RAID_PERMISSIONS = [
+  'Read',
+  'Glob',
+  'Grep',
+  'Bash',
+  'Write',
+  'Edit',
+  'Write(.claude/**)',
+  'Edit(.claude/**)',
+];
 
 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 +100,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 +138,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 +193,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

@@ -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,6 +413,15 @@ 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);

package/src/ui.js

@@ -143,6 +143,7 @@ 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', [

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