code-coordinator 0.5.542__tar.gz → 0.5.543__tar.gz

{code_coordinator-0.5.542 → code_coordinator-0.5.543}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.542
+Version: 0.5.543
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.542 → code_coordinator-0.5.543}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.542
+Version: 0.5.543
 Summary: Coordinate Claude Code workers across multiple machines and repos.
 Author-email: John Donaghy <johnfdonaghy@gmail.com>
 License-Expression: LicenseRef-FSL-1.1-MIT

{code_coordinator-0.5.542 → code_coordinator-0.5.543}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.542",
+  "tag": "0.5.543",
   "distance": 0,
-  "node": "gdf0736aada6feb22b04725dbc54d5aec689a1da6",
+  "node": "g46bffa6e864139be6fd12e036d29b7d76c2a4c02",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.542 → code_coordinator-0.5.543}/coord/drive.py

@@ -2405,6 +2405,7 @@ def decide(
     machine: str = "",
     oracle: OracleDecision | None = None,
     gate_checker: AcceptanceGateChecker | None = None,
+    reread_state: Callable[[], IssueState | None] | None = None,
 ) -> Action:
     """One step of the state machine: given the board, what next?
 
@@ -2420,6 +2421,20 @@ def decide(
     to ``coord assign``. *gate_checker* is only consulted when *oracle* is
     active (to resolve a routed repo's ``--for-path``, #1453 review finding
     1) — unused, like *oracle*, on every pre-#1453 call site.
+
+    *reread_state* (#2304) is the dead-end predicate's confirmation read.
+    ``detect_dead_end`` judges a single snapshot, and shape 1
+    (``review_terminal_no_verdict``) rests on the ABSENCE of a field — a
+    snapshot taken a moment before the verdict was written and evaluated a
+    moment after presents exactly the forbidden combination, and no amount of
+    staring at that one snapshot can tell "not written yet" apart from "never
+    coming". ``None`` (the default, every pre-#2304 caller) preserves the old
+    behaviour byte-for-byte: escalate on the first read. When supplied, a
+    dead-end verdict gets ONE fresh re-read before it is trusted; if the
+    re-read no longer reproduces the shape, *state* itself is swapped for the
+    fresh copy and the rest of this function runs on it — so a verdict that
+    landed in the interim is not just un-escalated, the drive actually
+    continues onto the fix/merge arm it unblocks, in this same call.
     """
     machine = machine or opts.machine or state.picked_machine
 
@@ -2902,6 +2917,22 @@ def decide(
     # #2024: `--skip-test` is a live Test-stage move (`_decide_test` records
     # `skipped`), so the human-attended-Test shape must not escalate past it.
     dead_end = detect_dead_end(state, can_waive_test_gate=opts.skip_test)
+    if dead_end is not None and reread_state is not None:
+        # #2304: a dead end whose predicate rests on an ABSENT field (shape
+        # 1's `not state.review_verdict`, above all) cannot be trusted off a
+        # single snapshot — presence is observable, absence-so-far is not.
+        # One confirmation re-read closes the whole class: if the fresh row
+        # still reproduces the shape, escalate on IT (so the recorded gates
+        # match what was actually seen last); if it does not, the verdict
+        # landed in the gap between the stale read and this check, and
+        # `state` is swapped for the fresh copy so every gate below sees it
+        # too — the drive falls through to the fix/merge arm the verdict
+        # unblocks in this same call, rather than merely suppressing a false
+        # escalation and waiting out another full poll for the same result.
+        fresh = reread_state()
+        if fresh is not None:
+            state = fresh
+            dead_end = detect_dead_end(state, can_waive_test_gate=opts.skip_test)
     if dead_end is not None:
         return replace(
             _escalate_dead_end(state, dead_end), warnings=warnings
@@ -5910,6 +5941,11 @@ class Driver:
             action = decide(
                 state, self.opts, counters, self.verifier,
                 machine=machine, oracle=oracle, gate_checker=self.oracle_gate,
+                # #2304: the dead-end predicate's confirmation re-read — the
+                # same board fetch this loop already does every poll, just
+                # available to `decide()` for an extra, immediate look before
+                # a `review_terminal_no_verdict`-shaped snapshot is trusted.
+                reread_state=self.read_state,
             )
             for warning in action.warnings:
                 self.warn(warning)

{code_coordinator-0.5.542 → code_coordinator-0.5.543}/tests/test_drive.py

@@ -186,6 +186,9 @@ def step(s: IssueState, opts: DriveOptions | None = None, **kw) -> Action:
         machine=kw.pop("machine", "precision"),
         oracle=kw.pop("oracle", None),
         gate_checker=gate_checker,
+        # #2304: absent by default, matching every pre-#2304 `decide()` call
+        # site byte-for-byte — the dead-end reread tests below pass their own.
+        reread_state=kw.pop("reread_state", None),
     )
 
 
@@ -3252,6 +3255,73 @@ def test_a_dead_end_exit_code_reaches_the_drive_exited_audit_row(
     assert len(escalations) == 1
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+# #2304: the dead-end predicate's confirmation re-read
+#
+# `detect_dead_end` judges a single snapshot and cannot tell "no verdict
+# yet" from "no verdict, ever" — shape 1's predicate rests on an ABSENT
+# field, so a snapshot taken a moment before the verdict write lands and
+# evaluated a moment after it presents the identical forbidden combination.
+# On quadraui#486 the verdict was durably on the board THREE SECONDS before
+# the drive declared it permanently absent. `decide()`'s `reread_state` hook
+# closes the race with one confirmation read before trusting the shape.
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+def test_a_stale_no_verdict_snapshot_is_not_trusted_and_the_drive_continues():
+    """quadraui#486, verbatim: the reread returns a row carrying a verdict —
+    the dead end must not fire, and the drive must actually continue onto
+    the fix arm the verdict unblocks, in this SAME `decide()` call (not
+    merely suppress the escalation and wait out another poll)."""
+    stale = work_tested(
+        review_aid="c9b489b2333e", review_status="done", review_verdict=""
+    )
+    fresh = work_tested(
+        review_aid="c9b489b2333e", review_status="done",
+        review_verdict="request-changes",
+    )
+    action = step(stale, reread_state=lambda: fresh)
+    assert action.kind == RUN
+    assert action.command == ("fix", "c9b489b2333e")
+
+
+def test_a_genuinely_verdict_less_review_still_dead_ends_after_the_reread():
+    """#1956's real signature — the reread ALSO comes back with no verdict —
+    must keep escalating. The confirmation read closes a race; it must never
+    become a way to suppress a genuine dead end."""
+    stale = work_tested(
+        review_aid="c9b489b2333e", review_status="done", review_verdict=""
+    )
+    action = step(stale, reread_state=lambda: stale)
+    assert action.is_exit
+    assert action.exit_code == EXIT_DEAD_END
+    assert "review_terminal_no_verdict" in action.message
+
+
+def test_a_failed_reread_falls_back_to_the_stale_reading_rather_than_blocking():
+    """A transport blip on the confirmation read (`None`, matching
+    `Driver.read_state`'s own contract for exactly this failure) must not
+    turn a genuine dead end into an indefinite wait — fall back to the one
+    reading actually in hand."""
+    stale = work_tested(
+        review_aid="c9b489b2333e", review_status="done", review_verdict=""
+    )
+    action = step(stale, reread_state=lambda: None)
+    assert action.is_exit
+    assert action.exit_code == EXIT_DEAD_END
+
+
+def test_the_default_call_site_shape_still_escalates_on_the_first_read():
+    """Every pre-#2304 `decide()` call passed no `reread_state` at all —
+    `step()`'s own default omits it — so the original #2019 behaviour (no
+    confirmation, escalate immediately) must be exactly preserved."""
+    action = step(
+        work_tested(review_aid="c9b489b2333e", review_status="done", review_verdict="")
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_DEAD_END
+
+
 def test_a_review_worker_that_died_retries_through_the_cli_then_stops_at_the_cap():
     """#1584: the review WORKER itself failed (transient API error, network
     drop, ...) before ever producing a verdict — `review_status="failed"`