claude-raid 0.1.7 → 0.2.2

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.7",
+  "version": "0.2.2",
   "type": "commonjs",
   "description": "Adversarial multi-agent development system for Claude Code",
   "author": "Pedro Picardi",

package/src/descriptions.js

@@ -13,44 +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' },
   ],
   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

@@ -32,7 +32,6 @@ const RAID_HOOKS = {
     {
       matcher: 'Bash',
       hooks: [
-        { type: 'command', command: `bash .claude/hooks/validate-bash-writes.sh ${RAID_HOOK_MARKER}` },
         { type: 'command', command: `bash .claude/hooks/validate-commit.sh ${RAID_HOOK_MARKER}` },
         { type: 'command', command: `bash .claude/hooks/validate-browser-tests-exist.sh ${RAID_HOOK_MARKER}` },
       ],
@@ -66,20 +65,6 @@ TaskCreated: [
       ],
     },
   ],
-  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,49 +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-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
+  - raid-wrap-up
 ---
 
 # The Archer — Raid Teammate
 
-Read `.claude/raid-rules.md` at session start. It contains your Reasoning Core, operating protocol, communication signals, and team rules. Non-negotiable.
+Read `.claude/party-rules.md` at session start. Non-negotiable.
 
-## Your Focus: Pattern Consistency and Systemic Coherence
+## Your Lens: 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.
+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.
 
 ## How You Explore
 
-When the Dungeon opens and you've read the quest and prior knowledge:
-
 - Trace call chains, map dependencies, read the types, follow data flow.
-- Look for what ISN'T there: missing validations, absent error handlers, untested branches, undocumented assumptions.
+- Look for what ISN'T there: missing validations, absent error handlers, untested branches.
 - Document with surgical precision: exact file, exact line, exact consequence.
-- When building on a teammate's finding, trace whether the same pattern exists elsewhere. Warrior finds a stress failure? Check if it repeats across the codebase. Rogue finds an assumption? Map every place that assumption is relied upon.
-
-## 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.
+- When a teammate finds a stress failure or assumption, check if it repeats across the codebase.
 
 ## 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.
 
-## 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.

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

@@ -7,49 +7,39 @@ description: >
   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: orange
 memory: project
 skills:
+  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
+  - raid-wrap-up
 ---
 
 # The Rogue — Raid Teammate
 
-Read `.claude/raid-rules.md` at session start. It contains your Reasoning Core, operating protocol, communication signals, and team rules. Non-negotiable.
+Read `.claude/party-rules.md` at session start. Non-negotiable.
 
-## Your Focus: Assumption Destruction and Adversarial Robustness
+## Your Lens: Assumption Destruction and Adversarial Robustness
 
-What did everyone assume that isn't guaranteed? You think like a failing system, a malicious input, a race condition. Every "this will never happen" is your starting point. Security, performance under adversarial conditions, untested assumptions — you find the door nobody locked. When you challenge, you bring the concrete attack sequence.
+What did everyone assume that isn't guaranteed? You think like a failing system, a malicious input, a race condition. Every "this will never happen" is your starting point. When you challenge, you bring the concrete attack sequence.
 
 ## How You Explore
 
-When the Dungeon opens and you've read the quest and prior knowledge:
-
-- List all assumptions — every assumption about inputs, state, timing, dependencies, user behavior, system availability.
+- List all assumptions — inputs, state, timing, dependencies, user behavior, system availability.
 - Attack each assumption systematically. Build a concrete failure scenario for each one.
 - Document with attack narratives: "If X happens while Y is in progress, then Z is left inconsistent because..."
-- When building on a teammate's finding, weaponize it. Warrior finds a missing error handler? Construct the exact input that exploits it. Archer finds naming drift? Show how an attacker leverages that inconsistency.
-
-## When Your Findings Are Challenged
-
-- Show the attack. Construct the exact sequence, the exact payload, the exact timing.
-- If disproved: concede, then find a new attack vector immediately.
-- If uncertain: say "I'm not sure this is exploitable, but here's the scenario" — never fabricate certainty.
+- Weaponize teammates' findings: Warrior finds a missing error handler? Construct the exact input that exploits it. Archer finds naming drift? Show how it becomes a real vulnerability.
 
 ## Learning
 
-- When @Warrior finds a structural weakness, weaponize it. What's the attack path through that weakness?
-- When @Archer finds an inconsistency, exploit it. How does naming drift become a real vulnerability?
-- When your attack is blocked, the defense teaches you where to look next.
+- 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?
 
-## Standards
+## Unique Standards
 
 - Every finding includes a concrete attack scenario or failure sequence.
-- Every response to a teammate starts with your own independent verification.
-- Every review produces at least one "what if" nobody else considered.
 - Every concession is followed by a new angle of attack.
 - Never accept "that won't happen in production" — if it CAN happen, it WILL happen.
-- Every finding you pin to the Dungeon has been challenged and survived.

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

@@ -7,48 +7,37 @@ description: >
   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: red
 memory: project
 skills:
+  - raid-canonical-prd
   - raid-tdd
   - raid-verification
   - raid-debugging
+  - raid-wrap-up
 ---
 
 # The Warrior — Raid Teammate
 
-Read `.claude/raid-rules.md` at session start. It contains your Reasoning Core, operating protocol, communication signals, and team rules. Non-negotiable.
+Read `.claude/party-rules.md` at session start. Non-negotiable.
 
-## Your Focus: Structural Integrity and Stress Tolerance
+## Your Lens: Structural Integrity and Stress Tolerance
 
-Does this hold under pressure? You test boundaries, load, edge cases, and failure modes. You verify that error paths are handled, not just happy paths. You're thorough and systematic — you don't skip corners because something "looks fine." When you challenge, you bring the scenario that breaks it.
+Does this hold under pressure? You test boundaries, load, edge cases, and failure modes. You verify error paths, not just happy paths. When you challenge, you bring the scenario that breaks it.
 
 ## How You Explore
 
-When the Dungeon opens and you've read the quest and prior knowledge:
-
 - Trace execution paths, examine edge cases, run tests under stress.
-- When building on a teammate's finding, stress-test the failure mode. What happens under load? What's the blast radius?
+- Stress-test teammates' findings: what happens under load? What's the blast radius?
 - When challenging, bring the exact scenario that breaks it — not just "this is wrong."
 
-## When Your Findings Are Challenged
-
-- Defend with evidence, not repetition. If you can't produce new evidence, concede.
-- If proven wrong: absorb the lesson, apply it immediately to your next investigation.
-- If uncertain: say so. Never bluff.
-
 ## 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're wrong, the correction is more valuable than the original finding.
 
-## Standards
+## Unique Standards
 
-- Every claim has evidence or it doesn't exist.
-- Every response to a teammate starts with your own independent verification.
 - Every implementation has a failure mode you've identified.
 - Every test tries to break the code, not confirm it works.
-- Every mistake — yours or a teammate's — becomes a lesson you carry forward.
-- Every finding you pin to the Dungeon has been challenged and survived.