okstra 0.186.7 → 0.187.0

package/runtime/python/okstra_ctl/convergence_engine.py

@@ -12,7 +12,7 @@ from .execution_identity import ExecutionManifest
 WORKING_SCHEMA_VERSION = "1.0"
 V2_WORKING_SCHEMA_VERSION = "2.0"
 EXECUTION_IDENTITY_VERSION = 2
-FINAL_SCHEMA_VERSION = "1.3"
+FINAL_SCHEMA_VERSION = "1.4"
 _AUDIENCES = {"analysis", "lead", "report-writer"}
 # 발견을 낼 수 있는 audience. 리드는 계약상 Phase 6 자체 리뷰를 수행하므로
 # 출처가 될 수 있지만, 교차검증 표는 아니다 — 합의 수는 아래에서 분석 워커만
@@ -25,17 +25,29 @@ _AUDIENCE_SOURCE_ROLES = {
     "report-writer": frozenset({"report-writer"}),
 }
 _VERIFICATION_MODES = {"lightweight", "full-reanalysis"}
+# `unverified` 가 없던 시절의 산출물. `reuse-final` 이 그대로 읽으므로 그
+# 어휘로 검증한다 — 없던 키를 요구하면 이미 디스크에 있는 리포트가 무효가 된다.
+_HISTORICAL_FINAL_VERSIONS = frozenset({"1.0", "1.1", "1.2", "1.3"})
 _CLASSIFICATION_COUNT_KEYS = {
     "full-consensus": "fullConsensus",
     "partial-consensus": "partialConsensus",
     "contested": "contested",
     "worker-unique": "workerUnique",
+    # 아무도 판정하지 않은 finding. `contested` 와 정반대 상태다 — 하나는
+    # 동료가 보고 반박한 것이고 이것은 동료가 못 본 것이다. 같은 칸에
+    # 세면 워커가 다투지 않은 run 이 다툰 것으로 읽힌다.
+    "unverified": "unverified",
 }
 _VERDICTS = {"agree", "disagree", "supplement", "verification-error"}
 _INPUT_VERDICTS = _VERDICTS | {"unverifiable"}
 _DISAGREE_BASES = {"counter-evidence", "burden-not-met"}
 _DISPATCH_STATUSES = {"completed", "timeout", "error", "not-run"}
-_CRITIC_CLASSIFICATIONS = set(_CLASSIFICATION_COUNT_KEYS) | {"unverified"}
+_CRITIC_CLASSIFICATIONS = set(_CLASSIFICATION_COUNT_KEYS)
+# gap 전용 분류 하나. critic 이 스스로 "이건 F-NNN 과 같은 것" 이라고 선언한 gap
+# 이며, 검증 라운드에 들어가지 않으므로 표가 없다. finding 분류에 넣으면
+# `finalClassificationCounts` 에 대응하는 칸이 없는 값이 생긴다.
+_CRITIC_DUPLICATE = "duplicate"
+_CRITIC_GAP_CLASSIFICATIONS = _CRITIC_CLASSIFICATIONS | {_CRITIC_DUPLICATE}
 _FINAL_V13_KEYS = {
     "schemaVersion",
     "taskKey",
@@ -49,6 +61,16 @@ _FINAL_V13_KEYS = {
     "criticVerification",
     "unverifiedGaps",
 }
+# 게이트가 닫힌 계획에 실리는 문구. 계획의 `round` 는 산출물 이름
+# (`convergence-round-<N>-plan-...`)의 순번이라 finalize 계획에도 값이 있고,
+# 리드가 그것을 "다음 디스패치 라운드"로 읽어 워커를 띄우면 `apply_round_results`
+# 에서 막힌다. 계획 자체가 다음 명령을 말하게 해 그 오독을 없앤다.
+FINALIZE_PLAN_NOTE = (
+    "the round gate closed: this plan is a finalize instruction, not a "
+    "dispatch round. Dispatch no reverify worker; run "
+    "`okstra convergence apply-critic-gaps` when the coverage critic is "
+    "enabled, then `okstra convergence finalize`."
+)
 
 
 class ConvergenceContractError(ValueError):
@@ -118,7 +140,6 @@ def seed_working_state(
         source.get("groups"),
         analysis_workers,
         finding_sources,
-        adversarial=config["adversarial"],
     )
     state["findings"] = findings
     state["queueFindingIds"] = queue
@@ -159,14 +180,20 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
         reason = "queue-empty"
     elif len(history) >= effective_max:
         reason = "max-rounds-reached"
+    # `round` 는 계획 산출물 이름의 `<N>` 이다. finalize 계획에도 이름이 필요해
+    # 값을 그대로 남기되, `dispatchable` 로 이 계획이 디스패치용인지 아닌지를
+    # 한 필드에서 읽히게 한다 — 두 액션 모두에 실어야 `dispatchable` 부재를
+    # false 로 오독하는 소비자가 생기지 않는다.
     round_number = len(history) + 1
     if reason is not None:
         return {
             "schemaVersion": WORKING_SCHEMA_VERSION,
             "action": "finalize",
             "round": round_number,
+            "dispatchable": False,
             "inputQueueSize": len(queue),
             "reason": reason,
+            "note": FINALIZE_PLAN_NOTE,
             "dispatches": [],
             "skippedWorkers": [],
         }
@@ -180,15 +207,11 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
         if not isinstance(worker, Mapping) or worker.get("audience") != "analysis":
             continue
         worker_id = _required_string(worker, "workerId", "working state worker")
-        worker_participant_ref = _worker_participant_ref(worker)
         eligible = [
             finding_id
             for finding_id in queue
             if _worker_is_independent_from_finding(
-                worker_id,
-                worker_participant_ref,
-                findings[finding_id],
-                workers,
+                worker, findings[finding_id], workers
             )
         ]
         if eligible:
@@ -209,6 +232,7 @@ def plan_next_round(state: Mapping[str, Any]) -> dict[str, Any]:
         "schemaVersion": WORKING_SCHEMA_VERSION,
         "action": "dispatch",
         "round": round_number,
+        "dispatchable": True,
         "inputQueueSize": len(queue),
         "dispatches": dispatches,
         "skippedWorkers": skipped,
@@ -221,14 +245,28 @@ def _worker_participant_ref(worker: Mapping[str, Any]) -> str | None:
 
 
 def _worker_is_independent_from_finding(
-    worker_id: str,
-    participant_ref: str | None,
+    worker: Mapping[str, Any],
     finding: Mapping[str, Any],
     workers: list[Any],
 ) -> bool:
+    """이 워커가 그 finding 의 원저자가 아닌가.
+
+    비교 기준은 role execution 이다 — participant(공급자+모델 세션)가 아니다.
+    ADR-0017 이 정하듯 공급자와 모델은 역할의 정체성이 아니고, 같은 모델이 두
+    역할에 배정되면 두 개의 독립된 워커가 된다. 저자와 검증자는 서로 다른 역할
+    계약·다른 duty·다른 세션이므로, 모델 이름이 같다는 이유로 검증에서 빼면
+    패널이 근거 없이 줄어든다 — 같은 doctrine 이 critic gap 에 대해서는 이미
+    `prompts/lead/convergence.md` §"Critic gaps" 에 적혀 있다.
+
+    `sourceRoleExecutionRef` 는 `participantRef` + `role` 로 유일하고
+    (`execution_manifest._validate_roles`), 워커마다 하나씩 검증된다
+    (`_validate_v2_workers` 의 duplicate 검사). v1 상태에는 그 필드가 없으므로
+    그때만 workerId 로 떨어진다.
+    """
     origin_worker = finding.get("originWorker")
-    if participant_ref is None:
-        return origin_worker != worker_id
+    source_ref = worker.get("sourceRoleExecutionRef")
+    if not isinstance(source_ref, str) or not source_ref:
+        return origin_worker != worker.get("workerId")
     origin = next(
         (
             row
@@ -237,10 +275,10 @@ def _worker_is_independent_from_finding(
         ),
         None,
     )
-    origin_participant_ref = (
-        _worker_participant_ref(origin) if origin is not None else None
+    origin_source_ref = (
+        origin.get("sourceRoleExecutionRef") if isinstance(origin, Mapping) else None
     )
-    return origin_participant_ref != participant_ref
+    return origin_source_ref != source_ref
 
 
 def _worker_execution_refs(worker: Mapping[str, Any]) -> dict[str, str]:
@@ -292,11 +330,15 @@ def classify_adversarial_round(
     if len(disagrees) == len(usable):
         return "worker-unique"
     if any(vote["disagreeBasis"] == "counter-evidence" for vote in disagrees):
-        return None
+        # 증거 기반 반증은 영구적이다 — 뒤 라운드의 동의가 그것을 지우지
+        # 못한다. 그러면 이 finding 을 다음 라운드로 넘겨도 검증자는 새 정보
+        # 없이 같은 표를 다시 던지고, 결과는 어차피 `contested` 다. 그 자리에서
+        # 종결해 재디스패치 비용을 0 으로 만든다.
+        return "contested"
     burden_count = sum(
         vote["disagreeBasis"] == "burden-not-met" for vote in disagrees
     )
-    if burden_count > len(usable) / 2:
+    if burden_count * 2 >= len(usable):
         return None
     return "partial-consensus"
 
@@ -315,7 +357,41 @@ def _round_has_counter_evidence(
 def _classify_adversarial_history(
     rounds: list[Mapping[str, Any]],
 ) -> str | None:
-    """Classify adversarial rounds without erasing earlier counter-evidence."""
+    """적대적 라운드 기록을 읽어 확정된 분류를 돌려준다.
+
+    분류를 낸 첫 라운드에서 멈춘다. `counter-evidence` 반증이 만드는
+    `contested` 도 그 라운드에서 종결이다 — 반증이 영구적이므로 다음 라운드는
+    같은 표를 다시 받을 뿐이다.
+
+    예외는 구 엔진이 남긴 상태 하나다. 구 엔진은 counter-evidence 를 마지막
+    라운드까지 끌고 갔고, 그 뒤로는 만장일치 반대(`worker-unique`)만 인정했다.
+    종결 라운드 뒤에도 이 finding 의 라운드 기록이 이어진다는 사실이 그 상태의
+    지문이다 — 현 엔진에서는 거기서 큐를 떠나므로 뒤 라운드가 생기지 않는다.
+    그때만 구 규칙으로 이어 읽어, 이미 기록된 세션을 소급해 실패시키지 않는다.
+    """
+    rows = [
+        row
+        for row in rounds
+        if isinstance(row, Mapping) and isinstance(row.get("votes"), Mapping)
+    ]
+    for index, row in enumerate(rows):
+        classification = classify_adversarial_round(row["votes"])
+        if classification is None:
+            continue
+        if classification == "contested" and index < len(rows) - 1:
+            return _legacy_adversarial_history(rows)
+        return classification
+    return None
+
+
+def _legacy_adversarial_history(
+    rounds: list[Mapping[str, Any]],
+) -> str | None:
+    """구 엔진의 적대적 분류 — 역호환 재생 전용.
+
+    counter-evidence 를 한 번 본 뒤로는 만장일치 반대만 분류를 확정했고, 그
+    외에는 계속 다음 라운드로 넘겨 finalize 가 `contested` 를 찍게 했다.
+    """
     counter_evidence_seen = False
     for row in rounds:
         votes = row.get("votes") if isinstance(row, Mapping) else None
@@ -342,7 +418,18 @@ def apply_round_results(
     expected_plan = plan_next_round(current)
     supplied_plan = _object(plan, "round plan")
     if expected_plan.get("action") != "dispatch":
-        raise ConvergenceContractError("working state has no dispatch round to apply")
+        # 예전 문구("no dispatch round to apply")는 상태를 말하지 않아서, 리드가
+        # finalize 계획의 `round` 를 디스패치 라운드로 읽고 워커를 띄운 뒤
+        # 여기서 막히면 무엇을 해야 하는지 알 수 없었다. 닫힌 사유와 다음 명령을
+        # 함께 낸다.
+        raise ConvergenceContractError(
+            "the round gate closed after round "
+            f"{len(current.get('roundHistory') or [])} "
+            f"(reason: {expected_plan.get('reason')}); the current plan is a "
+            "finalize instruction, not a dispatch round, and its `round` "
+            f"{expected_plan.get('round')} is only the artifact-name ordinal. "
+            "Dispatch nothing and run `okstra convergence finalize`."
+        )
     if supplied_plan != expected_plan:
         raise ConvergenceContractError("round plan does not match current working state")
     payload = _object(results, "round results")
@@ -469,6 +556,9 @@ def apply_critic_gap_results(
         gap["classification"] in {"contested", "worker-unique"}
         for gap in ledger_gaps
     )
+    duplicate = sum(
+        gap["classification"] == _CRITIC_DUPLICATE for gap in ledger_gaps
+    )
     updated["config"]["critic"] = {
         "provider": provider,
         "modelExecutionValue": model,
@@ -476,6 +566,9 @@ def apply_critic_gap_results(
         "gapsMerged": merged,
         "gapsRejected": rejected,
         "gapsUnverified": len(unverified),
+        # 선언된 중복은 제안됐으나 검증하지 않은 gap 이다. 넷 중 어느 칸에 넣어도
+        # 거짓이 된다 — 병합도 기각도 아니고, 판정을 못 받은 것도 아니다.
+        "gapsDuplicate": duplicate,
     }
     updated["unverifiedGaps"] = unverified
     updated_errors = validate_working_state(updated)
@@ -499,6 +592,9 @@ def finalize_working_state(state: Mapping[str, Any]) -> dict[str, Any]:
     for finding in findings:
         if finding["findingId"] not in queue:
             continue
+        if _received_no_verdict(finding):
+            finding["classification"] = "unverified"
+            continue
         finding["classification"] = (
             "contested"
             if adversarial
@@ -688,7 +784,7 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
     if not isinstance(state, Mapping):
         return ["final state must be an object"]
     version = state.get("schemaVersion")
-    if version not in {"1.0", "1.1", "1.2", FINAL_SCHEMA_VERSION}:
+    if version not in _HISTORICAL_FINAL_VERSIONS | {FINAL_SCHEMA_VERSION}:
         errors.append("unsupported final schemaVersion")
     config = state.get("config")
     if not isinstance(config, Mapping):
@@ -707,6 +803,10 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
         history = []
     errors.extend(_validate_round_history(history))
     adversarial = bool(config.get("adversarial"))
+    historical = version in _HISTORICAL_FINAL_VERSIONS
+    allowed_classifications = set(_CLASSIFICATION_COUNT_KEYS)
+    if historical:
+        allowed_classifications.discard("unverified")
     seen_ids: set[str] = set()
     for finding in findings:
         if not isinstance(finding, Mapping):
@@ -720,16 +820,26 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
         else:
             seen_ids.add(finding_id)
         classification = finding.get("classification")
-        if classification not in _CLASSIFICATION_COUNT_KEYS:
+        if classification not in allowed_classifications:
             errors.append(f"finding {finding_id} has invalid classification")
         errors.extend(_validate_finding_ledger(finding, len(history), adversarial))
         rounds = finding.get("rounds") if isinstance(finding.get("rounds"), list) else []
-        if classification == "contested" and rounds:
+        # `unverified`, 그리고 마지막 라운드까지 판정을 못 받아 finalize 가 찍은
+        # `contested` 는 둘 다 "마지막 라운드까지 큐에 남아 있었다"는 뜻이다.
+        # 라운드 안에서 확정된 `contested`(증거 기반 반증)는 다르다 — 그때 큐를
+        # 떠나므로 뒤 라운드 기록이 없는 것이 정상이다.
+        settled_in_round = (
+            adversarial and _round_settled_classification(rounds) is not None
+        )
+        unresolved = classification in {"contested", "unverified"}
+        if unresolved and rounds and not settled_in_round:
             if rounds[-1].get("round") != len(history):
                 errors.append(f"finding {finding_id} contested before the final round")
-        if classification != "contested":
+        if not unresolved:
             errors.extend(_validate_no_reappearance_after_resolution(finding, adversarial))
-        expected = _expected_final_classification(finding, adversarial)
+        expected = _expected_final_classification(
+            finding, adversarial, historical=historical
+        )
         if expected is not None and classification != expected:
             errors.append(
                 f"finding {finding_id} classification {classification} "
@@ -744,6 +854,8 @@ def validate_final_state(state: Mapping[str, Any]) -> list[str]:
         errors.append("finalClassificationCounts must be an object")
     else:
         actual = classification_counts_from_findings(findings)
+        if historical and "unverified" not in declared:
+            actual.pop("unverified")
         if dict(declared) != actual:
             errors.append(
                 f"finalClassificationCounts {dict(declared)} does not match findings {actual}"
@@ -784,22 +896,34 @@ def _parse_critic_gap_results(
         )
     provider = _required_string(payload, "provider", "critic gap results")
     model = _required_string(payload, "modelExecutionValue", "critic gap results")
-    roster = {
+    roster_order = [
         worker["workerId"]
         for worker in state.get("workers", [])
         if isinstance(worker, Mapping) and worker.get("audience") == "analysis"
-    }
+    ]
+    roster = set(roster_order)
     dispatches, completed = _parse_critic_dispatches(
-        payload.get("dispatches"), roster, provider
+        payload.get("dispatches"), roster
+    )
+    known_findings = {
+        finding["findingId"]
+        for finding in state.get("findings", [])
+        if isinstance(finding, Mapping) and _nonempty_string(finding.get("findingId"))
+    }
+    gaps = _parse_critic_gaps(
+        payload.get("gaps"), roster, completed, known_findings
+    )
+    coverage_errors = _critic_gap_coverage_errors(
+        roster_order, gaps, {row["worker"] for row in dispatches}
     )
-    gaps = _parse_critic_gaps(payload.get("gaps"), roster, provider, completed)
+    if coverage_errors:
+        raise ConvergenceContractError("; ".join(coverage_errors))
     return provider, model, dispatches, gaps
 
 
 def _parse_critic_dispatches(
     value: Any,
     roster: set[str],
-    provider: str,
 ) -> tuple[list[dict[str, Any]], set[str]]:
     if not isinstance(value, list):
         raise ConvergenceContractError("critic gap results dispatches must be an array")
@@ -824,22 +948,64 @@ def _parse_critic_dispatches(
             )
         seen.add(worker)
         dispatches.append({"worker": worker, "status": status, "durationMs": duration})
-    expected = set(roster)
-    if seen != expected:
-        missing = sorted(expected - seen)
-        raise ConvergenceContractError(
-            "critic dispatches must account for every non-critic analyser exactly "
-            f"once; missing: {', '.join(missing) or 'none'}"
-        )
     completed = {row["worker"] for row in dispatches if row["status"] == "completed"}
     return dispatches, completed
 
 
+def _critic_gap_assignees(
+    roster_order: list[str],
+    gaps: list[Mapping[str, Any]],
+) -> list[str]:
+    """gap 하나당 검증자 한 명. 로스터 순서 위의 round-robin 이다.
+
+    종전 계약은 gap 배치를 분석자 전원에게 부치라고 요구했다. 거부도 승인과 같은
+    값을 치르는데, 그 라운드는 `rounds: []` 로 기록조차 남지 않는 직렬 구간이다.
+    gap 마다 검증자 하나면 gap 이 로스터보다 적을 때 디스패치 수가 그만큼 줄고,
+    많을 때는 각 분석자가 전체가 아니라 자기 몫만 읽는다.
+
+    선언한 중복(`duplicateOf`)은 배정에서 빠진다 — 검증하지 않기로 한 gap 이다.
+    """
+    verifiable = [gap for gap in gaps if not gap.get("duplicateOf")]
+    if not roster_order:
+        return []
+    return [
+        roster_order[index % len(roster_order)]
+        for index in range(len(verifiable))
+    ]
+
+
+def _critic_gap_coverage_errors(
+    roster_order: list[str],
+    gaps: list[Mapping[str, Any]],
+    dispatched: set[str],
+) -> list[str]:
+    """디스패치 집합이 두 모양 중 하나인가.
+
+    구 산출물은 분석자 전원이 한 줄씩 있고(전면 fan-out), 새 산출물은 배정받은
+    분석자만 있다. 최종 산출물에는 어느 쪽으로 돌았는지 적히지 않으므로 둘 다
+    받는다 — `_validate_round_ledger_counts` 가 구/신 산술을 함께 받는 것과 같은
+    이유다. gap 수가 로스터 크기 이상이면 두 집합은 같아진다.
+
+    배정받은 분석자가 자기 몫 밖의 gap 에도 표를 던지는 것은 막지 않는다. 그건
+    계약 위반이 아니라 더 본 것이고, 그 사이 방치된 gap 은 표가 없어
+    `unverifiedGaps` 로 스스로 드러난다.
+    """
+    assignees = set(_critic_gap_assignees(roster_order, gaps))
+    if dispatched == set(roster_order) or dispatched == assignees:
+        return []
+    missing = sorted(assignees - dispatched)
+    return [
+        "critic dispatches must cover every gap exactly once (round-robin over "
+        "the analyser roster) or account for every non-critic analyser exactly "
+        f"once; missing: {', '.join(missing) or 'none'}"
+    ]
+
+
 def _parse_critic_gaps(
     value: Any,
     roster: set[str],
-    provider: str,
     completed: set[str],
+    known_findings: set[str],
 ) -> list[dict[str, Any]]:
     if not isinstance(value, list):
         raise ConvergenceContractError("critic gap results gaps must be an array")
@@ -851,7 +1017,7 @@ def _parse_critic_gaps(
         if gap_id in seen:
             raise ConvergenceContractError(f"duplicate critic gapId: {gap_id}")
         seen.add(gap_id)
-        parsed = _parse_critic_gap(gap, index, roster, provider, completed)
+        parsed = _parse_critic_gap(gap, index, roster, completed, known_findings)
         parsed["gapId"] = gap_id
         gaps.append(parsed)
     return gaps
@@ -861,11 +1027,28 @@ def _parse_critic_gap(
     gap: Mapping[str, Any],
     index: int,
     roster: set[str],
-    provider: str,
     completed: set[str],
+    known_findings: set[str],
 ) -> dict[str, Any]:
     label = f"critic gaps[{index}]"
-    votes_value = _object(gap.get("votes"), f"{label}.votes")
+    duplicate_of = gap.get("duplicateOf")
+    if duplicate_of is not None:
+        if not _nonempty_string(duplicate_of):
+            raise ConvergenceContractError(
+                f"{label}.duplicateOf must be a non-empty finding id"
+            )
+        if duplicate_of not in known_findings:
+            raise ConvergenceContractError(
+                f"{label}.duplicateOf names no existing finding: {duplicate_of}"
+            )
+        if gap.get("votes"):
+            raise ConvergenceContractError(
+                f"{label} declares duplicateOf and must carry no votes: a "
+                "declared duplicate never enters gap verification"
+            )
+    votes_value = _object(
+        {} if duplicate_of is not None else gap.get("votes"), f"{label}.votes"
+    )
     votes: dict[str, dict[str, Any]] = {}
     for worker, raw_vote in votes_value.items():
         if worker not in roster:
@@ -890,6 +1073,8 @@ def _parse_critic_gap(
         "originEvidence": _required_string(gap, "originEvidence", label),
         "votes": votes,
     }
+    if duplicate_of is not None:
+        parsed["duplicateOf"] = duplicate_of
     if "evidenceArtifacts" in gap:
         parsed["evidenceArtifacts"] = _parse_evidence_artifacts(
             gap.get("evidenceArtifacts"), label
@@ -906,7 +1091,12 @@ def _reduce_critic_gaps(
     unverified: list[dict[str, str]] = []
     next_number = _next_finding_number(state["findings"])
     for gap in gaps:
-        classification = _critic_gap_classification(gap["votes"])
+        duplicate_of = gap.get("duplicateOf")
+        classification = (
+            _CRITIC_DUPLICATE
+            if duplicate_of
+            else _critic_gap_classification(gap["votes"])
+        )
         merged_id = None
         if classification in {"full-consensus", "partial-consensus"}:
             merged_id = f"F-{next_number:03d}"
@@ -932,6 +1122,7 @@ def _reduce_critic_gaps(
                 "classification": classification,
                 "mergedFindingId": merged_id,
                 "votes": deepcopy(gap["votes"]),
+                **({"duplicateOf": duplicate_of} if duplicate_of else {}),
                 **(
                     {"evidenceArtifacts": deepcopy(gap["evidenceArtifacts"])}
                     if "evidenceArtifacts" in gap
@@ -1047,6 +1238,12 @@ def _validate_critic_contract(
             unverified,
             critic_config,
             ledger,
+            {
+                finding["findingId"]
+                for finding in findings
+                if isinstance(finding, Mapping)
+                and _nonempty_string(finding.get("findingId"))
+            },
         )
     )
     if critic_config.get("provider") != ledger.get("provider"):
@@ -1156,6 +1353,7 @@ def _validate_critic_gap_links(
     unverified: list[Any],
     config: Mapping[str, Any],
     ledger: Mapping[str, Any],
+    finding_ids: set[str],
 ) -> list[str]:
     errors: list[str] = []
     seen_gaps: set[str] = set()
@@ -1197,6 +1395,12 @@ def _validate_critic_gap_links(
                 )
         if classification == "unverified" and isinstance(gap_id, str):
             unverified_ids.add(gap_id)
+        duplicate_of = gap.get("duplicateOf") if isinstance(gap, Mapping) else None
+        if _nonempty_string(duplicate_of) and duplicate_of not in finding_ids:
+            errors.append(
+                f"criticVerification gap {gap_id} duplicateOf names no existing "
+                f"finding: {duplicate_of}"
+            )
     if set(critic_findings) != merged_ids:
         errors.append(
             "critic-origin findings do not match criticVerification "
@@ -1224,7 +1428,7 @@ def _validate_critic_gap_row(
         "mergedFindingId",
         "votes",
     }
-    allowed = required | {"evidenceArtifacts"}
+    allowed = required | {"evidenceArtifacts", "duplicateOf"}
     if set(gap) - allowed:
         errors.append(f"criticVerification.gaps[{index}] has unsupported fields")
     if required - set(gap):
@@ -1236,7 +1440,7 @@ def _validate_critic_gap_row(
         errors.append(f"criticVerification.gaps[{index}].gapId is invalid")
     classification_valid = (
         _nonempty_string(classification)
-        and classification in _CRITIC_CLASSIFICATIONS
+        and classification in _CRITIC_GAP_CLASSIFICATIONS
     )
     if not classification_valid:
         errors.append(f"criticVerification gap {gap_id} has invalid classification")
@@ -1245,6 +1449,14 @@ def _validate_critic_gap_row(
             errors.append(f"criticVerification gap {gap_id} requires mergedFindingId")
     elif classification_valid and merged_id is not None:
         errors.append(f"criticVerification gap {gap_id} must not be merged")
+    if classification_valid and (
+        (classification == _CRITIC_DUPLICATE)
+        != _nonempty_string(gap.get("duplicateOf"))
+    ):
+        errors.append(
+            f"criticVerification gap {gap_id} classification "
+            f"`{classification}` and duplicateOf do not agree"
+        )
     errors.extend(_validate_critic_gap_content(gap, gap_id))
     errors.extend(_validate_critic_gap_votes(gap_id, gap.get("votes"), classification))
     return errors, gap_id, merged_id, classification
@@ -1311,6 +1523,14 @@ def _validate_critic_gap_votes(
 ) -> list[str]:
     if not isinstance(votes, Mapping):
         return [f"criticVerification gap {gap_id} votes must be an object"]
+    if classification == _CRITIC_DUPLICATE:
+        # 선언된 중복은 아무도 판정하지 않는다. 표가 한 장이라도 있으면 그 gap 은
+        # 검증 라운드에 들어간 것이고, 그렇다면 분류가 표에서 나와야 한다.
+        return (
+            []
+            if not votes
+            else [f"criticVerification gap {gap_id} duplicate must carry no votes"]
+        )
     errors: list[str] = []
     parsed: dict[str, dict[str, Any]] = {}
     for worker, vote in votes.items():
@@ -1363,7 +1583,7 @@ def _validate_critic_counts(
     config: Mapping[str, Any],
     classifications: list[Any],
 ) -> list[str]:
-    allowed = {
+    required = {
         "provider",
         "modelExecutionValue",
         "gapsProposed",
@@ -1372,8 +1592,13 @@ def _validate_critic_counts(
         "gapsUnverified",
     }
     errors: list[str] = []
-    if set(config) != allowed:
+    # `gapsDuplicate` 이전에 쓰인 산출물에는 이 키가 없다. 중복이 0 건인 것과
+    # 중복이라는 개념이 없던 것을 구별할 수 없으므로 부재를 0 으로 읽는다.
+    if set(config) - {"gapsDuplicate"} != required:
         errors.append("config.critic has unsupported fields")
+    duplicate_count = sum(
+        value == _CRITIC_DUPLICATE for value in classifications
+    )
     expected = {
         "gapsProposed": len(classifications),
         "gapsMerged": sum(
@@ -1388,24 +1613,30 @@ def _validate_critic_counts(
         ),
         "gapsUnverified": sum(value == "unverified" for value in classifications),
     }
+    if "gapsDuplicate" in config or duplicate_count:
+        expected["gapsDuplicate"] = duplicate_count
     for key, value in expected.items():
         declared = config.get(key)
         if not isinstance(declared, int) or isinstance(declared, bool) or declared < 0:
             errors.append(f"config.critic.{key} must be a non-negative integer")
         elif declared != value:
             errors.append(f"config.critic.{key} {declared} does not match ledger {value}")
-    proposed = config.get("gapsProposed")
-    merged = config.get("gapsMerged")
-    rejected = config.get("gapsRejected")
-    unverified = config.get("gapsUnverified")
-    counts = (proposed, merged, rejected, unverified)
+    counts = (
+        config.get("gapsProposed"),
+        config.get("gapsMerged"),
+        config.get("gapsRejected"),
+        config.get("gapsUnverified"),
+        config.get("gapsDuplicate", 0),
+    )
     if all(
         isinstance(value, int) and not isinstance(value, bool)
         for value in counts
     ):
-        if proposed != merged + rejected + unverified:
+        proposed, *parts = counts
+        if proposed != sum(parts):
             errors.append(
-                "config.critic.gapsProposed must equal gapsMerged + gapsRejected + gapsUnverified"
+                "config.critic.gapsProposed must equal gapsMerged + gapsRejected "
+                "+ gapsUnverified + gapsDuplicate"
             )
     return errors
 
@@ -1436,17 +1667,19 @@ def _validate_critic_roster(
         worker = row.get("worker") if isinstance(row, Mapping) else None
         if not _nonempty_string(worker) or worker not in roster:
             errors.append(f"critic voter must be a non-critic analyser: {worker}")
-    expected_dispatches = set(roster)
     actual_dispatches = {
         row.get("worker")
         for row in dispatches
         if isinstance(row, Mapping) and _nonempty_string(row.get("worker"))
     } if isinstance(dispatches, list) else set()
-    if actual_dispatches != expected_dispatches:
-        errors.append(
-            "criticVerification.dispatches must account for every non-critic "
-            "analyser exactly once"
+    errors.extend(
+        _critic_gap_coverage_errors(
+            [worker for worker in declared if _nonempty_string(worker)]
+            if isinstance(declared, list) else [],
+            [gap for gap in ledger.get("gaps") or [] if isinstance(gap, Mapping)],
+            actual_dispatches,
         )
+    )
     completed = {
         row.get("worker")
         for row in dispatches
@@ -1467,6 +1700,38 @@ def _validate_critic_roster(
     return errors
 
 
+def _received_no_verdict(finding: Mapping[str, Any]) -> bool:
+    """이 finding 에 쓸 수 있는 표가 한 장도 없는가.
+
+    비결과 디스패치(`timeout` / `error` / 결과 파일 없음)는 계획된 워커마다
+    `verification-error` 표로 기록된다(`_votes_for_finding`). 실행된 모든
+    라운드가 그것뿐이면 아무도 이 finding 을 들여다보지 않은 것이고, 그 상태를
+    `contested` 로 적는 것은 없는 판정을 지어내는 일이다. gap 쪽에는 이미 같은
+    규칙이 있다(`prompts/lead/convergence.md` 의 "A gap that received no verdict
+    is NOT a rejected gap").
+
+    표가 한 장이라도 기록돼 있어야 한다. 라운드가 아예 없는 finding 은 Round 0
+    에서 이미 분류돼 큐를 떠난 쪽이 대부분이고, 최종 산출물에는 큐가 남지
+    않으므로 검증기가 그 둘을 구별할 수 없다. 구별할 수 없는 것을 판정하면
+    검증기와 엔진이 갈라진다.
+    """
+    rounds = finding.get("rounds")
+    if not isinstance(rounds, list):
+        return False
+    seen = False
+    for row in rounds:
+        votes = row.get("votes") if isinstance(row, Mapping) else None
+        if not isinstance(votes, Mapping):
+            continue
+        for vote in votes.values():
+            if not isinstance(vote, Mapping):
+                continue
+            seen = True
+            if vote.get("verdict") != "verification-error":
+                return False
+    return seen
+
+
 def _final_collaborative_classification(finding: Mapping[str, Any]) -> str:
     usable: list[Mapping[str, Any]] = []
     for round_row in finding.get("rounds", []):
@@ -1477,11 +1742,27 @@ def _final_collaborative_classification(finding: Mapping[str, Any]) -> str:
     return "partial-consensus" if usable and agreeing > len(usable) / 2 else "contested"
 
 
+def _round_settled_classification(rounds: list[Any]) -> str | None:
+    """라운드 기록만으로 확정된 적대적 분류. finalize 가 찍은 값과 구별한다."""
+    if not isinstance(rounds, list) or not rounds:
+        return None
+    try:
+        return _classify_adversarial_history(rounds)
+    except ConvergenceContractError:
+        # 표 자체가 계약 위반이면 그 사실은 `_validate_finding_ledger` 가 이미
+        # 별도 오류로 낸다. 여기서는 "라운드 안에서 확정되지 않았다"로만 읽는다.
+        return None
+
+
 def _expected_final_classification(
     finding: Mapping[str, Any],
     adversarial: bool,
+    *,
+    historical: bool = False,
 ) -> str | None:
     rounds = finding.get("rounds")
+    if not historical and _received_no_verdict(finding):
+        return "unverified"
     if not isinstance(rounds, list) or not rounds:
         return None
     if adversarial:
@@ -1511,16 +1792,28 @@ def _validate_round_ledger_counts(
         if not isinstance(history_row, Mapping):
             continue
         ledgers = _round_ledgers(findings, round_number)
-        resolved = _resolved_ledger_count(findings, round_number, adversarial)
-        expected = (len(ledgers), resolved, len(ledgers) - resolved)
+        # 두 엔진의 산술이 갈라지는 지점은 하나다 — `counter-evidence` 반증.
+        # 지금은 그 라운드에서 큐를 떠나고(현), 구 엔진은 마지막 라운드까지
+        # 끌고 갔다(구). 최종 산출물에는 큐가 남지 않아 어느 엔진이 썼는지
+        # 구별할 수 없으므로 두 산술을 모두 받는다.
+        accepted = {
+            (len(ledgers), resolved, len(ledgers) - resolved)
+            for resolved in {
+                _resolved_ledger_count(findings, round_number, adversarial),
+                _resolved_ledger_count(
+                    findings, round_number, adversarial, legacy=True
+                ),
+            }
+        }
         actual = (
             history_row.get("inputQueueSize"),
             history_row.get("resolvedCount"),
             history_row.get("carriedForwardCount"),
         )
-        if actual != expected:
+        if actual not in accepted:
             errors.append(
-                f"round {round_number} counters {actual} do not match finding ledgers {expected}"
+                f"round {round_number} counters {actual} do not match finding "
+                f"ledgers {sorted(accepted)}"
             )
     return errors
 
@@ -1548,7 +1841,10 @@ def _resolved_ledger_count(
     findings: list[Any],
     round_number: int,
     adversarial: bool,
+    *,
+    legacy: bool = False,
 ) -> int:
+    """이 라운드에서 큐를 떠난 finding 수. `legacy` 는 구 엔진 규칙으로 센다."""
     resolved = 0
     for finding in findings:
         rounds = finding.get("rounds") if isinstance(finding, Mapping) else None
@@ -1569,11 +1865,12 @@ def _resolved_ledger_count(
         if not isinstance(votes, Mapping):
             continue
         try:
-            classification = (
-                _classify_adversarial_history(current_rounds)
-                if adversarial
-                else classify_collaborative_round(votes)
-            )
+            if not adversarial:
+                classification = classify_collaborative_round(votes)
+            elif legacy:
+                classification = _legacy_adversarial_history(current_rounds)
+            else:
+                classification = _classify_adversarial_history(current_rounds)
         except ConvergenceContractError:
             continue
         resolved += classification is not None
@@ -1671,7 +1968,10 @@ def _validate_no_reappearance_after_resolution(
             )
         except ConvergenceContractError:
             continue
-        if classification is not None:
+        # 중간 라운드가 `contested` 로 읽히는 상태는 구 엔진만 만들 수 있다 —
+        # 현 엔진은 그 라운드에서 큐를 떠나므로 뒤 라운드가 생기지 않고, 그렇게
+        # 종결된 finding 은 `contested` 라 애초에 이 검사를 받지 않는다.
+        if classification is not None and classification != "contested":
             return [
                 f"finding {finding.get('findingId')} reappears after resolution in round {index + 1}"
             ]
@@ -2133,9 +2433,21 @@ def _parse_groups(
     value: Any,
     analysis_workers: list[str],
     finding_sources: list[str],
-    *,
-    adversarial: bool,
 ) -> tuple[list[dict[str, Any]], list[str]]:
+    """Round 0 을 분류하고 검증 큐를 만든다.
+
+    출처 role execution 이 둘 이상인 발견은 두 모드 모두 `full-consensus` 로
+    확정한다. 독립적인 공동 도출이 이미 교차검증이기 때문이다 — 적대적 모드의
+    입증 책임은 단일 출처 주장을 겨냥한다. 두 역할이 각자 도출한 발견을 큐에
+    넣으면 검증자는 새 정보 없이 표를 다시 던지고 라운드만 소모한다.
+
+    `source_workers` 의 길이가 곧 서로 다른 role execution 의 수다.
+    `_parse_group` 이 `analysis_workers` 를 훑어 만들고 그 목록은 workerId 가
+    유일하며(`_parse_workers` 의 duplicate 검사), workerId 와
+    `sourceRoleExecutionRef` 는 1:1 이다
+    (`_validate_worker_execution_identity` 의 duplicate 검사). 한 워커가 두 번
+    세어질 경로가 없다.
+    """
     if not isinstance(value, list):
         raise ConvergenceContractError("groups must be an array")
     findings: list[dict[str, Any]] = []
@@ -2150,7 +2462,7 @@ def _parse_groups(
         finding, source_workers = _parse_group(
             group, index, analysis_workers, finding_sources
         )
-        if len(source_workers) >= 2 and not adversarial:
+        if len(source_workers) >= 2:
             finding["classification"] = "full-consensus"
         else:
             queue.append(finding_id)