code-coordinator 0.5.503__tar.gz → 0.5.504__tar.gz

{code_coordinator-0.5.503 → code_coordinator-0.5.504}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.503
+Version: 0.5.504
 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.503 → code_coordinator-0.5.504}/code_coordinator.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.503
+Version: 0.5.504
 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.503 → code_coordinator-0.5.504}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.503",
+  "tag": "0.5.504",
   "distance": 0,
-  "node": "g51fb51670c6a8ed9b494ce9abd1b1aef2696d655",
+  "node": "g49844b3020453abade3c1f818b9dbe244559a8ce",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-20"

{code_coordinator-0.5.503 → code_coordinator-0.5.504}/coord/smoke.py

@@ -3292,6 +3292,23 @@ def dispatch_pending_smoke(
         # gate) instead of `None`/leaving it unset — leaving it unset would
         # re-enter this exact row on the very next tick and re-probe GitHub
         # forever for an answer that cannot change back.
+        #
+        # #3416: that `skipped` write is only correct when the row has NO
+        # verdict yet. A liveness refusal fires on "issue closed OR branch
+        # already merged" — a row can reach here carrying a real, terminal
+        # verdict (`passed`/`failed`/`blocked`) recorded moments earlier by
+        # `coord test`, and stamping `skipped` over it would destroy the
+        # only evidence a suite was ever run (#3357 exists precisely so
+        # `passed` reads differently from "nobody checked"), and — worse —
+        # would silently turn a gate-BLOCKING `failed` into a gate-
+        # SATISFYING `skipped`. Re-read the authoritative persisted state
+        # right here rather than trusting `completed.test_state` (a
+        # snapshot taken at the top of this loop, refreshed once at #3343
+        # but not since): fill `skipped` only when that read comes back
+        # empty; a terminal verdict is left exactly as it is, and the
+        # refusal is still recorded via `record_dispatch_refusal` below so
+        # it stays visible in the audit trail even when it changes nothing
+        # on the row.
         if issue_liveness_fetcher is not None:
             from coord.dispatch_liveness import (  # noqa: PLC0415
                 check_dispatch_liveness,
@@ -3312,14 +3329,28 @@ def dispatch_pending_smoke(
                 if completed.assignment_id is not None:
                     from coord.state import record_test_verdict  # noqa: PLC0415
 
-                    record_test_verdict(
-                        assignment_id=completed.assignment_id,
-                        test_state="skipped",
-                        test_reason=(
-                            f"Test stage skipped — {refusal.reason} (#3375)"
-                        ),
+                    current_state = load_assignment_test_state(
+                        completed.assignment_id
                     )
-                    completed.test_state = "skipped"
+                    if current_state is None:
+                        record_test_verdict(
+                            assignment_id=completed.assignment_id,
+                            test_state="skipped",
+                            test_reason=(
+                                f"Test stage skipped — {refusal.reason} "
+                                "(#3375)"
+                            ),
+                        )
+                        completed.test_state = "skipped"
+                    else:
+                        logger.info(
+                            "dispatch_pending_smoke: %s#%s row %s already "
+                            "carries a terminal test_state=%r — the #3375 "
+                            "liveness refusal is logged/audited only and "
+                            "leaves it untouched (#3416).",
+                            completed.repo_name, completed.issue_number,
+                            completed.assignment_id, current_state,
+                        )
                 record_dispatch_refusal(
                     refusal,
                     repo_name=completed.repo_name,

{code_coordinator-0.5.503 → code_coordinator-0.5.504}/tests/test_smoke.py

@@ -4008,6 +4008,97 @@ def test_dispatch_pending_smoke_default_fetcher_none_is_unaffected(
     assert result == [sentinel]
 
 
+# ── #3416: a liveness refusal must fill an EMPTY verdict, never overwrite an
+# existing terminal one. `test_dispatch_pending_smoke_refuses_when_*` above
+# already pin the "empty -> skipped" half (the #3375 fix itself, which must
+# keep working). These pin the other half: a refusal that fires while the
+# persisted row already carries `passed`/`failed`/`blocked` must record the
+# refusal as an audit-only log line and leave `test_state` exactly as it
+# was — never destroy the only evidence a suite actually ran (#3357), and
+# never turn a gate-BLOCKING `failed` into a gate-SATISFYING `skipped`.
+#
+# Reachability mirrors the #3343 repro just below: the liveness fetcher call
+# happens strictly after this loop's top-of-row DB refresh, so a terminal
+# verdict landed by a concurrent writer (another smoke leg's completion reap,
+# or the operator's own `coord test`) WHILE the fetcher call is in flight is
+# invisible to the in-memory snapshot but must still win over `skipped`. ──
+
+
+@pytest.mark.parametrize("terminal_state", ["passed", "failed", "blocked"])
+def test_dispatch_pending_smoke_liveness_refusal_preserves_existing_terminal_verdict(
+    gtk_and_server_config: Config, monkeypatch, terminal_state: str,
+) -> None:
+    from unittest.mock import patch as _patch
+
+    from coord.state import (
+        _record_dispatched_assignment_local,
+        load_assignment_test_state,
+        record_test_verdict,
+    )
+
+    monkeypatch.setattr("coord.state.get_issue_test_mode", lambda *a, **k: None)
+
+    parent = _completed(branch="issue-287-fix")
+    parent = replace(parent, assignment_id=f"liveness-preserve-{terminal_state}")
+    _record_dispatched_assignment_local(assignment=parent, repo_github="acme/api")
+
+    # In-memory row predates any verdict — mirrors the top-of-loop refresh
+    # finding nothing yet (`test_state=None`), exactly like the #3343 repro.
+    stale_row = replace(parent, test_state=None)
+    board = Board(completed=[stale_row])
+
+    def fetcher(repo_name: str, issue_number: int) -> tuple[bool, bool]:
+        # Simulate a concurrent writer landing a real, evidence-backed
+        # terminal verdict on the persisted row WHILE this liveness lookup
+        # is in flight — then report the issue closed, exactly like #1032
+        # (merging the PR closed the issue in the same window).
+        record_test_verdict(
+            assignment_id=parent.assignment_id, test_state=terminal_state,
+        )
+        return True, False
+
+    with _patch("coord.smoke._dispatch_smoke_legs") as mock_dispatch:
+        result = dispatch_pending_smoke(
+            board, gtk_and_server_config, issue_liveness_fetcher=fetcher,
+        )
+
+    assert result == []
+    assert not mock_dispatch.called
+    assert load_assignment_test_state(parent.assignment_id) == terminal_state, (
+        "a liveness refusal must never overwrite an existing terminal Test "
+        "verdict with 'skipped' (#3416)"
+    )
+
+
+def test_dispatch_pending_smoke_liveness_refusal_still_fills_empty_verdict(
+    gtk_and_server_config: Config, monkeypatch,
+) -> None:
+    """The #3375 fix itself must keep working: a row with NO verdict at all
+    still gets `skipped` recorded on a liveness refusal — only an already-
+    terminal row is left alone (#3416)."""
+    from unittest.mock import patch as _patch
+
+    from coord.state import _record_dispatched_assignment_local, load_assignment_test_state
+
+    monkeypatch.setattr("coord.state.get_issue_test_mode", lambda *a, **k: None)
+
+    row = replace(_completed(), assignment_id="liveness-fill-empty-1")
+    _record_dispatched_assignment_local(assignment=row, repo_github="acme/api")
+    board = Board(completed=[row])
+
+    def fetcher(repo_name: str, issue_number: int) -> tuple[bool, bool]:
+        return True, False
+
+    with _patch("coord.smoke._dispatch_smoke_legs") as mock_dispatch:
+        result = dispatch_pending_smoke(
+            board, gtk_and_server_config, issue_liveness_fetcher=fetcher,
+        )
+
+    assert result == []
+    assert not mock_dispatch.called
+    assert load_assignment_test_state(row.assignment_id) == "skipped"
+
+
 def test_dispatch_pending_smoke_skips_row_verdicted_after_the_scan_snapshot(
     gtk_and_server_config: Config, monkeypatch,
 ) -> None: