--- name: superreview description: "Review a scoped diff through three independent static lanes, deduplicate findings and apply the existing remediation policy. Use when Superreview is explicitly requested." --- # Superreview Primero lee [compatibilidad y alcance](references/package-runtime.md) y [formato de salida](references/output-contract.md). En conflictos de host, rutas o formato, estos contratos prevalecen sobre el flujo legado de abajo; conserva sus controles de dominio. Consulta [el catálogo](references/skill-routing.md) para proponer otro especialista sólo si encaja. ## Superreview A merged, maximum-rigor review set: thermos-style parallel fan-out + synthesis, fused with the stack-aware `code-review` agent. You (the parent) gather the diff **once**, run three reviewers **in parallel** over the exact same context, then synthesize one unified verdict. Nothing slips through, nobody re-runs git three times, and the final output is deduped and honestly calibrated. Before reviewing, read `references/review-policy.md`. It is the canonical source for severities, review criteria, finding fields, verdicts, and verification-request fields. Do not restate or fork that policy in lane prompts. ### Phase 0 — Establish a trustworthy base (non-negotiable) Before diffing, resolve and **fetch** the base branch — never reason off a stale local ref: 1. Resolve the base per repo (`develop` → `main` → `master`; honor CLAUDE.md if it names one). 2. `git fetch origin ` and diff against `origin/` (not the local branch) unless you've confirmed local == remote. Prefer `git -C ` over `cd` so a failed `cd` can't silently skip the fetch. 3. **Bare + worktree layouts** (`/.bare` + `//`): the local `main`/`develop` worktree is routinely BEHIND `origin`. Resolve the diff with `git --git-dir=/.bare fetch origin ` then diff `origin/...HEAD`. A file survey of a worktree is NOT proof of what's on `origin/`. ### Phase 1 — Gather scope ONCE Determine review scope from the user request, PR, current branch, or changed files. Then, in a **single message**, collect the context in parallel with two `Task` calls: - `subagent_type: "Explore"` (or `shell`) → run `git diff origin/...HEAD` (plus `git diff` / `git diff --cached` for uncommitted work) and capture the full unified diff. - `subagent_type: "Explore"` → read the **full contents** of every changed file (not just diff hunks — reviewers must evaluate cross-file side effects without guessing). Assemble two labeled sections you will pass verbatim to each reviewer: `### Git / diff output` and `### Changed file contents`. ### Phase 2 — Fan out three reviewers IN PARALLEL In **one message**, launch all three with `run_in_background: true`, passing each the **same** scoped context (the two labeled sections) plus the resolved base and PR URL if any: 1. `subagent_type: "superreview-correctness-security-subagent"` — bugs, breaking changes, security, devex regressions, feature-flag/gate leaks, UI-reachability. 2. `subagent_type: "superreview-code-quality-subagent"` — maintainability, code-judo restructurings, >1k-line rule, spaghetti, boundaries, design-fidelity. 3. `subagent_type: "superreview-stack-data-subagent"` — stack/framework/ORM/UI detection, CLAUDE.md-as-law, data integrity (N+1, cascades, indexes, transactions), frontend state/cache, and the `anti-slop` dimension. Instruct each reviewer to complete its **independent** audit first (fresh eyes), report only issues in **ADDED/MODIFIED** code, trace cross-file impact, and return prioritized findings with `file:line` evidence. No nested subagents unless explicitly asked. #### Static-only boundary for every lane The parallel lanes are reviewers, never verification runners. Their prompts must explicitly say: - Do not run tests, lint, typecheck, builds, package installation, migrations, generators, dev servers, benchmarks, or any other CPU/RAM-intensive or code-executing command. - Do not start background processes or services. - Use only read-only inspection. If dynamic evidence would materially change a finding, emit a verification request using the canonical fields in `references/review-policy.md`; do not execute it. This boundary applies even when repository instructions normally require running quality gates. The parent must preserve which lane requested each verification. ### Phase 3 — Synthesize After all three finish: - Merge findings, **deduplicated** across reviewers. Weight findings that **two or more** lanes independently raised more heavily — those are your highest-signal blockers. - Resolve disagreements with your own judgment and in-repo verification. Never present a finding with unfinished research when you can check it yourself in the repo. - Calibrate severity honestly (CRITICAL / MAJOR / MINOR). Do NOT inflate priority — over-reporting erodes trust. Respect **intended breakage**: if the branch's clear purpose is to remove/break something and the scope is well-constrained, don't flag it as a bug (unless it looks unintended, under-weighted, or malicious). - If background summaries are already visible to the user, don't restate them wholesale — surface the **unified verdict**, the highest-signal findings, and any remaining uncertainty. - Merge equivalent verification requests into one plan entry. Preserve all requesting lanes and choose the narrowest command/scope that answers the shared question. Order the plan serially; never imply that requests should run in parallel. Write all review feedback in the **project's primary language** (detect from UI strings, comments, CLAUDE.md, README). ### Final verdict ``` ### Superreview — Summary - Critical: [n] Major: [n] Minor: [n] - Cross-lane (raised by ≥2 reviewers): [n] - Result: [BLOCKED | REQUIRES CHANGES | APPROVED] ``` Decision: any CRITICAL → **BLOCKED**; any MAJOR (no CRITICAL) → **REQUIRES CHANGES**; only MINOR or none → **APPROVED**. ### Phase 4 — Fix immediately when BLOCKED or REQUIRES CHANGES (non-negotiable) When the verdict is **BLOCKED** or **REQUIRES CHANGES**, do **not** stop to ask "¿aplico los fixes?". Apply the fixes right away in the same turn: 1. **Scope:** fix every CRITICAL and MAJOR finding. Also fix MINOR findings that were raised by ≥2 lanes when the fix is local and mechanical. List the other MINORs as follow-ups, but do not apply them. 2. **Excluded from auto-fix** (surface them in the report, never guess): - Findings that need a product/design decision: the spec and the design disagree, or a requirement is ambiguous. Ask one precise question and fix everything else meanwhile. - Work items not owned by the logged-in user (ownership guardrail), or files another session is editing concurrently. If the working tree changes under you during the review, stop and confirm who owns those edits before writing. 3. **Fix discipline:** - Respect the repo conventions and CLAUDE.md. - Add a regression test for each CRITICAL/MAJOR fix when the stack has tests. - Never widen scope beyond the finding. 4. **Verify:** - Re-check each fixed finding statically against its original failure scenario. - Produce a deduplicated, serial **verification plan** for CI or a future isolated `review-verifier`; do not execute it in Superreview. - Request only the narrowest necessary checks. A lane may suggest a command, but only the parent may include it in the plan. Full suites and e2e are never automatic. - Never run tests, lint, typecheck, builds, installs, migrations, generators, or services from this skill or any lane. Report dynamic verification as `not run (delegated)`. 5. **Re-issue the verdict:** print the Final verdict block again for the post-fix state, with each finding marked fixed / pending decision / follow-up. 6. **Git:** do not commit or push unless the user asked. Leave the working tree for review. ### Verification plan output When any lane or fixed finding needs dynamic verification, end with one deduplicated table using the fields defined in `references/review-policy.md`: `key`, `requested_by`, `kind`, `scope`, `command`, and `reason`. Commands are recommendations for CI/a future isolated verifier, not shell instructions for the current session. If no dynamic evidence is needed, write `Dynamic verification: not requested`. The plan is executed by **one** verifier, serially, never by several agents at once. When the repo defines a sanctioned serialised entry point for heavy gates (a wrapper script, a `verify` script, a documented lock), every `command` in the table must use it rather than invoking `jest`, `vitest`, `turbo` or a package script directly — those default to one worker per CPU and several agents running them concurrently can exhaust the host's RAM.