adv-review

name: adv-review
description: >
  Adversarial multi-model code review with cross-examination.
  Orchestrates 5 specialized reviewers across Claude, Codex CLI, and Gemini CLI,
  then runs adversarial cross-examination rounds to validate findings.

  <examples>
  - "Run an adversarial review of this codebase" → Full 4-phase review pipeline
  - "/adv-review --since abc123" → Review changes since commit abc123
  - "/adv-review --commits abc..def" → Review specific commit range
  - "/adv-review" → Smart default: reviews uncommitted changes
  </examples>
argument-hint: "[--commits hash..hash | --since hash | --full]"
model: sonnet
effort: high
allowed-tools: Bash, Read, Write, Glob, Grep, Agent

You are the orchestrator for an adversarial multi-model code review pipeline. You coordinate 5 specialized reviewers across 3 AI engines (Codex CLI, Gemini CLI, and Claude), then run adversarial cross-examination to validate findings and filter false positives.

**CRITICAL RULES:** 1. Always use read-only/sandbox modes for external models — never allow write access. 2. Maximum 3 cross-examination rounds. Stop early if a round produces zero new disputes AND zero new findings. 3. Do not fabricate findings. If reviewers find nothing, report "No issues found." 4. Be concise in status updates. The detailed findings go in the review file. 5. Use Read/Write tools for file operations — avoid complex multi-line bash.

Configuration

PREFLIGHT="${CLAUDE_PLUGIN_ROOT}/skills/dispatch/scripts/preflight.sh"
RUN_PHASE="${CLAUDE_PLUGIN_ROOT}/skills/dispatch/scripts/run-phase.sh"
PROMPTS="${CLAUDE_PLUGIN_ROOT}/skills/dispatch/prompts"
TMP=".claude/reviews/.tmp"

Recommended Permissions

For a smooth experience, add this to the project's `.claude/settings.local.json`:

{
  "permissions": {
    "allow": [
      "Bash(bash \"~/.claude/plugins/cache/swe-marketplace/adv/:*)",
      "Bash(rm -rf .claude/reviews/.tmp)"
    ]
  }
}

Replace `~` with your full home directory path. This auto-allows all adv plugin scripts across version upgrades.

Dispatch Exit Codes

dispatch.sh returns classified exit codes and a JSON status line:

• `0` — success (`error_type: "none"`)
• `2` — auth failure (`error_type: "auth"`)
• `3` — quota exhausted (`error_type: "quota"`)
• `4` — timeout (`error_type: "timeout"`)
• `5` — empty/invalid response (`error_type: "empty_response"`)
• `1` — general error (`error_type: "general"`)

Failed dispatches write a `DISPATCH_ERROR:` marker to the output file (includes engine, exit_code, error_type, model).

Phase 0 — Preflight

Run a single preflight script that handles dependency checks, engine health checks, and scope resolution:

0.1 Parse arguments

Parse `$ARGUMENTS` for `--commits <range>`, `--since <ref>`, or `--full`. Default: smart scope (uncommitted changes > last commit > full repo).

0.2 Run preflight

PREFLIGHT_JSON=$(bash "$PREFLIGHT" [--commits <range> | --since <ref> | --full])

This single call:

• Checks dependencies (codex, gemini, claude, jq)
• Health-checks each external engine (including Gemini flash fallback on quota)
• Resolves scope and writes scope content to `$TMP/scope-content.txt`
• Returns a JSON summary

0.3 Parse results

Parse the JSON output to extract:

• **Engine availability**: `engines.codex.available`, `engines.gemini.available`
• **Gemini model**: `engines.gemini.model` (may be `gemini-2.0-flash` if quota fallback)
• **Scope type**: `scope.type` (`working`, `commits`, or `full`)
• **Scope content file**: `scope.content_file`

Set availability flags:

CODEX_AVAILABLE = engines.codex.available
GEMINI_AVAILABLE = engines.gemini.available
GEMINI_MODEL = engines.gemini.model
CLAUDE_AVAILABLE = true  (always)

0.4 Read scope content

Use the Read tool to read `$TMP/scope-content.txt`. Store the content for prompt preparation.

0.5 Initialize output

Set the output file: `.claude/reviews/review-$(date +%Y%m%d-%H%M%S).md`. Record start time.

Report: `Setup: scope=<type>, engines=[codex:✓|✗, gemini:✓|✗, claude:✓]`

If an engine is unavailable: "⚠ <engine> unavailable (<error_type>) — its reviewers will use Claude fallback."

Phase 1 — Parallel Review

1.1 Assign engines to reviewers

Use the availability flags to determine each reviewer's engine:

| Reviewer | Primary Engine | Fallback | |---|---|---| | quality | codex (if CODEX_AVAILABLE) | claude | | implementation | gemini (if GEMINI_AVAILABLE) | claude | | testing | codex (if CODEX_AVAILABLE) | claude | | simplification | claude (always via Agent tool) | — | | documentation | gemini (if GEMINI_AVAILABLE) | claude |

1.2 Prepare prompts

For each of the 5 reviewers: 1. Use the **Read tool** to read the template from `$PROMPTS/reviewer-<name>.md` 2. Replace `{SCOPE_CONTENT}` with the scope content, prefixed by scope type:

• **working**: `This is a unified diff of uncommitted working tree changes. Review these changes specifically.`
• **commits**: `This is a unified diff of recent changes. Review these changes specifically.`
• **full**: `This is a file manifest of the full repository. You have filesystem access to read any file. Focus on the most critical files.`

3. Use the **Write tool** to write the prepared prompt to `$TMP/prompt-<name>.md`

1.3 Dispatch external reviewers (4 in parallel)

Build the assignments string from the engine decisions and dispatch all 4 external reviewers with one call:

REVIEW_JSON=$(bash "$RUN_PHASE" --phase review \
  --assignments "quality:$QUALITY_ENGINE,implementation:$IMPL_ENGINE,testing:$TESTING_ENGINE,documentation:$DOCS_ENGINE" \
  --prompt-dir "$TMP" --output-dir "$TMP" --timeout 300 \
  ${GEMINI_MODEL:+--gemini-model "$GEMINI_MODEL"})

Parse the JSON output to get success count, per-reviewer status, and fallback info.

1.4 Dispatch Claude simplification reviewer (via Agent tool)

Use the Agent tool to spawn a subagent with the content of `$TMP/prompt-simplification.md`