code-coordinator 0.5.535__tar.gz → 0.5.536__tar.gz

{code_coordinator-0.5.535 → code_coordinator-0.5.536}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.535",
+  "tag": "0.5.536",
   "distance": 0,
-  "node": "gb4633aa4d9fe33c39961caa7723f8214fa8b67d0",
+  "node": "g88b4c49256bda59316741a2cfccb7ac352b3e665",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.535 → code_coordinator-0.5.536}/coord/commands/merge.py

@@ -137,7 +137,6 @@ def _apply_revalidation(items, board, config, gh_ops, *, dry_run: bool, skip_rev
 
 def _apply_ci_revalidation(
     items, board, config, ci_store, gh_ops, *, dry_run: bool,
-    poll_sleep=None, poll_clock=None,
 ) -> set[str]:
     """#1851: the ``--revalidate`` arm for CI staleness — the CI analogue of
     :func:`_apply_revalidation`'s stale-local-verdict arm, resolving a
@@ -147,64 +146,35 @@ def _apply_ci_revalidation(
     outlive the base it actually validated even when the local Test verdict
     is perfectly fresh).
 
-    Unlike :func:`_apply_revalidation` there is nothing to compose and no
-    local suite to run — the remedy is :meth:`coord.ci_store.CiStore.
-    rerun_for_pr`, a ``gh run rerun`` that costs CI minutes on GitHub's own
-    runners, not a routed Test-stage agent. Strictly cheaper than what
-    :func:`_apply_revalidation` does for the same reason CI should always be
-    preferred when both would establish the same fact (#1851's "Cost
-    framing").
+    #3276: every candidate :func:`coord.merge_queue.ci_revalidation_candidates`
+    returns is, by that function's own contract, blocked *solely* on CI
+    staleness — and the remedy that would have been here,
+    :meth:`coord.ci_store.CiStore.rerun_for_pr`, is a same-base ``gh run
+    rerun`` that a staleness reading (the base moved; the check didn't) can
+    never satisfy. #3266 already established exactly that and fixed the two
+    unattended call sites (``merge_queue.process()``'s own #2197 auto-rerun
+    and ``coord.commands.drive_queue._run_auto_revalidate_checks_stale``) to
+    stop spending a CI cycle on it — see ``MAX_CI_STALE_RERUNS``'s comment in
+    ``coord/merge_queue.py``. This CLI arm was left as a disclosed scope cut
+    (opt-in, human-invoked, no budget counter) with a docstring promising a
+    "tracked follow-up" that was never filed as an issue — #3276 is that
+    follow-up. So: no candidate here is ever handed to ``rerun_for_pr``
+    anymore. Each one gets the rebase remedy on stdout instead, both under
+    ``--dry-run`` and for real — the two cases are identical now because
+    nothing is actually triggered either way (#3276's acceptance: ``--dry-
+    run`` must say the same thing it would do).
 
     Opt-in behind ``--revalidate`` exactly like :func:`_apply_revalidation`
-    — never called from auto-drain (see ``docs/DRIVE_QUEUE.md``). Under
-    ``--dry-run`` this only *names* what it would trigger; no ``gh`` mutation
-    runs.
-
-    #1925: triggering a rerun and then handing the entry straight to
-    ``merge_queue.process()`` used to fail-close on the rerun's OWN
-    registration gap — ``gh pr checks`` errors for the few seconds before
-    GitHub has created any check-run record, which reads as the #1525
-    synthetic ``unknown`` conclusion and blocks exactly like a genuinely
-    broken CI would. :func:`coord.ci_store.wait_for_ci_settle` closes that
-    gap with a bounded poll right here, so the caller's subsequent
-    ``process()`` call sees a real, resolved result — pass or fail — for the
-    common case.
-
-    Returns the ``assignment_id``s whose wait ran out the budget while STILL
-    only seeing the registration-gap symptom (never a real check) —
-    :func:`wait_for_ci_settle`'s ``registering=True`` case. The caller must
-    exclude these from the ``process()`` call that follows: evaluating the
-    gate against that exact symptom is the bug this fixes, so it must not
-    reappear at the timeout edge just because the wait gave up. The entry
-    stays ``PENDING`` with an explanatory ``entry.error`` instead — legible
-    as "come back shortly", never as "checks failed" (#1925's acceptance:
-    an ``unknown`` this command caused must not be presented identically to
-    an ``unknown`` from genuinely broken CI).
-
-    #3266 — KNOWN FOLLOW-UP, not fixed here: every candidate this selects
-    (via :func:`coord.merge_queue.ci_revalidation_candidates`) is blocked
-    *solely* on CI staleness, and the ``rerun_for_pr`` call below is a
-    same-base ``gh run rerun`` that a staleness reading, by definition,
-    can never satisfy — see ``MAX_CI_STALE_RERUNS``'s comment in
-    ``coord/merge_queue.py``, which #3266 fixed identically at
-    ``merge_queue.process()`` and at ``coord.commands.drive_queue.
-    _run_auto_revalidate_checks_stale`` (the unattended periodic call
-    site). This CLI arm is the one remaining caller still spending a real
-    CI cycle on that guaranteed no-op. Left unfixed here on purpose for
-    this round — it is opt-in and human-invoked, unlike the unattended
-    drive-queue path, and the misleading ``ci_stale_reason`` remedy text
-    that used to point an operator at ``--revalidate`` *for this specific
-    condition* was already removed by #3266 — but an operator who runs
-    ``--revalidate`` for an unrelated reason (a genuine infra-failure
-    retry) on a PR that also happens to be ``checks_stale`` still silently
-    burns a no-op CI cycle for that PR. Tracked as a follow-up: the fix
-    would be to drop this entry from *candidates* (or from what gets
-    rerun) whenever the ONLY reason it is here is staleness, so
-    ``--revalidate`` never fires `rerun_for_pr` for a condition it cannot
-    clear.
+    — never called from auto-drain (see ``docs/DRIVE_QUEUE.md``).
+
+    Returns an empty set always now — kept as a ``set[str]`` return (rather
+    than ``None``) so the two call sites' "entries this arm deferred, exclude
+    them from this pass's ``process()`` call" plumbing (#1925's ``registering``
+    case, from when this arm still triggered a rerun and had to wait out its
+    own registration gap) needs no change; there is simply never anything to
+    defer any more, since nothing is triggered.
     """
     from coord import merge_queue as _mq  # noqa: PLC0415
-    from coord.ci_store import wait_for_ci_settle  # noqa: PLC0415
 
     deferred: set[str] = set()
     if ci_store is None or not ci_store.is_available:
@@ -218,61 +188,31 @@ def _apply_ci_revalidation(
         return deferred
     for entry in candidates:
         label = f"{entry.repo_name} #{entry.issue_number} ({entry.branch})"
-        if dry_run:
-            click.echo(
-                f"  --revalidate: would re-run CI for {label} "
-                f"(PR #{entry.pr_number}) — checks predate the current base"
-            )
-            continue
-        ok = ci_store.rerun_for_pr(entry.repo_github, entry.pr_number)
-        if not ok:
-            click.echo(
-                f"  --revalidate: could not trigger a CI re-run for {label} "
-                f"(PR #{entry.pr_number}) — see gh output above",
-                err=True,
-            )
-            continue
         click.echo(
-            f"  --revalidate: triggered a CI re-run for {label} "
-            f"(PR #{entry.pr_number})"
-        )
-        result = wait_for_ci_settle(
-            ci_store, entry.repo_github, entry.pr_number,
-            echo=click.echo, sleep=poll_sleep, clock=poll_clock,
+            f"  --revalidate: skipping {label} (PR #{entry.pr_number}) — "
+            "blocked solely on stale CI checks; a re-run replays the same "
+            "run against the same base it already ran against and can "
+            "never clear this (#3276). Rebase (or push a new commit) to "
+            "get a check against the current base."
         )
-        if result.settled:
-            click.echo(
-                f"  --revalidate: CI re-run for {label} settled after "
-                f"{result.waited_seconds:.0f}s — the merge gate will "
-                "evaluate the fresh result"
-            )
-        elif result.registering:
-            entry.error = (
-                f"{label}: the CI re-run --revalidate just triggered "
-                f"(PR #{entry.pr_number}) has not registered on GitHub yet "
-                f"after {result.waited_seconds:.0f}s — this is the re-run "
-                "THIS command started, not a CI failure; re-run `coord "
-                "merge --revalidate` (or plain `coord merge`) shortly (#1925)"
-            )
-            deferred.add(entry.assignment_id)
-            click.echo(f"  --revalidate: {entry.error}")
-        else:
-            click.echo(
-                f"  --revalidate: CI re-run for {label} is still running "
-                f"after {result.waited_seconds:.0f}s — leaving it to the "
-                "merge gate this pass (will report as CI still running)"
-            )
     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.
+    """#2143: force a fresh board read after ``--revalidate``'s CI-staleness
+    arm (:func:`_apply_ci_revalidation`) — which, like
+    :func:`_apply_revalidation`'s composite/solo suite runs, used to be able
+    to hold the caller for minutes via a post-rerun settle poll.
+
+    #3276: that poll is gone — :func:`_apply_ci_revalidation` no longer
+    triggers a rerun at all (see its own docstring), so it returns quickly.
+    This reload stays anyway: :func:`_apply_revalidation`'s local-suite arm,
+    called just before this in both callers, can still run for minutes, and
+    the same staleness argument below applies to it too.
 
     ``_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 —
+    only when *it* recorded a new verdict; it has no way to know what ran
+    after it. Real state can change on GitHub while either arm is running —
     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
@@ -283,9 +223,9 @@ def _reload_board_after_wait(board, *, dry_run: bool):
     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.
+    extra ``load_board()`` is a rounding error next to the suite run(s) that
+    just happened. Under ``--dry-run`` nothing was triggered (no suite run
+    actually ran), so the board is left untouched.
     """
     if dry_run:
         return board
@@ -2392,15 +2332,16 @@ 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.
+            # #2143: `_apply_revalidation`'s local-suite run just above can
+            # run for minutes — re-read the board so the gates `process()`
+            # runs below see whatever landed on GitHub during it, not a
+            # pre-run snapshot. (#3276: `_apply_ci_revalidation` itself no
+            # longer triggers a rerun, so this is no longer also covering a
+            # CI-settle wait — see its own docstring.)
             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
-        # avoid handing to the gate. It stays PENDING with the explanatory
-        # `entry.error` _apply_ci_revalidation already set.
+        # #1925/#3276: `deferred_ci` is always empty now that
+        # `_apply_ci_revalidation` never triggers a rerun — kept so this
+        # exclusion needs no change if that ever stops being true.
         if only_entry.assignment_id in deferred_ci:
             events_only = []
         else:
@@ -2841,15 +2782,17 @@ 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.
+        # #2143: `_apply_revalidation`'s local-suite run just above can run
+        # for minutes — re-read the board so the gates `process()` runs
+        # below see whatever landed on GitHub during it, not a pre-run
+        # snapshot. (#3276: `_apply_ci_revalidation` itself no longer
+        # triggers a rerun, so this is no longer also covering a CI-settle
+        # wait — see its own docstring.)
         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
-    # PENDING state and the explanatory `entry.error` it already set; `items`
-    # (unfiltered) still carries them through to the save step below.
+    # #1925/#3276: `deferred_ci` is always empty now that
+    # `_apply_ci_revalidation` never triggers a rerun — kept so this
+    # exclusion needs no change if that ever stops being true. `items`
+    # (unfiltered) still carries every entry through to the save step below.
     process_items = (
         [x for x in items if x.assignment_id not in deferred_ci]
         if deferred_ci else items

{code_coordinator-0.5.535 → code_coordinator-0.5.536}/coord/merge_queue.py

@@ -2539,9 +2539,12 @@ MAX_CI_INFRA_RERUNS = 2
 # all. Kept defined — rather than deleted — because `QueuedMerge.
 # ci_stale_reruns` still exists for rows written before this fix (see its
 # own comment) and because `coord.commands.merge._apply_ci_revalidation`
-# (the opt-in ``--revalidate`` CLI arm) still references it; that caller is
-# lower severity (opt-in, human-invoked) and is a tracked follow-up, not
-# something this fix's file scope covers.
+# (the opt-in ``--revalidate`` CLI arm) still references it in its own
+# docstring. #3276 closed the gap #3266 left open there: that caller now
+# reports the rebase remedy for a staleness-only candidate instead of
+# calling `rerun_for_pr` for it either — the third and last of this
+# primitive's call sites, so nothing left in this module calls `rerun_for_pr`
+# for a condition it can never clear.
 MAX_CI_STALE_RERUNS = 2
 
 # #2252: at most one auto-rerun per failure streak before a genuinely-
@@ -3804,12 +3807,12 @@ def ci_revalidation_candidates(
     `rerun_for_pr` replays the same run against the same base it already
     used, so it can never see the new one. `process()`'s OWN #2197
     auto-rerun for this trigger was dropped for that reason (see
-    `MAX_CI_STALE_RERUNS`'s comment). The one remaining caller that still
-    calls `rerun_for_pr` on what this returns is `coord.commands.merge
-    ._apply_ci_revalidation` (the opt-in ``--revalidate`` CI arm) — equally
-    unable to clear the block, but lower severity since a human has to
-    explicitly ask for it. Left as-is here: fixing it is a change to that
-    module, out of this function's/file's scope, and a tracked follow-up.
+    `MAX_CI_STALE_RERUNS`'s comment). `coord.commands.merge
+    ._apply_ci_revalidation` (the opt-in ``--revalidate`` CI arm) was the one
+    remaining caller that still called `rerun_for_pr` on what this returns —
+    #3276 fixed it too: it now reports the rebase remedy for every entry this
+    function returns (all of them are staleness-only, by this function's own
+    contract above) instead of spending a guaranteed no-op CI cycle.
 
     #3396: `coord.commands.drive_queue._run_auto_revalidate_checks_stale`
     (the unattended periodic call site) still calls this function to find
@@ -4099,12 +4102,13 @@ class QueuedMerge:
     # this column.
     #
     # `coord.commands.merge._apply_ci_revalidation` (the opt-in
-    # ``--revalidate`` CLI arm) is the one remaining caller of
-    # `ci_revalidation_candidates` that still calls `rerun_for_pr` for this
-    # exact condition — it does not touch this counter (no budget, no cap;
-    # a human invoked it once, on purpose), but it is equally unable to
-    # clear a staleness block for the reason above, and is a tracked,
-    # lower-severity follow-up (see its own docstring).
+    # ``--revalidate`` CLI arm) never touched this counter (no budget, no
+    # cap; a human invoked it once, on purpose) but, until #3276, was the
+    # one remaining caller of `ci_revalidation_candidates` that still called
+    # `rerun_for_pr` for this exact unclearable condition. #3276 fixed it:
+    # that arm now reports the rebase remedy for a staleness-only candidate
+    # instead of re-running, so nothing in the codebase calls `rerun_for_pr`
+    # for a block only a rebase can clear.
     ci_stale_reruns: int = 0
     # #2252: count of automatic `CiStore.rerun_failed_for_pr` calls
     # `process()` has issued for this entry's CURRENT streak of genuinely-

{code_coordinator-0.5.535 → code_coordinator-0.5.536}/tests/test_cli_merge.py

@@ -3203,10 +3203,12 @@ class TestResolveBoardWorkKey:
 
 
 class TestMergeRevalidateCiRerunCli:
-    """#1851 black-box: `coord merge --revalidate` re-runs CI (not a local
-    suite) for an entry blocked solely on stale CI checks. `--dry-run` names
-    it without triggering anything; plain `--dry-run` (no --revalidate)
-    still names the PR as CI-stale in the gate reading."""
+    """#1851 black-box, updated by #3276: `coord merge --revalidate` used to
+    re-run CI (not a local suite) for an entry blocked solely on stale CI
+    checks, but #3266 established a same-base rerun can never clear that —
+    so it now reports the rebase remedy instead, identically under
+    `--dry-run` and for real. Plain `--dry-run` (no `--revalidate`) still
+    names the PR as CI-stale in the gate reading."""
 
     @staticmethod
     def _config(tmp_path: Path) -> Path:
@@ -3291,9 +3293,12 @@ class TestMergeRevalidateCiRerunCli:
         assert ci.rerun_calls == []
         assert "checks_stale" in result.output or "CI stale" in result.output
 
-    def test_revalidate_dry_run_names_the_rerun_without_triggering(
+    def test_revalidate_dry_run_names_the_skip_without_triggering(
         self, tmp_path: Path, coord_db,
     ) -> None:
+        """#3276: every candidate here is blocked *solely* on CI staleness —
+        a same-base rerun can never clear that (#3266) — so `--dry-run`
+        must not promise a rerun it would not (and could not) make."""
         cfg = self._config(tmp_path)
         self._seed()
         ci = self._fake_ci()
@@ -3305,10 +3310,16 @@ class TestMergeRevalidateCiRerunCli:
 
         assert result.exit_code == 0, result.output
         assert ci.rerun_calls == []
-        assert "would re-run CI" in result.output
+        assert "would re-run CI" not in result.output
+        assert "blocked solely on stale CI checks" in result.output
         assert "PR #501" in result.output
 
-    def test_revalidate_triggers_the_ci_rerun(self, tmp_path: Path, coord_db) -> None:
+    def test_revalidate_never_triggers_the_ci_rerun_for_a_stale_only_entry(
+        self, tmp_path: Path, coord_db,
+    ) -> None:
+        """#3276: `--revalidate` (no `--dry-run`) must behave identically to
+        the dry-run case above — nothing was ever actually triggerable for a
+        staleness-only block."""
         cfg = self._config(tmp_path)
         self._seed()
         ci = self._fake_ci()
@@ -3317,24 +3328,28 @@ class TestMergeRevalidateCiRerunCli:
             result = CliRunner().invoke(main, ["merge", "--config", str(cfg), "--revalidate"])
 
         assert result.exit_code == 0, result.output
-        assert ci.rerun_calls == [("acme/api", 501)]
-        assert "triggered a CI re-run" in result.output
+        assert ci.rerun_calls == []
+        assert "triggered a CI re-run" not in result.output
+        assert "blocked solely on stale CI checks" 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.
+    """#2143 black-box: a review approval that lands while ``--revalidate``'s
+    CI-staleness arm runs must be seen by the gate that runs right after —
+    not the board snapshot loaded before that arm ran.
 
     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.
+    ``ci1`` is blocked solely on stale CI (the arm this reload runs after —
+    #3276: it reports the rebase remedy rather than re-running CI, since a
+    same-base rerun can never clear that) and entry ``rv1`` is a completely
+    unrelated PENDING entry whose review approval only exists on the board
+    that gets saved *while* ``ci1`` is being processed. 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. The reload is unconditional
+    (see `_reload_board_after_wait`'s docstring), so it still runs even
+    though #3276 means nothing was actually triggered for `ci1`.
     """
 
     @staticmethod
@@ -3371,11 +3386,10 @@ class TestMergeRevalidateRereadsBoardAfterWait:
             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.
+                    # commit time below — the #1851 CI-staleness signal that
+                    # makes ci1 a candidate. #3276: `--revalidate` never
+                    # reruns for this, so this stays unchanged across every
+                    # read in the test.
                     return [SimpleNamespace(
                         name="build", status="completed", conclusion="success",
                         started_at=500.0, completed_at=None,
@@ -3437,7 +3451,7 @@ class TestMergeRevalidateRereadsBoardAfterWait:
             ))
         return Board(active=[], completed=reviews)
 
-    def test_review_approved_during_the_wait_is_not_reported_stale(
+    def test_review_approved_while_ci_stale_arm_runs_is_not_reported_stale(
         self, tmp_path: Path, coord_db,
     ) -> None:
         cfg = self._config(tmp_path)
@@ -3470,14 +3484,14 @@ class TestMergeRevalidateRereadsBoardAfterWait:
             )
 
         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
+        # #3276: ci1 is blocked solely on stale CI — the arm this reload
+        # runs after must report the remedy, never fire a same-base rerun.
+        assert ci.rerun_calls == []
+        assert "blocked solely on stale CI checks" in result.output
         # The core #2143 assertion: rv1 must never be reported blocked on a
-        # stale review read, and must actually merge on the fresh one.
+        # stale review read, and must actually merge on the fresh one —
+        # proving the reload after the CI-stale arm still ran even though
+        # #3276 means that arm no longer triggers anything for ci1.
         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()}