cc-reviewer 3.0.1 → 5.0.0

package/commands/claude-review.md

@@ -0,0 +1,92 @@
+# Claude Review
+
+Get a review from a fresh Claude (Opus) instance with clean context — zero memory of this session.
+
+## Arguments
+- `$ARGUMENTS` - Optional: focus area or custom instructions
+
+## Claude Strengths
+- **Deep Analysis**: Thorough reasoning across all dimensions
+- **Correctness**: Logic errors, edge cases, subtle bugs
+- **Security**: Vulnerability detection, auth analysis
+- **Architecture**: Design patterns, coupling, abstractions
+- **Clean Context**: No confirmation bias from the current session
+
+## Before Calling - PREPARE THE HANDOFF
+
+### 1. Summarize What You Did (Brief!)
+```
+"Implemented WebSocket reconnection with exponential backoff
+and added session persistence across reconnects."
+```
+
+### 2. List Your Uncertainties
+What should Claude verify?
+
+```
+UNCERTAINTIES:
+- "Is the backoff strategy correct for this use case?"
+- "Could there be a race condition between reconnect and message send?"
+```
+
+### 3. Ask Specific Questions
+```
+QUESTIONS:
+- "Is the session token handling secure during reconnect?"
+- "Should I handle partial message delivery differently?"
+```
+
+## Tool Invocation
+
+Call `claude_review` with:
+
+```json
+{
+  "workingDir": "<current directory>",
+  "ccOutput": "<structured handoff - see below>",
+  "outputType": "analysis",
+  "focusAreas": ["<from $ARGUMENTS>"]
+}
+```
+
+### Structure your ccOutput:
+
+```
+SUMMARY:
+<what you did, 1-3 sentences>
+
+UNCERTAINTIES (verify these):
+1. <your uncertainty>
+2. <another uncertainty>
+
+QUESTIONS:
+1. <specific question>
+
+KEY DECISIONS:
+- <decision>: <rationale>
+
+PRIORITY FILES:
+- <file to focus on>
+```
+
+## After Receiving Review
+
+1. **Verify file references exist**
+   - Check mentioned file:line locations
+   - Flag any that don't exist
+
+2. **Cross-check findings**
+   - Read the actual code
+   - Confirm the issue exists
+
+3. **Mark confidence:**
+   - ✓✓ Verified by you
+   - ✓ Plausible, not verified
+   - ? Needs investigation
+   - ✗ Rejected
+
+4. **Apply judgment**
+   - You may disagree with findings
+   - Make YOUR recommendation
+
+$ARGUMENTS

package/commands/multi-review.md

@@ -1,13 +1,25 @@
 # Multi Review
 
-Get parallel reviews from both Codex and Gemini, raw output for manual synthesis.
+Get parallel standard AND adversarial reviews from all available models (Codex, Gemini, Claude Opus).
+
+Each model runs twice: once as a standard reviewer (finding bugs, issues, improvements) and once as an adversarial challenger (breaking confidence in the change, questioning assumptions, targeting hidden failure paths). Results are presented in two sections.
+
+Use `$ARGUMENTS` to steer the adversarial focus (e.g., "focus the challenge on race conditions and rollback safety").
 
 ## Arguments
-- `$ARGUMENTS` - Optional: focus area or custom instructions
+- `$ARGUMENTS` - Optional: focus area, custom instructions, or adversarial steering
 
 ## When to Use
 
-Use `/multi-review` when you want parallel reviews from both Codex and Gemini.
+Use `/multi-review` when you want thorough parallel reviews from all available models. Every invocation includes both standard and adversarial passes.
+
+## Examples
+
+```
+/multi-review
+/multi-review focus the challenge on race conditions and rollback safety
+/multi-review challenge whether this was the right caching and retry design
+```
 
 ## Before Calling - PREPARE THE HANDOFF
 
@@ -22,7 +34,6 @@ Added cache invalidation on product updates."
 UNCERTAINTIES:
 - "Is the cache TTL appropriate for this data?"
 - "Does the invalidation handle all update scenarios?"
-- "Is the Redis connection pooling configured correctly?"
 ```
 
 ### 3. Ask Specific Questions
@@ -42,7 +53,7 @@ Call `multi_review` with:
   "ccOutput": "<structured handoff>",
   "outputType": "analysis",
   "focusAreas": ["<from $ARGUMENTS>"],
-  "serviceTier": "<see below>"
+  "customPrompt": "<steering text from $ARGUMENTS for adversarial focus>"
 }
 ```
 
@@ -70,21 +81,22 @@ PRIORITY FILES:
 
 ## After Receiving Review
 
-You will receive separate reviews from each model.
+You will receive two sections: **Standard Review Findings** and **Challenge Review Findings**.
 
-### Synthesize Manually
+### Synthesize
 
-1. **Find agreements** (both models say same thing)
-   - Higher confidence
-   - Still verify yourself
+1. **Standard findings** — bugs, issues, improvements from each model
+   - Find agreements across models (higher confidence)
+   - Identify conflicts (YOU decide who's right)
 
-2. **Identify conflicts** (they disagree)
-   - Read the code
-   - YOU decide who's right
+2. **Challenge findings** — adversarial challenges from each model
+   - These target assumptions and design decisions, not just bugs
+   - Evaluate on merit — some challenges are speculative by design
+   - Strong challenges with evidence deserve serious consideration
 
-3. **Note unique insights**
-   - Findings only one model found
-   - Evaluate on merit
+3. **Cross-reference** standard vs challenge findings
+   - Standard + challenge agreement = high confidence issue
+   - Challenge-only finding = investigate further before acting
 
 4. **Verify all findings**
    - Check file/line references exist

package/dist/adapters/base.d.ts

@@ -41,6 +41,8 @@ export interface ReviewRequest {
     reasoningEffort?: ReasoningEffort;
     /** Service tier (for models that support it: priority = fast, flex = cheap) */
     serviceTier?: ServiceTier;
+    /** Review mode: standard finds bugs, adversarial challenges assumptions */
+    reviewMode?: 'standard' | 'adversarial';
 }
 /** @deprecated Use handoff.ts roles instead */
 export interface ExpertRole {

package/dist/adapters/claude.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Claude CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for Anthropic's Claude CLI.
+ * Spawns a FRESH Claude Code instance with zero session context.
+ * Returns raw text — CC handles interpretation.
+ *
+ * Read-only enforcement (defense-in-depth):
+ *   1. --permission-mode plan     (CLI-level read-only)
+ *   2. --disallowed-tools         (write tools explicitly blocked)
+ *   3. Handoff prompt             (explicit READ-ONLY instruction)
+ */
+import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult } from './base.js';
+export declare class ClaudeAdapter implements ReviewerAdapter {
+    readonly id = "claude";
+    getCapabilities(): ReviewerCapabilities;
+    isAvailable(): Promise<boolean>;
+    runReview(request: ReviewRequest): Promise<ReviewResult>;
+    private runCli;
+    private handleException;
+    private categorizeError;
+    private getSuggestion;
+}
+export declare const claudeAdapter: ClaudeAdapter;

package/dist/adapters/claude.js

@@ -0,0 +1,183 @@
+/**
+ * Claude CLI Adapter
+ *
+ * Implements the ReviewerAdapter interface for Anthropic's Claude CLI.
+ * Spawns a FRESH Claude Code instance with zero session context.
+ * Returns raw text — CC handles interpretation.
+ *
+ * Read-only enforcement (defense-in-depth):
+ *   1. --permission-mode plan     (CLI-level read-only)
+ *   2. --disallowed-tools         (write tools explicitly blocked)
+ *   3. Handoff prompt             (explicit READ-ONLY instruction)
+ */
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { registerAdapter, } from './base.js';
+import { CliExecutor } from '../executor.js';
+import { ClaudeEventDecoder } from '../decoders/index.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+// =============================================================================
+// CONFIGURATION
+// =============================================================================
+const INACTIVITY_TIMEOUT_MS = 300_000; // 5 min — Opus has long thinking phases
+const MAX_TIMEOUT_MS = 3_600_000; // 60 min absolute max
+const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB max buffer
+// Write tools explicitly blocked as defense-in-depth
+const DISALLOWED_TOOLS = 'Edit Write NotebookEdit';
+// =============================================================================
+// CLAUDE ADAPTER
+// =============================================================================
+export class ClaudeAdapter {
+    id = 'claude';
+    getCapabilities() {
+        return {
+            name: 'Claude',
+            description: 'Anthropic Claude (Opus) - fresh instance with clean context, excels at deep analysis across all dimensions',
+            strengths: ['correctness', 'security', 'architecture', 'maintainability'],
+            weaknesses: [],
+            hasFilesystemAccess: true,
+            supportsStructuredOutput: false,
+            maxContextTokens: 200000,
+            reasoningLevels: undefined,
+        };
+    }
+    async isAvailable() {
+        return new Promise((resolve) => {
+            const proc = spawn('claude', ['--version'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            proc.on('close', (code) => resolve(code === 0));
+            proc.on('error', () => resolve(false));
+            setTimeout(() => { proc.kill(); resolve(false); }, 5000);
+        });
+    }
+    async runReview(request) {
+        const startTime = Date.now();
+        if (!existsSync(request.workingDir)) {
+            return {
+                success: false,
+                error: { type: 'cli_error', message: `Working directory does not exist: ${request.workingDir}` },
+                suggestion: 'Check that the working directory path is correct',
+                executionTimeMs: Date.now() - startTime,
+            };
+        }
+        try {
+            const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
+            const prompt = request.reviewMode === 'adversarial'
+                ? buildAdversarialHandoffPrompt({ handoff })
+                : buildHandoffPrompt({ handoff, role: selectRole(request.focusAreas) });
+            const result = await this.runCli(prompt, request.workingDir);
+            if (result.exitCode !== 0) {
+                const error = this.categorizeError(result.stderr);
+                return { success: false, error, suggestion: this.getSuggestion(error), executionTimeMs: Date.now() - startTime };
+            }
+            if (!result.stdout.trim()) {
+                return {
+                    success: false,
+                    error: { type: 'cli_error', message: 'Claude returned empty response' },
+                    suggestion: 'Try again or use /codex-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
+    async runCli(prompt, workingDir) {
+        const args = [
+            '-p', // Non-interactive, print and exit
+            '--model', 'opus', // Use Opus
+            '--bare', // Skip hooks, plugins, CLAUDE.md, auto-memory
+            '--permission-mode', 'plan', // Read-only enforcement (layer 1)
+            '--verbose', // Required for stream-json
+            '--output-format', 'stream-json', // Structured streaming events
+            '--no-session-persistence', // Ephemeral — no trace
+            '--disable-slash-commands', // No skills — minimal startup
+            '--disallowed-tools', DISALLOWED_TOOLS, // Block write tools (layer 2)
+            '-', // Read prompt from stdin
+        ];
+        const decoder = new ClaudeEventDecoder();
+        const cliStartTime = Date.now();
+        console.error('[claude] Running Opus review...');
+        decoder.onProgress = (eventType, detail) => {
+            const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+            const detailStr = detail ? ` — ${detail}` : '';
+            console.error(`[claude] ${eventType}${detailStr} (${elapsed}s)`);
+        };
+        const executor = new CliExecutor({
+            command: 'claude',
+            args,
+            cwd: workingDir,
+            stdin: prompt,
+            inactivityTimeoutMs: INACTIVITY_TIMEOUT_MS,
+            maxTimeoutMs: MAX_TIMEOUT_MS,
+            maxBufferSize: MAX_BUFFER_SIZE,
+            onLine: (line) => {
+                decoder.processLine(line);
+            },
+        });
+        const result = await executor.run();
+        const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
+        console.error(`[claude] ✓ complete (${elapsed}s)`);
+        // Check for errors captured from stream events
+        const decoderError = decoder.getError();
+        if (decoderError) {
+            const combined = result.stderr ? `${decoderError}\n\nCLI stderr: ${result.stderr}` : decoderError;
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        const finalResponse = decoder.getFinalResponse();
+        if (!finalResponse && decoder.hasNoOutput()) {
+            const combined = result.stderr ? `No output from Claude\n\nCLI stderr: ${result.stderr}` : 'No output from Claude';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        if (!finalResponse) {
+            const combined = result.stderr ? `No result event from Claude\n\nCLI stderr: ${result.stderr}` : 'No result event from Claude';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        return {
+            stdout: finalResponse,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            truncated: result.truncated,
+        };
+    }
+    handleException(error, startTime) {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return { success: false, error: { type: 'cli_not_found', message: 'Claude CLI not found' },
+                suggestion: 'Install Claude Code: https://docs.anthropic.com/en/docs/claude-code', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Claude timed out — no events received' },
+                suggestion: 'Try a smaller scope or use /codex-review', executionTimeMs: Date.now() - startTime };
+        }
+        if (err.message === 'MAX_TIMEOUT') {
+            return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
+                suggestion: 'Try a smaller scope', executionTimeMs: Date.now() - startTime };
+        }
+        return { success: false, error: { type: 'cli_error', message: err.message }, executionTimeMs: Date.now() - startTime };
+    }
+    categorizeError(stderr) {
+        const lower = stderr.toLowerCase();
+        if (lower.includes('rate limit') || lower.includes('rate_limit') || lower.includes('quota')) {
+            return { type: 'rate_limit', message: `Claude rate limit: ${stderr.slice(0, 500)}` };
+        }
+        if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
+            return { type: 'auth_error', message: `Authentication failed: ${stderr.slice(0, 500)}`, details: { stderr } };
+        }
+        return { type: 'cli_error', message: stderr.slice(0, 500) || 'Unknown error' };
+    }
+    getSuggestion(error) {
+        switch (error.type) {
+            case 'rate_limit': return 'Wait and retry, or use /codex-review or /gemini-review instead';
+            case 'auth_error': return 'Run `claude auth` to authenticate';
+            case 'cli_not_found': return 'Install Claude Code: https://docs.anthropic.com/en/docs/claude-code';
+            default: return 'Check the error message and try again';
+        }
+    }
+}
+// Register the adapter
+registerAdapter(new ClaudeAdapter());
+export const claudeAdapter = new ClaudeAdapter();

package/dist/adapters/codex.js

@@ -10,7 +10,7 @@ import { existsSync } from 'fs';
 import { registerAdapter, } from './base.js';
 import { CliExecutor } from '../executor.js';
 import { CodexEventDecoder } from '../decoders/index.js';
-import { buildSimpleHandoff, buildHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
 // =============================================================================
 // CONFIGURATION
 // =============================================================================
@@ -59,8 +59,9 @@ export class CodexAdapter {
         }
         try {
             const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
-            const role = selectRole(request.focusAreas);
-            const prompt = buildHandoffPrompt({ handoff, role });
+            const prompt = request.reviewMode === 'adversarial'
+                ? buildAdversarialHandoffPrompt({ handoff })
+                : buildHandoffPrompt({ handoff, role: selectRole(request.focusAreas) });
             const result = await this.runCli(prompt, request.workingDir, request.reasoningEffort || 'high', request.serviceTier);
             if (result.exitCode !== 0) {
                 const error = this.categorizeError(result.stderr);
@@ -123,14 +124,20 @@ export class CodexAdapter {
         // Check for errors captured from JSONL events
         const decoderError = decoder.getError();
         if (decoderError) {
-            return { stdout: '', stderr: decoderError, exitCode: 1, truncated: false };
+            const combined = result.stderr ? `${decoderError}\n\nCLI stderr: ${result.stderr}` : decoderError;
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
         }
         const finalResponse = decoder.getFinalResponse();
         if (!finalResponse && decoder.hasNoOutput()) {
-            return { stdout: '', stderr: 'No response from Codex — possible rate limit or model rejection', exitCode: 1, truncated: false };
+            const combined = result.stderr ? `No output from Codex\n\nCLI stderr: ${result.stderr}` : 'No output from Codex';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
+        }
+        if (!finalResponse) {
+            const combined = result.stderr ? `No result event from Codex\n\nCLI stderr: ${result.stderr}` : 'No result event from Codex';
+            return { stdout: '', stderr: combined, exitCode: 1, truncated: false };
         }
         return {
-            stdout: finalResponse || result.rawStdout,
+            stdout: finalResponse,
             stderr: result.stderr,
             exitCode: result.exitCode,
             truncated: result.truncated,
@@ -154,16 +161,16 @@ export class CodexAdapter {
     }
     categorizeError(stderr) {
         const lower = stderr.toLowerCase();
-        if (lower.includes('rate limit') || lower.includes('possible rate limit') || lower.includes('no response from codex')) {
-            return { type: 'rate_limit', message: 'Codex rate limit — no tokens available' };
+        if (lower.includes('rate limit') || lower.includes('rate_limit')) {
+            return { type: 'rate_limit', message: `Codex rate limit: ${stderr.slice(0, 500)}` };
         }
         if (lower.includes('unauthorized') || lower.includes('authentication') || stderr.includes('401') || stderr.includes('403')) {
-            return { type: 'auth_error', message: 'Authentication failed', details: { stderr } };
+            return { type: 'auth_error', message: `Authentication failed: ${stderr.slice(0, 500)}`, details: { stderr } };
         }
         if (lower.includes('invalid_json_schema') || lower.includes('invalid_request_error')) {
-            return { type: 'cli_error', message: `API error: ${stderr.slice(0, 300)}` };
+            return { type: 'cli_error', message: `API error: ${stderr.slice(0, 500)}` };
         }
-        return { type: 'cli_error', message: stderr || 'Unknown error' };
+        return { type: 'cli_error', message: stderr.slice(0, 500) || 'Unknown error' };
     }
     getSuggestion(error) {
         switch (error.type) {

package/dist/adapters/gemini.js

@@ -10,7 +10,7 @@ import { existsSync } from 'fs';
 import { registerAdapter, } from './base.js';
 import { CliExecutor } from '../executor.js';
 import { GeminiEventDecoder } from '../decoders/index.js';
-import { buildSimpleHandoff, buildHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
 // =============================================================================
 // CONFIGURATION
 // =============================================================================
@@ -56,8 +56,9 @@ export class GeminiAdapter {
         }
         try {
             const handoff = buildSimpleHandoff(request.workingDir, request.ccOutput, request.analyzedFiles, request.focusAreas, request.customPrompt);
-            const role = selectRole(request.focusAreas);
-            const prompt = buildHandoffPrompt({ handoff, role });
+            const prompt = request.reviewMode === 'adversarial'
+                ? buildAdversarialHandoffPrompt({ handoff })
+                : buildHandoffPrompt({ handoff, role: selectRole(request.focusAreas) });
             const result = await this.runCli(prompt, request.workingDir);
             if (result.exitCode !== 0) {
                 const error = this.categorizeError(result.stderr);
@@ -109,8 +110,11 @@ export class GeminiAdapter {
         const elapsed = Math.round((Date.now() - cliStartTime) / 1000);
         console.error(`[gemini] ✓ complete (${elapsed}s)`);
         const finalResponse = decoder.getFinalResponse();
+        if (!finalResponse && result.exitCode === 0) {
+            return { stdout: '', stderr: 'Gemini produced no output — review may have failed silently', exitCode: 1, truncated: false };
+        }
         return {
-            stdout: finalResponse || result.rawStdout,
+            stdout: finalResponse || '',
             stderr: result.stderr,
             exitCode: result.exitCode,
             truncated: result.truncated,
@@ -135,12 +139,12 @@ export class GeminiAdapter {
     categorizeError(stderr) {
         const lower = stderr.toLowerCase();
         if (lower.includes('rate limit') || lower.includes('quota')) {
-            return { type: 'rate_limit', message: 'Rate limit or quota exceeded' };
+            return { type: 'rate_limit', message: `Rate limit or quota exceeded: ${stderr.slice(0, 500)}` };
         }
         if (lower.includes('unauthorized') || lower.includes('authentication') || lower.includes('api key') || stderr.includes('401') || stderr.includes('403')) {
-            return { type: 'auth_error', message: 'Authentication failed', details: { stderr } };
+            return { type: 'auth_error', message: `Authentication failed: ${stderr.slice(0, 500)}`, details: { stderr } };
         }
-        return { type: 'cli_error', message: stderr || 'Unknown error' };
+        return { type: 'cli_error', message: stderr.slice(0, 500) || 'Unknown error' };
     }
     getSuggestion(error) {
         switch (error.type) {

package/dist/adapters/index.d.ts

@@ -5,6 +5,8 @@
  */
 import './codex.js';
 import './gemini.js';
+import './claude.js';
 export * from './base.js';
 export { codexAdapter } from './codex.js';
 export { geminiAdapter } from './gemini.js';
+export { claudeAdapter } from './claude.js';

package/dist/adapters/index.js

@@ -6,8 +6,10 @@
 // Import adapters to register them
 import './codex.js';
 import './gemini.js';
+import './claude.js';
 // Re-export everything from base
 export * from './base.js';
 // Export specific adapters
 export { codexAdapter } from './codex.js';
 export { geminiAdapter } from './gemini.js';
+export { claudeAdapter } from './claude.js';

package/dist/cli/check.js

@@ -22,11 +22,12 @@ async function commandExists(command) {
  * Check availability of all supported CLIs
  */
 export async function checkCliAvailability() {
-    const [codex, gemini] = await Promise.all([
+    const [codex, gemini, claude] = await Promise.all([
         commandExists('codex'),
-        commandExists('gemini')
+        commandExists('gemini'),
+        commandExists('claude')
     ]);
-    return { codex, gemini };
+    return { codex, gemini, claude };
 }
 /**
  * Check if a specific CLI is available
@@ -67,9 +68,11 @@ export async function logCliStatus() {
     console.error('AI Reviewer CLI Status:');
     console.error(`  - Codex: ${status.codex ? '✓ Available' : '✗ Not found'}`);
     console.error(`  - Gemini: ${status.gemini ? '✓ Available' : '✗ Not found'}`);
-    if (!status.codex && !status.gemini) {
-        console.error('\nWarning: No AI CLIs found. Install with:');
+    console.error(`  - Claude: ${status.claude ? '✓ Available' : '✗ Not found'}`);
+    if (!status.codex && !status.gemini && !status.claude) {
+        console.error('\nWarning: No AI CLIs found. Install at least one:');
         console.error('  npm install -g @openai/codex-cli');
         console.error('  npm install -g @google/gemini-cli');
+        console.error('  Claude Code: https://docs.anthropic.com/en/docs/claude-code');
     }
 }

package/dist/commands.js

@@ -18,6 +18,7 @@ const DEPRECATED_COMMANDS = [
     'ask-codex.md',
     'ask-gemini.md',
     'ask-multi.md',
+    'multi-review-adv.md',
 ];
 /**
  * Get source and target paths for command files

package/dist/decoders/claude.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ClaudeEventDecoder — Parses Claude CLI stream-json JSONL events.
+ *
+ * Event stream format (with --output-format stream-json --verbose):
+ *   {"type":"system","subtype":"init",...}
+ *   {"type":"assistant","message":{"content":[{"type":"text","text":"..."}],...},...}
+ *   {"type":"result","subtype":"success","result":"...","duration_ms":...,"usage":{...}}
+ */
+export interface ClaudeEvent {
+    type: string;
+    subtype?: string;
+    session_id?: string;
+    model?: string;
+    result?: string;
+    is_error?: boolean;
+    duration_ms?: number;
+    message?: {
+        content?: Array<{
+            type: string;
+            text?: string;
+        }>;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_read_input_tokens?: number;
+            cache_creation_input_tokens?: number;
+        };
+    };
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_read_input_tokens?: number;
+        cache_creation_input_tokens?: number;
+    };
+    tool_use_id?: string;
+    tool_name?: string;
+}
+export declare class ClaudeEventDecoder {
+    onProgress?: (eventType: string, detail?: string) => void;
+    private _finalResponse;
+    private _usage;
+    private _error;
+    private _eventCount;
+    private _durationMs;
+    processLine(line: string): void;
+    getFinalResponse(): string | null;
+    getUsage(): ClaudeEvent['usage'] | null;
+    getError(): string | null;
+    getDurationMs(): number | null;
+    hasNoOutput(): boolean;
+    private _handleEvent;
+    private _describeEvent;
+}

package/dist/decoders/claude.js

@@ -0,0 +1,106 @@
+/**
+ * ClaudeEventDecoder — Parses Claude CLI stream-json JSONL events.
+ *
+ * Event stream format (with --output-format stream-json --verbose):
+ *   {"type":"system","subtype":"init",...}
+ *   {"type":"assistant","message":{"content":[{"type":"text","text":"..."}],...},...}
+ *   {"type":"result","subtype":"success","result":"...","duration_ms":...,"usage":{...}}
+ */
+// =============================================================================
+// DECODER
+// =============================================================================
+export class ClaudeEventDecoder {
+    onProgress;
+    _finalResponse = null;
+    _usage = null;
+    _error = null;
+    _eventCount = 0;
+    _durationMs = null;
+    // =============================================================================
+    // PUBLIC API
+    // =============================================================================
+    processLine(line) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            return;
+        let event;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+                return;
+            event = parsed;
+        }
+        catch {
+            return;
+        }
+        if (!event.type)
+            return;
+        this._handleEvent(event);
+    }
+    getFinalResponse() {
+        return this._finalResponse;
+    }
+    getUsage() {
+        return this._usage;
+    }
+    getError() {
+        return this._error;
+    }
+    getDurationMs() {
+        return this._durationMs;
+    }
+    hasNoOutput() {
+        return this._eventCount > 0 && this._finalResponse === null;
+    }
+    // =============================================================================
+    // PRIVATE HELPERS
+    // =============================================================================
+    _handleEvent(event) {
+        this._eventCount++;
+        switch (event.type) {
+            case 'result':
+                // The result event contains the final text response
+                if (event.subtype === 'success' && typeof event.result === 'string') {
+                    this._finalResponse = event.result;
+                }
+                if (event.is_error) {
+                    this._error = event.result || 'Claude review failed';
+                }
+                if (event.usage) {
+                    this._usage = event.usage;
+                }
+                if (event.duration_ms != null) {
+                    this._durationMs = event.duration_ms;
+                }
+                break;
+            case 'assistant':
+                // Track usage from assistant messages
+                if (event.message?.usage) {
+                    this._usage = event.message.usage;
+                }
+                break;
+            case 'error':
+                this._error = event.result || 'Unknown error from Claude CLI';
+                break;
+        }
+        this.onProgress?.(event.type, this._describeEvent(event));
+    }
+    _describeEvent(event) {
+        switch (event.type) {
+            case 'system':
+                if (event.subtype === 'init')
+                    return `model: ${event.model || 'opus'}`;
+                if (event.subtype)
+                    return event.subtype;
+                return undefined;
+            case 'assistant':
+                return 'assistant message';
+            case 'tool_use':
+                return event.tool_name ? `tool: ${event.tool_name}` : 'tool use';
+            case 'result':
+                return `status: ${event.subtype || 'unknown'}`;
+            default:
+                return undefined;
+        }
+    }
+}

package/dist/decoders/index.d.ts

@@ -2,3 +2,5 @@ export { CodexEventDecoder } from './codex.js';
 export type { CodexEvent } from './codex.js';
 export { GeminiEventDecoder } from './gemini.js';
 export type { GeminiEvent } from './gemini.js';
+export { ClaudeEventDecoder } from './claude.js';
+export type { ClaudeEvent } from './claude.js';

package/dist/decoders/index.js

@@ -1,2 +1,3 @@
 export { CodexEventDecoder } from './codex.js';
 export { GeminiEventDecoder } from './gemini.js';
+export { ClaudeEventDecoder } from './claude.js';

package/dist/errors.js

@@ -6,17 +6,20 @@
 // Gemini: https://github.com/google-gemini/gemini-cli
 const INSTALL_COMMANDS = {
     codex: 'npm install -g @openai/codex-cli',
-    gemini: 'npm install -g @google/gemini-cli'
+    gemini: 'npm install -g @google/gemini-cli',
+    claude: 'https://docs.anthropic.com/en/docs/claude-code'
 };
 // Environment variables for API keys
 const ENV_VARS = {
     codex: 'OPENAI_API_KEY',
-    gemini: 'GEMINI_API_KEY'
+    gemini: 'GEMINI_API_KEY',
+    claude: 'ANTHROPIC_API_KEY'
 };
 // Authentication commands
 const AUTH_COMMANDS = {
     codex: 'codex login',
-    gemini: 'gemini (follow prompts)'
+    gemini: 'gemini (follow prompts)',
+    claude: 'claude auth'
 };
 /**
  * Create a CLI not found error
@@ -83,7 +86,8 @@ export function createCliError(cli, exitCode, stderr) {
  * Format an error for user display
  */
 export function formatErrorForUser(error) {
-    const otherCli = error.cli === 'codex' ? 'gemini' : 'codex';
+    const others = ['codex', 'gemini', 'claude'].filter(c => c !== error.cli);
+    const otherCli = others[0];
     switch (error.type) {
         case 'cli_not_found':
             return `❌ ${error.cli} CLI not found.

package/dist/handoff.d.ts

@@ -4,9 +4,10 @@
  * Defines the minimal, targeted information that should flow from CC to reviewers.
  *
  * Philosophy:
- * - Reviewers have filesystem + git access - don't duplicate what they can discover
+ * - Reviewers have filesystem access - don't duplicate what they can discover
  * - Pass ONLY what CC uniquely knows: uncertainties, decisions, questions
- * - Let reviewer use their tools (git diff, file reading) for actual code
+ * - Let reviewer use their tools (file reading) for actual code
+ * - Do NOT assume git — working directory may not be a git repo
  */
 import { z } from 'zod';
 import { FocusArea } from './types.js';
@@ -211,6 +212,13 @@ export declare const ROLES: Record<string, ReviewerRole>;
  * Select the best role based on focus areas
  */
 export declare function selectRole(focusAreas?: FocusArea[]): ReviewerRole;
+export declare const ADVERSARIAL_REVIEWER: ReviewerRole;
+/**
+ * Build an adversarial handoff prompt with challenge-mode stance sections.
+ * Same structure as buildHandoffPrompt but adds adversarial XML sections
+ * and uses the ADVERSARIAL_REVIEWER role.
+ */
+export declare function buildAdversarialHandoffPrompt(options: PromptOptions): string;
 export interface PromptOptions {
     handoff: Handoff;
     role?: ReviewerRole;

package/dist/handoff.js

@@ -4,9 +4,10 @@
  * Defines the minimal, targeted information that should flow from CC to reviewers.
  *
  * Philosophy:
- * - Reviewers have filesystem + git access - don't duplicate what they can discover
+ * - Reviewers have filesystem access - don't duplicate what they can discover
  * - Pass ONLY what CC uniquely knows: uncertainties, decisions, questions
- * - Let reviewer use their tools (git diff, file reading) for actual code
+ * - Let reviewer use their tools (file reading) for actual code
+ * - Do NOT assume git — working directory may not be a git repo
  */
 import { z } from 'zod';
 // =============================================================================
@@ -87,7 +88,7 @@ export const CHANGE_FOCUSED_REVIEWER = {
     isGeneric: true,
     applicableFocusAreas: [],
     systemPrompt: `Change reviewer. Focus on: goal achievement, regressions, edge cases, side effects.
-Reference specific lines in the diff.`,
+Reference specific lines in the source files.`,
 };
 /**
  * Specialized roles - when specific focus is requested
@@ -153,6 +154,121 @@ export function selectRole(focusAreas) {
     }
     return CHANGE_FOCUSED_REVIEWER;
 }
+// =============================================================================
+// ADVERSARIAL REVIEWER — Challenge mode for multi_review
+// =============================================================================
+export const ADVERSARIAL_REVIEWER = {
+    id: 'adversarial',
+    name: 'Adversarial Reviewer',
+    description: 'Actively tries to break confidence in the change — challenges assumptions, not just bugs',
+    isGeneric: false,
+    applicableFocusAreas: [],
+    systemPrompt: `Senior staff engineer performing an adversarial review. Your job is to break confidence in the change, not to validate it.`,
+};
+/**
+ * Build an adversarial handoff prompt with challenge-mode stance sections.
+ * Same structure as buildHandoffPrompt but adds adversarial XML sections
+ * and uses the ADVERSARIAL_REVIEWER role.
+ */
+export function buildAdversarialHandoffPrompt(options) {
+    const { handoff } = options;
+    const role = ADVERSARIAL_REVIEWER;
+    const sections = [];
+    // SECTION 1: ROLE
+    sections.push(`# ROLE: ${role.name}\n\n${role.systemPrompt}`);
+    // SECTION 2: ADVERSARIAL STANCE
+    sections.push(`## ADVERSARIAL STANCE
+
+<operating_stance>
+Default to skepticism. Assume the change can fail in subtle, high-cost,
+or user-visible ways until the evidence says otherwise. Do not give credit
+for good intent, partial fixes, or likely follow-up work.
+</operating_stance>
+
+<attack_surface>
+Prioritized failure categories:
+1. Auth/permissions bypass
+2. Data loss or corruption
+3. Rollback safety
+4. Race conditions / concurrency
+5. Empty-state / null / timeout handling
+6. Version skew / backwards compatibility
+7. Observability gaps (missing logs, metrics, alerts)
+</attack_surface>
+
+<review_method>
+Actively try to disprove the change. Look for violated invariants,
+missing guards, unhandled failure paths. If the user supplied a focus area,
+weight it heavily, but still report any other material issue you can defend.
+</review_method>
+
+<finding_bar>
+Material findings only. Each must answer:
+1. What can go wrong?
+2. Why is this code path vulnerable?
+3. What is the likely impact?
+4. What concrete change would reduce the risk?
+</finding_bar>
+
+<calibration_rules>
+Prefer one strong finding over several weak ones. If you cannot defend
+a finding from the provided code, drop it.
+</calibration_rules>
+
+<grounding_rules>
+Be aggressive, but stay grounded. Every finding must be defensible from
+the repository context. No speculative findings. No "might be an issue"
+without concrete evidence from the code.
+</grounding_rules>`);
+    // SECTION 3: TASK (same as standard)
+    sections.push(`## YOUR TASK
+
+Review code in \`${handoff.workingDir}\`.
+
+**Summary:** ${handoff.summary}${handoff.confidence !== undefined && handoff.confidence < 0.9 ? `\n**CC Confidence:** ${Math.round(handoff.confidence * 100)}% — verify weak areas` : ''}
+
+**IMPORTANT:**
+- This is a READ-ONLY review. Do NOT create, modify, or delete any files. Only read files to verify claims.
+- Do NOT assume a git repository exists. Do NOT run git commands. Read files directly from the filesystem.`);
+    // SECTION 4: CC'S UNCERTAINTIES
+    if (handoff.uncertainties && handoff.uncertainties.length > 0) {
+        sections.push(`## CC'S UNCERTAINTIES
+
+${handoff.uncertainties.map((u, i) => `### ${i + 1}. ${u.topic} ${u.severity === 'critical' ? '⚠️' : ''}
+- **Question:** ${u.question}
+${u.ccAssumption ? `- **CC assumed:** ${u.ccAssumption}` : ''}
+${u.relevantFiles ? `- **Files:** ${u.relevantFiles.join(', ')}` : ''}`).join('\n\n')}`);
+    }
+    // SECTION 5: SPECIFIC QUESTIONS
+    if (handoff.questions && handoff.questions.length > 0) {
+        sections.push(`## QUESTIONS FROM CC
+
+${handoff.questions.map((q, i) => `${i + 1}. **${q.question}**
+   ${q.context ? `Context: ${q.context}` : ''}
+   ${q.ccGuess ? `CC Guess: ${q.ccGuess}` : ''}`).join('\n')}`);
+    }
+    // SECTION 6: DECISIONS TO EVALUATE
+    if (handoff.decisions && handoff.decisions.length > 0) {
+        sections.push(`## DECISIONS TO EVALUATE
+
+${handoff.decisions.map((d, i) => `${i + 1}. **${d.decision}**
+   Rationale: ${d.rationale}
+   ${d.alternatives ? `Alternatives: ${d.alternatives.join(', ')}` : ''}`).join('\n')}`);
+    }
+    // SECTION 7: FOCUS AREAS
+    if (handoff.focusAreas && handoff.focusAreas.length > 0) {
+        sections.push(`## FOCUS AREAS\n\nWeight these areas heavily in your adversarial analysis:\n${handoff.focusAreas.map(f => `- **${f}**`).join('\n')}`);
+    }
+    // SECTION 8: PRIORITY FILES
+    if (handoff.priorityFiles && handoff.priorityFiles.length > 0) {
+        sections.push(`## PRIORITY FILES\n\n${handoff.priorityFiles.map(f => `- \`${f}\``).join('\n')}`);
+    }
+    // SECTION 9: ADVERSARIAL FOCUS (customInstructions steers the challenge)
+    if (handoff.customInstructions) {
+        sections.push(`## ADVERSARIAL FOCUS\n\n${handoff.customInstructions}`);
+    }
+    return sections.join('\n\n');
+}
 /**
  * Build the review prompt using minimal, targeted context.
  * No output format constraints — reviewer responds naturally, CC interprets.
@@ -166,11 +282,13 @@ export function buildHandoffPrompt(options) {
     // SECTION 2: TASK
     sections.push(`## YOUR TASK
 
-Review recent work in \`${handoff.workingDir}\`.
+Review code in \`${handoff.workingDir}\`.
 
 **Summary:** ${handoff.summary}${handoff.confidence !== undefined && handoff.confidence < 0.9 ? `\n**CC Confidence:** ${Math.round(handoff.confidence * 100)}% — verify weak areas` : ''}
 
-**IMPORTANT: This is a READ-ONLY review. Do NOT create, modify, or delete any files. Only read files to verify claims.**`);
+**IMPORTANT:**
+- This is a READ-ONLY review. Do NOT create, modify, or delete any files. Only read files to verify claims.
+- Do NOT assume a git repository exists. Do NOT run git commands. Read files directly from the filesystem.`);
     // SECTION 3: CC'S UNCERTAINTIES
     if (handoff.uncertainties && handoff.uncertainties.length > 0) {
         sections.push(`## CC'S UNCERTAINTIES
@@ -200,6 +318,10 @@ ${handoff.decisions.map((d, i) => `${i + 1}. **${d.decision}**
     if (handoff.priorityFiles && handoff.priorityFiles.length > 0) {
         sections.push(`## PRIORITY FILES\n\n${handoff.priorityFiles.map(f => `- \`${f}\``).join('\n')}`);
     }
+    // SECTION 7: CUSTOM INSTRUCTIONS
+    if (handoff.customInstructions) {
+        sections.push(`## ADDITIONAL INSTRUCTIONS\n\n${handoff.customInstructions}`);
+    }
     return sections.join('\n\n');
 }
 // =============================================================================

package/dist/index.js

@@ -18,7 +18,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { handleCodexReview, handleGeminiReview, handleMultiReview, ReviewInputSchema, TOOL_DEFINITIONS } from './tools/feedback.js';
+import { handleCodexReview, handleGeminiReview, handleClaudeReview, handleMultiReview, ReviewInputSchema, TOOL_DEFINITIONS } from './tools/feedback.js';
 import { logCliStatus } from './cli/check.js';
 import { installCommands } from './commands.js';
 // Read version from package.json
@@ -62,6 +62,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         tools: [
             TOOL_DEFINITIONS.codex_review,
             TOOL_DEFINITIONS.gemini_review,
+            TOOL_DEFINITIONS.claude_review,
             TOOL_DEFINITIONS.multi_review,
         ],
     };
@@ -79,6 +80,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const input = ReviewInputSchema.parse(args);
                 return await handleGeminiReview(input);
             }
+            case 'claude_review': {
+                const input = ReviewInputSchema.parse(args);
+                return await handleClaudeReview(input);
+            }
             case 'multi_review': {
                 const input = ReviewInputSchema.parse(args);
                 return await handleMultiReview(input);

package/dist/prompt.js

@@ -101,6 +101,7 @@ ${request.customPrompt}`);
 CONSTRAINTS:
 • You have filesystem access - READ files to verify claims
 • Do NOT modify any files (advisory mode only)
+• Do NOT assume a git repository exists - do NOT run git commands
 • Reference specific file:line when making claims
 • Do NOT hallucinate file paths - verify they exist
 • Be skeptical - verify before agreeing with CC's findings`);

package/dist/tools/feedback.d.ts

@@ -46,6 +46,12 @@ export declare function handleGeminiReview(input: ReviewInput): Promise<{
         text: string;
     }>;
 }>;
+export declare function handleClaudeReview(input: ReviewInput): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;
 export declare function handleMultiReview(input: ReviewInput): Promise<{
     content: Array<{
         type: 'text';
@@ -147,6 +153,48 @@ export declare const TOOL_DEFINITIONS: {
             required: string[];
         };
     };
+    claude_review: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {
+                workingDir: {
+                    type: string;
+                    description: string;
+                };
+                ccOutput: {
+                    type: string;
+                    description: string;
+                };
+                outputType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                analyzedFiles: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                    description: string;
+                };
+                focusAreas: {
+                    type: string;
+                    items: {
+                        type: string;
+                        enum: string[];
+                    };
+                    description: string;
+                };
+                customPrompt: {
+                    type: string;
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
     multi_review: {
         name: string;
         description: string;

package/dist/tools/feedback.js

@@ -73,6 +73,16 @@ export async function handleGeminiReview(input) {
     const result = await adapter.runReview(toReviewRequest(input));
     return { content: [{ type: 'text', text: formatResult(result, 'Gemini') }] };
 }
+export async function handleClaudeReview(input) {
+    const adapter = getAdapter('claude');
+    if (!adapter)
+        return { content: [{ type: 'text', text: '❌ Claude adapter not registered' }] };
+    const available = await adapter.isAvailable();
+    if (!available)
+        return { content: [{ type: 'text', text: '❌ Claude CLI not found.\n\nInstall Claude Code: https://docs.anthropic.com/en/docs/claude-code\n\nAlternative: Use codex_review or gemini_review instead' }] };
+    const result = await adapter.runReview(toReviewRequest(input));
+    return { content: [{ type: 'text', text: formatResult(result, 'Claude (Opus)') }] };
+}
 // =============================================================================
 // MULTI-MODEL HANDLER
 // =============================================================================
@@ -82,24 +92,38 @@ export async function handleMultiReview(input) {
     if (availableAdapters.length === 0) {
         return { content: [{ type: 'text', text: '❌ No AI CLIs found.\n\nInstall at least one:\n  - Codex: npm install -g @openai/codex-cli\n  - Gemini: npm install -g @google/gemini-cli' }] };
     }
-    const results = await Promise.all(availableAdapters.map(async (adapter) => {
-        const result = await adapter.runReview({ ...request });
-        return { adapter, result };
-    }));
-    const lines = [];
+    // Spawn 2 reviews per adapter: standard + adversarial (all in parallel)
+    // customPrompt steers the adversarial focus only — strip it from standard pass to avoid bias
+    const { customPrompt, ...standardRequest } = request;
+    const reviewPromises = availableAdapters.flatMap((adapter) => [
+        adapter.runReview({ ...standardRequest }).then(result => ({ adapter, result, mode: 'standard' })),
+        adapter.runReview({ ...request, reviewMode: 'adversarial' }).then(result => ({ adapter, result, mode: 'adversarial' })),
+    ]);
+    const results = await Promise.all(reviewPromises);
+    const standardResults = results.filter(r => r.mode === 'standard');
+    const adversarialResults = results.filter(r => r.mode === 'adversarial');
     const allFailed = results.every(r => !r.result.success);
     const someFailed = results.some(r => !r.result.success);
+    const lines = [];
     if (allFailed)
         lines.push('## Multi-Model Review ❌ All Failed\n');
     else if (someFailed)
         lines.push('## Multi-Model Review ⚠️ Partial Success\n');
     else
         lines.push('## Multi-Model Review ✓\n');
-    lines.push(`**Models:** ${availableAdapters.map(a => a.id).join(', ')}\n`);
-    for (const { adapter, result } of results) {
+    lines.push(`**Models:** ${availableAdapters.map(a => a.id).join(', ')} (standard + adversarial)\n`);
+    // Standard section
+    lines.push('## Standard Review Findings\n');
+    for (const { adapter, result } of standardResults) {
         lines.push(formatResult(result, adapter.getCapabilities().name));
         lines.push('');
     }
+    // Adversarial section
+    lines.push('## Challenge Review Findings\n');
+    for (const { adapter, result } of adversarialResults) {
+        lines.push(formatResult(result, `${adapter.getCapabilities().name} (Adversarial)`));
+        lines.push('');
+    }
     return { content: [{ type: 'text', text: lines.join('\n') }] };
 }
 // =============================================================================
@@ -140,9 +164,25 @@ export const TOOL_DEFINITIONS = {
             required: ['workingDir', 'ccOutput', 'outputType']
         }
     },
+    claude_review: {
+        name: 'claude_review',
+        description: "ONLY use when user explicitly requests '/claude-review' or 'review with claude'. Get second-opinion from a fresh Claude (Opus) instance with clean context — no memory of this session. Excels at deep analysis across all dimensions. DO NOT use for general 'review' requests.",
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workingDir: { type: 'string', description: 'Working directory for the CLI to operate in' },
+                ccOutput: { type: 'string', description: "Claude Code's output to review (findings, plan, analysis)" },
+                outputType: { type: 'string', enum: ['plan', 'findings', 'analysis', 'proposal'], description: 'Type of output being reviewed' },
+                analyzedFiles: { type: 'array', items: { type: 'string' }, description: 'File paths that CC analyzed' },
+                focusAreas: { type: 'array', items: { type: 'string', enum: ['security', 'performance', 'architecture', 'correctness', 'maintainability', 'scalability', 'testing', 'documentation'] }, description: 'Areas to focus the review on' },
+                customPrompt: { type: 'string', description: 'Custom instructions for the reviewer' },
+            },
+            required: ['workingDir', 'ccOutput', 'outputType']
+        }
+    },
     multi_review: {
         name: 'multi_review',
-        description: "ONLY use when user explicitly requests '/multi-review' or 'review with both codex and gemini'. Get parallel second-opinions from both external CLIs (Codex and Gemini). Returns combined reviews for synthesis. DO NOT use for general 'review' requests.",
+        description: "ONLY use when user explicitly requests '/multi-review' or 'review with all models'. Runs parallel standard AND adversarial reviews from all available models. Each model reviews twice: standard (bugs/issues) + adversarial (challenge assumptions/design decisions). Use customPrompt to steer the adversarial focus. DO NOT use for general 'review' requests.",
         inputSchema: {
             type: 'object',
             properties: {
@@ -151,7 +191,7 @@ export const TOOL_DEFINITIONS = {
                 outputType: { type: 'string', enum: ['plan', 'findings', 'analysis', 'proposal'], description: 'Type of output being reviewed' },
                 analyzedFiles: { type: 'array', items: { type: 'string' }, description: 'File paths that CC analyzed' },
                 focusAreas: { type: 'array', items: { type: 'string', enum: ['security', 'performance', 'architecture', 'correctness', 'maintainability', 'scalability', 'testing', 'documentation'] }, description: 'Areas to focus the review on' },
-                customPrompt: { type: 'string', description: 'Custom instructions for the reviewer' },
+                customPrompt: { type: 'string', description: 'Custom instructions for standard review + adversarial focus steering' },
                 serviceTier: { type: 'string', enum: ['default', 'fast', 'flex'], description: 'Codex service tier (fast = priority processing, flex = cheaper/slower). Only applies to Codex.' }
             },
             required: ['workingDir', 'ccOutput', 'outputType']

package/dist/types.d.ts

@@ -3,7 +3,7 @@
  */
 export type OutputType = 'plan' | 'findings' | 'analysis' | 'proposal';
 export type FocusArea = 'security' | 'performance' | 'architecture' | 'correctness' | 'maintainability' | 'scalability' | 'testing' | 'documentation';
-export type CliType = 'codex' | 'gemini';
+export type CliType = 'codex' | 'gemini' | 'claude';
 export type ReasoningEffort = 'high' | 'xhigh';
 export type ServiceTier = 'default' | 'fast' | 'flex';
 export interface FeedbackRequest {
@@ -69,6 +69,7 @@ export interface MultiFeedbackResult {
 export interface CliStatus {
     codex: boolean;
     gemini: boolean;
+    claude: boolean;
 }
 export interface StructuredFeedback {
     agreements: Array<{

package/dist/types.js

@@ -11,6 +11,11 @@ export const REVIEWER_PERSONAS = {
         name: 'Gemini',
         focus: 'design patterns, scalability, tech debt',
         style: 'Think holistically - consider broader context.'
+    },
+    claude: {
+        name: 'Claude',
+        focus: 'deep analysis, correctness, security, architecture',
+        style: 'Fresh perspective with clean context - challenge assumptions.'
     }
 };
 // Focus area descriptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-reviewer",
-  "version": "3.0.1",
+  "version": "5.0.0",
   "description": "MCP server for Claude Code - Get second-opinion feedback from Codex/Gemini CLIs",
   "type": "module",
   "main": "dist/index.js",