agentjury 0.4.4__tar.gz

agentjury-0.4.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RASHID HASSAN AL-DERHAM
+
+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.

agentjury-0.4.4/PKG-INFO

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: agentjury
+Version: 0.4.4
+Summary: Peer review for AI agents using independent model juries and deterministic aggregation.
+Author: Rashid Al-Derham
+License: MIT
+Project-URL: Homepage, https://github.com/madad-rashid/AgentJury
+Project-URL: Repository, https://github.com/madad-rashid/AgentJury
+Project-URL: Issues, https://github.com/madad-rashid/AgentJury/issues
+Project-URL: Changelog, https://github.com/madad-rashid/AgentJury/releases
+Keywords: ai-agents,llm,llm-evaluation,agent-evaluation,multi-agent,peer-review
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.30; extra == "anthropic"
+Provides-Extra: all
+Requires-Dist: openai>=1.0; extra == "all"
+Requires-Dist: anthropic>=0.30; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# AgentJury
+
+[![tests](https://github.com/madad-rashid/AgentJury/actions/workflows/tests.yml/badge.svg)](https://github.com/madad-rashid/AgentJury/actions/workflows/tests.yml)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Peer review for AI agents.**
+
+Your agent says the task is finished. AgentJury asks independent, blind AI reviewers whether the work is good enough before you trust it.
+
+Each reviewer votes ▲ approve, ▼ revise, or – abstain. AgentJury combines those opinions with deterministic rules. No final LLM gets a deciding vote.
+
+```text
+Controlled Institutional Private-Credit Pilot.md   +43
+▲4 ▼1   score 8.7   consensus 80%   verified
+```
+
+AgentJury is framework-independent. The first live integration is Hermes, and the core protocol works with any system that can build a `ReviewRequest`.
+
+## Looking for testers
+
+AgentJury is in public alpha. I am looking for developers running real agent workflows who are willing to test the jury on completed tasks and report where it fails.
+
+Useful feedback includes:
+
+- the framework or agent you used
+- the reviewer panel and models
+- the verdict, latency, and approximate cost
+- reviewer disagreements or false findings
+- installation friction and integration problems
+
+Open an issue at <https://github.com/madad-rashid/AgentJury/issues>. Please do not post proprietary task content or API keys.
+
+## Quick start
+
+Install AgentJury from PyPI:
+
+```bash
+pip install "agentjury[all]"
+```
+
+Set `OPENAI_API_KEY` and `ANTHROPIC_API_KEY` in your environment or a local `.env` file, then review an agent output:
+
+```bash
+agentjury review task.md output.md
+```
+
+Example:
+
+```text
+▲2 ▼1  score 7.0  consensus 67%  diversity 67%  jury 3/3  verified
+jury confidence index 35%  (heuristic, not a probability)
+
+▲  8  accuracy/openai        Sourced figure, drivers accurately characterized.
+▼  5  critic/anthropic       Citation has no year or report; one claim is unsupported.
+▲  8  executive/openai       Concise and decision-ready.
+```
+
+Choose your own panel:
+
+```bash
+agentjury review task.md output.md \
+  --panel accuracy:openai,critic:anthropic,evidence:anthropic,executive:openai
+```
+
+Run `agentjury roles` to see the built-in roles. Every verdict is saved to `.agentjury/verdicts/`.
+
+## Architecture
+
+```mermaid
+flowchart LR
+    A[Agent or framework] --> R[ReviewRequest]
+    R --> O[OpenAI judge]
+    R --> C[Anthropic judge]
+    R --> X[Local or custom judge]
+    O --> G[Deterministic aggregator]
+    C --> G
+    X --> G
+    G --> V[Verdict]
+    V --> H[Human adjudication]
+    H --> P[(Future reviewer reputation)]
+```
+
+AgentJury separates generation from verification. Reviewers see the task and output, but never see one another's votes before submitting their own.
+
+## Design principles
+
+- **Blind review.** Judges do not see other reviewers' opinions before voting.
+- **Deterministic aggregation.** No model acts as a final arbiter.
+- **Provider diversity.** A multi-provider jury cannot verify work from one provider's judges alone.
+- **Strict quorum.** Failed calls and abstentions do not silently become approval.
+- **No unilateral block.** A single reviewer cannot block a task by itself.
+- **Auditable identity.** Requests, runs, reviews, reviewer configurations, and findings each have stable IDs.
+- **Human adjudication.** Individual findings can be graded so reviewer reliability can later be measured from evidence rather than assumed.
+- **Framework independence.** AgentJury reviews work produced elsewhere. It is not another agent framework.
+
+## How a verdict is reached
+
+Judges vote ▲ approve, ▼ revise, or – abstain. Abstentions are recorded but never counted as approval, and they count against quorum.
+
+No single judge can block. `blocked` requires blocking findings from two different providers. One blocking finding downgrades the result to `needs_revision`.
+
+A panel needs a quorum of voters, by default a strict majority of requested judges:
+
+```text
+1→1, 2→2, 3→2, 4→3, 5→3, 6→4
+```
+
+A panel built from several providers must also hear from at least two of them. Otherwise the status is `insufficient_jury` and the votes are informational only.
+
+Each judge call has a timeout, one retry on provider error, and one repair round-trip if the reply is not valid JSON. A failed judge is recorded as an error and the rest of the panel continues.
+
+Exit codes:
+
+```text
+0  verified
+1  needs_revision
+2  blocked
+3  insufficient_jury
+```
+
+The confidence figure is a heuristic index, not a calibrated probability. The plan is to calibrate it against human adjudication once enough real data exists.
+
+Judges treat everything they review as untrusted data. Instructions hidden inside an agent output are treated as content, not reviewer instructions. `tests/test_adversarial_live.py` attacks the jury with `examples/injected_output.md`; run it with `AGENTJURY_LIVE=1`.
+
+## Adjudication
+
+Reputation is designed to come from human grading of individual findings, not from treating an entire review as one correct or incorrect event.
+
+```bash
+agentjury verdicts --dir <where-verdicts-live>
+agentjury adjudicate 9a9a900dc86b --judge critic/anthropic \
+    --finding 1 wrong --finding 2 wrong --finding 3 correct \
+    --verdict disagree --note "figure is in the cited source"
+agentjury adjudicate 9a9a900dc86b --producer-verdict correct
+```
+
+Findings are numbered as displayed. Grades are written back into the verdict JSON as current state and appended as events to `adjudications.jsonl` in the same folder. The event log records who changed which finding, from what to what, when, and why.
+
+Set `AGENTJURY_VERDICT_DIR` to avoid repeating `--dir`.
+
+Identity hierarchy:
+
+- `request_id`: the work being evaluated
+- `run_id`: one jury execution of that request
+- `review_id`: one judge's opinion
+- `config_id`: the reviewer configuration used for future reputation measurement, including provider, model, role, prompt hash, and relevant parameters
+- `finding.id`: one specific issue raised by a reviewer
+
+Verdicts are saved as `<request_id>-<run_id>.json`.
+
+## Custom roles
+
+Give a jury domain expertise with a JSON file of `{"role_name": "description"}`:
+
+```bash
+agentjury review task.md output.md \
+  --roles examples/roles.json \
+  --panel accuracy:openai,domain_expert:anthropic,executive:openai
+```
+
+## Integrations
+
+### Hermes Agent
+
+`integrations/hermes/` contains the first live integration. It reviews substantial Hermes responses in the background, saves verdicts, writes verdict metadata into markdown frontmatter, and feeds major findings back on the next relevant turn.
+
+See [integrations/hermes/README.md](integrations/hermes/README.md) for installation and configuration.
+
+Adapters for other agent frameworks are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Protocol
+
+Current schema: **0.5**.
+
+Print the schemas with:
+
+```bash
+agentjury schema request
+agentjury schema verdict
+```
+
+The main objects are:
+
+- `ReviewRequest`: task, agent output, optional context and artifacts, task type, domain, and producer metadata
+- `Review`: one independent judge opinion with vote, score, reason, findings, IDs, reviewer configuration, telemetry, and adjudication slots
+- `Verdict`: deterministic aggregate with votes, score, consensus, diversity, confidence index, status, and the underlying reviews
+
+Every field needed by the planned reputation system is recorded from the first review. Reputation weighting is not active yet.
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup, tests, judge-provider adapters, framework integrations, and pull requests.
+
+See [docs/PUBLISHING.md](docs/PUBLISHING.md) for the release and PyPI checklist.
+
+## Status
+
+Public alpha. The core aggregation rules are intentionally stable while real verdicts are collected through the Hermes integration and direct CLI use.
+
+The next research step is reviewer reputation by task type using human-adjudicated findings, followed by diversity weighting from observed disagreement patterns.
+
+## Roadmap
+
+- [x] Protocol schema
+- [x] Judge interface with OpenAI and Anthropic adapters
+- [x] Deterministic aggregator
+- [x] CLI: `agentjury review task.md output.md`
+- [x] Hermes integration
+- [x] Review-event schema with telemetry and adjudication slots
+- [x] Quorum, non-unilateral blocking, prompt-injection defence, custom roles
+- [x] Abstain vote, provider floor, retry, repair, timeouts, CI
+- [x] Human finding-level adjudication and append-only adjudication history
+- [x] PyPI release
+- [ ] Additional judge providers and local-model adapter
+- [ ] Reviewer reputation by task type, weighted by human agreement over time
+- [ ] Jury diversity weighting from historical disagreement
+- [ ] Calibrated confidence from observed outcomes
+
+## License
+
+MIT

agentjury-0.4.4/README.md

@@ -0,0 +1,222 @@
+# AgentJury
+
+[![tests](https://github.com/madad-rashid/AgentJury/actions/workflows/tests.yml/badge.svg)](https://github.com/madad-rashid/AgentJury/actions/workflows/tests.yml)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Peer review for AI agents.**
+
+Your agent says the task is finished. AgentJury asks independent, blind AI reviewers whether the work is good enough before you trust it.
+
+Each reviewer votes ▲ approve, ▼ revise, or – abstain. AgentJury combines those opinions with deterministic rules. No final LLM gets a deciding vote.
+
+```text
+Controlled Institutional Private-Credit Pilot.md   +43
+▲4 ▼1   score 8.7   consensus 80%   verified
+```
+
+AgentJury is framework-independent. The first live integration is Hermes, and the core protocol works with any system that can build a `ReviewRequest`.
+
+## Looking for testers
+
+AgentJury is in public alpha. I am looking for developers running real agent workflows who are willing to test the jury on completed tasks and report where it fails.
+
+Useful feedback includes:
+
+- the framework or agent you used
+- the reviewer panel and models
+- the verdict, latency, and approximate cost
+- reviewer disagreements or false findings
+- installation friction and integration problems
+
+Open an issue at <https://github.com/madad-rashid/AgentJury/issues>. Please do not post proprietary task content or API keys.
+
+## Quick start
+
+Install AgentJury from PyPI:
+
+```bash
+pip install "agentjury[all]"
+```
+
+Set `OPENAI_API_KEY` and `ANTHROPIC_API_KEY` in your environment or a local `.env` file, then review an agent output:
+
+```bash
+agentjury review task.md output.md
+```
+
+Example:
+
+```text
+▲2 ▼1  score 7.0  consensus 67%  diversity 67%  jury 3/3  verified
+jury confidence index 35%  (heuristic, not a probability)
+
+▲  8  accuracy/openai        Sourced figure, drivers accurately characterized.
+▼  5  critic/anthropic       Citation has no year or report; one claim is unsupported.
+▲  8  executive/openai       Concise and decision-ready.
+```
+
+Choose your own panel:
+
+```bash
+agentjury review task.md output.md \
+  --panel accuracy:openai,critic:anthropic,evidence:anthropic,executive:openai
+```
+
+Run `agentjury roles` to see the built-in roles. Every verdict is saved to `.agentjury/verdicts/`.
+
+## Architecture
+
+```mermaid
+flowchart LR
+    A[Agent or framework] --> R[ReviewRequest]
+    R --> O[OpenAI judge]
+    R --> C[Anthropic judge]
+    R --> X[Local or custom judge]
+    O --> G[Deterministic aggregator]
+    C --> G
+    X --> G
+    G --> V[Verdict]
+    V --> H[Human adjudication]
+    H --> P[(Future reviewer reputation)]
+```
+
+AgentJury separates generation from verification. Reviewers see the task and output, but never see one another's votes before submitting their own.
+
+## Design principles
+
+- **Blind review.** Judges do not see other reviewers' opinions before voting.
+- **Deterministic aggregation.** No model acts as a final arbiter.
+- **Provider diversity.** A multi-provider jury cannot verify work from one provider's judges alone.
+- **Strict quorum.** Failed calls and abstentions do not silently become approval.
+- **No unilateral block.** A single reviewer cannot block a task by itself.
+- **Auditable identity.** Requests, runs, reviews, reviewer configurations, and findings each have stable IDs.
+- **Human adjudication.** Individual findings can be graded so reviewer reliability can later be measured from evidence rather than assumed.
+- **Framework independence.** AgentJury reviews work produced elsewhere. It is not another agent framework.
+
+## How a verdict is reached
+
+Judges vote ▲ approve, ▼ revise, or – abstain. Abstentions are recorded but never counted as approval, and they count against quorum.
+
+No single judge can block. `blocked` requires blocking findings from two different providers. One blocking finding downgrades the result to `needs_revision`.
+
+A panel needs a quorum of voters, by default a strict majority of requested judges:
+
+```text
+1→1, 2→2, 3→2, 4→3, 5→3, 6→4
+```
+
+A panel built from several providers must also hear from at least two of them. Otherwise the status is `insufficient_jury` and the votes are informational only.
+
+Each judge call has a timeout, one retry on provider error, and one repair round-trip if the reply is not valid JSON. A failed judge is recorded as an error and the rest of the panel continues.
+
+Exit codes:
+
+```text
+0  verified
+1  needs_revision
+2  blocked
+3  insufficient_jury
+```
+
+The confidence figure is a heuristic index, not a calibrated probability. The plan is to calibrate it against human adjudication once enough real data exists.
+
+Judges treat everything they review as untrusted data. Instructions hidden inside an agent output are treated as content, not reviewer instructions. `tests/test_adversarial_live.py` attacks the jury with `examples/injected_output.md`; run it with `AGENTJURY_LIVE=1`.
+
+## Adjudication
+
+Reputation is designed to come from human grading of individual findings, not from treating an entire review as one correct or incorrect event.
+
+```bash
+agentjury verdicts --dir <where-verdicts-live>
+agentjury adjudicate 9a9a900dc86b --judge critic/anthropic \
+    --finding 1 wrong --finding 2 wrong --finding 3 correct \
+    --verdict disagree --note "figure is in the cited source"
+agentjury adjudicate 9a9a900dc86b --producer-verdict correct
+```
+
+Findings are numbered as displayed. Grades are written back into the verdict JSON as current state and appended as events to `adjudications.jsonl` in the same folder. The event log records who changed which finding, from what to what, when, and why.
+
+Set `AGENTJURY_VERDICT_DIR` to avoid repeating `--dir`.
+
+Identity hierarchy:
+
+- `request_id`: the work being evaluated
+- `run_id`: one jury execution of that request
+- `review_id`: one judge's opinion
+- `config_id`: the reviewer configuration used for future reputation measurement, including provider, model, role, prompt hash, and relevant parameters
+- `finding.id`: one specific issue raised by a reviewer
+
+Verdicts are saved as `<request_id>-<run_id>.json`.
+
+## Custom roles
+
+Give a jury domain expertise with a JSON file of `{"role_name": "description"}`:
+
+```bash
+agentjury review task.md output.md \
+  --roles examples/roles.json \
+  --panel accuracy:openai,domain_expert:anthropic,executive:openai
+```
+
+## Integrations
+
+### Hermes Agent
+
+`integrations/hermes/` contains the first live integration. It reviews substantial Hermes responses in the background, saves verdicts, writes verdict metadata into markdown frontmatter, and feeds major findings back on the next relevant turn.
+
+See [integrations/hermes/README.md](integrations/hermes/README.md) for installation and configuration.
+
+Adapters for other agent frameworks are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Protocol
+
+Current schema: **0.5**.
+
+Print the schemas with:
+
+```bash
+agentjury schema request
+agentjury schema verdict
+```
+
+The main objects are:
+
+- `ReviewRequest`: task, agent output, optional context and artifacts, task type, domain, and producer metadata
+- `Review`: one independent judge opinion with vote, score, reason, findings, IDs, reviewer configuration, telemetry, and adjudication slots
+- `Verdict`: deterministic aggregate with votes, score, consensus, diversity, confidence index, status, and the underlying reviews
+
+Every field needed by the planned reputation system is recorded from the first review. Reputation weighting is not active yet.
+
+## Development
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for local setup, tests, judge-provider adapters, framework integrations, and pull requests.
+
+See [docs/PUBLISHING.md](docs/PUBLISHING.md) for the release and PyPI checklist.
+
+## Status
+
+Public alpha. The core aggregation rules are intentionally stable while real verdicts are collected through the Hermes integration and direct CLI use.
+
+The next research step is reviewer reputation by task type using human-adjudicated findings, followed by diversity weighting from observed disagreement patterns.
+
+## Roadmap
+
+- [x] Protocol schema
+- [x] Judge interface with OpenAI and Anthropic adapters
+- [x] Deterministic aggregator
+- [x] CLI: `agentjury review task.md output.md`
+- [x] Hermes integration
+- [x] Review-event schema with telemetry and adjudication slots
+- [x] Quorum, non-unilateral blocking, prompt-injection defence, custom roles
+- [x] Abstain vote, provider floor, retry, repair, timeouts, CI
+- [x] Human finding-level adjudication and append-only adjudication history
+- [x] PyPI release
+- [ ] Additional judge providers and local-model adapter
+- [ ] Reviewer reputation by task type, weighted by human agreement over time
+- [ ] Jury diversity weighting from historical disagreement
+- [ ] Calibrated confidence from observed outcomes
+
+## License
+
+MIT

agentjury-0.4.4/agentjury/__init__.py

@@ -0,0 +1,22 @@
+"""AgentJury: peer review for AI agents."""
+
+from .aggregate import aggregate
+from .panel import Panel
+from .protocol import (
+    SCHEMA_VERSION,
+    Artifact,
+    Finding,
+    HumanReview,
+    Producer,
+    Review,
+    ReviewRequest,
+    Verdict,
+    Vote,
+)
+
+__version__ = "0.4.4"
+
+__all__ = [
+    "SCHEMA_VERSION", "Artifact", "Finding", "HumanReview", "Producer",
+    "Review", "ReviewRequest", "Verdict", "Vote", "Panel", "aggregate",
+]

agentjury-0.4.4/agentjury/aggregate.py

@@ -0,0 +1,120 @@
+"""
+Turn a list of independent Reviews into one Verdict.
+
+No LLM calls here. The rules are written down so anyone can predict the verdict:
+
+  voters       responding judges who did not abstain
+  up / down    count of approve / revise votes among voters
+  score        mean of voters' scores
+  consensus    share of voters who sided with the majority vote
+  diversity    distinct providers among voters / voters
+  confidence   heuristic index: consensus, discounted for small panels, wide
+               score spread, and low diversity. NOT a calibrated probability.
+
+  status
+    insufficient_jury  fewer than `quorum` judges voted, OR the panel was built
+                       from two or more providers but only one provider's judges
+                       voted. Votes are reported; no verdict is reached.
+    blocked            blocking findings from at least two providers (or from at
+                       least two judges when the panel has only one provider).
+                       No single judge can block on its own.
+    needs_revision     majority revise, a tie, or exactly one blocking source.
+    verified           majority approve and no blocking finding.
+
+  quorum       default is a strict majority of requested judges:
+               1->1, 2->2, 3->2, 4->3, 5->3, 6->4
+
+Reviewer reputation will later weight these votes. For now every voter counts once.
+"""
+
+from __future__ import annotations
+
+from .protocol import Review, ReviewRequest, Verdict, Vote
+
+
+def default_quorum(requested: int) -> int:
+    """Strict majority of the requested panel."""
+    return max(1, requested // 2 + 1)
+
+
+def _empty(request: ReviewRequest, reviews, errors, requested, quorum, panel_id) -> Verdict:
+    return Verdict(
+        request_id=request.request_id, panel_id=panel_id,
+        requested=requested, responded=len(reviews), abstained=len(reviews), quorum=quorum,
+        task_type=request.task_type, domain=request.domain, producer=request.producer,
+        up=0, down=0, score=0.0, consensus=0.0, diversity=0.0, confidence=0.0,
+        status="insufficient_jury", reviews=reviews, errors=errors or [],
+    )
+
+
+def aggregate(
+    request: ReviewRequest,
+    reviews: list[Review],
+    errors: list[str] | None = None,
+    *,
+    requested: int | None = None,
+    quorum: int | None = None,
+    panel_id: str | None = None,
+    requested_providers: int | None = None,
+) -> Verdict:
+    requested = requested if requested is not None else len(reviews)
+    quorum = quorum if quorum is not None else default_quorum(requested)
+
+    voters = [r for r in reviews if r.vote != Vote.ABSTAIN]
+    abstained = len(reviews) - len(voters)
+    if not voters:
+        return _empty(request, reviews, errors, requested, quorum, panel_id)
+
+    n = len(voters)
+    up = sum(1 for r in voters if r.vote == Vote.APPROVE)
+    down = n - up
+    scores = [r.score for r in voters]
+    score = sum(scores) / n
+
+    consensus = max(up, down) / n
+    providers = {r.provider for r in voters}
+    diversity = len(providers) / n
+
+    panel_factor = n / (n + 1)  # 1 voter -> 0.5, 3 -> 0.75, 5 -> 0.83
+    spread_factor = 1 - (max(scores) - min(scores)) / 10  # identical scores -> 1.0
+    diversity_factor = 0.5 + 0.5 * diversity  # all one provider (n=3) -> 0.67; all distinct -> 1.0
+    confidence = round(consensus * panel_factor * spread_factor * diversity_factor, 3)
+
+    blocking_reviews = [r for r in voters if r.blocking]
+    blocking_providers = {r.provider for r in blocking_reviews}
+    independent_blocks = len(blocking_providers) >= 2 or (len(providers) == 1 and len(blocking_reviews) >= 2)
+
+    # A multi-provider panel that only heard from one provider has lost the
+    # independence it was built for, so it cannot reach a verdict.
+    wanted_providers = requested_providers if requested_providers is not None else len(providers)
+    provider_floor = min(2, wanted_providers)
+
+    if n < quorum or len(providers) < provider_floor:
+        status = "insufficient_jury"
+    elif independent_blocks:
+        status = "blocked"
+    elif blocking_reviews or up <= down:
+        status = "needs_revision"
+    else:
+        status = "verified"
+
+    return Verdict(
+        request_id=request.request_id,
+        panel_id=panel_id,
+        requested=requested,
+        responded=len(reviews),
+        abstained=abstained,
+        quorum=quorum,
+        task_type=request.task_type,
+        domain=request.domain,
+        producer=request.producer,
+        up=up,
+        down=down,
+        score=round(score, 2),
+        consensus=round(consensus, 3),
+        diversity=round(diversity, 3),
+        confidence=confidence,
+        status=status,
+        reviews=reviews,
+        errors=errors or [],
+    )