code-coordinator 0.5.57__tar.gz → 0.5.58__tar.gz

{code_coordinator-0.5.57/code_coordinator.egg-info → code_coordinator-0.5.58}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.57",
+  "tag": "0.5.58",
   "distance": 0,
-  "node": "ge814fae5eeda1e29d1a4fc796dc41051c4ae8d99",
+  "node": "g36b37b343666fd25278ef49e2b4521e94ec1a50a",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/coord/db.py

@@ -188,7 +188,8 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
             enqueued_at REAL,
             assignment_type TEXT DEFAULT 'work',
             required_gates TEXT,
-            ci_infra_reruns INTEGER NOT NULL DEFAULT 0
+            ci_infra_reruns INTEGER NOT NULL DEFAULT 0,
+            ci_stale_reruns INTEGER NOT NULL DEFAULT 0
         );
 
         CREATE TABLE IF NOT EXISTS plans (
@@ -697,6 +698,12 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # predating this column (no auto-reruns spent yet), same as the
         # column's own default for freshly-enqueued entries.
         "ALTER TABLE merge_queue ADD COLUMN ci_infra_reruns INTEGER NOT NULL DEFAULT 0",
+        # #2197: the CI-staleness auto-rerun's OWN counter — see
+        # `coord.merge_queue.MAX_CI_STALE_RERUNS` and
+        # `QueuedMerge.ci_stale_reruns`'s docstring for why it is kept
+        # separate from `ci_infra_reruns` rather than sharing it. 0 for
+        # every row predating this column, same as a freshly-enqueued entry.
+        "ALTER TABLE merge_queue ADD COLUMN ci_stale_reruns INTEGER NOT NULL DEFAULT 0",
         # #1956: verdict provenance — WHO recorded `review_verdict` and HOW
         # (see coord.models.Assignment.verdict_source for the three values
         # and why conflating them was the second half of #1956). NULL for

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/coord/merge_queue.py

@@ -1417,6 +1417,19 @@ def is_ci_infra_reason(reason: str | None) -> bool:
 # standing breakage.
 MAX_CI_INFRA_RERUNS = 2
 
+# #2197: same shape as MAX_CI_INFRA_RERUNS above, but for the OTHER CI
+# auto-rerun trigger `process()` supports — a PASSING check recorded against
+# a base that has since moved (:data:`CI_STALE_PREFIX`, #1851's staleness
+# signal), not a failure. Deliberately a SEPARATE constant/counter from
+# `ci_infra_reruns`: the two triggers answer opposite readings of CI ("this
+# failed and needs to prove itself again" vs. "this passed but predates the
+# base and needs a fresh answer") and must be independently capped and
+# independently legible in the audit trail. A base that keeps moving out
+# from under one PR (a busy queue, or a genuinely wedged branch) would
+# otherwise auto-rerun forever; two tries rides out an ordinary busy tick
+# without masking a PR that just isn't going to catch up unattended.
+MAX_CI_STALE_RERUNS = 2
+
 
 def _ci_infra_reason(
     ci: "CiStore", repo: str, number: int, failed: "list[CheckRun]"
@@ -2168,6 +2181,15 @@ class QueuedMerge:
     # forever. 0 for every entry that has never hit a verdictless failure,
     # and for rows predating this column.
     ci_infra_reruns: int = 0
+    # #2197: count of automatic `CiStore.rerun_for_pr` calls `process()` has
+    # issued for this entry's CURRENT run of CI staleness (#1851) — a
+    # PASSING check recorded against a base that has since moved. Kept
+    # separate from `ci_infra_reruns` above on purpose (see
+    # `MAX_CI_STALE_RERUNS`'s comment): the two triggers must be
+    # independently capped and independently legible in the audit trail.
+    # Capped at `MAX_CI_STALE_RERUNS`. 0 for every entry that has never gone
+    # CI-stale, and for rows predating this column.
+    ci_stale_reruns: int = 0
 
 
 class GhOps(Protocol):
@@ -2459,6 +2481,9 @@ def load_queue() -> list[QueuedMerge]:
             # #1892: column added via migration; NULL (pre-migration rows)
             # decodes to 0 — no auto-reruns spent yet, same as a fresh entry.
             ci_infra_reruns=row["ci_infra_reruns"] or 0,
+            # #2197: same NULL-to-0 decoding as ci_infra_reruns above, for
+            # rows predating this column.
+            ci_stale_reruns=row["ci_stale_reruns"] or 0,
         )
         for row in rows
     ]
