rvw 0.1.0__tar.gz

rvw-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soju06
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rvw-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: rvw
+Version: 0.1.0
+Summary: Layered, replicated, self-adjudicating code review orchestrator
+Keywords: cli,code-review,llm,orchestrator,static-analysis
+Author: Soju06
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: typer>=0.27.0
+Requires-Dist: rich>=15.0.0
+Requires-Dist: pydantic>=2.13.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: pytest>=9.1.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.4.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=7.1.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.16.0 ; extra == 'dev'
+Requires-Dist: ty>=0.0.63 ; extra == 'dev'
+Requires-Dist: pre-commit>=4.6.0 ; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.12 ; extra == 'dev'
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/Soju06/rvw
+Project-URL: Issues, https://github.com/Soju06/rvw/issues
+Project-URL: Changelog, https://github.com/Soju06/rvw/releases
+Provides-Extra: dev
+Description-Content-Type: text/markdown
+
+# rvw
+
+[![CI](https://github.com/Soju06/rvw/actions/workflows/ci.yml/badge.svg)](https://github.com/Soju06/rvw/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/rvw)](https://pypi.org/project/rvw/)
+[![Python](https://img.shields.io/pypi/pyversions/rvw)](https://pypi.org/project/rvw/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**Layered, replicated, self-adjudicating code review orchestrator.**
+
+`rvw` turns LLM code review from a single noisy pass into a deterministic
+pipeline: activate rule lanes in layers, fire every lane with N replicas in one
+concurrent wave, merge findings by content-derived keys, adjudicate each
+candidate against the actual source, and publish one synthesized report.
+
+```
+DISCOVER ──▶ MERGE ──▶ ADJUDICATE ──▶ REPORT ──▶ publish
+ lanes ×       collapse    replicas vote   Korean md    GitHub review
+ replicas      + folds     on real source  + coverage   (inline anchors)
+```
+
+## Why
+
+Single-pass LLM review has three structural problems, each addressed by a
+measured design decision (see [DECISIONS.md](DECISIONS.md)):
+
+| Problem | Mechanism | Measured |
+|---|---|---|
+| One pass misses findings | 3 replicas per lane, one wave | recall 88% → 99% (ADR-006) |
+| Scoped rules go blind outside their scope | mandatory `unscoped-sweep` lane | 3/3 deep defects only the sweep caught (ADR-005) |
+| LLMs fabricate findings | separate adjudication lane, votes grounded in real source | 3/3 fabricated rejected, 0/6 genuine lost (ADR-007) |
+
+Findings are forced through closed rule enums via strict `--output-schema` —
+measured: the schema beats the prompt, and closed enums cost zero recall vs
+free-form ids (ADR-004).
+
+## Install
+
+```bash
+pip install rvw          # or: uv tool install rvw
+```
+
+Requires Python 3.12+ and a working [Codex CLI](https://github.com/openai/codex)
+(`codex exec`) as the review runtime.
+
+## Quickstart
+
+```bash
+# One command: resolve PR → discover → merge → adjudicate → report
+rvw review --target 1119 --repo-dir /path/to/pr-head-checkout
+
+# Plan only (no execution): which lanes activate, how many runs
+rvw plan --target 1119 --json
+
+# Deterministic gate for CI: exit 0 PASS / 1 BLOCK
+rvw auto --target 1119 --repo-dir /path/to/checkout
+
+# Publish the report as a GitHub review (dry-run by default)
+rvw publish --run <run-id> --execute
+```
+
+## Concepts
+
+- **Rule** — one atomic check (`slop/sot-violation`, `bug/severe-defect`, …)
+- **Lane** — a named rule bundle + prompt executed as one review pass; rules
+  form the closed output enum
+- **Layer** — activation tier owning lanes: `base` (always) → `project`
+  (repo predicate) → `scope` (path predicate) → `dynamic` (per-PR brief)
+- **Runtime** — the execution engine (`codex exec --sandbox read-only`)
+- **Run** — lane × runtime × replica
+
+The registry lives outside the package (default `~/.hermes/review/`):
+`layers.yaml` + `lanes/**.md` (YAML frontmatter + prompt body) + `policies/`.
+Everything is referenced by name so documents, lanes, and runtimes can be
+swapped without touching code.
+
+## Pipeline guarantees
+
+- **Validity contract** — a run counts only if: exit 0, artifact exists,
+  strict-schema JSON validates, completion marker present. INVALID replicas
+  are never promoted; an all-INVALID lane is re-dispatched exactly once.
+- **Deterministic merge** — findings collapse by `(file, hunk, rule)`;
+  cross-lane corroboration and replica agreement are computed, not guessed.
+  Display folds (same-pattern-across-files, same-region) never merge
+  verdicts and never chain transitively.
+- **Source-grounded verdicts** — adjudication replicas run inside the target
+  checkout; REJECTED requires a verbatim disproving source quote, otherwise
+  it is coerced to UNCERTAIN. Unresolved candidates are reported as
+  unverified, never silently dropped.
+- **Approve is not expressible** — the publish layer hardcodes COMMENT.
+  `rvw auto` decides PASS/BLOCK from a YAML threshold policy; nothing in the
+  pipeline can emit an approving review.
+
+## Lane health
+
+```bash
+rvw lanes list                 # registry overview
+rvw sample --lane slop-hygiene --fixture tests/fixtures/deep.ts
+                               # enum-vs-free A/B gate for new lanes
+rvw doctor                     # INVALID rate, /other rate, rejection rate
+```
+
+## Development
+
+```bash
+git clone https://github.com/Soju06/rvw && cd rvw
+uv sync --all-extras
+uv run pytest -q -m "not live"   # unit suite
+uv run pytest -q -m live         # exercises real codex (needs credentials)
+```
+
+Gates: `ruff check` · `ruff format` · `ty check` · `pytest`. Architecture
+decisions are append-only in [DECISIONS.md](DECISIONS.md).
+
+## License
+
+[MIT](LICENSE)

rvw-0.1.0/README.md

@@ -0,0 +1,116 @@
+# rvw
+
+[![CI](https://github.com/Soju06/rvw/actions/workflows/ci.yml/badge.svg)](https://github.com/Soju06/rvw/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/rvw)](https://pypi.org/project/rvw/)
+[![Python](https://img.shields.io/pypi/pyversions/rvw)](https://pypi.org/project/rvw/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**Layered, replicated, self-adjudicating code review orchestrator.**
+
+`rvw` turns LLM code review from a single noisy pass into a deterministic
+pipeline: activate rule lanes in layers, fire every lane with N replicas in one
+concurrent wave, merge findings by content-derived keys, adjudicate each
+candidate against the actual source, and publish one synthesized report.
+
+```
+DISCOVER ──▶ MERGE ──▶ ADJUDICATE ──▶ REPORT ──▶ publish
+ lanes ×       collapse    replicas vote   Korean md    GitHub review
+ replicas      + folds     on real source  + coverage   (inline anchors)
+```
+
+## Why
+
+Single-pass LLM review has three structural problems, each addressed by a
+measured design decision (see [DECISIONS.md](DECISIONS.md)):
+
+| Problem | Mechanism | Measured |
+|---|---|---|
+| One pass misses findings | 3 replicas per lane, one wave | recall 88% → 99% (ADR-006) |
+| Scoped rules go blind outside their scope | mandatory `unscoped-sweep` lane | 3/3 deep defects only the sweep caught (ADR-005) |
+| LLMs fabricate findings | separate adjudication lane, votes grounded in real source | 3/3 fabricated rejected, 0/6 genuine lost (ADR-007) |
+
+Findings are forced through closed rule enums via strict `--output-schema` —
+measured: the schema beats the prompt, and closed enums cost zero recall vs
+free-form ids (ADR-004).
+
+## Install
+
+```bash
+pip install rvw          # or: uv tool install rvw
+```
+
+Requires Python 3.12+ and a working [Codex CLI](https://github.com/openai/codex)
+(`codex exec`) as the review runtime.
+
+## Quickstart
+
+```bash
+# One command: resolve PR → discover → merge → adjudicate → report
+rvw review --target 1119 --repo-dir /path/to/pr-head-checkout
+
+# Plan only (no execution): which lanes activate, how many runs
+rvw plan --target 1119 --json
+
+# Deterministic gate for CI: exit 0 PASS / 1 BLOCK
+rvw auto --target 1119 --repo-dir /path/to/checkout
+
+# Publish the report as a GitHub review (dry-run by default)
+rvw publish --run <run-id> --execute
+```
+
+## Concepts
+
+- **Rule** — one atomic check (`slop/sot-violation`, `bug/severe-defect`, …)
+- **Lane** — a named rule bundle + prompt executed as one review pass; rules
+  form the closed output enum
+- **Layer** — activation tier owning lanes: `base` (always) → `project`
+  (repo predicate) → `scope` (path predicate) → `dynamic` (per-PR brief)
+- **Runtime** — the execution engine (`codex exec --sandbox read-only`)
+- **Run** — lane × runtime × replica
+
+The registry lives outside the package (default `~/.hermes/review/`):
+`layers.yaml` + `lanes/**.md` (YAML frontmatter + prompt body) + `policies/`.
+Everything is referenced by name so documents, lanes, and runtimes can be
+swapped without touching code.
+
+## Pipeline guarantees
+
+- **Validity contract** — a run counts only if: exit 0, artifact exists,
+  strict-schema JSON validates, completion marker present. INVALID replicas
+  are never promoted; an all-INVALID lane is re-dispatched exactly once.
+- **Deterministic merge** — findings collapse by `(file, hunk, rule)`;
+  cross-lane corroboration and replica agreement are computed, not guessed.
+  Display folds (same-pattern-across-files, same-region) never merge
+  verdicts and never chain transitively.
+- **Source-grounded verdicts** — adjudication replicas run inside the target
+  checkout; REJECTED requires a verbatim disproving source quote, otherwise
+  it is coerced to UNCERTAIN. Unresolved candidates are reported as
+  unverified, never silently dropped.
+- **Approve is not expressible** — the publish layer hardcodes COMMENT.
+  `rvw auto` decides PASS/BLOCK from a YAML threshold policy; nothing in the
+  pipeline can emit an approving review.
+
+## Lane health
+
+```bash
+rvw lanes list                 # registry overview
+rvw sample --lane slop-hygiene --fixture tests/fixtures/deep.ts
+                               # enum-vs-free A/B gate for new lanes
+rvw doctor                     # INVALID rate, /other rate, rejection rate
+```
+
+## Development
+
+```bash
+git clone https://github.com/Soju06/rvw && cd rvw
+uv sync --all-extras
+uv run pytest -q -m "not live"   # unit suite
+uv run pytest -q -m live         # exercises real codex (needs credentials)
+```
+
+Gates: `ruff check` · `ruff format` · `ty check` · `pytest`. Architecture
+decisions are append-only in [DECISIONS.md](DECISIONS.md).
+
+## License
+
+[MIT](LICENSE)

rvw-0.1.0/pyproject.toml

@@ -0,0 +1,90 @@
+[project]
+name = "rvw"
+version = "0.1.0"
+description = "Layered, replicated, self-adjudicating code review orchestrator"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Soju06" }]
+requires-python = ">=3.12"
+keywords = ["cli", "code-review", "llm", "orchestrator", "static-analysis"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "typer>=0.27.0",
+    "rich>=15.0.0",
+    "pydantic>=2.13.0",
+    "pyyaml>=6.0.3",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=9.1.0",
+    "pytest-asyncio>=1.4.0",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.16.0",
+    "ty>=0.0.63",
+    "pre-commit>=4.6.0",
+    "types-pyyaml>=6.0.12",
+]
+
+[project.scripts]
+# IMPORTANT: target the Typer app object, not a main() function.
+rvw = "rvw.cli:app"
+
+[project.urls]
+Repository = "https://github.com/Soju06/rvw"
+Issues = "https://github.com/Soju06/rvw/issues"
+Changelog = "https://github.com/Soju06/rvw/releases"
+
+[build-system]
+requires = ["uv_build>=0.10.9,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+extend-exclude = [".hermes"]
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "B",   # flake8-bugbear
+    "UP",  # pyupgrade
+    "SIM", # flake8-simplify
+    "RUF", # ruff-specific
+]
+ignore = [
+    "E501", # line too long (formatter handles)
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.ty.environment]
+python-version = "3.12"
+
+[tool.ty.src]
+include = ["src", "tests"]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-ra --strict-markers"
+testpaths = ["tests"]
+asyncio_mode = "auto"
+markers = [
+    "live: requires a real codex CLI invocation (deselect with -m 'not live')",
+]

rvw-0.1.0/src/rvw/__init__.py

@@ -0,0 +1,10 @@
+"""rvw package layout.
+
+The command surface lives in ``cli`` and wire models in ``schema``. Registry,
+lane, target, hunks, dispatch, and runtimes modules implement review planning
+and execution. Architectural decisions are recorded in ``DECISIONS.md``.
+"""
+
+from rvw._version import __version__
+
+__all__: list[str] = ["__version__"]

rvw-0.1.0/src/rvw/_version.py

@@ -0,0 +1,3 @@
+"""Single source of truth for the rvw version string."""
+
+__version__ = "0.1.0"

rvw-0.1.0/src/rvw/adjudicate.py

@@ -0,0 +1,282 @@
+"""Evidence-bearing, majority-voted adjudication of merged findings."""
+
+from __future__ import annotations
+
+import asyncio
+from collections import Counter
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, cast
+
+from rvw.merge import CollapseGroup, MergeResult
+from rvw.runtimes import RunResult, RunStatus, Runtime
+from rvw.schema import RuntimeAdjudication, RuntimeAdjudicationItem, Verdict
+from rvw.target import ResolvedTarget
+
+
+def adjudication_schema(group_keys: Sequence[str]) -> dict[str, Any]:
+    """Build the closed, OpenAI-strict schema for one candidate batch."""
+
+    schema = RuntimeAdjudication.model_json_schema()
+    schema.pop("$defs", None)
+    item_properties = dict(RuntimeAdjudicationItem.model_json_schema()["properties"])
+    item_properties["group_key"] = {"type": "string", "enum": list(group_keys)}
+    item_properties["verdict"] = {
+        "type": "string",
+        "enum": [verdict.value for verdict in Verdict],
+    }
+    schema["additionalProperties"] = False
+    schema["required"] = list(schema["properties"])
+    schema["properties"]["items"]["items"] = {
+        "type": "object",
+        "properties": item_properties,
+        "required": list(item_properties),
+        "additionalProperties": False,
+    }
+    return schema
+
+
+def build_adjudication_prompt(groups: Sequence[CollapseGroup], *, diff: str, expanded: bool) -> str:
+    """Render an adjudication-only prompt with every replica body preserved."""
+
+    parts = [
+        "# Role",
+        (
+            "You are an adjudicator, not a reviewer. For each candidate finding, decide from "
+            "the ACTUAL SOURCE in this working directory whether it is real. Do not report new "
+            "findings."
+        ),
+        "# Verdict contract",
+        (
+            "CONFIRMED = the defect is real at HEAD; evidence must quote the offending source "
+            "line(s) verbatim."
+        ),
+        (
+            "REJECTED = the claim is factually wrong; evidence MUST quote the disproving source "
+            "line(s) verbatim."
+        ),
+        "UNCERTAIN = you cannot decide from the available context.",
+        (
+            "Never guess: an unverifiable claim is UNCERTAIN, not REJECTED. Return exactly one "
+            "verdict for each supplied candidate and no other findings."
+        ),
+    ]
+    if expanded:
+        parts.extend(
+            [
+                "# Expanded context",
+                (
+                    "EXPANDED CONTEXT PASS: you may and should explore beyond the diff — read "
+                    "the full enclosing function/class, find the symbol's definition and its "
+                    "callers (grep), and check tests covering the path, before deciding. Prior "
+                    "pass returned UNCERTAIN for these."
+                ),
+            ]
+        )
+
+    parts.append("# Candidates")
+    for group in groups:
+        parts.extend(
+            [
+                f"## Candidate {group.key}",
+                f"group_key: {group.key}",
+                f"rule_id: {group.rule_id}",
+                f"location: {group.file}:{group.line if group.line is not None else 'unknown'}",
+                "Replica reports (verbatim):",
+            ]
+        )
+        for index, body in enumerate(group.bodies, start=1):
+            parts.extend([f"### Body {index}", body])
+
+    parts.extend(["# Unified diff", "```diff", diff, "```"])
+    return "\n\n".join(parts)
+
+
+@dataclass(frozen=True)
+class AdjudicationOutcome:
+    verdicts: dict[str, Verdict]
+    reasons: dict[str, str]
+    evidence: dict[str, str]
+    replica_votes: dict[str, list[Verdict]]
+    unresolved: list[str]
+    coerced_rejections: int
+
+
+@dataclass(frozen=True)
+class _Vote:
+    verdict: Verdict
+    reason: str
+    evidence: str
+
+
+@dataclass(frozen=True)
+class _BatchVote:
+    verdicts: dict[str, Verdict]
+    reasons: dict[str, str]
+    evidence: dict[str, str]
+    replica_votes: dict[str, list[Verdict]]
+    coerced_rejections: int
+
+
+def _vote_batch(groups: Sequence[CollapseGroup], results: Sequence[RunResult[Any]]) -> _BatchVote:
+    valid_outputs = [
+        cast(RuntimeAdjudication, result.output)
+        for result in results
+        if result.status is RunStatus.VALID and result.output is not None
+    ]
+    votes_by_key: dict[str, list[_Vote]] = {group.key: [] for group in groups}
+    coerced_rejections = 0
+    for output in valid_outputs:
+        by_key: dict[str, RuntimeAdjudicationItem] = {}
+        for adjudication_item in output.items:
+            by_key.setdefault(adjudication_item.group_key, adjudication_item)
+        for group in groups:
+            adjudication_item = by_key.get(group.key)
+            if adjudication_item is None:
+                votes_by_key[group.key].append(_Vote(Verdict.UNCERTAIN, "", ""))
+                continue
+            verdict = adjudication_item.verdict
+            if verdict is Verdict.REJECTED and not adjudication_item.evidence.strip():
+                verdict = Verdict.UNCERTAIN
+                coerced_rejections += 1
+            votes_by_key[group.key].append(
+                _Vote(verdict, adjudication_item.reason, adjudication_item.evidence)
+            )
+
+    verdicts: dict[str, Verdict] = {}
+    reasons: dict[str, str] = {}
+    evidence: dict[str, str] = {}
+    replica_votes: dict[str, list[Verdict]] = {}
+    for group in groups:
+        group_votes = votes_by_key[group.key]
+        replica_votes[group.key] = [vote.verdict for vote in group_votes]
+        counts = Counter(vote.verdict for vote in group_votes)
+        verdict = Verdict.UNCERTAIN
+        for candidate in Verdict:
+            if counts[candidate] > len(group_votes) / 2:
+                verdict = candidate
+                break
+        verdicts[group.key] = verdict
+        supporting_vote = next((vote for vote in group_votes if vote.verdict is verdict), None)
+        reasons[group.key] = supporting_vote.reason if supporting_vote is not None else ""
+        evidence[group.key] = supporting_vote.evidence if supporting_vote is not None else ""
+
+    return _BatchVote(
+        verdicts=verdicts,
+        reasons=reasons,
+        evidence=evidence,
+        replica_votes=replica_votes,
+        coerced_rejections=coerced_rejections,
+    )
+
+
+async def adjudicate(
+    merged: MergeResult,
+    *,
+    target: ResolvedTarget,
+    runtime: Runtime,
+    repo_dir: Path,
+    out_root: Path,
+    replicas: int = 3,
+    deadline_seconds: int = 600,
+    concurrency: int = 16,
+) -> AdjudicationOutcome:
+    """Adjudicate all collapse groups, widening context once for uncertainty."""
+
+    if replicas < 1:
+        raise ValueError("replicas must be at least 1")
+    if deadline_seconds < 1:
+        raise ValueError("deadline_seconds must be at least 1")
+    if concurrency < 1:
+        raise ValueError("concurrency must be at least 1")
+    if not merged.groups:
+        return AdjudicationOutcome({}, {}, {}, {}, [], 0)
+
+    semaphore = asyncio.Semaphore(concurrency)
+
+    async def execute_wave(
+        groups: Sequence[CollapseGroup], *, expanded: bool, label: str, deadline: int
+    ) -> list[RunResult[Any]]:
+        prompt = build_adjudication_prompt(groups, diff=target.diff, expanded=expanded)
+        schema = adjudication_schema([group.key for group in groups])
+
+        async def execute_one(replica: int) -> RunResult[Any]:
+            async with semaphore:
+                run_dir = out_root / label / f"r{replica}"
+                return await runtime.execute_raw(
+                    schema=schema,
+                    prompt=prompt,
+                    run_dir=run_dir,
+                    deadline_seconds=deadline,
+                    workdir=repo_dir,
+                    validate=RuntimeAdjudication.model_validate,
+                )
+
+        return list(
+            await asyncio.gather(
+                *(asyncio.create_task(execute_one(replica)) for replica in range(1, replicas + 1))
+            )
+        )
+
+    async def execute_pass(
+        groups: Sequence[CollapseGroup], *, expanded: bool, label: str, deadline: int
+    ) -> list[RunResult[Any]]:
+        results = await execute_wave(groups, expanded=expanded, label=label, deadline=deadline)
+        if all(result.status is RunStatus.INVALID for result in results):
+            return await execute_wave(
+                groups,
+                expanded=expanded,
+                label=f"{label}-retry",
+                deadline=deadline,
+            )
+        return results
+
+    initial_results = await execute_pass(
+        merged.groups,
+        expanded=False,
+        label="initial",
+        deadline=deadline_seconds,
+    )
+    initial = _vote_batch(merged.groups, initial_results)
+    verdicts = dict(initial.verdicts)
+    reasons = dict(initial.reasons)
+    evidence = dict(initial.evidence)
+    replica_votes = {key: list(votes) for key, votes in initial.replica_votes.items()}
+    coerced_rejections = initial.coerced_rejections
+
+    uncertain_groups = [
+        group for group in merged.groups if verdicts[group.key] is Verdict.UNCERTAIN
+    ]
+    if uncertain_groups:
+        expanded_results = await execute_pass(
+            uncertain_groups,
+            expanded=True,
+            label="expanded",
+            deadline=deadline_seconds * 2,
+        )
+        expanded_vote = _vote_batch(uncertain_groups, expanded_results)
+        coerced_rejections += expanded_vote.coerced_rejections
+        for group in uncertain_groups:
+            verdicts[group.key] = expanded_vote.verdicts[group.key]
+            reasons[group.key] = expanded_vote.reasons[group.key]
+            evidence[group.key] = expanded_vote.evidence[group.key]
+            replica_votes[group.key] = expanded_vote.replica_votes[group.key]
+
+    unresolved = [group.key for group in merged.groups if verdicts[group.key] is Verdict.UNCERTAIN]
+    return AdjudicationOutcome(
+        verdicts=verdicts,
+        reasons=reasons,
+        evidence=evidence,
+        replica_votes=replica_votes,
+        unresolved=unresolved,
+        coerced_rejections=coerced_rejections,
+    )
+
+
+__all__ = [
+    "AdjudicationOutcome",
+    "adjudicate",
+    "adjudication_schema",
+    "build_adjudication_prompt",
+]