okstra 0.142.0 → 0.144.0

package/runtime/python/okstra_ctl/convergence_engine.py

@@ -78,7 +78,9 @@ def seed_working_state(grouped_input: Mapping[str, Any]) -> dict[str, Any]:
         state["stopReason"] = "auto-disabled"
         return state
 
-    findings, queue = _parse_groups(source.get("groups"), analysis_workers)
+    findings, queue = _parse_groups(
+        source.get("groups"), analysis_workers, adversarial=config["adversarial"]
+    )
     state["findings"] = findings
     state["queueFindingIds"] = queue
     return state
@@ -206,6 +208,37 @@ def classify_adversarial_round(
     return "partial-consensus"
 
 
+def _round_has_counter_evidence(
+    votes: Mapping[str, Mapping[str, Any]],
+) -> bool:
+    return any(
+        vote.get("verdict") == "disagree"
+        and vote.get("disagreeBasis") == "counter-evidence"
+        for vote in votes.values()
+        if isinstance(vote, Mapping)
+    )
+
+
+def _classify_adversarial_history(
+    rounds: list[Mapping[str, Any]],
+) -> str | None:
+    """Classify adversarial rounds without erasing earlier counter-evidence."""
+    counter_evidence_seen = False
+    for row in rounds:
+        votes = row.get("votes") if isinstance(row, Mapping) else None
+        if not isinstance(votes, Mapping):
+            continue
+        counter_evidence_seen = (
+            counter_evidence_seen or _round_has_counter_evidence(votes)
+        )
+        classification = classify_adversarial_round(votes)
+        if classification == "worker-unique":
+            return classification
+        if classification is not None and not counter_evidence_seen:
+            return classification
+    return None
+
+
 def apply_round_results(
     state: Mapping[str, Any],
     plan: Mapping[str, Any],
@@ -251,7 +284,7 @@ def apply_round_results(
             {"round": expected_plan["round"], "votes": round_votes}
         )
         classification = (
-            classify_adversarial_round(round_votes)
+            _classify_adversarial_history(finding["rounds"])
             if adversarial
             else classify_collaborative_round(round_votes)
         )
@@ -1321,20 +1354,21 @@ def _expected_final_classification(
     rounds = finding.get("rounds")
     if not isinstance(rounds, list) or not rounds:
         return None
+    if adversarial:
+        try:
+            return _classify_adversarial_history(rounds) or "contested"
+        except ConvergenceContractError:
+            return "contested"
     for row in rounds:
         if not isinstance(row, Mapping) or not isinstance(row.get("votes"), Mapping):
             continue
         try:
-            resolved = (
-                classify_adversarial_round(row["votes"])
-                if adversarial
-                else classify_collaborative_round(row["votes"])
-            )
+            resolved = classify_collaborative_round(row["votes"])
         except ConvergenceContractError:
             continue
         if resolved is not None:
             return resolved
-    return "contested" if adversarial else _final_collaborative_classification(finding)
+    return _final_collaborative_classification(finding)
 
 
 def _validate_round_ledger_counts(
@@ -1347,7 +1381,7 @@ def _validate_round_ledger_counts(
         if not isinstance(history_row, Mapping):
             continue
         ledgers = _round_ledgers(findings, round_number)
-        resolved = _resolved_ledger_count(ledgers, adversarial)
+        resolved = _resolved_ledger_count(findings, round_number, adversarial)
         expected = (len(ledgers), resolved, len(ledgers) - resolved)
         actual = (
             history_row.get("inputQueueSize"),
@@ -1381,17 +1415,32 @@ def _round_ledgers(
 
 
 def _resolved_ledger_count(
-    ledgers: list[Mapping[str, Any]],
+    findings: list[Any],
+    round_number: int,
     adversarial: bool,
 ) -> int:
     resolved = 0
-    for row in ledgers:
-        votes = row.get("votes")
+    for finding in findings:
+        rounds = finding.get("rounds") if isinstance(finding, Mapping) else None
+        if not isinstance(rounds, list):
+            continue
+        current_rounds = [
+            row
+            for row in rounds
+            if isinstance(row, Mapping)
+            and isinstance(row.get("round"), int)
+            and row["round"] <= round_number
+        ]
+        current = next(
+            (row for row in current_rounds if row.get("round") == round_number),
+            None,
+        )
+        votes = current.get("votes") if isinstance(current, Mapping) else None
         if not isinstance(votes, Mapping):
             continue
         try:
             classification = (
-                classify_adversarial_round(votes)
+                _classify_adversarial_history(current_rounds)
                 if adversarial
                 else classify_collaborative_round(votes)
             )
@@ -1486,7 +1535,7 @@ def _validate_no_reappearance_after_resolution(
             continue
         try:
             classification = (
-                classify_adversarial_round(votes)
+                _classify_adversarial_history(rounds[: index + 1])
                 if adversarial
                 else classify_collaborative_round(votes)
             )
@@ -1842,6 +1891,8 @@ def _parse_workers(value: Any) -> list[dict[str, str]]:
 def _parse_groups(
     value: Any,
     analysis_workers: list[str],
+    *,
+    adversarial: bool,
 ) -> tuple[list[dict[str, Any]], list[str]]:
     if not isinstance(value, list):
         raise ConvergenceContractError("groups must be an array")
@@ -1855,7 +1906,7 @@ def _parse_groups(
             raise ConvergenceContractError(f"duplicate findingId: {finding_id}")
         seen_ids.add(finding_id)
         finding, source_workers = _parse_group(group, index, analysis_workers)
-        if len(source_workers) >= 2:
+        if len(source_workers) >= 2 and not adversarial:
             finding["classification"] = "full-consensus"
         else:
             queue.append(finding_id)