@@ -2475,15 +2500,16 @@ def save_queue(items: list[QueuedMerge]) -> None:
                     assignment_id, repo_name, repo_github, branch,
                     target_branch, issue_number, issue_title, state,
                     pr_number, pr_url, size, last_attempt, error, enqueued_at,
-                    assignment_type, required_gates, ci_infra_reruns
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                    assignment_type, required_gates, ci_infra_reruns,
+                    ci_stale_reruns
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                 (
                     item.assignment_id, item.repo_name, item.repo_github,
                     item.branch, item.target_branch, item.issue_number,
                     item.issue_title, item.state, item.pr_number, item.pr_url,
                     item.size, item.last_attempt, item.error, item.enqueued_at,
                     item.assignment_type, json.dumps(list(item.required_gates or [])),
-                    item.ci_infra_reruns,
+                    item.ci_infra_reruns, item.ci_stale_reruns,
                 ),
             )
 
@@ -4503,16 +4529,69 @@ def process(
                 # distinctly (`checks_stale`) from checks_failed/
                 # checks_pending above so an operator (and `coord merge
                 # --revalidate`, the remedy) can tell the three apart.
+                #
+                # #2197: this used to always block here, escalating to a
+                # human (or, via `coord drive`, spending a merge attempt)
+                # for a condition a re-run resolves on its own — the exact
+                # #2170 regression (a docs-only base move stales a
+                # perfectly good green PR). Mirror #1892's shape exactly:
+                # auto-rerun via the SAME `CiStore.rerun_for_pr` this
+                # module already calls unattended for verdictless
+                # failures, up to `MAX_CI_STALE_RERUNS` — but track it
+                # with its OWN counter (`ci_stale_reruns`), never
+                # `ci_infra_reruns`, so a failed-then-stale (or
+                # stale-then-failed) PR does not have one trigger silently
+                # spend the other's budget, and so the audit trail can
+                # always tell which condition an auto-rerun was answering.
                 if checks and _ci_checks_are_stale(
                     checks, gh_ops, entry.repo_github, entry.target_branch, smoke,
                 ):
+                    if entry.ci_stale_reruns < MAX_CI_STALE_RERUNS:
+                        entry.ci_stale_reruns += 1
+                        reran = ci.rerun_for_pr(entry.repo_github, entry.pr_number)
+                        _log.info(
+                            "#2197 auto-rerun %d/%d for stale CI on %s#%d "
+                            "(PR #%s) (rerun_for_pr %s)",
+                            entry.ci_stale_reruns, MAX_CI_STALE_RERUNS,
+                            entry.repo_name, entry.issue_number,
+                            entry.pr_number,
+                            "triggered" if reran else "FAILED",
+                        )
+                        # #1891: same `CI_PENDING_PREFIX` wording the
+                        # genuinely-still-running case uses above — this is
+                        # what lets `coord drive`'s `is_ci_pending_reason`
+                        # check (coord/drive.py) treat a re-run THIS auto-
+                        # trigger just kicked off exactly like any other
+                        # in-flight CI: a bare wait, never a spent merge
+                        # attempt. The queue resumes it automatically once
+                        # the re-run reports, no operator needed.
+                        msg = (
+                            f"{CI_PENDING_PREFIX} re-run triggered for CI "
+                            "checks that predate the current base (#2197 "
+                            f"auto-rerun {entry.ci_stale_reruns}/"
+                            f"{MAX_CI_STALE_RERUNS} "
+                            f"{'triggered' if reran else 'failed to trigger'})"
+                        )
+                        entry.error = msg
+                        events.append(MergeEvent(entry, "checks_stale_rerun", msg))
+                        continue  # #292: skip, don't halt the group
                     msg = (
                         f"{CI_STALE_PREFIX} checks predate the current base "
-                        "— re-run CI (`coord merge --revalidate`) before merging"
+                        f"— auto-rerun budget exhausted ({entry.ci_stale_reruns}/"
+                        f"{MAX_CI_STALE_RERUNS}); re-run CI (`coord merge "
+                        "--revalidate`) before merging"
                     )
                     entry.error = msg
                     events.append(MergeEvent(entry, "checks_stale", msg))
                     continue  # #292: skip, don't halt the group
+                # #2197: reached only once the checks are genuinely fresh
+                # (or the smoke-side #1738/#1778/#1847 base-move exemption
+                # spared them) — mirrors the `ci_infra_reruns = 0` reset
+                # above and for the identical reason: whatever staleness
+                # streak the budget was tracking has now actually resolved,
+                # so a LATER base move starts its own budget from zero
+                # rather than inheriting an unrelated exhausted count.
+                entry.ci_stale_reruns = 0
             # #1318: cache is_epic_issue lookups for this entry — the same
             # referenced number can show up in both the PR body and one or
             # more commit messages below, and each lookup is a `gh` round

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/tests/test_cli_merge.py

@@ -2803,8 +2803,28 @@ class TestMergeRevalidateCiRerunCli:
             def __init__(self):
                 self.is_available = True
                 self.rerun_calls: list = []
+                self._checks_since_rerun = 0
 
             def list_checks_for_pr(self, repo, number):
+                # #2197: once --revalidate has triggered its own re-run,
+                # the read immediately after (inside `wait_for_ci_settle`)
+                # still reports the OLD stale-but-"completed" record — real
+                # GitHub can lag a beat before a rerun registers, and
+                # `wait_for_ci_settle` is specifically tolerant of a
+                # "completed" read regardless of content. Every read AFTER
+                # that one reflects the new run actually executing (real
+                # GitHub behaviour), which is what stops `process()`'s own
+                # #2197 auto-rerun from firing a REDUNDANT `gh run rerun`
+                # for the very run --revalidate just triggered and is
+                # already watching settle.
+                if self.rerun_calls:
+                    self._checks_since_rerun += 1
+                    if self._checks_since_rerun > 1:
+                        return [SimpleNamespace(
+                            name="build", status="in_progress",
+                            conclusion=None, started_at=None,
+                            completed_at=None,
+                        )]
                 # Green, but started well before the (mocked) base commit
                 # time below — the #1851 staleness signal.
                 return [SimpleNamespace(

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/tests/test_db.py

@@ -319,6 +319,79 @@ class TestMergeQueueCiInfraRerunsColumn:
         conn.close()
 
 
+# ── merge_queue.ci_stale_reruns column (#2197) ───────────────────────────────
+
+# Same pre-migration shape as _PRE_1892_MERGE_QUEUE_TABLE, plus the #1892
+# column — exercises the #2197 migration landing on a DB that already
+# picked up ci_infra_reruns but predates ci_stale_reruns.
+_PRE_2197_MERGE_QUEUE_TABLE = """
+    CREATE TABLE merge_queue (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        assignment_id TEXT NOT NULL,
+        repo_name TEXT NOT NULL,
+        repo_github TEXT NOT NULL,
+        branch TEXT NOT NULL,
+        target_branch TEXT NOT NULL,
+        issue_number INTEGER NOT NULL,
+        issue_title TEXT NOT NULL,
+        state TEXT NOT NULL DEFAULT 'pending',
+        pr_number INTEGER,
+        pr_url TEXT,
+        size INTEGER,
+        last_attempt REAL,
+        error TEXT,
+        enqueued_at REAL,
+        assignment_type TEXT DEFAULT 'work',
+        required_gates TEXT,
+        ci_infra_reruns INTEGER NOT NULL DEFAULT 0
+    )
+"""
+
+
+class TestMergeQueueCiStaleRerunsColumn:
+    def test_fresh_database_has_it_from_the_create(
+        self, isolated_conn: sqlite3.Connection
+    ) -> None:
+        assert "ci_stale_reruns" in _merge_queue_columns(isolated_conn)
+
+    def test_existing_database_gains_it_in_place(self) -> None:
+        """The real path: a coord.db created before #2197 (but after #1892),
+        upgraded by _ensure_schema."""
+        conn = sqlite3.connect(":memory:")
+        conn.row_factory = sqlite3.Row
+        conn.execute(_PRE_2197_MERGE_QUEUE_TABLE)
+        conn.execute(
+            "INSERT INTO merge_queue "
+            "(assignment_id, repo_name, repo_github, branch, target_branch, "
+            "issue_number, issue_title) "
+            "VALUES ('w1', 'api', 'acme/api', 'b', 'main', 7, 't')"
+        )
+        conn.commit()
+        assert "ci_stale_reruns" not in _merge_queue_columns(conn)
+
+        _ensure_schema(conn)
+
+        assert "ci_stale_reruns" in _merge_queue_columns(conn)
+        # A pre-existing row survives and reads as "no auto-reruns spent
+        # yet" — the same default a freshly-enqueued entry gets.
+        row = conn.execute(
+            "SELECT ci_stale_reruns FROM merge_queue WHERE issue_number = 7"
+        ).fetchone()
+        assert row["ci_stale_reruns"] == 0
+        conn.close()
+
+    def test_migration_is_idempotent(self) -> None:
+        conn = sqlite3.connect(":memory:")
+        conn.row_factory = sqlite3.Row
+        conn.execute(_PRE_2197_MERGE_QUEUE_TABLE)
+        conn.commit()
+        _ensure_schema(conn)
+        _ensure_schema(conn)
+        _ensure_schema(conn)
+        assert "ci_stale_reruns" in _merge_queue_columns(conn)
+        conn.close()
+
+
 # ── override_connection ────────────────────────────────────────────────────────
 
 class TestOverrideConnection:

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/tests/test_merge_queue.py

@@ -153,6 +153,15 @@ class TestPersistence:
         again = {x.assignment_id: x.ci_infra_reruns for x in load_queue()}
         assert again == {"a": 2, "b": 0}
 
+    def test_roundtrip_preserves_ci_stale_reruns(self, coord_db) -> None:
+        # #2197: same durability requirement as ci_infra_reruns above, for
+        # the CI-staleness auto-rerun's own independent counter.
+        a = _q("a")
+        a.ci_stale_reruns = 2
+        save_queue([a, _q("b")])
+        again = {x.assignment_id: x.ci_stale_reruns for x in load_queue()}
+        assert again == {"a": 2, "b": 0}
+
 
 class TestEnqueue:
     def _assignment(self, *, branch: str | None = "worker/foo") -> Assignment:
@@ -5626,19 +5635,43 @@ class TestCiRevalidationCandidates:
 class TestProcessCiStaleness:
     """#1851: `process()` refuses to merge a green-but-CI-stale entry, in
     both the live path and the `--dry-run` preview — named distinctly
-    (`checks_stale`) from `checks_failed`/`checks_pending`."""
+    (`checks_stale`) from `checks_failed`/`checks_pending`.
+
+    #2197: the live path no longer blocks on the FIRST stale reading — it
+    auto-reruns CI first (mirroring #1892's verdictless-failure arm, same
+    `CiStore.rerun_for_pr` call), parking as `checks_stale_rerun`
+    (`CI_PENDING_PREFIX` wording, so `coord drive`'s #1891 "wait, don't
+    spend an attempt" logic applies) up to `MAX_CI_STALE_RERUNS` times.
+    Only once that budget is exhausted does it report the terminal
+    `checks_stale` block a human has to act on. `--dry-run` is unaffected —
+    it only ever previews, never mutates, so it keeps reporting
+    `checks_stale` on the very first pass and never calls `rerun_for_pr`.
+    """
 
     @staticmethod
-    def _ci(started_at: float | None):
+    def _ci(started_at: float | None, *, rerun_ok: bool = True):
         from types import SimpleNamespace
 
         class _Ci:
             is_available = True
-            def list_checks_for_pr(self, repo, number):
-                return [SimpleNamespace(
+
+            def __init__(self):
+                self.rerun_calls: list = []
+                # Mutable — a test can flip this between two `process()`
+                # calls to simulate the re-run GitHub was asked to trigger
+                # reporting back, the same way a real CiStore's backing
+                # check-run data would change between two live reads.
+                self.checks = [SimpleNamespace(
                     name="build", status="completed", conclusion="success",
                     started_at=started_at, completed_at=None,
                 )]
+
+            def list_checks_for_pr(self, repo, number):
+                return self.checks
+
+            def rerun_for_pr(self, repo, number):
+                self.rerun_calls.append((repo, number))
+                return rerun_ok
         return _Ci()
 
     class _Gh(FakeGh):
@@ -5646,37 +5679,124 @@ class TestProcessCiStaleness:
         def get_branch_commit_timestamp(self, repo, branch):
             return self.ts
 
-    def test_live_merge_blocked_and_reports_checks_stale(self) -> None:
+    def test_first_stale_reading_auto_reruns_instead_of_blocking(self) -> None:
+        """The exact #2170 regression: a docs-only base move stales an
+        otherwise-green PR. The first live pass must not escalate — it
+        triggers a CI re-run and parks, unattended."""
         items = [_q("w1", pr=99)]
         gh = self._Gh()
-        events = process(items, gh, ci_store=self._ci(started_at=500.0))
+        ci = self._ci(started_at=500.0)
+        events = process(items, gh, ci_store=ci)
         assert items[0].state == PENDING
         assert gh.merge_calls == []
+        assert ci.rerun_calls == [("acme/api", 99)]
+        assert items[0].ci_stale_reruns == 1
         kinds = [e.kind for e in events]
-        assert "checks_stale" in kinds
+        assert "checks_stale_rerun" in kinds
+        assert "checks_stale" not in kinds
         assert "checks_failed" not in kinds
         assert "checks_pending" not in kinds
+        # #1891: CI_PENDING_PREFIX wording — `coord drive` waits rather
+        # than spending a merge attempt on this.
+        assert items[0].error.startswith("CI running:")
+
+    def test_merges_on_a_later_pass_once_the_rerun_reports_green(self) -> None:
+        """Full #2170 lifecycle, end to end: stale → auto-rerun → a LATER
+        `process()` tick (the re-run having reported back fresh and green,
+        no operator involved) actually merges it. Acceptance criterion,
+        verbatim from #2197: "process() triggers a CI re-run and the entry
+        parks as checks_pending without spending an attempt, then merges on
+        a later pass once green.\""""
+        items = [_q("w1", pr=99)]
+        gh = self._Gh()
+        ci = self._ci(started_at=500.0)
+
+        first = process(items, gh, ci_store=ci)
+        assert items[0].state == PENDING
+        assert "checks_stale_rerun" in [e.kind for e in first]
+        assert ci.rerun_calls == [("acme/api", 99)]
+
+        # The re-run GitHub was asked to trigger has now reported back: a
+        # fresh, green check — the same `ci` object, no new `coord merge`
+        # flag involved.
+        from types import SimpleNamespace
+        ci.checks = [SimpleNamespace(
+            name="build", status="completed", conclusion="success",
+            started_at=1500.0, completed_at=None,
+        )]
+
+        second = process(items, gh, ci_store=ci)
+        assert items[0].state == MERGED
+        assert ci.rerun_calls == [("acme/api", 99)]  # unchanged — no 2nd rerun
+        kinds = [e.kind for e in second]
+        assert "merged" in kinds
+        assert "checks_stale" not in kinds
+        assert "checks_stale_rerun" not in kinds
+
+    def test_reruns_stop_at_the_cap_and_then_reports_checks_stale(self) -> None:
+        from coord.merge_queue import MAX_CI_STALE_RERUNS
+
+        items = [_q("w1", pr=99)]
+        gh = self._Gh()
+        ci = self._ci(started_at=500.0)
+        for expected in range(1, MAX_CI_STALE_RERUNS + 1):
+            events = process(items, gh, ci_store=ci)
+            assert items[0].ci_stale_reruns == expected
+            assert "checks_stale_rerun" in [e.kind for e in events]
+        assert len(ci.rerun_calls) == MAX_CI_STALE_RERUNS
+
+        # Budget exhausted — the next pass reports the terminal block and
+        # triggers no further rerun.
+        events = process(items, gh, ci_store=ci)
+        assert len(ci.rerun_calls) == MAX_CI_STALE_RERUNS  # unchanged
+        assert items[0].ci_stale_reruns == MAX_CI_STALE_RERUNS  # unchanged
+        kinds = [e.kind for e in events]
+        assert "checks_stale" in kinds
+        assert "checks_stale_rerun" not in kinds
+        assert items[0].state == PENDING
 
     def test_live_merge_proceeds_when_checks_fresh(self) -> None:
         items = [_q("w1", pr=99)]
         gh = self._Gh()
-        events = process(items, gh, ci_store=self._ci(started_at=1500.0))
+        ci = self._ci(started_at=1500.0)
+        events = process(items, gh, ci_store=ci)
         assert items[0].state == MERGED
+        assert ci.rerun_calls == []
         kinds = [e.kind for e in events]
         assert "checks_stale" not in kinds
+        assert "checks_stale_rerun" not in kinds
+
+    def test_resets_after_a_clean_pass_so_a_later_staleness_starts_fresh(self) -> None:
+        """Mirrors `ci_infra_reruns`'s own reset test (#1892): a later,
+        unrelated base move must not inherit a budget already spent on an
+        earlier staleness streak."""
+        from coord.merge_queue import MAX_CI_STALE_RERUNS
+
+        items = [_q("w1", pr=99)]
+        items[0].ci_stale_reruns = MAX_CI_STALE_RERUNS
+        gh = self._Gh()
+        ci = self._ci(started_at=1500.0)  # fresh — resolves the old streak
+        process(items, gh, ci_store=ci)
+        assert items[0].state == MERGED
+        assert items[0].ci_stale_reruns == 0
 
     def test_force_merge_overrides_ci_staleness(self) -> None:
         items = [_q("w1", pr=99)]
         gh = self._Gh()
-        process(items, gh, ci_store=self._ci(started_at=500.0), force_merge=True)
+        ci = self._ci(started_at=500.0)
+        process(items, gh, ci_store=ci, force_merge=True)
         assert items[0].state == MERGED
+        assert ci.rerun_calls == []  # force_merge skips the CI gate entirely
 
-    def test_dry_run_previews_checks_stale_without_merging(self) -> None:
+    def test_dry_run_previews_checks_stale_without_rerunning(self) -> None:
         items = [_q("w1", pr=99)]
         gh = self._Gh()
-        events = process(items, gh, ci_store=self._ci(started_at=500.0), dry_run=True)
+        ci = self._ci(started_at=500.0)
+        events = process(items, gh, ci_store=ci, dry_run=True)
         assert items[0].state == PENDING
         assert gh.merge_calls == []
+        assert ci.rerun_calls == []
+        assert items[0].ci_stale_reruns == 0
         kinds = [e.kind for e in events]
         assert "checks_stale" in kinds
         assert "merged" not in kinds
@@ -6020,19 +6140,29 @@ class TestProcessCiInfraAutoRerun:
 
     def test_jobs_api_never_called_on_the_all_green_path(self) -> None:
         """Acceptance criterion: the extra jobs API call happens only on the
-        failure path — assert it is not called when all checks pass."""
+        failure path — assert it is not called when all checks pass.
+
+        #2197: a plain `FakeGh` has no `get_branch_commit_timestamp`, which
+        makes the unrelated #1851 staleness gate fail closed (stale) — and
+        since #2197 that ALSO calls `rerun_for_pr` (the very same method
+        this test's `rerun_calls` tracks for the #1892 dimension), so the
+        check here must be unambiguously fresh to keep this test isolated
+        to the jobs-call dimension it's actually about.
+        """
         items = [_q("w1", pr=99)]
-        gh = FakeGh()
+
+        class _Gh(FakeGh):
+            def get_branch_commit_timestamp(self, repo, branch):
+                return 1000.0
+
+        gh = _Gh()
         passing = _check("e2e", conclusion="success")
         passing.run_id = "999"
+        passing.started_at = 1500.0  # after the mocked base — fresh, not stale
         ci = self._Ci(checks=[passing], jobs_by_run={})
 
         process(items, gh, ci_store=ci)
 
-        # #1892's acceptance criterion is specifically about the extra jobs
-        # call, not about whether the merge itself completes — a plain
-        # `FakeGh` has no `get_branch_commit_timestamp`, so the unrelated
-        # #1851 staleness gate fails closed regardless of #1892.
         assert ci.jobs_calls == []
         assert ci.rerun_calls == []
 

{code_coordinator-0.5.57 → code_coordinator-0.5.58}/tui/tests/fixtures/board_sample.json

@@ -314,6 +314,7 @@
       "assignment_type": "work",
       "branch": "issue-748-fixture",
       "ci_infra_reruns": 0,
+      "ci_stale_reruns": 0,
       "enqueued_at": 1000000950.0,
       "error": null,
       "id": 1,