code-coordinator 0.5.514__tar.gz → 0.5.515__tar.gz

{code_coordinator-0.5.514 → code_coordinator-0.5.515}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.514",
+  "tag": "0.5.515",
   "distance": 0,
-  "node": "g1db1111f52a074ffa43d96868edfe6dd44b84b97",
+  "node": "ge613e87191b4cc036d660b56820c2096be20c180",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-21"

{code_coordinator-0.5.514 → code_coordinator-0.5.515}/coord/ci_store.py

@@ -539,6 +539,25 @@ CI_RERUN_POLL_INTERVAL_SECONDS = 10.0
 CI_RERUN_MAX_WAIT_SECONDS = 360.0
 
 
+def is_unreadable_check_name(name: str) -> bool:
+    """The name-only half of :func:`is_unreadable_check` (#3438).
+
+    Split out so a caller holding only a bare check *name* — not a full
+    ``CheckRun`` with a ``.conclusion`` — can still recognize the #1525
+    synthetic stand-in. This is exactly the shape of
+    ``QueuedMerge.ci_seen_check_names_json`` (:mod:`coord.merge_queue`'s
+    #3263 shrinkage guard persists names, not whole ``CheckRun`` objects),
+    so a row poisoned before #3438's write-side fix — one whose stored JSON
+    already contains a synthetic name — can be filtered on *read* too,
+    recovering in place rather than needing manual DB repair.
+
+    One question, one answer: :func:`is_unreadable_check` delegates here for
+    its own name check rather than re-deriving the same prefix/substring
+    test, so the two can never drift apart.
+    """
+    return name.startswith("coord: ") and "read CI status" in name
+
+
 def is_unreadable_check(check) -> bool:
     """True for the #1525 synthetic "could not read CI status" / "gh too
     old" stand-ins (``coord.ci_github._unreadable_check`` /
@@ -570,11 +589,7 @@ def is_unreadable_check(check) -> bool:
     than the prose these three call sites already commit to.
     """
     name = str(getattr(check, "name", ""))
-    return (
-        getattr(check, "conclusion", None) == "unknown"
-        and name.startswith("coord: ")
-        and "read CI status" in name
-    )
+    return getattr(check, "conclusion", None) == "unknown" and is_unreadable_check_name(name)
 
 
 @dataclass

{code_coordinator-0.5.514 → code_coordinator-0.5.515}/coord/merge_queue.py

