code-coordinator 0.5.500__tar.gz → 0.5.501__tar.gz

{code_coordinator-0.5.500 → code_coordinator-0.5.501}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.500",
+  "tag": "0.5.501",
   "distance": 0,
-  "node": "gd2476088b8684b908e08f1fbde1d3d82d3f02271",
+  "node": "gf1c4fc8c6aabba829d2631892fc576fd10bbc58a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-19"

{code_coordinator-0.5.500 → code_coordinator-0.5.501}/coord/notify.py

@@ -4171,12 +4171,26 @@ def _dispatch_board_pending_smoke(config: Config) -> None:
     passed/failed/skipped verdict and re-dispatch instead of skipping it
     forever — without it, the staleness check fails open and this call would
     be no more capable than before that fix.
+
+    #3375: also passes a real *issue_liveness_fetcher*
+    (`coord.dispatch_liveness.github_issue_liveness_fetcher`) so the Test
+    stage — which dispatches over `httpx` directly rather than through
+    `coord.dispatch.dispatch()` — gets the SAME "is this issue closed / has
+    this branch already merged" precondition #3376 wired into every other
+    dispatch chokepoint. Without it, this stage stays the one path #3376
+    missed, and the five-smoke-agents-after-merge incident can still recur.
     """
     from coord.board_service import read_board, write_board
+    from coord.dispatch_liveness import github_issue_liveness_fetcher
     from coord.smoke import dispatch_pending_smoke
 
     board = read_board()
-    dispatched = dispatch_pending_smoke(board, config, gh_ops=github_ops)
+    dispatched = dispatch_pending_smoke(
+        board,
+        config,
+        gh_ops=github_ops,
+        issue_liveness_fetcher=github_issue_liveness_fetcher(config),
+    )
     if dispatched:
         write_board(board)
 

{code_coordinator-0.5.500 → code_coordinator-0.5.501}/coord/reconcile.py

@@ -2699,10 +2699,22 @@ def reconcile(board: Board, config: Config) -> list[str]:
     # passed/failed/skipped verdict (a rebase moved the base or branch out
     # from under it) is re-dispatched instead of skipped forever — without
     # it, the staleness check inside `dispatch_pending_smoke` fails open.
+    #
+    # #3375: also passes a real *issue_liveness_fetcher* so `coord resume`
+    # gets the same "issue closed / branch already merged" precondition
+    # #3376 wired into every other dispatch chokepoint — the Test stage
+    # bypasses `coord.dispatch.dispatch()` entirely (a direct `httpx` POST
+    # to `/assign`), so it was the one path #3376 didn't reach.
     from coord import github_ops  # noqa: PLC0415
+    from coord.dispatch_liveness import github_issue_liveness_fetcher  # noqa: PLC0415
     from coord.smoke import dispatch_pending_smoke
 
-    for smoke in dispatch_pending_smoke(board, config, gh_ops=github_ops):
+    for smoke in dispatch_pending_smoke(
+        board,
+        config,
+        gh_ops=github_ops,
+        issue_liveness_fetcher=github_issue_liveness_fetcher(config),
+    ):
         if smoke.assignment_id is not None:
             changed.append(smoke.assignment_id)
 

{code_coordinator-0.5.500 → code_coordinator-0.5.501}/coord/smoke.py

@@ -3033,6 +3033,7 @@ def dispatch_pending_smoke(
     *,
     now: float | None = None,
     gh_ops: "GhOps | None" = None,
+    issue_liveness_fetcher: Callable[[str, int], tuple[bool, bool]] | None = None,
 ) -> list[Assignment]:
     """Bulk Test-stage dispatch — the smoke analogue of
     :func:`coord.review.dispatch_pending_reviews`.
@@ -3064,6 +3065,23 @@ def dispatch_pending_smoke(
     real :mod:`coord.github_ops` explicitly, the same module every other
     live gate check in this codebase hands `merge_queue`'s gate functions.
 
+    #3375: *issue_liveness_fetcher* is the SAME opt-in
+    ``(repo_name, issue_number) -> (issue_closed, branch_merged)`` contract
+    `coord.dispatch_liveness.check_dispatch_liveness` already gates
+    `coord.dispatch.dispatch()` with (#3376) — but this stage never went
+    through that call path. `dispatch_smoke`/`_dispatch_smoke_legs` POST
+    straight to a machine's `/assign` over `httpx`, so #3376's dispatch-time
+    gate never saw a Test-stage dispatch at all, and the five-smoke-agents
+    incident that motivated both issues could still reproduce after #3376
+    landed. Checked once per eligible row here, BEFORE any candidate is
+    walked or any machine chosen (`_dispatch_smoke_legs` needs no machine
+    name to know the issue is closed or the branch already merged) — a hit
+    records a `skipped` verdict (there is nothing left to gate) via
+    `record_test_verdict` and an audit row via
+    `coord.dispatch_liveness.record_dispatch_refusal`, and the row is left
+    alone rather than walking the candidate list for nothing. Default
+    ``None`` refuses nothing — identical to every pre-#3375 caller.
+
     A confirmed-stale verdict is **cleared** (``record_test_verdict(...,
     test_state=None)``, mirrored in-memory on ``completed.test_state``)
     *before* the re-dispatch, not left in place — so the row reads
@@ -3264,6 +3282,59 @@ def dispatch_pending_smoke(
             )
             continue
 
+        # #3375: refuse to dispatch a Test stage for a row whose issue has
+        # already closed or whose branch has already merged — the liveness
+        # precondition #3376 built for `coord.dispatch.dispatch()` but never
+        # reached this stage, because smoke dispatch never calls it (see the
+        # docstring above). Checked here, right before candidate walking,
+        # because it needs no machine selection to answer. A hit records a
+        # `skipped` verdict (there is nothing left for a Test verdict to
+        # 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.
+        if issue_liveness_fetcher is not None:
+            from coord.dispatch_liveness import (  # noqa: PLC0415
+                check_dispatch_liveness,
+                record_dispatch_refusal,
+            )
+
+            issue_closed, branch_merged = issue_liveness_fetcher(
+                completed.repo_name, completed.issue_number
+            )
+            refusal = check_dispatch_liveness(
+                repo_name=completed.repo_name,
+                issue_number=completed.issue_number,
+                machine_name="(smoke: no machine selected yet)",
+                issue_closed=issue_closed,
+                branch_merged=branch_merged,
+            )
+            if refusal is not None:
+                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)"
+                        ),
+                    )
+                    completed.test_state = "skipped"
+                record_dispatch_refusal(
+                    refusal,
+                    repo_name=completed.repo_name,
+                    issue_number=completed.issue_number,
+                    machine_name="(smoke: no machine selected yet)",
+                    assignment_type="smoke",
+                )
+                logger.info(
+                    "dispatch_pending_smoke: refused to dispatch for %s#%s "
+                    "row %s — %s",
+                    completed.repo_name, completed.issue_number,
+                    completed.assignment_id, refusal.reason,
+                )
+                continue
+
         # #3182: the full-list implementation — a capability fan-out
         # dispatches more than one leg per completion, so this loop cannot
         # go through the compat-wrapping `dispatch_smoke` (which only ever

{code_coordinator-0.5.500 → code_coordinator-0.5.501}/tests/test_smoke.py

@@ -3898,6 +3898,116 @@ def test_dispatch_pending_smoke_keeps_skipping_a_fresh_passed_verdict(
     assert not mock_dispatch.called
 
 
+# ── #3375: the Test stage dispatches over `httpx` directly
+# (`_dispatch_smoke_legs` -> `_walk_candidates_and_dispatch`), bypassing
+# `coord.dispatch.dispatch()` entirely — so #3376's dispatch-liveness gate
+# (issue closed / branch already merged) never reached it. These pin the
+# opt-in `issue_liveness_fetcher` parameter this fix adds: a refusal must
+# record a `skipped` verdict (never leave the row silent) AND never reach
+# candidate walking; an "alive" answer must dispatch exactly as before. ──────
+
+
+def test_dispatch_pending_smoke_refuses_when_issue_already_closed(
+    gtk_and_server_config: Config, monkeypatch,
+) -> None:
+    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="closed-issue-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  # issue closed, branch not (necessarily) merged
+
+    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, (
+        "a closed issue must never reach candidate walking (#3375)"
+    )
+    assert load_assignment_test_state(row.assignment_id) == "skipped", (
+        "a refused dispatch must record a verdict, not leave the gate "
+        "silent — a silent gate is the #3375 loop condition"
+    )
+
+
+def test_dispatch_pending_smoke_refuses_when_branch_already_merged(
+    gtk_and_server_config: Config, monkeypatch,
+) -> None:
+    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="merged-branch-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 False, True  # branch already merged
+
+    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_dispatches_when_liveness_fetcher_says_alive(
+    gtk_and_server_config: Config, monkeypatch,
+) -> None:
+    """The opt-in fetcher reporting an open issue and an unmerged branch
+    must not change ordinary dispatch behaviour at all."""
+    from unittest.mock import patch as _patch
+
+    monkeypatch.setattr("coord.state.get_issue_test_mode", lambda *a, **k: None)
+
+    row = replace(_completed(), assignment_id="alive-1")
+    board = Board(completed=[row])
+    sentinel = object()
+
+    def fetcher(repo_name: str, issue_number: int) -> tuple[bool, bool]:
+        return False, False
+
+    with _patch(
+        "coord.smoke._dispatch_smoke_legs", return_value=[sentinel],
+    ) as mock_dispatch:
+        result = dispatch_pending_smoke(
+            board, gtk_and_server_config, issue_liveness_fetcher=fetcher,
+        )
+    assert mock_dispatch.called
+    assert result == [sentinel]
+
+
+def test_dispatch_pending_smoke_default_fetcher_none_is_unaffected(
+    gtk_and_server_config: Config, monkeypatch,
+) -> None:
+    """No *issue_liveness_fetcher* wired in (the pre-#3375 default) refuses
+    nothing — byte-for-byte the old behaviour."""
+    from unittest.mock import patch as _patch
+
+    monkeypatch.setattr("coord.state.get_issue_test_mode", lambda *a, **k: None)
+
+    row = replace(_completed(), assignment_id="no-fetcher-1")
+    board = Board(completed=[row])
+    sentinel = object()
+    with _patch(
+        "coord.smoke._dispatch_smoke_legs", return_value=[sentinel],
+    ) as mock_dispatch:
+        result = dispatch_pending_smoke(board, gtk_and_server_config)
+    assert mock_dispatch.called
+    assert result == [sentinel]
+
+
 def test_dispatch_pending_smoke_skips_row_verdicted_after_the_scan_snapshot(
     gtk_and_server_config: Config, monkeypatch,
 ) -> None: