let an operator's adjudication reach the score

The review vocabulary already separates a model error from a reference gap,
because the product's position is that official footprints are not
automatically perfect ground truth. Those verdicts were only counted. An
operator who inspected forty false positives and established that twelve are
buildings the reference simply lacks still saw a precision counting all forty
against the model — a number they had personally disproved, on the panel where
they disproved it.

Applying the verdicts gives an adjudicated score reported next to the raw one,
so nothing is quietly improved. Not being able to judge is not evidence in the
model's favour, so uncertain and obscured verdicts keep counting, as does a
decision from a later release that this runtime does not recognise.

Because part of the evidence is usually still unreviewed, the honest form is an
interval rather than a single corrected number: pessimistic assumes every
unreviewed finding is a model error, optimistic assumes none is, and the
headline equals the pessimistic reading so a partly reviewed check never
presents as a settled one.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

backend/app/services/detection_review_service.py

@@ -7,6 +7,7 @@ from uuid import UUID
 from sqlalchemy.orm import Session
 
 from app.core.errors import AppError
+from app.services.reviewed_metrics_service import ReviewedMetricsService
 from app.models import Detection, DetectionReview, QualityCheck, VectorFeature
 from app.schemas.detection_review import (
     DetectionReviewList,
@@ -80,7 +81,11 @@ class DetectionReviewService:
         return {(row.evidence_role, row.evidence_feature_id): row for row in rows}
 
     @staticmethod
-    def _summary(evidence: list[dict[str, str]], reviews: dict[tuple[str, str], DetectionReview]) -> DetectionReviewSummary:
+    def _summary(
+        evidence: list[dict[str, str]],
+        reviews: dict[tuple[str, str], DetectionReview],
+        quality_check: QualityCheck | None = None,
+    ) -> DetectionReviewSummary:
         evidence_keys = {(item["evidence_role"], item["evidence_feature_id"]) for item in evidence}
         decisions = Counter(
             reviews[key].decision if key in reviews else "unreviewed"
@@ -96,6 +101,43 @@ class DetectionReviewService:
             false_positive_total=false_positive_total,
             false_negative_total=false_negative_total,
             decision_counts=dict(sorted(decisions.items())),
+            reviewed_metrics=DetectionReviewService._reviewed_metrics(evidence_keys, reviews, quality_check),
+        )
+
+    @staticmethod
+    def _reviewed_metrics(
+        evidence_keys: set[tuple[str, str]],
+        reviews: dict[tuple[str, str], DetectionReview],
+        quality_check: QualityCheck | None,
+    ) -> dict | None:
+        """The score with the operator's verdicts applied.
+
+        Without this the panel shows a precision the operator has already
+        disproved: a false positive adjudicated as a reference gap is not the
+        model's error, and the raw number keeps counting it as one.
+        """
+
+        if quality_check is None:
+            return None
+        findings = quality_check.findings_json if isinstance(quality_check.findings_json, dict) else {}
+        matches = findings.get("matches")
+        false_positives = findings.get("false_positives")
+        false_negatives = findings.get("false_negatives")
+        if not all(isinstance(value, int) for value in (matches, false_positives, false_negatives)):
+            return None
+
+        per_role: dict[str, Counter] = {"false_positive": Counter(), "false_negative": Counter()}
+        for role, feature_id in evidence_keys:
+            review = reviews.get((role, feature_id))
+            if review is not None and role in per_role:
+                per_role[role][review.decision] += 1
+
+        return ReviewedMetricsService.adjudicate(
+            matches=int(matches),
+            false_positives=int(false_positives),
+            false_negatives=int(false_negatives),
+            false_positive_decisions=dict(per_role["false_positive"]),
+            false_negative_decisions=dict(per_role["false_negative"]),
         )
 
     @staticmethod
@@ -180,7 +222,7 @@ class DetectionReviewService:
             total=len(filtered),
             limit=limit,
             offset=offset,
-            summary=DetectionReviewService._summary(evidence, reviews),
+            summary=DetectionReviewService._summary(evidence, reviews, quality_check),
         )
 
     @staticmethod