claude-raid 0.1.6 → 0.2.1

package/bin/cli.js

@@ -10,6 +10,17 @@ const versionCheck = require('../src/version-check');
 const showUpdateNotice = versionCheck.start();
 
 const COMMANDS = {
+  // Start a Raid quest — launches wizard with full permissions
+  start: () => {
+    const { spawn } = require('child_process');
+    console.log('\n' + banner());
+    console.log(header('Summoning the Wizard...') + '\n');
+    const child = spawn('claude', ['--dangerously-skip-permissions', '--agent', 'wizard'], {
+      stdio: 'inherit',
+      env: process.env,
+    });
+    child.on('exit', (code) => process.exit(code || 0));
+  },
   // Sync local with remote after CI version bump
   sync: async () => {
     const { execSync } = require('child_process');
@@ -53,6 +64,7 @@ if (!command || !COMMANDS[command]) {
   console.log('\n' + banner());
   console.log(header('Commands') + '\n');
   const cmds = [
+    ['start',     'Begin the Raid (launches Wizard)'],
     ['summon',    'Summon the party into this realm'],
     ['update',    'Reforge the party\'s arsenal'],
     ['dismantle', 'Dismantle the camp and retreat'],
@@ -63,7 +75,7 @@ if (!command || !COMMANDS[command]) {
     console.log('    ' + colors.bold(name.padEnd(12)) + desc);
   }
   console.log(header('Begin the Raid') + '\n');
-  console.log('    claude --agent wizard\n');
+  console.log('    claude-raid start\n');
   console.log(colors.dim('  github.com/pedropicardi/claude-raid') + '\n');
   process.exit(command ? 1 : 0);
 }

package/package.json

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

package/src/descriptions.js

@@ -13,45 +13,46 @@ const AGENTS = {
 const HOOKS = {
   lifecycle: [
     { name: 'raid-lib.sh',            desc: 'Shared config — reads raid.json, exports session state' },
-    { name: 'raid-session-start.sh',   desc: 'Activates Raid workflow when session begins' },
-    { name: 'raid-session-end.sh',     desc: 'Archives Dungeon, cleans up when session ends' },
-    { name: 'raid-stop.sh',           desc: 'Backs up Dungeon on phase transitions' },
+    { 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' },
     { name: 'raid-task-created.sh',   desc: 'Validates task subjects are meaningful' },
-    { name: 'raid-task-completed.sh', desc: 'Blocks task completion without test evidence' },
-    { name: 'raid-teammate-idle.sh',  desc: 'Nudges idle agents to participate' },
   ],
   gates: [
-    { name: 'validate-commit.sh',              desc: 'Enforces conventional commits + test gate' },
-    { name: 'validate-write-gate.sh',          desc: 'Blocks implementation before design doc exists' },
+    { name: 'validate-commit.sh',              desc: 'Enforces conventional commit format' },
+    { name: 'validate-write-gate.sh',          desc: 'Protects session files, 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 and plans' },
-    { name: 'validate-dungeon.sh',             desc: 'Requires multi-agent verification on pins' },
+    { 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' },
   ],
 };
 
 const SKILLS = {
-  'raid-protocol':            'Session lifecycle and team rules',
-  'raid-design':              'Phase 1: adversarial exploration',
-  'raid-implementation-plan': 'Phase 2: task decomposition',
-  'raid-implementation':      'Phase 3: TDD with direct challenge',
-  'raid-review':              'Phase 4: independent review + fighting',
-  'raid-finishing':           'Completeness debate + merge options',
-  'raid-tdd':                 'RED-GREEN-REFACTOR enforcement',
-  'raid-debugging':           'Root-cause investigation',
-  'raid-verification':        'Evidence-before-claims gate',
-  'raid-git-worktrees':       'Isolated workspace creation',
-  'raid-browser':             'Browser startup discovery',
-  'raid-browser-playwright':  'Playwright test authoring',
-  'raid-browser-chrome':      'Live browser inspection',
+  // Core
+  'raid-init':                            'Quest selection, greeting, session setup',
+  // Canonical Quest chain
+  'raid-canonical-protocol':              'Canonical Quest protocol and rules',
+  'raid-canonical-prd':                   'Phase 1: PRD creation (optional)',
+  'raid-canonical-design':                'Phase 2: adversarial design exploration',
+  'raid-canonical-implementation-plan':   'Phase 3: task decomposition',
+  'raid-canonical-implementation':        'Phase 4: TDD with cross-testing',
+  'raid-canonical-review':                'Phase 5: pinning + fixing + black cards',
+  'raid-wrap-up':                         'Phase 6: storyboard, PR, vault archival',
+  // Reusable (quest-agnostic)
+  'raid-tdd':                             'RED-GREEN-REFACTOR enforcement',
+  'raid-verification':                    'Evidence-before-claims gate',
+  'raid-debugging':                       'Root-cause investigation',
+  'raid-browser':                         'Browser startup discovery',
+  'raid-browser-chrome':                  'Live browser inspection',
 };
 
 const CONFIG = {
-  'raid.json':      'Project settings (editable)',
-  'raid-rules.md':  '17 team rules (editable)',
-  'settings.json':  'Hooks merged into existing (backup created)',
+  'raid.json':                'Project settings (editable)',
+  'party-rules.md':           'Party agent rules (editable)',
+  'dungeon-master-rules.md':  'Wizard rules (editable)',
+  'settings.json':            'Hooks merged into existing (backup created)',
 };
 
 module.exports = { AGENTS, HOOKS, SKILLS, CONFIG };

package/src/init.js

@@ -37,7 +37,7 @@ function install(cwd) {
   const result = { skipped: [], alreadyInstalled: false, detected: null };
 
   // Check if already installed
-  if (fs.existsSync(path.join(claudeDir, 'raid-rules.md'))) {
+  if (fs.existsSync(path.join(claudeDir, 'party-rules.md'))) {
     result.alreadyInstalled = true;
   }
 
@@ -97,6 +97,7 @@ function install(cwd) {
       },
       raid: {
         defaultMode: 'full',
+        agentEffort: 'medium',
         vault: {
           path: '.claude/vault',
           enabled: true,
@@ -141,10 +142,7 @@ function install(cwd) {
   const ignoreEntries = [
     '.claude/raid-last-test-run',
     '.claude/raid-session',
-    '.claude/raid-dungeon.md',
-    '.claude/raid-dungeon-phase-*',
-    '.claude/raid-dungeon-backup.md',
-    '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/dungeon/',
     '.claude/vault/.draft/',
     '.env.raid',
   ];
@@ -212,7 +210,8 @@ async function run() {
   console.log('');
   console.log('  ' + header('Config'));
   console.log('    Generated ' + bold('raid.json') + '          ' + dim('Project settings (editable)'));
-  console.log('    Copied ' + bold('raid-rules.md') + '         ' + dim('17 team rules (editable)'));
+  console.log('    Copied ' + bold('party-rules.md') + '        ' + dim('Party agent rules (editable)'));
+  console.log('    Copied ' + bold('dungeon-master-rules.md') + ' ' + dim('Wizard rules (editable)'));
   console.log('    Merged ' + bold('settings.json') + '         ' + dim('Backup at .pre-raid-backup'));
 
   // Skipped files
@@ -293,10 +292,7 @@ function dryRun(cwd) {
   const ignoreEntries = [
     '.claude/raid-last-test-run',
     '.claude/raid-session',
-    '.claude/raid-dungeon.md',
-    '.claude/raid-dungeon-phase-*',
-    '.claude/raid-dungeon-backup.md',
-    '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/dungeon/',
     '.claude/vault/.draft/',
     '.env.raid',
   ];

package/src/merge-settings.js

@@ -58,34 +58,13 @@ const RAID_HOOKS = {
       ],
     },
   ],
-  TeammateIdle: [
-    {
-      hooks: [
-        { type: 'command', command: `bash .claude/hooks/raid-teammate-idle.sh ${RAID_HOOK_MARKER}` },
-      ],
-    },
-  ],
-  TaskCreated: [
+TaskCreated: [
     {
       hooks: [
         { type: 'command', command: `bash .claude/hooks/raid-task-created.sh ${RAID_HOOK_MARKER}` },
       ],
     },
   ],
-  TaskCompleted: [
-    {
-      hooks: [
-        { type: 'command', command: `bash .claude/hooks/raid-task-completed.sh ${RAID_HOOK_MARKER}` },
-      ],
-    },
-  ],
-  Stop: [
-    {
-      hooks: [
-        { type: 'command', command: `bash .claude/hooks/raid-stop.sh ${RAID_HOOK_MARKER}` },
-      ],
-    },
-  ],
   PreCompact: [
     {
       hooks: [

package/src/remove.js

@@ -7,10 +7,13 @@ const { banner, header, colors } = require('./ui');
 
 const RAID_AGENTS = ['wizard.md', 'warrior.md', 'archer.md', 'rogue.md'];
 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',
+  // Legacy (v0.1.x)
   'raid-protocol', 'raid-design', 'raid-implementation-plan', 'raid-implementation',
-  'raid-review', 'raid-finishing', 'raid-tdd', 'raid-debugging',
-  'raid-verification', 'raid-git-worktrees',
-  'raid-browser', 'raid-browser-playwright', 'raid-browser-chrome',
+  'raid-review', 'raid-prd', 'raid-finishing', 'raid-browser-playwright', 'raid-git-worktrees',
 ];
 
 function rmSafe(filePath) {
@@ -54,13 +57,19 @@ function performRemove(cwd) {
   rmDirIfEmpty(path.join(claudeDir, 'hooks'));
   rmDirIfEmpty(path.join(claudeDir, 'skills'));
 
-  rmSafe(path.join(claudeDir, 'raid-rules.md'));
+  rmSafe(path.join(claudeDir, 'party-rules.md'));
+  rmSafe(path.join(claudeDir, 'dungeon-master-rules.md'));
+  rmSafe(path.join(claudeDir, 'raid-rules.md')); // legacy cleanup
   rmSafe(path.join(claudeDir, 'raid.json'));
   rmSafe(path.join(claudeDir, 'raid-last-test-run'));
   rmSafe(path.join(claudeDir, 'raid-session'));
 
-  // Clean up Dungeon files
+  // Clean up quest dungeon directory
+  rmDirSafe(path.join(claudeDir, 'dungeon'));
+
+  // Clean up legacy flat dungeon files (v0.1.x)
   rmSafe(path.join(claudeDir, 'raid-dungeon.md'));
+  rmSafe(path.join(claudeDir, 'raid-dungeon-backup.md'));
   if (fs.existsSync(claudeDir)) {
     const dungeonFiles = fs.readdirSync(claudeDir).filter(f => f.startsWith('raid-dungeon-phase-'));
     for (const file of dungeonFiles) {
@@ -68,15 +77,6 @@ function performRemove(cwd) {
     }
   }
 
-  // Clean up Dungeon backups
-  rmSafe(path.join(claudeDir, 'raid-dungeon-backup.md'));
-  if (fs.existsSync(claudeDir)) {
-    const backupFiles = fs.readdirSync(claudeDir).filter(f => f.startsWith('raid-dungeon-phase-') && f.endsWith('-backup.md'));
-    for (const file of backupFiles) {
-      rmSafe(path.join(claudeDir, file));
-    }
-  }
-
   // Clean up Vault draft
   rmDirSafe(path.join(claudeDir, 'vault', '.draft'));
 
@@ -86,10 +86,12 @@ function performRemove(cwd) {
   const gitignorePath = path.join(cwd, '.gitignore');
   const raidIgnoreEntries = [
     '.claude/raid-last-test-run', '.claude/raid-session',
-    '.claude/raid-dungeon.md', '.claude/raid-dungeon-phase-*',
-    '.claude/raid-dungeon-backup.md', '.claude/raid-dungeon-phase-*-backup.md',
+    '.claude/dungeon/',
     '.claude/vault/.draft/',
     '.env.raid',
+    // Legacy (v0.1.x)
+    '.claude/raid-dungeon.md', '.claude/raid-dungeon-phase-*',
+    '.claude/raid-dungeon-backup.md', '.claude/raid-dungeon-phase-*-backup.md',
   ];
   if (fs.existsSync(gitignorePath)) {
     const lines = fs.readFileSync(gitignorePath, 'utf8').split('\n');

package/src/ui.js

@@ -143,7 +143,7 @@ function referenceCard() {
     '  ' + colors.dim('interfere with normal coding outside of a Raid.'),
     '',
     '  Config:  ' + colors.bold('.claude/raid.json') + '       ' + colors.dim('project settings'),
-    '  Rules:   ' + colors.bold('.claude/raid-rules.md') + '   ' + colors.dim('editable team rules'),
+    '  Rules:   ' + colors.bold('.claude/party-rules.md') + '  ' + colors.dim('editable party rules'),
   ]);
 
   const nextStep = box('Next Step', [

package/src/update.js

@@ -35,7 +35,8 @@ function performUpdate(cwd) {
   const claudeDir = path.join(cwd, '.claude');
   const skippedAgents = [];
 
-  if (!fs.existsSync(path.join(claudeDir, 'raid-rules.md'))) {
+  // Accept either new or legacy rules file as proof of installation
+  if (!fs.existsSync(path.join(claudeDir, 'party-rules.md')) && !fs.existsSync(path.join(claudeDir, 'raid-rules.md'))) {
     return { success: false, message: 'No party found. Run `claude-raid summon` first.', skippedAgents };
   }
 
@@ -66,15 +67,29 @@ function performUpdate(cwd) {
     }
   }
 
-  // Update raid-rules.md — skip if user has customized it
-  const rulesSrc = path.join(TEMPLATE_DIR, 'raid-rules.md');
-  const rulesDest = path.join(claudeDir, 'raid-rules.md');
-  let skippedRules = false;
-  if (fs.existsSync(rulesSrc)) {
-    if (fs.existsSync(rulesDest) && !filesAreEqual(rulesSrc, rulesDest)) {
-      skippedRules = true;
-    } else {
-      fs.copyFileSync(rulesSrc, rulesDest);
+  // Migrate legacy raid-rules.md -> party-rules.md
+  const legacyRules = path.join(claudeDir, 'raid-rules.md');
+  const partyRulesDest = path.join(claudeDir, 'party-rules.md');
+  if (fs.existsSync(legacyRules) && !fs.existsSync(partyRulesDest)) {
+    fs.renameSync(legacyRules, partyRulesDest);
+  }
+  // Clean up legacy file if both exist
+  if (fs.existsSync(legacyRules) && fs.existsSync(partyRulesDest)) {
+    try { fs.unlinkSync(legacyRules); } catch {}
+  }
+
+  // Update rules files — skip if user has customized them
+  const rulesFiles = ['party-rules.md', 'dungeon-master-rules.md'];
+  const skippedRulesFiles = [];
+  for (const rulesFile of rulesFiles) {
+    const rulesSrc = path.join(TEMPLATE_DIR, rulesFile);
+    const rulesDest = path.join(claudeDir, rulesFile);
+    if (fs.existsSync(rulesSrc)) {
+      if (fs.existsSync(rulesDest) && !filesAreEqual(rulesSrc, rulesDest)) {
+        skippedRulesFiles.push(rulesFile);
+      } else {
+        fs.copyFileSync(rulesSrc, rulesDest);
+      }
     }
   }
 
@@ -136,10 +151,10 @@ function performUpdate(cwd) {
   if (skippedAgents.length > 0) {
     message += `\nSkipped customized agents: ${skippedAgents.join(', ')}`;
   }
-  if (skippedRules) {
-    message += '\nSkipped customized raid-rules.md';
+  if (skippedRulesFiles.length > 0) {
+    message += '\nSkipped customized ' + skippedRulesFiles.join(', ');
   }
-  if (skippedAgents.length > 0 || skippedRules) {
+  if (skippedAgents.length > 0 || skippedRulesFiles.length > 0) {
     message += '\nUse `claude-raid dismantle` then `claude-raid summon` to reset.';
   }
 

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

@@ -7,134 +7,39 @@ description: >
   concedes with evidence, moves on. Collaborates through rigor, not agreement.
 model: claude-opus-4-6
 tools: SendMessage, TaskCreate, TaskUpdate, Read, Grep, Glob, Bash, Write, Edit
-effort: max
+effort: medium
 color: green
 memory: project
 skills:
-  - raid-protocol
+  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
+  - raid-wrap-up
 ---
 
 # The Archer — Raid Teammate
 
-## Reasoning Core
+Read `.claude/party-rules.md` at session start. Non-negotiable.
 
-You are a senior engineer. You think before you speak. Every claim you make has evidence you gathered yourself — file paths, line numbers, test output, concrete scenarios. Every claim a teammate makes is unverified until you verify it independently.
+## Your Lens: Pattern Consistency and Systemic Coherence
 
-You have zero trust in reports and summaries — including your own from prior turns. If you haven't read the code or run the command this turn, you don't know what it says.
+Does this fit? You trace how changes ripple through the system. You catch naming drift, contract violations, inconsistent conventions, and implicit dependencies that will break silently. When you challenge, you bring the inconsistency with its downstream consequence.
 
-You have zero ego. When proven wrong, concede instantly and move on. Being wrong is information — it sharpens your next move. Defending a dead position wastes everyone's time.
+## How You Explore
 
-You collaborate by being rigorous, not by being agreeable. The best thing you can do for a teammate is catch their mistake before it ships. The best thing they can do for you is the same.
+- Trace call chains, map dependencies, read the types, follow data flow.
+- Look for what ISN'T there: missing validations, absent error handlers, untested branches.
+- Document with surgical precision: exact file, exact line, exact consequence.
+- When a teammate finds a stress failure or assumption, check if it repeats across the codebase.
 
-Efficiency matters. Say what you found, what it means, and what should happen. No preamble. No restating what others said. No performative analysis.
-
-## Your Focus: Pattern Consistency and Systemic Coherence
-
-Does this fit? You trace how changes ripple through the system. You catch naming drift, contract violations, inconsistent conventions, and implicit dependencies that will break silently. You see the connection between module A and module C that nobody else mapped. When you challenge, you bring the inconsistency with its downstream consequence.
-
-## Team Rules
-
-You follow the Raid Team Rules in `.claude/raid-rules.md`. Read them at session start. Non-negotiable.
-
-## Mode Awareness
-
-You operate differently depending on the mode the Wizard sets:
-- **Full Raid** — 3 agents active. You work alongside @Warrior and @Rogue. Cross-verify everything.
-- **Skirmish** — 2 agents active. The Wizard selects which two.
-- **Scout** — 1 agent alone. Full responsibility, no backup.
-
-In every mode: maximum effort.
-
-## How You Operate
-
-### When the Wizard Opens the Dungeon
-
-The Wizard dispatches with angles and goes silent. You own the phase from here:
-
-1. Read the quest and your assigned angle.
-2. Read the Dungeon for any prior phase knowledge (archived Dungeons).
-3. Explore with precision — trace call chains, map dependencies, read the types, follow data flow.
-4. Look for what ISN'T there: missing validations, absent error handlers, untested branches, undocumented assumptions.
-5. Document findings with surgical precision: exact file, exact line, exact consequence.
-6. Share findings with @Warrior and @Rogue directly — don't wait for the Wizard to relay.
-7. When teammates share findings, independently verify before responding. Trace the code yourself. Then engage — challenge, extend, or confirm with your own evidence.
-8. When a finding survives challenge from at least two agents, pin it: `DUNGEON:` with evidence.
-
-### Working With Teammates
-
-You talk to @Warrior and @Rogue directly. You don't route through the Wizard.
-
-**The independent verification rule:** Before you respond to any teammate's finding — to challenge it, agree with it, or build on it — you first independently investigate the same area. Read the actual code. Trace the actual chain. Form your own conclusion. Then respond with your evidence alongside theirs.
-
-**Challenging:** When your independent verification contradicts a teammate's finding, show what they missed. Not just "this is wrong" — trace the actual inconsistency, show the ripple effect, demonstrate the downstream consequence.
-
-**Building:** When your verification confirms and deepens a teammate's finding, extend it through your lens. Warrior finds a stress failure? Trace whether the same pattern exists elsewhere in the codebase. Rogue finds an assumption? Map every place that assumption is relied upon.
-
-**Conceding:** When a teammate's challenge holds up against your evidence — concede immediately and redirect into the next angle.
-
-**Chain reactions:** If a teammate's finding triggers a new pattern you want to trace, follow it immediately. Don't wait for permission or turns. The conversation is the mechanism — findings compound when the team reacts in real-time.
-
-### When Your Findings Are Challenged
-
-- Respond with evidence. Show the exact line, the exact dependency, the exact consequence.
-- If proven wrong: concede immediately, refine your analysis, find the next inconsistency.
-- If uncertain: say so. Never fabricate certainty.
-
-### Learning
+## 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're wrong about a pattern, the correction sharpens your recognition.
-
-## Communication
-
-Lead with the conclusion, follow with the evidence. Be specific: not "this might have issues" but "line 47 of auth.ts assumes user.role is never null, but createGuestUser() on line 12 of users.ts sets it to undefined."
-
-Signals are shorthand for scanning, not ceremony:
-- `FINDING:` — something you discovered with your own evidence
-- `CHALLENGE:` — you independently verified a teammate's claim and found a problem
-- `BUILDING:` — you independently verified a teammate's claim and it goes deeper
-- `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
-
-## Team Communication
-
-You are a team member. Your teammates are in separate tmux panes.
-
-**Messaging teammates:**
-- `SendMessage(to="wizard", message="...")` — escalate to the Wizard
-- `SendMessage(to="warrior", message="...")` — challenge or build on Warrior's work
-- `SendMessage(to="rogue", message="...")` — challenge or build on Rogue's work
-
-Messages are delivered automatically. Idle teammates wake up when they receive a message.
-
-**Discovering teammates:** Read the team config at `~/.claude/teams/{team_name}/config.json` to see your teammates' names.
-
-**Task coordination:**
-- `TaskCreate(subject="...", description="...")` — create a new task for discovered work
-- `TaskUpdate(taskId="...", owner="archer")` — claim a task
-- `TaskUpdate(taskId="...", status="completed")` — mark a task done
-- Check `TaskList` after completing each task to find next available work
-
-**The Dungeon is still your knowledge artifact.** Pin verified findings there via Write tool. Use SendMessage for real-time conversation and challenges. Both systems coexist.
-
-## User Direct Access
-
-The user can talk to you directly in your tmux pane. Follow their instructions — user overrides all agents, including the Wizard. If the user gives you a protocol-level instruction (skip a phase, change mode, implement something directly), follow it and notify the Wizard:
-
-```
-SendMessage(to="wizard", message="User directed me to [X]. Proceeding.")
-```
 
-## Standards
+## Unique Standards
 
 - Every finding includes the exact location and the exact consequence.
-- Every response to a teammate starts with your own independent verification.
 - Every challenge traces the ripple effect at least two levels deep.
-- Every review checks for consistency with existing patterns, not just correctness in isolation.
-- Naming patterns, file structure, and interface consistency are your specialty — you catch the drift.
-- Every finding you pin to the Dungeon has been challenged and survived.
+- Naming patterns, file structure, and interface consistency are your specialty.