code-coordinator 0.5.662__tar.gz → 0.5.663__tar.gz

{code_coordinator-0.5.662 → code_coordinator-0.5.663}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.662",
+  "tag": "0.5.663",
   "distance": 0,
-  "node": "ge117a8cdf2f43c28be0be40fec94a54767d63259",
+  "node": "g4fa82a0d22ef5481ff797449d2d357cd31981a6d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-22"

{code_coordinator-0.5.662 → code_coordinator-0.5.663}/coord/db.py

@@ -1155,7 +1155,16 @@ def retry_on_locked(
 # request-changes rates between workflow and single legs over a sample of
 # issues BEFORE anyone considers relaxing Test/Review for workflow legs —
 # a separate, later decision this column only supplies the data for.
-_DB_SCHEMA_VERSION = 24
+#
+# #3754: bumped 24 -> 25 for the new `merge_queue.ci_rerun_budget_sha` column
+# appended to `_MIGRATE_ADD_COLUMNS` below — the `branch_head_sha` that
+# `ci_infra_reruns`/`ci_flaky_reruns`/`ci_unreadable_reruns`/`ci_flaky_pending`
+# were last accrued against, same pairing shape as #3263's `ci_seen_checks_
+# sha`. Lets a new commit landing while CI is still red (a ci-fix leg's own
+# push, most commonly) re-arm those budgets for its own fair rerun-once
+# chance instead of inheriting an already-exhausted count from an unrelated
+# prior commit. See `coord.merge_queue.QueuedMerge.ci_rerun_budget_sha`.
+_DB_SCHEMA_VERSION = 25
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -1403,7 +1412,8 @@ _SCHEMA_SQL = """
             ci_fix_detail_sha TEXT NOT NULL DEFAULT '',
             ci_fix_detail_json TEXT,
             ci_seen_checks_sha TEXT NOT NULL DEFAULT '',
-            ci_seen_check_names_json TEXT
+            ci_seen_check_names_json TEXT,
+            ci_rerun_budget_sha TEXT NOT NULL DEFAULT ''
         );
 
         CREATE TABLE IF NOT EXISTS plans (
@@ -2640,6 +2650,16 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # commit" by `coord.merge_queue._ci_seen_check_names`.
     "ALTER TABLE merge_queue ADD COLUMN ci_seen_checks_sha TEXT NOT NULL DEFAULT ''",
     "ALTER TABLE merge_queue ADD COLUMN ci_seen_check_names_json TEXT",
+    # #3754: the `branch_head_sha` that `ci_infra_reruns`/`ci_flaky_reruns`/
+    # `ci_unreadable_reruns`/`ci_flaky_pending` were last accrued against --
+    # see `coord.merge_queue.QueuedMerge.ci_rerun_budget_sha`'s docstring.
+    # Lets a new commit landing while CI is still red (a ci-fix leg's own
+    # push, most commonly) re-arm those rerun budgets for its own fair
+    # rerun-once chance instead of inheriting an already-exhausted count
+    # from an unrelated prior commit. '' for every row predating this
+    # migration, read identically to "no live CI-failure read yet" by
+    # `coord.merge_queue.MergeQueue.process`.
+    "ALTER TABLE merge_queue ADD COLUMN ci_rerun_budget_sha TEXT NOT NULL DEFAULT ''",
     # #3339: the explicit operator assertion that clears a terminal
     # `refused_premise` row — see `coord.state.mark_premise_rechecked` and
     # `coord drive-queue clear-refusal`. Unlike `refused_policy`, a premise

{code_coordinator-0.5.662 → code_coordinator-0.5.663}/coord/merge_queue.py

@@ -4897,6 +4897,23 @@ class QueuedMerge:
     # is nothing to contradict on the very first read of a fresh SHA.
     ci_seen_checks_sha: str = ""
     ci_seen_check_names_json: str | None = None
+    # #3754: `branch_head_sha` (see the field above) that `ci_infra_reruns`/
+    # `ci_flaky_reruns`/`ci_unreadable_reruns`/`ci_flaky_pending` were last
+    # accrued against. Those four durable fields used to be reset ONLY in
+    # the "genuinely resolved" block below (reached only once CI reads
+    # fully green) — so a NEW commit landing while CI is STILL red (most
+    # commonly a ci-fix leg's own push) inherited whatever was left of the
+    # PRIOR commit's budget instead of getting its own fair rerun-once
+    # chance. That silently turned a single flaky required check into two
+    # consecutive `checks_failed` verdicts back to back, burning the
+    # #2972 fix-round ceiling on a PR nothing was actually wrong with.
+    # Compared against `branch_head_sha` at the top of the `if failed:`
+    # block below: a mismatch re-arms all four fields for the new commit
+    # before any of #2347/#1892/#2252's own budget checks run, mirroring
+    # the `ci_seen_checks_sha` pairing immediately above. '' for every
+    # entry that has never had a live CI-failure read, and for rows
+    # predating this column.
+    ci_rerun_budget_sha: str = ""
 
 
 class GhOps(Protocol):
@@ -5308,6 +5325,9 @@ def load_queue() -> list[QueuedMerge]:
             # ci_fix_detail_json above, for rows predating this migration.
             ci_seen_checks_sha=row["ci_seen_checks_sha"] or "",
             ci_seen_check_names_json=row["ci_seen_check_names_json"],
+            # #3754: same NULL-to-'' decoding as ci_seen_checks_sha above,
+            # for rows predating this migration.
+            ci_rerun_budget_sha=row["ci_rerun_budget_sha"] or "",
         )
         for row in rows
     ]
@@ -5332,8 +5352,9 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         ci_unreadable_reruns, ci_fix_dispatches,
                         ci_fix_head_sha, ci_fix_noop_streak,
                         ci_fix_detail_sha, ci_fix_detail_json,
-                        ci_seen_checks_sha, ci_seen_check_names_json
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                        ci_seen_checks_sha, ci_seen_check_names_json,
+                        ci_rerun_budget_sha
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                     (
                         item.assignment_id, item.repo_name, item.repo_github,
                         item.branch, item.target_branch, item.issue_number,
@@ -5346,6 +5367,7 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         item.ci_fix_head_sha, item.ci_fix_noop_streak,
                         item.ci_fix_detail_sha, item.ci_fix_detail_json,
                         item.ci_seen_checks_sha, item.ci_seen_check_names_json,
+                        item.ci_rerun_budget_sha,
                     ),
                 )
 
@@ -9036,6 +9058,25 @@ def process(
                     summary = ", ".join(
                         f"{c.name} ({c.conclusion})" for c in failed
                     )
+                    # #3754: a NEW commit landing while CI is still red
+                    # (most commonly a ci-fix leg's own push) must get its
+                    # own fair rerun-once chance, not inherit whatever is
+                    # left of a DIFFERENT, prior commit's budget — the
+                    # "genuinely resolved" reset later in this function only
+                    # fires once CI reads fully green, which a still-broken
+                    # (or still-flaky) new commit never reaches. Guarded on
+                    # `branch_head_sha` being known at all: an unknown SHA
+                    # carries no information either way, so leave the
+                    # existing budget alone rather than reset against "".
+                    if (
+                        entry.branch_head_sha
+                        and entry.branch_head_sha != entry.ci_rerun_budget_sha
+                    ):
+                        entry.ci_infra_reruns = 0
+                        entry.ci_flaky_reruns = 0
+                        entry.ci_flaky_pending = ""
+                        entry.ci_unreadable_reruns = 0
+                        entry.ci_rerun_budget_sha = entry.branch_head_sha
                     # #2347: classify a bare check-list FETCH failure
                     # BEFORE #1892's infra classifier gets a chance — a
                     # synthetic unreadable check always carries `run_id ==
@@ -9320,6 +9361,12 @@ def process(
                 # failures the budget was tracking is over. A LATER,
                 # unrelated fetch failure starts its own count from zero.
                 entry.ci_unreadable_reruns = 0
+                # #3754: keep `ci_rerun_budget_sha` in lockstep with the
+                # three counters above — harmless if it's already current
+                # (the `if failed:` guard above is idempotent), but keeps a
+                # later failure on this SAME sha (a flaky green-then-read)
+                # from being misread as stale tracking.
+                entry.ci_rerun_budget_sha = entry.branch_head_sha or ""
                 # #1851: a green CI result can itself be stale relative to the
                 # base — see `_ci_checks_are_stale`'s docstring. Named
                 # distinctly (`checks_stale`) from checks_failed/

{code_coordinator-0.5.662 → code_coordinator-0.5.663}/tests/test_db.py

@@ -2508,7 +2508,11 @@ class TestUatStateAndReasonColumns:
 # `review_claims` / #3333's `smoke_claims` bumps above. Closes the race where
 # the live review-completion path and the orphan sweep both see
 # `review_posted_at IS NULL` and both post the identical GitHub comment.
-_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (24, 100)
+# #3754 bumped this to (25, 101): `merge_queue.ci_rerun_budget_sha` — the
+# `branch_head_sha` the CI-flaky/infra/unreadable rerun budgets were last
+# accrued against, so a new commit landing while CI is still red gets its
+# own fair rerun-once chance instead of inheriting an exhausted budget.
+_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (25, 101)
 
 
 class TestMigrateAddColumnsVersionGuard:

{code_coordinator-0.5.662 → code_coordinator-0.5.663}/tests/test_merge_queue.py

@@ -11703,6 +11703,109 @@ class TestProcessCiFlakyAutoRerun:
         assert "ci_flaky_rerun" not in kinds
 
 
+# ── #3754: rerun budgets are scoped to the commit they were accrued for ─────
+
+class TestProcessCiRerunBudgetScopedToCommit:
+    """A NEW ``branch_head_sha`` (a ci-fix leg's own push, most commonly)
+    must get its own fair #2252 rerun-once chance rather than inherit
+    whatever is left of a DIFFERENT, prior commit's exhausted budget —
+    the repro in #3754 is exactly a ci-fix leg landing at the fix-round
+    ceiling because its fresh push inherited an already-spent streak."""
+
+    def test_new_commit_after_exhausted_budget_gets_its_own_rerun(self) -> None:
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        # Commit A: budget already exhausted and confirmed real (mirrors
+        # `test_fails_again_spends_the_attempt_identical_to_today` above).
+        entry.branch_head_sha = "sha_a"
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_infra_reruns = mq.MAX_CI_INFRA_RERUNS
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_unreadable_reruns = mq.MAX_CI_UNREADABLE_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        # Commit A still red -> budget exhausted, plain checks_failed,
+        # no rerun attempted -- unchanged from today's behaviour.
+        events = process(items, gh, ci_store=ci)
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert ci.rerun_failed_calls == []
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+
+        # A new commit lands (e.g. a ci-fix leg's own push) and ALSO
+        # fails CI -- it must get its own fresh rerun-once chance rather
+        # than being immediately confirmed as broken from A's exhausted
+        # budget.
+        entry.branch_head_sha = "sha_b"
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "ci_flaky_rerun" in kinds
+        assert "checks_failed" not in kinds
+        assert ci.rerun_failed_calls == [("acme/api", 99)]
+        assert entry.ci_infra_reruns == 0
+        assert entry.ci_flaky_reruns == 1
+        assert entry.ci_unreadable_reruns == 0
+        assert entry.ci_flaky_pending
+        assert entry.ci_rerun_budget_sha == "sha_b"
+
+    def test_same_commit_failing_again_keeps_the_exhausted_budget(self) -> None:
+        """Control: without a NEW sha, the existing exhausted-budget
+        behaviour (today's `checks_failed` on a repeat failure) is
+        unchanged — the reset is scoped to a genuinely new commit, not
+        every tick."""
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        entry.branch_head_sha = "sha_a"
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert ci.rerun_failed_calls == []
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+        assert entry.ci_rerun_budget_sha == "sha_a"
+
+    def test_unknown_branch_head_sha_does_not_reset_the_budget(self) -> None:
+        """An unknown sha (``board=None``, the dry-preview path with no
+        live `gh` fetch) carries no information either way -- leave the
+        existing budget alone rather than reset against ``""``."""
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        entry.branch_head_sha = None
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+        assert entry.ci_rerun_budget_sha == "sha_a"
+
+
 # ── #778: staging_items() ─────────────────────────────────────────────────────
 
 class TestStagingItems: