cc-reviewer 5.4.0 → 6.1.0

package/README.md

@@ -11,7 +11,7 @@ claude mcp add -s user cc-reviewer -- npx -y cc-reviewer
 
 **Step 2: Restart Claude Code**
 
-The MCP tools and slash commands (`/codex-review`, `/gemini-review`, `/multi-review`) are automatically installed.
+The MCP tools and slash commands (`/multi-review`, `/multi-consult`) are automatically installed.
 
 **Manual command install** (if needed):
 ```bash
@@ -51,11 +51,9 @@ gemini  # follow auth prompts
 
 These tools provide **external second-opinion reviews** from Codex and Gemini CLIs. They are designed to complement Claude Code's native review capabilities, not replace them.
 
-**Review tools** (external second-opinion on your work):
-- `/codex-review` or "review with codex" - Get external Codex review
-- `/codex-xhigh-review` - Deep-thinking Codex review with xhigh reasoning
-- `/gemini-review` or "review with gemini" - Get external Gemini review
-- `/multi-review` - Get parallel reviews from both CLIs
+**Slash commands:**
+- `/multi-review` - Parallel standard + adversarial reviews from all available CLIs (Codex, Gemini, Claude). For reviewing CC-produced work (plan, findings, code).
+- `/multi-consult` - Ask all CLIs the same question and synthesize their answers. For consultation/Q&A — what's the best approach, how to solve X.
 
 **For regular reviews:** Just say "review" and Claude Code will use its native capabilities. These external tools are only invoked when explicitly requested.
 
@@ -64,18 +62,17 @@ These tools provide **external second-opinion reviews** from Codex and Gemini CL
 These commands are available after restart:
 
 ```bash
-/codex-review             # Review with Codex
-/codex-review security    # Focus on security
-/codex-xhigh-review       # Codex with xhigh reasoning effort
-/gemini-review            # Review with Gemini
-/gemini-review architecture # Focus on architecture
-/multi-review             # Both models in parallel
+/multi-review                          # Parallel standard + adversarial reviews from all CLIs
+/multi-review focus on race conditions # Steer the adversarial focus
+/multi-consult <question>              # Ask all CLIs and synthesize
+/multi-consult <question> [flex]       # Use Codex flex tier (cheaper/slower)
 ```
 
 ## How It Works
 
 ```
-CC does work → User: /codex-review → External CLI reviews → CC synthesizes → Updated output
+CC does work → User: /multi-review → External CLIs review → CC synthesizes → Final output
+User has a question → User: /multi-consult → External CLIs answer → CC synthesizes → Consolidated answer
 ```
 
 **Key Principles:**
@@ -98,13 +95,12 @@ CC does work → User: /codex-review → External CLI reviews → CC synthesizes
 
 ## MCP Tools
 
-The plugin exposes three MCP tools:
+The plugin exposes two MCP tools:
 
 | Tool | Description |
 |------|-------------|
-| `codex_review` | Get Codex review (correctness, edge cases, performance) |
-| `gemini_review` | Get Gemini review (design patterns, scalability, tech debt) |
-| `multi_review` | Parallel review from both models |
+| `multi_review` | Parallel standard + adversarial review from all available CLIs (Codex, Gemini, Claude). Requires `ccOutput`. |
+| `multi_consult` | Ask all available CLIs the same question and receive a 5-section structured response per model. For consultation/Q&A. |
 
 ## Output Format
 

package/commands/multi-consult.md

@@ -0,0 +1,109 @@
+# Multi Consult
+
+Ask Codex, Gemini, and Claude (Opus, fresh context) the same question in parallel and synthesize their answers. Use this for **consultation** — finding the best approach, weighing alternatives, getting a panel's take. NOT for reviewing work CC has already done (use `/multi-review` for that).
+
+## Arguments
+- `$ARGUMENTS` — the question itself, optional steering, or both
+
+## When to Use
+
+Use `/multi-consult` when you have a question or problem and want a synthesized panel opinion. The panel responds in a fixed 5-section structure (Recommendation / Reasoning / Tradeoffs / Risks / Open questions). CC reads all three responses and presents one consolidated answer with a "Models said:" provenance footer.
+
+## Examples
+
+```
+/multi-consult Should we use Postgres or DynamoDB for a write-heavy timeseries workload?
+/multi-consult How should I refactor the auth middleware? Focus on rollback safety.
+/multi-consult What's the cleanest way to memoize this expensive selector? [flex]
+```
+
+## Before Calling - PREPARE THE HANDOFF
+
+### 1. Pre-compose the question
+
+**`$ARGUMENTS` parsing rule (pinned):**
+
+- **If conversation context already contains the question CC has been working on:** compose `question` from that context. `$ARGUMENTS` is treated as pure steering — extract reserved tokens (see below) into schema fields; remainder goes into `customPrompt`.
+- **Otherwise — `$ARGUMENTS` IS the literal question.** Set `customPrompt` to empty. Reserved tokens are extracted *only* when they appear at the *end* of `$ARGUMENTS` inside brackets or parens — e.g., `... [flex]`, `... (high reasoning)`. A bare occurrence of `flex` / `cheap` / `default tier` inside the prose is treated as part of the question, NOT a flag, to avoid corrupting questions like *"Should we offer a flex tier or default tier for customers?"*.
+
+### 2. Triage code-grounded questions
+
+If the question references the codebase, populate `relevantFiles` with the minimal subset (3-10 files typically) the panel needs. For purely general questions ("Postgres vs Mongo for X workload?"), omit `relevantFiles` — the panel will answer from expertise without trawling the filesystem.
+
+### 3. Refuse sensitive working directories
+
+If the current working directory is `/etc`, `~`, `~/.ssh`, or any other clearly sensitive system path, **refuse**. Tell the user: "Please invoke `/multi-consult` from a project root — `<cwd>` looks sensitive." Do not call the tool.
+
+### 4. Extract criteria; clarify load-bearing assumptions BEFORE calling
+
+Pin what the question is being judged against. Once criteria are explicit, the panel's recommendation is anchored to them instead of floating — this is the fix for "ask twice, get a different answer." Stochastic re-runs converge much better against fixed criteria than against an under-specified question.
+
+**4a. Append a CRITERIA block to the end of `question`**, priority-ordered, each tagged `[stated]` or `[assumed]`:
+
+```
+CRITERIA (priority order):
+1. [stated] cost-per-request under $X / 1M ops
+2. [stated] team writes Go; minimize ops complexity
+3. [assumed] sustained ~10k QPS write rate
+4. [assumed] eventual consistency acceptable for analytics
+```
+
+- `[stated]` = explicit in the user's message or earlier conversation.
+- `[assumed]` = you needed to fix it to recommend; the user did NOT say.
+- Cap `[assumed]` at 3. If the top 3 don't fit, the question is too vague — bounce back to the user before calling.
+
+**4b. Pre-call clarification gate.** Scan your `[assumed]` criteria. If any is **load-bearing** (the recommendation would flip if the assumption is wrong), STOP and ask the user before invoking the tool:
+
+> "Before I consult the panel, I need to confirm: <restate assumption>. Is that right, or should I adjust to <plausible alternative>?"
+
+A burned panel call on a wrong assumed criterion costs more than the round-trip.
+
+**Skip the gate when:**
+- `[stated]` criteria fully pin the answer space (no assumptions needed).
+- The user told you to proceed without clarification.
+- Remaining assumptions are clearly incidental (would not flip the rec).
+
+## Tool Invocation
+
+Call `multi_consult` with:
+
+```json
+{
+  "workingDir": "<current directory>",
+  "question": "<CC-composed question OR literal $ARGUMENTS minus end-bracket reserved tokens>",
+  "relevantFiles": ["<file1>", "<file2>"],
+  "customPrompt": "<steering text or empty>"
+}
+```
+
+### Reserved-token mappings (only when bracketed at end of $ARGUMENTS)
+
+- `[flex]` / `[cheap]` / `[budget]` → `serviceTier: "flex"`
+- `[default tier]` / `[standard tier]` → `serviceTier: "default"`
+- `[high reasoning]` → `reasoningEffort: "high"` (overrides default `xhigh`)
+
+If the user types one of these mid-question (not in brackets), leave it in the question.
+
+## After Receiving the Panel
+
+You will receive each model's structured 5-section response. Some may carry a `⚠️ Format drift: missing sections [...]` marker — degrade synthesis confidence accordingly for that model.
+
+### Synthesize
+
+1. **Cross-compare Recommendations.** Agreement across all three → high confidence. 2-vs-1 split → take a side and *surface the dissent explicitly* in your answer (don't flatten it). All three disagree → present the tradeoff space honestly and pick.
+2. **Mine Tradeoffs and Risks.** Even when models agree on the recommendation, the *reasons* and *risks* often diverge — surface the union, not just the intersection. If a single model raised a Risk the others missed, surface it as "1 model raised: …" — *do not silently drop it.*
+3. **Forward Open questions** to the user only if material — do not dump every "what's your scale?" clarifier.
+4. **Apply your own judgment.** You have full conversation context the panel does not; you may dismiss panel suggestions that miss the user's actual constraint, but say so explicitly when overriding.
+5. **Respond with one consolidated answer**, structured as: **Recommendation** (what to do) → **Why** (synthesis of reasoning) → **Watch out for** (consolidated risks, including any single-model-only risks) → optional **Open question for you** if a real ambiguity blocks the answer.
+6. **Append a "Models said:" provenance footer** — a single line per model with the recommendation in <80 chars. Example:
+
+   ```
+   ---
+   **Models said:**  Codex → Postgres + read replicas.  Gemini → Postgres + Citus.  Claude → DynamoDB w/ caveat on cost at scale.
+   ```
+
+   This is **non-negotiable**. The footer is the audit trail; without it, synthesis-only is opaque.
+7. **Do NOT paste full raw model outputs to the user** unless they explicitly ask ("show me what each model said", "raw").
+8. **All-failed special case:** if the header is `❌ All Failed`, surface the failure types and **ASK** the user *"Panel unavailable — want my solo answer instead?"*. **Do NOT silently substitute** your own answer for the panel's.
+
+$ARGUMENTS

package/commands/multi-review.md

@@ -23,17 +23,27 @@ Use `/multi-review` when you want thorough parallel reviews from all available m
 
 ## Before Calling - PREPARE THE HANDOFF
 
-### 1. Summarize What You Did (Brief!)
+### 1. Summarize What You Did + State the Acceptance Bar
+
+Don't just say what you did — also state the bar the work needs to clear. The bar is what lets reviewers calibrate "material" vs "nice to have." Without it, reviewers default to general code-quality vibes, which produces drift across runs.
+
 ```
-"Implemented caching layer for the product catalog API using Redis.
-Added cache invalidation on product updates."
+"Implemented caching layer for the product catalog API using Redis with cache invalidation on product updates.
+Bar: safe under concurrent updates (no stale reads on the next request) AND p95 read latency under 50ms."
 ```
 
-### 2. List Your Uncertainties
+### 2. List Your Uncertainties — Tag Load-Bearing vs Incidental
+
+Tag each uncertainty:
+- `[load-bearing]` = if your assumption here is wrong, the work is NOT shipping-ready
+- `[incidental]` = nice to verify but won't block ship
+
+Reviewers prioritize accordingly, and your synthesis can elevate `[load-bearing]` items above stylistic findings.
+
 ```
 UNCERTAINTIES:
-- "Is the cache TTL appropriate for this data?"
-- "Does the invalidation handle all update scenarios?"
+- [load-bearing] "Is the cache invalidation race-free under concurrent updates?"
+- [incidental] "Is the TTL value optimal — could it be 60s instead of 30s?"
 ```
 
 ### 3. Ask Specific Questions
@@ -43,6 +53,16 @@ QUESTIONS:
 - "Is there a race condition in the invalidation logic?"
 ```
 
+### 4. Identify Decisions You Made
+
+If you chose between alternatives — caching strategy, retry policy, error-handling shape, schema design, etc. — list them with rationale. The handoff schema's `decisions[]` field gives the adversarial reviewer a concrete hook to attack the design choice rather than just hunt for bugs. Skip if the change is a straightforward bug fix with no design choice involved.
+
+```
+DECISIONS:
+1. Chose write-through cache over write-behind. Rationale: stronger read-after-write consistency at the cost of slightly slower writes; we prioritize correctness for catalog data.
+2. Chose 30s TTL with explicit invalidation on update. Rationale: TTL bounds staleness if invalidation misses; explicit invalidation catches the common path immediately.
+```
+
 ## Tool Invocation
 
 Call `multi_review` with:
@@ -67,14 +87,19 @@ Call `multi_review` with:
 ```
 SUMMARY:
 <what you did, 1-3 sentences>
+Bar: <what counts as shipping-ready — concrete acceptance criteria>
 
 UNCERTAINTIES (verify these):
-1. <uncertainty>
-2. <uncertainty>
+1. [load-bearing|incidental] <uncertainty>
+2. [load-bearing|incidental] <uncertainty>
 
 QUESTIONS:
 1. <question>
 
+DECISIONS:
+1. <choice>. Rationale: <why this over alternatives>
+2. <choice>. Rationale: <why this over alternatives>
+
 PRIORITY FILES:
 - <file>
 ```

package/dist/adapters/base.d.ts

@@ -44,6 +44,21 @@ export interface ReviewRequest {
     /** Review mode: standard finds bugs, adversarial challenges assumptions */
     reviewMode?: 'standard' | 'adversarial';
 }
+export interface ConsultRequest {
+    /** Working directory containing the code (always passed) */
+    workingDir: string;
+    /** CC-composed, self-contained question for the panel */
+    question: string;
+    /** CC-triaged file subset for code-grounded questions; omitted on general questions */
+    relevantFiles?: string[];
+    /** Free-form steering from $ARGUMENTS */
+    customPrompt?: string;
+    /** Reasoning effort (Codex). Default 'xhigh' for consult (deeper questions). */
+    reasoningEffort?: ReasoningEffort;
+    /** Service tier (Codex). Same defaulting rules as ReviewRequest. */
+    serviceTier?: ServiceTier;
+}
+export type ConsultResult = ReviewResult;
 /** @deprecated Use handoff.ts roles instead */
 export interface ExpertRole {
     name: string;
@@ -87,6 +102,8 @@ export interface ReviewerAdapter {
     isAvailable(): Promise<boolean>;
     /** Run a review and return structured output */
     runReview(request: ReviewRequest): Promise<ReviewResult>;
+    /** Run a consultation (Q&A) — required on every adapter. */
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
     /**
      * Optional: Run peer review of another model's output
      * Future capability - not currently implemented by any adapter

package/dist/adapters/claude.d.ts

@@ -10,7 +10,7 @@
  *   2. --disallowed-tools         (write tools explicitly blocked)
  *   3. Handoff prompt             (explicit READ-ONLY instruction)
  */
-import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult } from './base.js';
+import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult, ConsultRequest, ConsultResult } from './base.js';
 export declare class ClaudeAdapter implements ReviewerAdapter {
     readonly id = "claude";
     getCapabilities(): ReviewerCapabilities;
@@ -20,5 +20,6 @@ export declare class ClaudeAdapter implements ReviewerAdapter {
     private handleException;
     private categorizeError;
     private getSuggestion;
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
 }
 export declare const claudeAdapter: ClaudeAdapter;

package/dist/adapters/claude.js

@@ -16,6 +16,7 @@ import { registerAdapter, } from './base.js';
 import { CliExecutor } from '../executor.js';
 import { ClaudeEventDecoder } from '../decoders/index.js';
 import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
 import { getConfig } from '../config.js';
 // Write tools explicitly blocked as defense-in-depth
 const DISALLOWED_TOOLS = 'Edit Write NotebookEdit';
@@ -76,7 +77,7 @@ export class ClaudeAdapter {
                 return {
                     success: false,
                     error: { type: 'cli_error', message: 'Claude returned empty response' },
-                    suggestion: 'Try again or use /codex-review instead',
+                    suggestion: 'Try again or use /multi-review instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
@@ -153,7 +154,7 @@ export class ClaudeAdapter {
         }
         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 };
+                suggestion: 'Try a smaller scope or use /multi-review', executionTimeMs: Date.now() - startTime };
         }
         if (err.message === 'MAX_TIMEOUT') {
             return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
@@ -173,12 +174,43 @@ export class ClaudeAdapter {
     }
     getSuggestion(error) {
         switch (error.type) {
-            case 'rate_limit': return 'Wait and retry, or use /codex-review or /gemini-review instead';
+            case 'rate_limit': return 'Wait and retry, or use /multi-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';
         }
     }
+    async runConsult(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 prompt = buildConsultPrompt(request);
+            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 /multi-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
 }
 // Register the adapter
 registerAdapter(new ClaudeAdapter());

package/dist/adapters/codex.d.ts

@@ -5,7 +5,7 @@
  * Returns raw text — no JSON parsing or schema enforcement.
  * CC handles interpretation of the reviewer's response.
  */
-import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult } from './base.js';
+import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult, ConsultRequest, ConsultResult } from './base.js';
 export declare class CodexAdapter implements ReviewerAdapter {
     readonly id = "codex";
     getCapabilities(): ReviewerCapabilities;
@@ -15,5 +15,6 @@ export declare class CodexAdapter implements ReviewerAdapter {
     private handleException;
     private categorizeError;
     private getSuggestion;
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
 }
 export declare const codexAdapter: CodexAdapter;

package/dist/adapters/codex.js

@@ -11,6 +11,7 @@ import { registerAdapter, } from './base.js';
 import { CliExecutor } from '../executor.js';
 import { CodexEventDecoder } from '../decoders/index.js';
 import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
 import { getConfig } from '../config.js';
 // =============================================================================
 // CODEX ADAPTER
@@ -70,7 +71,7 @@ export class CodexAdapter {
                 return {
                     success: false,
                     error: { type: 'cli_error', message: 'Codex returned empty response' },
-                    suggestion: 'Try again or use /gemini-review instead',
+                    suggestion: 'Try again or use /multi-review instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
@@ -154,7 +155,7 @@ export class CodexAdapter {
         }
         if (err.message === 'TIMEOUT') {
             return { success: false, error: { type: 'timeout', message: 'Codex timed out — no events received' },
-                suggestion: 'Try a smaller scope or use /gemini-review', executionTimeMs: Date.now() - startTime };
+                suggestion: 'Try a smaller scope or use /multi-review', executionTimeMs: Date.now() - startTime };
         }
         if (err.message === 'MAX_TIMEOUT') {
             return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
@@ -177,12 +178,49 @@ export class CodexAdapter {
     }
     getSuggestion(error) {
         switch (error.type) {
-            case 'rate_limit': return 'Wait and retry, or use /gemini-review instead';
+            case 'rate_limit': return 'Wait and retry, or use /multi-review instead';
             case 'auth_error': return 'Run `codex login` to authenticate';
             case 'cli_not_found': return 'Install with: npm install -g @openai/codex-cli';
             default: return 'Check the error message and try again';
         }
     }
+    async runConsult(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 prompt = buildConsultPrompt(request);
+            // Consult-specific defaults live in config (Zod defaults to xhigh + fast).
+            // Request value > config value > Zod default. Users who want to cap cost
+            // can set codex.consultServiceTier: "flex" without touching review.
+            const cfg = getConfig().codex;
+            const reasoningEffort = request.reasoningEffort ?? cfg.consultReasoningEffort;
+            const serviceTier = request.serviceTier ?? cfg.consultServiceTier;
+            const result = await this.runCli(prompt, request.workingDir, reasoningEffort, serviceTier);
+            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: 'Codex returned empty response' },
+                    suggestion: 'Try again or use /multi-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
 }
 // Register the adapter
 registerAdapter(new CodexAdapter());

package/dist/adapters/gemini.d.ts

@@ -5,7 +5,7 @@
  * Returns raw text — no JSON parsing or schema enforcement.
  * CC handles interpretation of the reviewer's response.
  */
-import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult } from './base.js';
+import { ReviewerAdapter, ReviewerCapabilities, ReviewRequest, ReviewResult, ConsultRequest, ConsultResult } from './base.js';
 export declare class GeminiAdapter implements ReviewerAdapter {
     readonly id = "gemini";
     getCapabilities(): ReviewerCapabilities;
@@ -15,5 +15,6 @@ export declare class GeminiAdapter implements ReviewerAdapter {
     private handleException;
     private categorizeError;
     private getSuggestion;
+    runConsult(request: ConsultRequest): Promise<ConsultResult>;
 }
 export declare const geminiAdapter: GeminiAdapter;

package/dist/adapters/gemini.js

@@ -11,6 +11,7 @@ import { registerAdapter, } from './base.js';
 import { CliExecutor } from '../executor.js';
 import { GeminiEventDecoder } from '../decoders/index.js';
 import { buildSimpleHandoff, buildHandoffPrompt, buildAdversarialHandoffPrompt, selectRole, } from '../handoff.js';
+import { buildConsultPrompt } from '../consult-prompt.js';
 import { getConfig } from '../config.js';
 // =============================================================================
 // GEMINI ADAPTER
@@ -69,7 +70,7 @@ export class GeminiAdapter {
                 return {
                     success: false,
                     error: { type: 'cli_error', message: 'Gemini returned empty response' },
-                    suggestion: 'Try again or use /codex-review instead',
+                    suggestion: 'Try again or use /multi-review instead',
                     executionTimeMs: Date.now() - startTime,
                 };
             }
@@ -133,7 +134,7 @@ export class GeminiAdapter {
         }
         if (err.message === 'TIMEOUT') {
             return { success: false, error: { type: 'timeout', message: 'Gemini timed out — no events received' },
-                suggestion: 'Try a smaller scope or use /codex-review', executionTimeMs: Date.now() - startTime };
+                suggestion: 'Try a smaller scope or use /multi-review', executionTimeMs: Date.now() - startTime };
         }
         if (err.message === 'MAX_TIMEOUT') {
             return { success: false, error: { type: 'timeout', message: 'Task exceeded 60 minute maximum' },
@@ -153,12 +154,43 @@ export class GeminiAdapter {
     }
     getSuggestion(error) {
         switch (error.type) {
-            case 'rate_limit': return 'Wait and retry, or use /codex-review instead';
+            case 'rate_limit': return 'Wait and retry, or use /multi-review instead';
             case 'auth_error': return 'Run `gemini` and follow auth prompts, or set GEMINI_API_KEY';
             case 'cli_not_found': return 'Install with: npm install -g @google/gemini-cli';
             default: return 'Check the error message and try again';
         }
     }
+    async runConsult(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 prompt = buildConsultPrompt(request);
+            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: 'Gemini returned empty response' },
+                    suggestion: 'Try again or use /multi-review instead',
+                    executionTimeMs: Date.now() - startTime,
+                };
+            }
+            return { success: true, output: result.stdout, executionTimeMs: Date.now() - startTime };
+        }
+        catch (error) {
+            return this.handleException(error, startTime);
+        }
+    }
 }
 // Register the adapter
 registerAdapter(new GeminiAdapter());

