auto-review

name	auto-review
description	Structured code review closeout. Codex review is the default when no engine is set and is the recommended reviewer. Use this for auto-review, autoreview, second-model review, CodeRabbit, Greptile, Cursor, Codex review, Claude review, PR review, and final quality/security review requests.

Code Review

Run the bundled structured review helper as a closeout check. This is code review, not Guardian auto_review approval routing.

Codex review is the default when no engine is set. It usually delivers the best review results and should remain the normal final closeout engine.

Use when:

• user asks for auto-review / autoreview / Codex review / Claude review / Cursor review / CodeRabbit review / Greptile review / second-model review
• after non-trivial code edits, before final/commit/ship
• reviewing a local branch or PR branch after fixes

Contract

• Treat review output as advisory. Never blindly apply it.
• Verify every finding by reading the real code path and adjacent files.
• Read dependency docs/source/types when the finding depends on external behavior.
• Reject unrealistic edge cases, speculative risks, broad rewrites, and fixes that over-complicate the codebase.
• Prefer small fixes at the right ownership boundary; no refactor unless it clearly improves the bug class.
• Keep going until structured review returns no accepted/actionable findings.
• If a review-triggered fix changes code, rerun focused tests and rerun the structured review helper.
• For security-audit suppression changes, verify accepted findings remain auditable: suppressed findings stay in structured output, active output keeps an unsuppressible suppression notice, and aggregate findings cannot hide unrelated active risk.
• Never switch or override the requested review engine/model. If the review hits model capacity, retry the same command a few times with the same engine/model.
• Be patient with large bundles. Structured review can take up to 30 minutes while the model call is active, especially with Codex tools or web search.
• Treat heartbeat lines like review still running: ... elapsed=... pid=... as healthy progress, not a hang. Let the helper continue while heartbeats are advancing. Pass --stream-engine-output when live engine text is useful; Codex and Claude filter tool/file chatter, other engines pass raw output through.
• Do not kill a review just because it has been quiet for 2-5 minutes, or because it is still running under the 30-minute window. Inspect the process only after missing multiple expected heartbeats, after 30 minutes, or after an obviously failed subprocess; prefer letting the same helper command finish.
• Tools are useful in review mode. The helper allows read-only inspection tools and web search by default so reviewers can check dependency contracts, upstream docs, and current behavior.
• Security perspective is always included, but it should not cripple legitimate functionality. Report security findings only when the change creates a concrete, actionable risk or removes an important safety check.
• For regression provenance, keep roles separate: blamed code author, blamed PR author, PR merger/committer, current PR author, and PR/date. If no blamed PR is traceable, use the blamed commit as the provenance: commit SHA, date, and author username. Do not guess a merger or frame missing PR metadata as a separate finding.
• Do not invoke built-in codex review, nested reviewers, or reviewer panels from inside the review. The helper builds one bundle, calls one selected engine, validates one structured result, and stops.
• Stop as soon as the helper exits 0 with no accepted/actionable findings. Do not run an extra review just to get a nicer "clean" line, a second opinion, or clearer closeout wording.
• Treat the helper's successful exit plus absence of actionable findings as the clean review result, even if the underlying Codex CLI output is terse.
• Multi-reviewer panels are opt-in only. Use them when explicitly requested or when risk justifies the extra spend; the main agent still verifies every accepted finding before fixing.
• If rejecting a finding as intentional/not worth fixing, add a brief inline code comment only when it explains a real invariant or ownership decision that future reviewers should know.
• Do not push just to review. Push only when the user requested push/ship/PR update.

Pick Target

In examples, <path-to-auto-review-skill> means the absolute path to this skill directory. The bundled helper is:

<path-to-auto-review-skill>/scripts/autoreview

Dirty local work:

<path-to-auto-review-skill>/scripts/autoreview --mode local

Use this only when the patch is actually unstaged/staged/untracked in the current checkout. --mode uncommitted is accepted as an alias for --mode local. For committed, pushed, or PR work, point the helper at the commit or branch diff instead; do not force dirty modes just because the helper docs mention dirty work first. A clean local review only proves there is no local patch.

Branch/PR work:

<path-to-auto-review-skill>/scripts/autoreview --mode branch --base origin/main

Optional review context is first-class:

<path-to-auto-review-skill>/scripts/autoreview --mode branch --base origin/main --prompt-file /tmp/review-notes.md --dataset /tmp/evidence.json

If an open PR exists, use its actual base:

base=$(gh pr view --json baseRefName --jq .baseRefName)
<path-to-auto-review-skill>/scripts/autoreview --mode branch --base "origin/$base"

Committed single change:

<path-to-auto-review-skill>/scripts/autoreview --mode commit --commit HEAD

Use commit review for already-landed or already-pushed work on main. Reviewing clean main against origin/main is usually an empty diff after push. For a small stack, review each commit explicitly or review the branch before merging with --base.

Parallel Closeout

Format first if formatting can change line locations. Then it is OK to run tests and review in parallel:

<path-to-auto-review-skill>/scripts/autoreview --parallel-tests "<focused test command>"

On Windows, the default --parallel-tests shell preserves the platform cmd.exe semantics used by Python shell=True. Use --parallel-tests-shell powershell or --parallel-tests-shell pwsh when the focused test command is PowerShell-specific.

Tradeoff: tests may force code changes that stale the review. If tests or review lead to code edits, rerun the affected tests and rerun review until no accepted/actionable findings remain. Once that rerun exits cleanly, stop; do not spend another long review cycle on redundant confirmation.

Review Panels

Run multiple reviewers against one frozen bundle:

<path-to-auto-review-skill>/scripts/autoreview --reviewers codex,claude

--panel is shorthand for Codex plus Claude unless --engine changes the first reviewer:

<path-to-auto-review-skill>/scripts/autoreview --panel

Set reviewer models and thinking/effort explicitly:

<path-to-auto-review-skill>/scripts/autoreview --reviewers codex,claude --model codex=gpt-5.1 --thinking codex=high --model claude=sonnet --thinking claude=max

Inline syntax is also supported:

<path-to-auto-review-skill>/scripts/autoreview --reviewers codex:gpt-5.1:high,claude:sonnet:max

Codex maps thinking to model_reasoning_effort and accepts low, medium, high, or xhigh. Claude maps thinking to --effort and also accepts max. Engines without a real thinking knob reject --thinking.

Cursor, CodeRabbit, and Greptile can be selected as single reviewers or panel members:

<path-to-auto-review-skill>/scripts/autoreview --engine cursor --mode branch --base origin/main
<path-to-auto-review-skill>/scripts/autoreview --engine coderabbit --mode branch --base origin/main
<path-to-auto-review-skill>/scripts/autoreview --engine greptile --mode branch --base origin/main

Cursor uses cursor-agent --print --mode ask --sandbox enabled and is pinned to composer-2.5. composer-2.5 does not expose a Cursor thinking setting, so --thinking is rejected for Cursor. --model is rejected unless it is the pinned composer-2.5 value. CodeRabbit uses coderabbit review --agent, supports local dirty review, branch review, and --mode commit --commit HEAD. Additional --prompt, --prompt-file, and --dataset content is passed through as a temporary CodeRabbit config file. Greptile uses greptile review --json --no-color and supports branch review only.

Context Efficiency

Run the helper directly so target selection, engine choice, structured validation, and exit status all stay in one path. If output is noisy, summarize the completed helper output after it returns; do not ask another agent or reviewer to rerun the review.

Helper

Resolve <path-to-auto-review-skill> to the directory containing this SKILL.md, then invoke bundled scripts from that directory:

<path-to-auto-review-skill>/scripts/autoreview --help

For this checkout:

/Users/gannonhall/dev/skills/auto-review/scripts/autoreview --help

On native Windows, invoke the extensionless Python helper through Python:

python <path-to-auto-review-skill>\scripts\autoreview --help

The smoke harness has thin shell wrappers over a shared Python implementation:

<path-to-auto-review-skill>/scripts/test-review-harness --fixture benign --engine codex

<path-to-auto-review-skill>\scripts\test-review-harness.ps1 -Fixture benign -Engine codex

The helper:

• chooses dirty local changes first
• accepts --mode uncommitted as an alias for --mode local
• otherwise uses current PR base if gh pr view works
• otherwise uses origin/main for non-main branches
• supports --engine codex, claude, droid, copilot, cursor, coderabbit, and greptile; default is AUTOREVIEW_ENGINE or codex; Codex should remain the default when nothing is set
• resolves bare git, gh, reviewer, and PowerShell shell commands from absolute PATH entries only, never from the reviewed checkout; explicit relative --*-bin paths are resolved from the reviewed repository root
• use --mode commit --commit <ref> for already-committed work, especially clean main after landing
• should be left in --mode auto or forced to --mode branch for PR/branch work; do not force --mode local after committing
• writes only to stdout unless --output, --json-output, or live streamed engine stderr is set
• supports --dry-run, --parallel-tests, --parallel-tests-shell, --prompt, --prompt-file, --dataset, --no-tools, --no-web-search, and commit refs
• supports --stream-engine-output or AUTOREVIEW_STREAM_ENGINE_OUTPUT=1 for live engine text while preserving structured validation; Codex and Claude hide tool/file event details, emit compact activity summaries, and report usage at turn completion
• supports opt-in review panels with --panel / --reviewers, plus per-engine --model and --thinking
• allows read-only tools and web search by default where the selected CLI supports them; forbids nested review in the prompt; Codex is run through codex exec with read-only sandbox and structured output
• prints to stderr at long-running intervals while waiting for the selected review engine, unless streamed output or compact Codex activity has been visible recently

Final Report

Include:

• review command used
• tests/proof run
• findings accepted/rejected, briefly why
• the clean review result from the final helper/review run, or why a remaining finding was consciously rejected

Do not run another review solely to improve the final report wording. If the final helper run exited 0 and produced no accepted/actionable findings, report that exact run as clean.