@@ -38,6 +38,7 @@ from coord.ci_store import (
     failed_checks,
     in_flight_checks,
     is_unreadable_check,
+    is_unreadable_check_name,
     is_verdictless_job,
     shrunk_check_names,
     summarize,
@@ -2442,7 +2443,11 @@ def _ci_seen_check_names(entry: "QueuedMerge") -> frozenset[str]:
         return frozenset()
     if not isinstance(names, list):
         return frozenset()
-    return frozenset(str(n) for n in names)
+    # #3438: filter defensively on READ too, not just at the #3438 write-side
+    # fix in `_ci_record_seen_check_names` — a row already poisoned in the
+    # wild (written before this fix) recovers on its very next read here,
+    # rather than being stuck until someone hand-edits the DB.
+    return frozenset(str(n) for n in names if not is_unreadable_check_name(str(n)))
 
 
 def _ci_record_seen_check_names(entry: "QueuedMerge", checks: list[CheckRun]) -> None:
@@ -2462,9 +2467,20 @@ def _ci_record_seen_check_names(entry: "QueuedMerge", checks: list[CheckRun]) ->
     that disappears for more than one consecutive tick keeps being flagged
     rather than being silently dropped from the record the moment it first
     vanishes.
+
+    #3438: the #1525 synthetic "could not read CI status" stand-in
+    (:func:`coord.ci_store.is_unreadable_check`) is excluded from
+    *current_names* on BOTH branches. That stand-in only ever appears in a
+    read where the real checks could not be fetched at all; memoizing its
+    name would poison this entry permanently, because the only read that
+    could ever re-supply it (another failed fetch) would simultaneously
+    fail to report every real check name too, which the #3263 guard would
+    also reject as shrinkage — a closed loop with no exit. Filtering here,
+    at the point of record, means it never enters
+    ``ci_seen_check_names_json`` in the first place, on either branch.
     """
     sha = entry.branch_head_sha or ""
-    current_names = {c.name for c in checks}
+    current_names = {c.name for c in checks if not is_unreadable_check(c)}
     if entry.ci_seen_checks_sha != sha:
         entry.ci_seen_checks_sha = sha
         entry.ci_seen_check_names_json = json.dumps(sorted(current_names))

{code_coordinator-0.5.514 → code_coordinator-0.5.515}/tests/test_ci_store.py

@@ -218,6 +218,46 @@ class TestShrunkCheckNames:
         assert shrunk_check_names(seen, checks) == frozenset({"a", "b"})
 
 
+class TestIsUnreadableCheckName:
+    """#3438: the name-only half of `is_unreadable_check`, split out so a
+    caller holding only a bare check NAME (e.g. `coord.merge_queue`'s
+    persisted `ci_seen_check_names_json`, which stores names, not whole
+    `CheckRun` objects) can still recognize the #1525 synthetic stand-in."""
+
+    def test_matches_the_unreadable_check_stand_in_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: could not read CI status for acme/api#99 (HTTP 503)"
+        assert is_unreadable_check_name(name) is True
+
+    def test_matches_the_gh_too_old_stand_in_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: gh is too old to read CI status for acme/api#99 (v1.0)"
+        assert is_unreadable_check_name(name) is True
+
+    def test_does_not_match_a_real_check_name(self) -> None:
+        from coord.ci_store import is_unreadable_check_name
+        assert is_unreadable_check_name("cargo-test") is False
+
+    def test_does_not_match_the_gate_snapshot_stale_stand_in(self) -> None:
+        """A different `coord: `-prefixed synthetic, for a different local
+        condition (#2347's own documented distinction) — must not match
+        just because it shares the prefix."""
+        from coord.ci_store import is_unreadable_check_name
+        name = "coord: gate snapshot stale (120s)"
+        assert is_unreadable_check_name(name) is False
+
+    def test_agrees_with_is_unreadable_check_on_full_check_objects(self) -> None:
+        """One question, one answer: `is_unreadable_check` must delegate
+        here rather than re-deriving the same test, so the two can never
+        drift apart."""
+        from coord.ci_github import _unreadable_check
+        from coord.ci_store import is_unreadable_check, is_unreadable_check_name
+
+        check = _unreadable_check("acme/api", 99, "HTTP 503")
+        assert is_unreadable_check(check) is True
+        assert is_unreadable_check_name(check.name) is True
+
+
 class _FakeClock:
     """Deterministic (clock, sleep) pair for `wait_for_ci_settle` tests
     (#1925) — `sleep` advances the same counter `clock` reads, so a bounded

{code_coordinator-0.5.514 → code_coordinator-0.5.515}/tests/test_merge_queue.py

@@ -9568,6 +9568,142 @@ class TestProcessCiCheckShrinkage:
         assert "checks_pending" not in [e.kind for e in events]
 
 
+class TestProcessCiCheckShrinkageIgnoresSyntheticUnreadableStandIn:
+    """#3438: the #1525 synthetic "could not read CI status" stand-in must
+    never be memoized into the #3263 shrinkage guard's seen-name set. It
+    only ever appears in a read where the real checks could not be fetched,
+    so recording it would close a loop with no exit: the only read that
+    could ever re-supply it (another failed fetch) would simultaneously
+    fail to report every real check name too, which the guard would also
+    reject as shrinkage. `quadraui#1043` deadlocked exactly this way for
+    ~9 hours (2026-09-21) with all 10 real checks green the whole time.
+    """
+
+    class _Gh(FakeGh):
+        """A fixed, current base timestamp so #1851's staleness gate never
+        fires once the real checks resolve — every check below has
+        `started_at` safely after it."""
+
+        def get_branch_commit_timestamp(self, repo: str, branch: str) -> float | None:
+            return 1000.0
+
+    class _Ci:
+        is_available = True
+
+        def __init__(self, checks):
+            self.checks = checks
+
+        def list_checks_for_pr(self, repo, number):
+            return self.checks
+
+    @staticmethod
+    def _c(name: str, conclusion: str) -> CheckRun:
+        return CheckRun(
+            name=name, status="completed", conclusion=conclusion,
+            url=f"https://gh/runs/{name}", run_id=name,
+            started_at=1500.0, completed_at=None,
+        )
+
+    @staticmethod
+    def _synthetic(repo: str, number: int, detail: str = "HTTP 503") -> CheckRun:
+        from coord.ci_github import _unreadable_check
+        return _unreadable_check(repo, number, detail)
+
+    def test_synthetic_stand_in_is_never_recorded_as_seen(self) -> None:
+        """A read with N real (green) checks plus the synthetic stand-in
+        must not persist the synthetic's name — only the real ones."""
+        items = [_q("w1", pr=99)]
+        items[0].branch_head_sha = "sha1"
+        gh = self._Gh()
+        real = [
+            self._c("cargo-test", "success"),
+            self._c("cargo-test-gtk", "success"),
+        ]
+        ci = self._Ci(real + [self._synthetic("acme/api", 99)])
+
+        first = process(items, gh, ci_store=ci)
+        assert "checks_unreadable" in [e.kind for e in first]
+        assert items[0].state == PENDING
+
+        seen = json.loads(items[0].ci_seen_check_names_json)
+        assert set(seen) == {"cargo-test", "cargo-test-gtk"}
+        assert not any(str(n).startswith("coord: ") for n in seen)
+
+    def test_a_later_clean_read_of_only_the_real_checks_merges(self) -> None:
+        """The acceptance scenario end to end: a read with the synthetic
+        plus N real checks, then a read with only the N real checks — the
+        shrinkage guard must report nothing missing and the entry must
+        become merge-eligible, not deadlock forever."""
+        items = [_q("w1", pr=99)]
+        items[0].branch_head_sha = "sha1"
+        gh = self._Gh()
+        real = [
+            self._c("cargo-test", "success"),
+            self._c("cargo-test-gtk", "success"),
+        ]
+        ci = self._Ci(real + [self._synthetic("acme/api", 99)])
+        process(items, gh, ci_store=ci)
+        assert items[0].state == PENDING
+
+        ci.checks = real
+        second = process(items, gh, ci_store=ci)
+        kinds = [e.kind for e in second]
+        assert "checks_pending" not in kinds
+        assert items[0].state == MERGED
+        assert "merged" in kinds
+
+    def test_recovers_a_row_poisoned_before_this_fix(self) -> None:
+        """An entry whose PERSISTED `ci_seen_check_names_json` already
+        contains a synthetic name — simulating a row poisoned by a
+        pre-#3438 write — must resolve normally on the next real-check
+        read, with no manual DB repair (the read-side filter in
+        `_ci_seen_check_names`)."""
+        items = [_q("w1", pr=99)]
+        items[0].branch_head_sha = "sha1"
+        items[0].ci_seen_checks_sha = "sha1"
+        items[0].ci_seen_check_names_json = json.dumps([
+            "cargo-test",
+            "cargo-test-gtk",
+            "coord: could not read CI status for acme/api#99 (HTTP 503)",
+        ])
+        gh = self._Gh()
+        ci = self._Ci([
+            self._c("cargo-test", "success"),
+            self._c("cargo-test-gtk", "success"),
+        ])
+
+        events = process(items, gh, ci_store=ci)
+        kinds = [e.kind for e in events]
+        assert "checks_pending" not in kinds
+        assert items[0].state == MERGED
+        assert "merged" in kinds
+
+    def test_a_genuinely_vanished_real_check_still_trips_the_guard(self) -> None:
+        """Regression guard: this fix must not blunt #3263 itself — a REAL
+        check name that actually vanishes (no synthetic involved) still
+        parks the entry as pending with the CI_PENDING_PREFIX reason."""
+        items = [_q("w1", pr=99)]
+        items[0].branch_head_sha = "sha1"
+        gh = self._Gh()
+        ci = self._Ci([
+            self._c("cargo-test", "success"),
+            self._c("cargo-test-gtk", "failure"),
+        ])
+        first = process(items, gh, ci_store=ci)
+        assert "checks_failed" in [e.kind for e in first]
+        assert items[0].state == PENDING
+
+        # `cargo-test-gtk` (a REAL check, not the synthetic stand-in)
+        # vanishes from the next read — must still be caught.
+        ci.checks = [self._c("cargo-test", "success")]
+        second = process(items, gh, ci_store=ci)
+        kinds = [e.kind for e in second]
+        assert "checks_pending" in kinds
+        assert "merged" not in kinds
+        assert items[0].error.startswith(mq.CI_PENDING_PREFIX)
+        assert "cargo-test-gtk" in items[0].error
+
+
 class TestProcessCiInfraAutoRerun:
     """#1892: `process()`'s live merge path auto-reruns CI (instead of just
     blocking) when every failing check is verdictless, capped at