package/dist/commands.d.ts

@@ -19,6 +19,10 @@ export declare function getCommandPaths(): {
 /**
  * Install slash commands to ~/.claude/commands/
  *
+ * @param overrides Test-only path overrides; production callers pass nothing.
  * @returns Result object with success status and installed commands
  */
-export declare function installCommands(): InstallResult;
+export declare function installCommands(overrides?: Partial<{
+    source: string;
+    target: string;
+}>): InstallResult;

package/dist/commands.js

@@ -3,7 +3,7 @@
  *
  * Used by index.ts (auto-install on MCP server startup and `update` subcommand)
  */
-import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { existsSync, mkdirSync, copyFileSync, readdirSync, renameSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { homedir } from 'os';
 import { fileURLToPath } from 'url';
@@ -19,6 +19,11 @@ const DEPRECATED_COMMANDS = [
     'ask-gemini.md',
     'ask-multi.md',
     'multi-review-adv.md',
+    // Removed in favor of /multi-review and /multi-consult only:
+    'codex-review.md',
+    'codex-xhigh-review.md',
+    'gemini-review.md',
+    'claude-review.md',
 ];
 /**
  * Get source and target paths for command files
@@ -32,10 +37,13 @@ export function getCommandPaths() {
 /**
  * Install slash commands to ~/.claude/commands/
  *
+ * @param overrides Test-only path overrides; production callers pass nothing.
  * @returns Result object with success status and installed commands
  */
-export function installCommands() {
-    const { source, target } = getCommandPaths();
+export function installCommands(overrides) {
+    const defaults = getCommandPaths();
+    const source = overrides?.source ?? defaults.source;
+    const target = overrides?.target ?? defaults.target;
     // Check source exists
     if (!existsSync(source)) {
         return { success: false, installed: [], removed: [], error: 'Commands directory not found' };
@@ -59,13 +67,21 @@ export function installCommands() {
     if (files.length === 0) {
         return { success: false, installed: [], removed: [], error: 'No command files found' };
     }
-    // Prune deprecated commands from target
+    // Prune deprecated commands from target by renaming to .deprecated.bak
+    // (lossless — preserves any user edits the operator may have made). If the
+    // backup already exists from a previous upgrade, leave it alone.
     const removed = [];
     for (const oldFile of DEPRECATED_COMMANDS) {
         const oldPath = join(target, oldFile);
         if (existsSync(oldPath)) {
+            const backupPath = `${oldPath}.deprecated.bak`;
             try {
-                unlinkSync(oldPath);
+                if (!existsSync(backupPath)) {
+                    renameSync(oldPath, backupPath);
+                }
+                // If the backup already exists, the original was already moved on a
+                // prior install. The file we see now must be a recreation; leave it
+                // alone — the user clearly wants it.
                 removed.push(oldFile.replace('.md', ''));
             }
             catch {