/unified-review

name: unified-review
description: Orchestrates multi-domain review (code, arch, tests, security) in a single pass. Use when thorough pre-release review is needed.
alwaysApply: false
category: orchestration
tags:
- review
- orchestration
- code-quality
- analysis
- multi-domain
tools: []
usage_patterns:
- auto-detect-review
- full-review
- focused-review
complexity: intermediate
model_hint: standard
estimated_tokens: 400
progressive_loading: true
dependencies:
- imbue:proof-of-work
- imbue:structured-output
orchestrates:
- pensive:rust-review
- pensive:api-review
- pensive:architecture-review
- pensive:bug-review
- pensive:test-review
- pensive:makefile-review
- pensive:math-review
- imbue:justify

Table of Contents

• [Quick Start](#quick-start)
• [When to Use](#when-to-use)
• [Review Skill Selection Matrix](#review-skill-selection-matrix)
• [Workflow](#workflow)
• [1. Analyze Repository Context](#1-analyze-repository-context)
• [2. Select Review Skills](#2-select-review-skills)
• [3. Execute Reviews](#3-execute-reviews)
• [4. Integrate Findings](#4-integrate-findings)
• [Review Modes](#review-modes)
• [Auto-Detect (default)](#auto-detect-(default))
• [Focused Mode](#focused-mode)
• [Full Review Mode](#full-review-mode)
• [Quality Gates](#quality-gates)
• [Deliverables](#deliverables)
• [Executive Summary](#executive-summary)
• [Domain-Specific Reports](#domain-specific-reports)
• [Integrated Action Plan](#integrated-action-plan)
• [Modular Architecture](#modular-architecture)
• [Exit Criteria](#exit-criteria)

Unified Review Orchestration

Intelligently selects and executes appropriate review skills based on codebase analysis and context.

Quick Start

# Auto-detect and run appropriate reviews
/full-review

# Focus on specific areas
/full-review api          # API surface review
/full-review architecture # Architecture review
/full-review bugs         # Bug hunting
/full-review tests        # Test suite review
/full-review all          # Run all applicable skills

**Verification:** Run `pytest -v` to verify tests pass.

When To Use

• Starting a full code review
• Reviewing changes across multiple domains
• Need intelligent selection of review skills
• Want integrated reporting from multiple review types
• Before merging major feature branches

When NOT To Use

• Specific review type known
• use bug-review
• Test-review
• Architecture-only focus - use

architecture-review

• Specific review type known
• use bug-review

Review Skill Selection Matrix

| Codebase Pattern | Review Skills | Triggers | |-----------------|---------------|----------| | Rust files (`*.rs`, `Cargo.toml`) | rust-review, bug-review, api-review | Rust project detected | | API changes (`openapi.yaml`, `routes/`) | api-review, architecture-review | Public API surfaces | | Test files (`test_*.py`, `*_test.go`) | test-review, bug-review | Test infrastructure | | Makefile/build system | makefile-review, architecture-review | Build complexity | | Mathematical algorithms | math-review, bug-review | Numerical computation | | Architecture docs/ADRs | architecture-review, api-review | System design | | General code quality | bug-review, test-review | Default review | | Post-implementation audit | imbue:justify | High add/delete ratio, test changes, new abstractions |

Workflow

1. Analyze Repository Context

• Detect primary languages from extensions and manifests
• Analyze git status and diffs for change scope
• Identify project structure (monorepo, microservices, library)
• Detect build systems, testing frameworks, documentation

2. Select Review Skills

# Detection logic
if has_rust_files():
    schedule_skill("rust-review")
if has_api_changes():
    schedule_skill("api-review")
if has_test_files():
    schedule_skill("test-review")
if has_makefiles():
    schedule_skill("makefile-review")
if has_math_code():
    schedule_skill("math-review")
if has_architecture_changes():
    schedule_skill("architecture-review")
# Default
schedule_skill("bug-review")

**Verification:** Run `pytest -v` to verify tests pass.

3. Execute Reviews

Dispatch selected skills concurrently via the Agent tool. Use this mapping to resolve skill names to agent types:

| Skill Name | Agent Type | Notes | |---|---|---| | bug-review | `pensive:code-reviewer` | Covers bugs, API, tests | | api-review | `pensive:code-reviewer` | Same agent, API focus | | test-review | `pensive:code-reviewer` | Same agent, test focus | | architecture-review | `pensive:architecture-reviewer` | ADR compliance | | rust-review | `pensive:rust-auditor` | Rust-specific | | code-refinement | `pensive:code-refiner` | Duplication, quality | | math-review | `general-purpose` | Prompt: invoke `Skill(pensive:math-review)` | | makefile-review | `general-purpose` | Prompt: invoke `Skill(pensive:makefile-review)` | | shell-review | `general-purpose` | Prompt: invoke `Skill(pensive:shell-review)` |

**Sub-agent isolation (required).** One lens must not color how the next is read. Two ways to get that, and the second only runs when the user asks for it:

| Path | How isolation holds | |------|---------------------| | Agent tool | Dispatch ALL selected agents in a SINGLE parallel call, and read no output until every agent has returned. Reading the first result anchors synthesis toward it: each later result gets judged against the first rather than independently. Collect all, then synthesize once | | `/pensive:unified-review` workflow (`workflows/unified-review.js`) | The script holds the results. It is not a reasoning entity, so it cannot be anchored by reading one stage before another, and findings pass between stages without entering anyone's context. Verification also starts per dimension instead of waiting for the slowest lens |

Prefer the workflow when the dimension list is known before the work and each finding should face an adversarial check. Prefer the Agent tool when the roster has to adapt to what the first lens f