code-coordinator 0.5.74__tar.gz → 0.5.75__tar.gz

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.74",
+  "tag": "0.5.75",
   "distance": 0,
-  "node": "g6932f7816982a66f6e4945073a12324dd56fc91b",
+  "node": "g73af79d5b857f3191b459e4fa74599e9d5f6e319",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/coord/commands/merge.py

@@ -218,6 +218,37 @@ def _apply_ci_revalidation(
     return deferred
 
 
+def _reload_board_after_wait(board, *, dry_run: bool):
+    """#2143: force a fresh board read after ``_apply_ci_revalidation``'s
+    ``wait_for_ci_settle`` poll — which, like ``_apply_revalidation``'s
+    composite/solo suite runs, can hold the caller for minutes.
+
+    ``_apply_revalidation`` already refreshes the board it hands back, but
+    only when *it* recorded a new verdict; it has no way to know a CI-settle
+    wait ran afterwards. Real state can change on GitHub during that wait —
+    most dangerously a review approval landing, or a concurrent merge driver
+    (the drive-queue timer, another operator) merging the exact branch this
+    run is about to act on — and `merge_queue.process()` must not evaluate
+    review/smoke gates against a *board* snapshot that predates any of it
+    (the 2026-08-12 incident: a review approved 89s into the wait was still
+    reported as unapproved because the pre-wait board was never re-read).
+
+    Unconditional (not "only when something looks stale"): the risk here is
+    a stale *read*, and there's no cheap way to tell "nothing changed" from
+    "something changed but we didn't notice" without just re-reading. One
+    extra ``load_board()`` is a rounding error next to the suite run(s) or
+    the CI-settle poll that just happened. Under ``--dry-run`` nothing was
+    triggered (no wait actually ran), so the board is left untouched.
+    """
+    if dry_run:
+        return board
+    from coord.models import Board as _Board  # noqa: PLC0415
+    from coord.state import load_board as _load_board  # noqa: PLC0415
+
+    refreshed = _load_board()
+    return refreshed if refreshed is not None else _Board(active=[], completed=[])
+
+
 def _dispatch_conflict_fixes(events, config, *, dry_run: bool) -> None:
     """#241: classify any conflict events and dispatch a conflict-fix worker
     for the eligible ones.  Mutates each conflict event's ``ev.entry.state``
@@ -1564,6 +1595,10 @@ def merge(
                 only_items, board_only, cfg_only, ci_store_only, gh_ops,
                 dry_run=dry_run,
             )
+            # #2143: the CI-settle wait just above can run for minutes —
+            # re-read the board so the gates `process()` runs below see
+            # whatever landed on GitHub during it, not the pre-wait snapshot.
+            board_only = _reload_board_after_wait(board_only, dry_run=dry_run)
         # #1925: an entry deferred by the CI-settle wait above must not go
         # through process() this pass — that would immediately re-derive the
         # exact self-triggered "unknown" reading the wait was just trying to
@@ -1870,6 +1905,10 @@ def merge(
         deferred_ci = _apply_ci_revalidation(
             pending, board, cfg, ci_store, gh_ops, dry_run=dry_run,
         )
+        # #2143: the CI-settle wait just above can run for minutes —
+        # re-read the board so the gates `process()` runs below see
+        # whatever landed on GitHub during it, not the pre-wait snapshot.
+        board = _reload_board_after_wait(board, dry_run=dry_run)
     # #1925: entries the CI-settle wait above gave up on while still only
     # seeing the registration-gap symptom must not go through process() this
     # pass — see `_apply_ci_revalidation`'s docstring. They keep their

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/coord/merge_queue.py

@@ -2316,6 +2316,29 @@ class GhOps(Protocol):
         """
         ...
 
+    def pr_is_merged(self, repo: str, branch: str) -> bool:
+        """True when *branch*'s current tip is a commit that already merged.
+
+        Used by :func:`process` (#2143) as the last check before opening a
+        PR for an entry with no ``pr_number`` yet — right before the
+        mutating ``create_pr`` call, not at snapshot time, so a branch
+        another merge driver (the drive-queue timer, a concurrent
+        ``coord merge``) merged out from under a long-running ``--revalidate``
+        wait is never handed a second, purposeless PR.  Unlike
+        :meth:`find_pr_for_branch` (open PRs only — ``gh pr list --state
+        open``), this resolves regardless of PR state, so "no open PR" is
+        never misread as "no PR at all".
+
+        Optional on stub ``GhOps`` implementations, same contract as
+        :meth:`branch_has_merge_commit`: callers detect support via
+        ``getattr(gh_ops, "pr_is_merged", None)`` and treat a missing method
+        (or a lookup failure) as "not merged" — fail *open* here, since the
+        cost of a false negative is the pre-#2143 status quo (an extra PR
+        that a human or the next pass closes) while a false positive would
+        silently strand real, unmerged work in a MERGED state.
+        """
+        ...
+
     def get_default_branch_head(self, repo: str, branch: str) -> str:
         """Return the full commit SHA at the tip of *branch*.
 
@@ -4144,6 +4167,29 @@ def process(
                         entry, "opened",
                         f"PR #{entry.pr_number} (existed) for {entry.branch}",
                     ))
+                    continue
+                # #2143: mirror the real path's already-merged check so a
+                # dry-run preview never claims "would open PR" for a branch
+                # another driver already merged — `find_pr_for_branch` above
+                # only ever looks at OPEN PRs, so a merged-and-closed PR is
+                # otherwise indistinguishable here from "never opened".
+                _pr_is_merged = getattr(gh_ops, "pr_is_merged", None)
+                already_merged = False
+                if _pr_is_merged is not None:
+                    try:
+                        already_merged = _pr_is_merged(
+                            entry.repo_github, entry.branch
+                        )
+                    except Exception:  # noqa: BLE001 — fail open, same
+                        # contract as the real path's check.
+                        already_merged = False
+                if already_merged:
+                    events.append(MergeEvent(
+                        entry, "already_merged",
+                        f"(dry run) {entry.branch} was already merged by "
+                        "another merge driver — would skip PR creation "
+                        "(#2143)",
+                    ))
                 else:
                     events.append(MergeEvent(
                         entry, "opened",
@@ -4393,6 +4439,37 @@ def process(
         # Open PRs first so every entry has a pr_number when we sort & merge.
         for entry in group:
             if entry.pr_number is None:
+                # #2143: re-check right here, immediately before the
+                # mutating create_pr call — not against whatever snapshot
+                # this entry was resolved from — whether another merge
+                # driver already merged this exact branch while this run
+                # was doing something else (a `--revalidate` CI-settle
+                # wait, a composite suite run, simply queueing behind a
+                # concurrent merge). `create_pr` internally only ever looks
+                # for an OPEN PR (`find_pr_for_branch`), so a branch that
+                # was merged (and its PR closed) in the meantime reads as
+                # "no PR" and would otherwise get a second, purposeless PR
+                # opened against it — the 2026-08-12 incident this closes.
+                _pr_is_merged = getattr(gh_ops, "pr_is_merged", None)
+                if _pr_is_merged is not None:
+                    try:
+                        already_merged = _pr_is_merged(
+                            entry.repo_github, entry.branch
+                        )
+                    except Exception:  # noqa: BLE001 — fail open: never
+                        # block a legitimate merge on a transient lookup
+                        # failure; worst case is the pre-#2143 status quo.
+                        already_merged = False
+                    if already_merged:
+                        entry.state = MERGED
+                        entry.error = None
+                        events.append(MergeEvent(
+                            entry, "already_merged",
+                            f"{entry.branch} was already merged by another "
+                            "merge driver while this run was in progress — "
+                            "skipping duplicate PR creation (#2143)",
+                        ))
+                        continue
                 try:
                     pr = gh_ops.create_pr(
                         entry.repo_github,

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/tests/test_cli_merge.py

@@ -2885,6 +2885,169 @@ class TestMergeRevalidateCiRerunCli:
         assert "triggered a CI re-run" in result.output
 
 
+class TestMergeRevalidateRereadsBoardAfterWait:
+    """#2143 black-box: a review approval that lands *during* the
+    ``--revalidate`` CI-settle wait must be seen by the gate that runs right
+    after — not the board snapshot loaded before the wait started.
+
+    Reproduces the 2026-08-12 incident's shape with two sibling queue
+    entries sharing one repo-wide `coord merge --revalidate` run: entry
+    ``ci1`` is blocked solely on stale CI (the thing `--revalidate` actually
+    re-runs and waits on) and entry ``rv1`` is a completely unrelated
+    PENDING entry whose review approval only exists on the board that gets
+    saved *while* the ``ci1`` wait is in flight. Before #2143 the board was
+    loaded once at the top of `coord merge` and never re-read, so `rv1`
+    would be reported `review_required` for an approval that, by the time
+    `process()` ran, had already landed.
+    """
+
+    @staticmethod
+    def _config(tmp_path: Path) -> Path:
+        p = tmp_path / "coordinator.yml"
+        p.write_text(
+            "repos:\n"
+            "  - name: api\n"
+            "    github: acme/api\n"
+            "    default_branch: main\n"
+            "machines:\n"
+            "  - name: laptop\n"
+            "    host: laptop.tailnet\n"
+            "    repos: [api]\n"
+            "    repo_paths:\n"
+            "      api: /tmp/api\n"
+            "pipeline:\n"
+            "  default_gates: [review]\n"
+            "ci_store:\n"
+            "  type: github\n"
+        )
+        return p
+
+    @staticmethod
+    def _fake_ci():
+        from types import SimpleNamespace
+
+        class _Ci:
+            is_available = True
+
+            def __init__(self):
+                self.rerun_calls: list = []
+
+            def list_checks_for_pr(self, repo, number):
+                if number == 501:
+                    # Green, but started well before the (mocked) base
+                    # commit time below — the #1851 CI-staleness signal
+                    # `--revalidate` re-runs for. Returned unchanged on
+                    # every read (including the post-rerun settle read),
+                    # so ``wait_for_ci_settle`` sees an immediately-resolved
+                    # (not in-flight) result and never actually sleeps.
+                    return [SimpleNamespace(
+                        name="build", status="completed", conclusion="success",
+                        started_at=500.0, completed_at=None,
+                    )]
+                # 502 (rv1): fresh and green — started well AFTER the mocked
+                # base commit time, so the CI gate never blocks rv1; the
+                # only thing standing between rv1 and a merge is the review
+                # gate this test is about.
+                return [SimpleNamespace(
+                    name="build", status="completed", conclusion="success",
+                    started_at=5000.0, completed_at=None,
+                )]
+
+            def rerun_for_pr(self, repo, number):
+                self.rerun_calls.append((repo, number))
+                return True
+
+        return _Ci()
+
+    @staticmethod
+    def _seed() -> None:
+        from coord.merge_queue import PENDING, QueuedMerge, save_queue
+
+        ci1 = QueuedMerge(
+            assignment_id="ci1", repo_name="api", repo_github="acme/api",
+            branch="worker/ci1", target_branch="main", issue_number=501,
+            issue_title="t", state=PENDING, pr_number=501,
+        )
+        rv1 = QueuedMerge(
+            assignment_id="rv1", repo_name="api", repo_github="acme/api",
+            branch="worker/rv1", target_branch="main", issue_number=502,
+            issue_title="t", state=PENDING, pr_number=502,
+        )
+        save_queue([ci1, rv1])
+
+    @staticmethod
+    def _board(*, rv1_approved: bool):
+        """`ci1`'s review is always approved (so it qualifies as a
+        CI-staleness-only `--revalidate` candidate); `rv1`'s approval is the
+        one that only shows up once ``rv1_approved`` — i.e. only on the
+        *second*, post-wait ``load_board()`` read once #2143's fix is in
+        place."""
+        from coord.models import Assignment, Board
+
+        reviews = [
+            Assignment(
+                machine_name="laptop", repo_name="api", issue_number=501,
+                issue_title="r", assignment_id="ci1-review", type="review",
+                status="done", review_of_assignment_id="ci1",
+                review_verdict="approve",
+            ),
+        ]
+        if rv1_approved:
+            reviews.append(Assignment(
+                machine_name="laptop", repo_name="api", issue_number=502,
+                issue_title="r", assignment_id="rv1-review", type="review",
+                status="done", review_of_assignment_id="rv1",
+                review_verdict="approve",
+            ))
+        return Board(active=[], completed=reviews)
+
+    def test_review_approved_during_the_wait_is_not_reported_stale(
+        self, tmp_path: Path, coord_db,
+    ) -> None:
+        cfg = self._config(tmp_path)
+        self._seed()
+        ci = self._fake_ci()
+        board_before = self._board(rv1_approved=False)
+        board_after = self._board(rv1_approved=True)
+
+        merge_calls: list[int] = []
+
+        def fake_merge(repo, number, method="rebase"):
+            merge_calls.append(number)
+            return True, "ok"
+
+        with patch("coord.ci_store.build_ci_store", return_value=ci), \
+             patch(
+                 "coord.github_ops.get_branch_commit_timestamp",
+                 return_value=1000.0,
+             ), \
+             patch("coord.github_ops.get_branch_patch_id", return_value=None), \
+             patch("coord.github_ops.get_pr_size", return_value=10), \
+             patch("coord.github_ops.merge_pr", side_effect=fake_merge), \
+             patch("coord.github_ops.close_issue"), \
+             patch(
+                 "coord.state.load_board",
+                 side_effect=[board_before, board_after],
+             ):
+            result = CliRunner().invoke(
+                main, ["merge", "--config", str(cfg), "--revalidate"],
+            )
+
+        assert result.exit_code == 0, result.output
+        # The CI-settle wait for ci1 actually ran (proves the repro shape —
+        # rv1's fresh approval is only visible because *something* re-read
+        # the board after this). `--revalidate`'s own trigger is the first
+        # call; `process()`'s independent #2197 auto-rerun (still-stale
+        # after the settle read) may add a second — irrelevant to this test.
+        assert ("acme/api", 501) in ci.rerun_calls
+        # The core #2143 assertion: rv1 must never be reported blocked on a
+        # stale review read, and must actually merge on the fresh one.
+        assert "review required but not approved" not in result.output
+        assert 502 in merge_calls
+        persisted = {x.assignment_id: x.state for x in mq.load_queue()}
+        assert persisted["rv1"] == mq.MERGED
+
+
 class TestMergeGateChecksAbsent:
     """#1904 black-box: `checks == []` is ambiguous — "no CI configured"
     (merge is correct) vs. "CI exists but never triggered for this PR" (a

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/tests/test_merge_queue.py

@@ -297,11 +297,23 @@ class FakeGh:
     # matching pre-#1624 behavior.
     existing_prs: dict[str, dict] = field(default_factory=dict)
     find_pr_calls: list[tuple[str, str]] = field(default_factory=list)
+    # #2143: branch names already merged by "another driver" — checked
+    # immediately before `create_pr` so a duplicate PR is never opened
+    # against a branch that merged while this run was mid-flight (e.g. a
+    # `--revalidate` CI-settle wait). Defaults keep every prior test (none
+    # of which set this) inert — `pr_is_merged` returns False for every
+    # branch, matching pre-#2143 behavior.
+    merged_branches: set[str] = field(default_factory=set)
+    pr_is_merged_calls: list[tuple[str, str]] = field(default_factory=list)
 
     def find_pr_for_branch(self, repo: str, branch: str) -> dict | None:
         self.find_pr_calls.append((repo, branch))
         return self.existing_prs.get(branch)
 
+    def pr_is_merged(self, repo: str, branch: str) -> bool:
+        self.pr_is_merged_calls.append((repo, branch))
+        return branch in self.merged_branches
+
     def create_pr(self, repo: str, *, base: str, head: str, title: str, body: str) -> dict:
         self.create_calls.append((repo, {"base": base, "head": head, "title": title}))
         pr_num = self.next_pr
@@ -378,6 +390,59 @@ class TestProcess:
         # All entries left in MERGED state
         assert {x.state for x in items} == {MERGED}
 
+    def test_skips_pr_creation_when_branch_already_merged(self) -> None:
+        # #2143: an entry with no pr_number yet (e.g. a stale in-memory
+        # snapshot resolved before another merge driver merged this exact
+        # branch, or a full `--revalidate` CI-settle wait that ran long
+        # enough for a sibling driver to land it) must not get a second,
+        # purposeless PR opened against it.
+        items = [_q("a", branch="issue-1-done")]
+        gh = FakeGh(merged_branches={"issue-1-done"})
+        events = process(items, gh)
+
+        assert gh.create_calls == []
+        assert items[0].state == MERGED
+        assert items[0].error is None
+        already_merged = [e for e in events if e.kind == "already_merged"]
+        assert len(already_merged) == 1
+        assert "issue-1-done" in already_merged[0].message
+        # No merge attempted either — nothing to merge, it's already done.
+        assert gh.merge_calls == []
+
+    def test_pr_is_merged_check_is_optional_on_gh_ops_stub(self) -> None:
+        # #2143: `pr_is_merged` is optional on GhOps, same contract as
+        # `find_pr_for_branch`/`branch_has_merge_commit` — a stub predating
+        # #2143 must keep opening PRs exactly as before.
+        @dataclass
+        class _NoMergedCheckGh(FakeGh):
+            # Shadow the inherited method with plain `None`, so
+            # `getattr(gh_ops, "pr_is_merged", None)` sees the same
+            # "missing method" shape a pre-#2143 stub would.
+            pr_is_merged = None
+
+        items = [_q("a")]
+        gh = _NoMergedCheckGh()
+        events = process(items, gh)
+        assert len(gh.create_calls) == 1
+        assert items[0].state == MERGED
+        assert any(e.kind == "opened" for e in events)
+
+    def test_dry_run_previews_already_merged_instead_of_would_open(self) -> None:
+        # #2143: the dry-run preview mirrors the real path's check so it
+        # never claims "would open PR" for a branch another driver already
+        # merged.
+        items = [_q("a", branch="issue-1-done")]
+        gh = FakeGh(merged_branches={"issue-1-done"})
+        events = process(items, gh, dry_run=True)
+
+        assert gh.create_calls == []
+        already_merged = [e for e in events if e.kind == "already_merged"]
+        assert len(already_merged) == 1
+        assert "(dry run)" in already_merged[0].message
+        assert not any(
+            e.kind == "opened" and "would open PR" in e.message for e in events
+        )
+
     def test_closes_linked_issue_on_merge(self) -> None:
         # #806: a successful merge must close the linked issue deterministically,
         # not rely on the worker having put `Closes #N` in the PR body.

{code_coordinator-0.5.74 → code_coordinator-0.5.75}/tests/test_thin_client_board_audit.py

@@ -169,6 +169,13 @@ COMMANDS_ALLOWLIST: dict[str, set[tuple[str, str]]] = {
         # runs on the daemon host / a standalone dev environment, exactly like
         # `merge`'s own `load_board` above.
         ("_apply_revalidation", "load_board"),
+        # #2143-routed: `_reload_board_after_wait` is likewise only called from
+        # the `merge` command body (both the whole-queue and `--only` paths),
+        # i.e. after the same `daemon_reroute_target("COORD_MERGE_ON_DAEMON")`
+        # early-return — so this post-wait re-read (the board snapshot can go
+        # stale across a minutes-long CI-settle poll) only ever runs on the
+        # daemon host / a standalone dev environment.
+        ("_reload_board_after_wait", "load_board"),
     },
     # #2182-guarded: `_fetch_live_ci_gate` re-derives a `parked` entry's merge
     # gate live on the drive-queue tick (instead of waiting out the 45-minute