devlyn-cli 2.9.3 → 2.10.1

package/config/skills/_shared/verify-merge-findings.py

@@ -41,6 +41,7 @@ ALLOWED_PAIR_SKIP_REASONS = {
     "auto_pair_other_engine_unavailable",
 }
 KNOWN_PAIR_TRIGGER_REASONS = {
+    "pair.default",
     "mode.verify-only",
     "mode.pair-verify",
     "complexity.high",
@@ -109,6 +110,10 @@ def all_known_pair_trigger_reasons(reasons: list[str]) -> bool:
     return all(is_known_pair_trigger_reason(reason) for reason in reasons)
 
 
+def state_uses_default_pair_contract(state: dict[str, Any]) -> bool:
+    return state.get("version") == "3.0"
+
+
 def finding_rank(finding: dict[str, Any]) -> int:
     severity = str(finding.get("severity") or "").upper()
     if severity in {"CRITICAL", "HIGH"}:
@@ -164,6 +169,44 @@ def read_findings(devlyn: pathlib.Path) -> tuple[list[dict[str, Any]], dict[str,
                     source_verdicts[source], RANK_VERDICT[finding_rank(item)]
                 )
     findings.extend(detect_pair_stdout_contract_violations(devlyn, source_verdicts))
+    pair_summary_path = devlyn / "pair-judge.summary.json"
+    pair_carrier_exists = any(
+        (devlyn / name).is_file()
+        for name in ("verify.pair.findings.jsonl", "verify.pair-judge.findings.jsonl")
+    )
+    if pair_carrier_exists and pair_summary_path.is_file():
+        try:
+            pair_summary = loads_strict_json(pair_summary_path.read_text(encoding="utf-8"))
+        except ValueError as exc:
+            summary_error = f"pair-judge.summary.json is malformed JSON: {exc}"
+        else:
+            pair_verdict = pair_summary.get("verdict") if isinstance(pair_summary, dict) else None
+            summary_error = None
+            if not isinstance(pair_summary, dict):
+                summary_error = "pair-judge.summary.json must be a JSON object."
+            elif not isinstance(pair_verdict, str) or pair_verdict not in {
+                "PASS", "PASS_WITH_ISSUES", "FAIL", "NEEDS_WORK", "BLOCKED"
+            }:
+                summary_error = (
+                    "pair-judge.summary.json verdict must be PASS, PASS_WITH_ISSUES, "
+                    "FAIL, NEEDS_WORK, or BLOCKED."
+                )
+        if summary_error is not None:
+            findings.append(
+                pair_blocker(
+                    "verify-pair-summary-invalid",
+                    summary_error,
+                    pair_summary_path.name,
+                )
+            )
+            source_verdicts["pair_judge"] = "BLOCKED"
+        elif (
+            source_verdicts["pair_judge"] != "TIMEOUT"
+            or rank(pair_verdict) > rank("TIMEOUT")
+        ):
+            source_verdicts["pair_judge"] = worse(
+                source_verdicts["pair_judge"], pair_verdict
+            )
     return findings, source_verdicts
 
 
@@ -338,6 +381,63 @@ def risk_profile_contract_violation(devlyn: pathlib.Path) -> dict[str, Any] | No
     return None
 
 
+def verify_state_contract_violation(devlyn: pathlib.Path) -> dict[str, Any] | None:
+    state_path = devlyn / "pipeline.state.json"
+    if not state_path.is_file():
+        return None
+    try:
+        state = loads_strict_json(state_path.read_text(encoding="utf-8"))
+    except ValueError:
+        return None
+    if not isinstance(state, dict) or not state_uses_default_pair_contract(state):
+        return None
+    source = state.get("source")
+    if not isinstance(source, dict) or source.get("type") != "generated":
+        return None
+    goal_path = source.get("goal_path")
+    goal_sha256 = source.get("goal_sha256")
+    if (
+        not isinstance(goal_path, str)
+        or not goal_path
+        or not isinstance(goal_sha256, str)
+        or re.fullmatch(r"[0-9a-f]{64}", goal_sha256) is None
+    ):
+        rule = "verify.state.goal-persistence-missing"
+        return {
+            "id": rule,
+            "rule_id": rule,
+            "message": (
+                "schema-v3 generated runs require source.goal_path as a non-empty string "
+                "and source.goal_sha256 as 64 lowercase hexadecimal characters."
+            ),
+            "file": "pipeline.state.json",
+        }
+    if state.get("complexity") in {"trivial", "medium"}:
+        phases = state.get("phases")
+        surface_close = phases.get("surface_close") if isinstance(phases, dict) else None
+        skipped = (
+            isinstance(surface_close, dict)
+            and surface_close.get("verdict") is None
+            and surface_close.get("started_at") is None
+            and surface_close.get("skipped_reason") == "auto_surface_close_claude_unavailable"
+        )
+        if (
+            not isinstance(surface_close, dict)
+            or (surface_close.get("verdict") is None and not skipped)
+        ):
+            rule = "verify.state.surface-close-skipped"
+            return {
+                "id": rule,
+                "rule_id": rule,
+                "message": (
+                    "schema-v3 generated trivial/medium runs require completed SURFACE_CLOSE "
+                    "or its canonical automatic Claude-unavailable skip before VERIFY merge."
+                ),
+                "file": "pipeline.state.json",
+            }
+    return None
+
+
 def source_spec_text(state: dict[str, Any]) -> str | None:
     source = state.get("source") if isinstance(state.get("source"), dict) else {}
     for key in ("spec_path", "criteria_path"):
@@ -424,6 +524,11 @@ def state_pair_trigger_reasons(
     verify_state = state.get("verify") if isinstance(state.get("verify"), dict) else {}
     risk_profile = state.get("risk_profile") if isinstance(state.get("risk_profile"), dict) else {}
     reasons: list[str] = []
+    if (
+        state_uses_default_pair_contract(state)
+        and risk_profile.get("pair_default_enabled") is not False
+    ):
+        reasons.append("pair.default")
     if state.get("mode") == "verify-only":
         reasons.append("mode.verify-only")
     if state.get("pair_verify") is True:
@@ -455,11 +560,19 @@ def state_pair_trigger_reasons(
     return reasons
 
 
+def outcome_independent_reasons(devlyn: pathlib.Path) -> list[str]:
+    return [
+        reason
+        for reason in state_pair_trigger_reasons(devlyn, {})
+        if reason not in ("coverage.failed", "mechanical.warning", "judge.warning")
+    ]
+
+
 def pair_trigger_missing_contract_violation(
     devlyn: pathlib.Path,
     source_verdicts: dict[str, str | None],
 ) -> dict[str, Any] | None:
-    if rank(source_verdicts.get("mechanical")) >= 2 or rank(source_verdicts.get("judge")) >= 2:
+    if rank(source_verdicts.get("mechanical")) >= 2:
         return None
     reasons = state_pair_trigger_reasons(devlyn, source_verdicts)
     if not reasons:
@@ -558,15 +671,36 @@ def pair_trigger_skip_contract_violation(
             ),
             "file": "pipeline.state.json",
         }
-    if skipped_reason == "primary_judge_blocker" and rank(source_verdicts.get("judge")) < 2:
-        return {
-            "id": "verify-pair-trigger-primary-judge-blocker-unsupported",
-            "message": (
-                "pair_trigger skipped_reason primary_judge_blocker requires a "
-                "verdict-binding primary JUDGE finding."
-            ),
-            "file": "pipeline.state.json",
-        }
+    if skipped_reason == "primary_judge_blocker":
+        if state_uses_default_pair_contract(state):
+            return {
+                "id": "verify-pair-trigger-primary-judge-blocker-retired",
+                "message": (
+                    "pair_trigger skipped_reason primary_judge_blocker is archived-v2.0 "
+                    "state only; schema-v3 runs must dispatch the pair-JUDGE."
+                ),
+                "file": "pipeline.state.json",
+            }
+        if rank(source_verdicts.get("judge")) < 2:
+            return {
+                "id": "verify-pair-trigger-primary-judge-blocker-unsupported",
+                "message": (
+                    "pair_trigger skipped_reason primary_judge_blocker requires a "
+                    "verdict-binding primary JUDGE finding."
+                ),
+                "file": "pipeline.state.json",
+            }
+        preknown_reasons = outcome_independent_reasons(devlyn)
+        if preknown_reasons:
+            return {
+                "id": "verify-pair-trigger-primary-judge-blocker-preknown",
+                "message": (
+                    "pair_trigger cannot skip the pair-JUDGE for a primary JUDGE blocker "
+                    "when outcome-independent reasons applied at spawn: "
+                    + ", ".join(preknown_reasons)
+                ),
+                "file": "pipeline.state.json",
+            }
     return None
 
 
@@ -574,7 +708,7 @@ def pair_trigger_reason_completeness_violation(
     devlyn: pathlib.Path,
     source_verdicts: dict[str, str | None],
 ) -> dict[str, Any] | None:
-    if rank(source_verdicts.get("mechanical")) >= 2 or rank(source_verdicts.get("judge")) >= 2:
+    if rank(source_verdicts.get("mechanical")) >= 2:
         return None
     state_path = devlyn / "pipeline.state.json"
     if not state_path.is_file():
@@ -614,10 +748,15 @@ def pair_trigger_reason_completeness_violation(
     }
 
 
-def pair_blocker(id_: str, message: str, file_: str | None = None) -> dict[str, Any]:
+def pair_blocker(
+    id_: str,
+    message: str,
+    file_: str | None = None,
+    rule_id: str = "verify.pair.emission-contract",
+) -> dict[str, Any]:
     return {
         "id": id_,
-        "rule_id": "verify.pair.emission-contract",
+        "rule_id": rule_id,
         "severity": "CRITICAL",
         "confidence": "high",
         "file": file_,
@@ -715,6 +854,17 @@ def detect_pair_stdout_contract_violations(
                 risk_profile_violation["file"],
             )
         ]
+    state_violation = verify_state_contract_violation(devlyn)
+    if state_violation is not None:
+        source_verdicts["pair_judge"] = "BLOCKED"
+        return [
+            pair_blocker(
+                state_violation["id"],
+                state_violation["message"],
+                state_violation["file"],
+                state_violation["rule_id"],
+            )
+        ]
     if not required and not pair_trigger_present(devlyn):
         missing_violation = pair_trigger_missing_contract_violation(devlyn, source_verdicts)
         if missing_violation is not None:
@@ -892,7 +1042,15 @@ def self_test() -> int:
         # the real shape write_state() sees on every VERIFY completion, not
         # the pre-populated {} the other scenarios below seed for brevity.
         (devlyn / "pipeline.state.json").write_text(
-            json.dumps({"phases": {"verify": {"verdict": None, "sub_verdicts": None}}}),
+            json.dumps({
+                "phases": {
+                    "verify": {
+                        "verdict": None,
+                        "sub_verdicts": None,
+                        "judge_durations_ms": {"judge": 23, "pair_judge": 31},
+                    }
+                }
+            }),
             encoding="utf-8",
         )
         (devlyn / "verify.findings.jsonl").write_text("", encoding="utf-8")
@@ -904,13 +1062,130 @@ def self_test() -> int:
         assert state["phases"]["verify"]["sub_verdicts"] == {
             "mechanical": "PASS", "judge": "PASS", "pair_judge": None,
         }, state
+        assert state["phases"]["verify"]["judge_durations_ms"] == {
+            "judge": 23, "pair_judge": 31,
+        }, state
+
+        # iter-0072 Amendment 3: generated schema-v3 runs mechanically prove
+        # raw-goal persistence and required SURFACE_CLOSE dispatch.
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "3.0",
+                "complexity": "large",
+                "source": {"type": "generated"},
+                "phases": {"verify": {"verdict": None, "sub_verdicts": None}},
+            }),
+            encoding="utf-8",
+        )
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "BLOCKED", summary
+        assert summary["source_verdicts"]["pair_judge"] == "BLOCKED", summary
+        assert any(
+            finding.get("rule_id") == "verify.state.goal-persistence-missing"
+            for finding in findings
+        ), findings
+
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "3.0",
+                "complexity": "large",
+                "source": {"type": "generated", "goal_path": "", "goal_sha256": "A" * 64},
+            }),
+            encoding="utf-8",
+        )
+        violation = verify_state_contract_violation(devlyn)
+        assert violation is not None, violation
+        assert violation["rule_id"] == "verify.state.goal-persistence-missing", violation
+
+        generated_source = {
+            "type": "generated",
+            "goal_path": ".devlyn/goal.raw.txt",
+            "goal_sha256": "a" * 64,
+        }
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "3.0",
+                "complexity": "medium",
+                "source": generated_source,
+                "phases": {
+                    "surface_close": None,
+                    "verify": {"verdict": None, "sub_verdicts": None},
+                },
+            }),
+            encoding="utf-8",
+        )
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "BLOCKED", summary
+        assert any(
+            finding.get("rule_id") == "verify.state.surface-close-skipped"
+            for finding in findings
+        ), findings
+
+        for surface_entry in (
+            {"verdict": "PASS"},
+            {
+                "verdict": None,
+                "started_at": None,
+                "skipped_reason": "auto_surface_close_claude_unavailable",
+            },
+        ):
+            (devlyn / "pipeline.state.json").write_text(
+                json.dumps({
+                    "version": "3.0",
+                    "complexity": "medium",
+                    "source": generated_source,
+                    "phases": {"surface_close": surface_entry},
+                }),
+                encoding="utf-8",
+            )
+            assert verify_state_contract_violation(devlyn) is None
+
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "3.0",
+                "complexity": "medium",
+                "source": generated_source,
+                "phases": {
+                    "surface_close": {
+                        "verdict": None,
+                        "started_at": None,
+                        "skipped_reason": "claude-unavailable",
+                    },
+                },
+            }),
+            encoding="utf-8",
+        )
+        assert verify_state_contract_violation(devlyn)["rule_id"] == "verify.state.surface-close-skipped"
+
+        for state_shape in (
+            {
+                "version": "3.0", "complexity": "medium",
+                "source": {"type": "spec"}, "phases": {"surface_close": None},
+            },
+            {
+                "version": "3.0", "complexity": "large",
+                "source": generated_source, "phases": {"surface_close": None},
+            },
+            {
+                "version": "2.0", "complexity": "medium",
+                "source": {"type": "generated"}, "phases": {"surface_close": None},
+            },
+        ):
+            (devlyn / "pipeline.state.json").write_text(
+                json.dumps(state_shape), encoding="utf-8",
+            )
+            assert verify_state_contract_violation(devlyn) is None
 
         # 2026-07-04 field bug (iter-0060 G1): an AUTO pair trigger skipped on
         # OTHER-engine unavailability spawns no second judge — pair_judge must
         # be recorded null, never a synthesized PASS.
         (devlyn / "pipeline.state.json").write_text(
             json.dumps({
+                "version": "3.0",
                 "mode": "spec",
+                "risk_profile": {"pair_default_enabled": True},
                 "phases": {
                     "verify": {
                         "verdict": None,
@@ -1936,18 +2211,128 @@ def self_test() -> int:
             for finding in findings
         ), findings
 
+        # Self-test: preknown_primary_blocker_requires_pair.
+        (devlyn / "verify.pair.findings.jsonl").unlink(missing_ok=True)
         (devlyn / "verify.findings.jsonl").write_text(
-            json.dumps({"id": "j2", "severity": "HIGH"}) + "\n",
+            json.dumps({"id": "j-preknown", "severity": "HIGH"}) + "\n",
+            encoding="utf-8",
+        )
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "2.0",
+                "mode": "spec",
+                "pair_verify": True,
+                "phases": {
+                    "verify": {
+                        "verdict": "PASS",
+                        "sub_verdicts": {},
+                        "pair_trigger": {
+                            "eligible": False,
+                            "reasons": [],
+                            "skipped_reason": "primary_judge_blocker",
+                        },
+                    }
+                },
+            }),
+            encoding="utf-8",
+        )
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "BLOCKED", summary
+        assert any(
+            finding.get("id") == "verify-pair-trigger-primary-judge-blocker-preknown"
+            and "mode.pair-verify" in str(finding.get("message"))
+            for finding in findings
+        ), findings
+
+        # Self-test: schema-v3 default pair reason is required before merge.
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "3.0",
+                "mode": "spec",
+                "pair_verify": True,
+                "phases": {
+                    "verify": {
+                        "verdict": "PASS",
+                        "sub_verdicts": {},
+                        "pair_trigger": {
+                            "eligible": True,
+                            "reasons": ["mode.pair-verify"],
+                            "skipped_reason": None,
+                        },
+                    }
+                },
+            }),
+            encoding="utf-8",
+        )
+        (devlyn / "verify.pair.findings.jsonl").write_text(
+            json.dumps({"id": "p-preknown", "severity": "LOW"}) + "\n",
+            encoding="utf-8",
+        )
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "BLOCKED", summary
+        assert any(
+            finding.get("id") == "verify-pair-trigger-reasons-incomplete"
+            and "pair.default" in str(finding.get("message"))
+            for finding in findings
+        ), findings
+        state = loads_strict_json((devlyn / "pipeline.state.json").read_text(encoding="utf-8"))
+        state["phases"]["verify"]["pair_trigger"]["reasons"].insert(0, "pair.default")
+        (devlyn / "pipeline.state.json").write_text(json.dumps(state), encoding="utf-8")
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "NEEDS_WORK", summary
+        assert summary["source_verdicts"]["judge"] == "NEEDS_WORK", summary
+        assert summary["source_verdicts"]["pair_judge"] == "PASS_WITH_ISSUES", summary
+        assert '"id":"p-preknown"' in (
+            devlyn / "verify-merged.findings.jsonl"
+        ).read_text(encoding="utf-8"), findings
+
+        # Self-test: archived-v2 sequential primary blocker remains legal.
+        (devlyn / "verify.pair.findings.jsonl").unlink()
+        (devlyn / "pipeline.state.json").write_text(
+            json.dumps({
+                "version": "2.0",
+                "mode": "spec",
+                "phases": {
+                    "verify": {
+                        "verdict": "PASS",
+                        "sub_verdicts": {},
+                        "pair_trigger": {
+                            "eligible": False,
+                            "reasons": [],
+                            "skipped_reason": "primary_judge_blocker",
+                        },
+                    }
+                },
+            }),
             encoding="utf-8",
         )
         findings, source_verdicts = read_findings(devlyn)
         summary = write_outputs(devlyn, findings, source_verdicts)
         assert summary["verdict"] == "NEEDS_WORK", summary
+        assert summary["source_verdicts"]["pair_judge"] is None, summary
         assert not any(
-            finding.get("id") == "verify-pair-trigger-primary-judge-blocker-unsupported"
+            finding.get("id") in {
+                "verify-pair-trigger-primary-judge-blocker-unsupported",
+                "verify-pair-trigger-primary-judge-blocker-preknown",
+            }
+            for finding in findings
+        ), findings
+        # Replay the same state as schema v3 and require the retired-skip blocker.
+        state = loads_strict_json((devlyn / "pipeline.state.json").read_text(encoding="utf-8"))
+        state["version"] = "3.0"
+        (devlyn / "pipeline.state.json").write_text(json.dumps(state), encoding="utf-8")
+        findings, source_verdicts = read_findings(devlyn)
+        summary = write_outputs(devlyn, findings, source_verdicts)
+        assert summary["verdict"] == "BLOCKED", summary
+        assert any(
+            finding.get("id") == "verify-pair-trigger-primary-judge-blocker-retired"
             for finding in findings
         ), findings
         (devlyn / "verify.findings.jsonl").write_text("", encoding="utf-8")
+        (devlyn / "verify.pair.findings.jsonl").write_text("", encoding="utf-8")
 
         (devlyn / "pipeline.state.json").write_text(
             json.dumps({
@@ -1984,6 +2369,138 @@ def self_test() -> int:
         state = loads_strict_json((devlyn / "pipeline.state.json").read_text(encoding="utf-8"))
         assert summary["verdict"] == "PASS", summary
         assert state["phases"]["verify"]["sub_verdicts"]["pair_judge"] == "PASS", state
+
+        # iter-0083: canonical summary verdict conservation.
+        iter_0083_paths = (
+            "pipeline.state.json",
+            "verify-mechanical.findings.jsonl",
+            "verify.findings.jsonl",
+            "verify.pair.findings.jsonl",
+            "verify.pair-judge.findings.jsonl",
+            "pair-judge.summary.json",
+            "codex-primary-judge.summary.json",
+            "grok-judge.summary.json",
+            "verify.pair.timeout.json",
+            "codex-judge.stdout",
+            "claude-judge.stdout",
+        )
+
+        def iter_0083_reset() -> None:
+            for name in iter_0083_paths:
+                (devlyn / name).unlink(missing_ok=True)
+
+        def iter_0083_case(
+            summary_payload: object | None,
+            severity: str | None,
+            *,
+            carrier: str | None = "verify.pair.findings.jsonl",
+            other_summary: str | None = None,
+            timeout: bool = False,
+        ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+            iter_0083_reset()
+            if carrier is not None:
+                content = (
+                    json.dumps({"id": "iter-0083", "severity": severity}) + "\n"
+                    if severity
+                    else ""
+                )
+                (devlyn / carrier).write_text(content, encoding="utf-8")
+            if summary_payload is not None:
+                content = (
+                    summary_payload
+                    if isinstance(summary_payload, str)
+                    else json.dumps(summary_payload)
+                )
+                (devlyn / "pair-judge.summary.json").write_text(content, encoding="utf-8")
+            if other_summary is not None:
+                (devlyn / other_summary).write_text(
+                    json.dumps({"verdict": "BLOCKED"}), encoding="utf-8"
+                )
+            if timeout:
+                (devlyn / "verify.pair.timeout.json").write_text(
+                    json.dumps({"engine": "claude", "budget_seconds": 600}),
+                    encoding="utf-8",
+                )
+            case_findings, case_source_verdicts = read_findings(devlyn)
+            return case_findings, write_outputs(devlyn, case_findings, case_source_verdicts)
+
+        for case_id, verdict, severity, expected in (
+            ("P1", "NEEDS_WORK", "INFO", "NEEDS_WORK"),
+            ("P2", "NEEDS_WORK", "LOW", "NEEDS_WORK"),
+            ("P3", "NEEDS_WORK", "MEDIUM", "NEEDS_WORK"),
+            ("P4", "PASS", "HIGH", "NEEDS_WORK"),
+            ("P5", "BLOCKED", "INFO", "BLOCKED"),
+            ("P6", "FAIL", "INFO", "NEEDS_WORK"),
+            ("P7", "PASS", None, "PASS"),
+        ):
+            _, summary = iter_0083_case({"verdict": verdict}, severity)
+            assert summary["source_verdicts"]["pair_judge"] == expected, case_id
+            assert summary["verdict"] == expected, case_id
+
+        for case_id, severity, expected in (
+            ("P8-INFO", "INFO", "PASS"),
+            ("P8-LOW", "LOW", "PASS_WITH_ISSUES"),
+        ):
+            _, summary = iter_0083_case(None, severity)
+            assert summary["source_verdicts"]["pair_judge"] == expected, case_id
+            assert summary["verdict"] == expected, case_id
+
+        def assert_iter_0083_blocked(
+            case_id: str,
+            case_findings: list[dict[str, Any]],
+            summary: dict[str, Any],
+        ) -> None:
+            assert summary["source_verdicts"]["pair_judge"] == "BLOCKED", case_id
+            assert summary["verdict"] == "BLOCKED", case_id
+            assert any(
+                finding.get("source") == "pair_judge"
+                and finding.get("severity") == "CRITICAL"
+                and finding.get("file") == "pair-judge.summary.json"
+                for finding in case_findings
+            ), case_id
+
+        for case_id, payload in (
+            ("N1-malformed", "{"),
+            ("N1-non-object", []),
+            ("N1-unknown", {"verdict": "UNKNOWN"}),
+            ("N2", {}),
+            ("N7", {"verdict": "TIMEOUT"}),
+        ):
+            case_findings, summary = iter_0083_case(payload, "INFO")
+            assert_iter_0083_blocked(case_id, case_findings, summary)
+
+        _, summary = iter_0083_case({"verdict": "BLOCKED"}, None, carrier=None)
+        assert summary["source_verdicts"]["pair_judge"] is None, summary
+        assert summary["verdict"] == "PASS", summary
+
+        _, summary = iter_0083_case(
+            {"verdict": "PASS"},
+            "INFO",
+            other_summary="codex-primary-judge.summary.json",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "PASS", "N4"
+        assert summary["verdict"] == "PASS", "N4"
+
+        _, summary = iter_0083_case(
+            None,
+            "INFO",
+            other_summary="grok-judge.summary.json",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "PASS", "N5"
+        assert summary["verdict"] == "PASS", "N5"
+
+        _, summary = iter_0083_case(
+            {"verdict": "NEEDS_WORK"},
+            "INFO",
+            carrier="verify.pair-judge.findings.jsonl",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "NEEDS_WORK", "N6"
+        assert summary["verdict"] == "NEEDS_WORK", "N6"
+
+        case_findings, summary = iter_0083_case({"verdict": "BLOCKED"}, None, timeout=True)
+        assert case_findings == [], "VERIFY-JUDGE-001"
+        assert summary["source_verdicts"]["pair_judge"] == "BLOCKED", "VERIFY-JUDGE-001"
+        assert summary["verdict"] == "BLOCKED", "VERIFY-JUDGE-001"
     return 0