code-coordinator 0.5.124__tar.gz → 0.5.125__tar.gz

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.124",
+  "tag": "0.5.125",
   "distance": 0,
-  "node": "g6db81a3b5b4ce09b2be4da91abbbe348a1fdebc7",
+  "node": "g45b284e5f4bdc6047cbd9db9e0a0d4f1c11ca154",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-17"

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/ci_store.py

@@ -324,7 +324,7 @@ CI_RERUN_POLL_INTERVAL_SECONDS = 10.0
 CI_RERUN_MAX_WAIT_SECONDS = 360.0
 
 
-def _is_unreadable_check(check) -> bool:
+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`` /
     ``_gh_too_old_check``) — the read itself failed, so this says nothing
@@ -332,10 +332,33 @@ def _is_unreadable_check(check) -> bool:
     importing ``coord.ci_github`` — this module must stay backend-agnostic,
     and every stub/fake ``CheckRun``-alike in the test suite already has
     both attributes.
+
+    Public (#2347) — :mod:`coord.merge_queue` reuses this directly to
+    classify a ``checks_failed`` block whose failures are ALL this stand-in
+    as a bare check-list *fetch* failure (``CI_UNREADABLE_PREFIX``), distinct
+    from both a real "still running" and a real "ran and failed" verdict; see
+    that module's docstring for the classification this feeds.
+
+    Deliberately narrower than "any ``coord: ``-named synthetic check with
+    ``conclusion == "unknown"``": :class:`coord.gate_snapshot.GateSnapshot`
+    (the board *read* path's ``CiStore`` — :mod:`coord.merge_queue`'s
+    ``_entry_gate_status`` can be, and in production is, called with one —
+    see ``coord.serve_app``'s ``/board`` handler) emits its OWN such
+    stand-in, ``_stale_check`` (``"coord: gate snapshot stale (...)"``), for
+    a completely different local condition — the daemon's own refresh loop
+    fell behind, not a GitHub read failure — and #2347's classification must
+    not relabel that as "GitHub unreachable". Both `coord.ci_github` stand-ins
+    share the phrase "read CI status" in their name; `_stale_check` does not,
+    so requiring it is what keeps the two apart without this module having
+    to import `coord.gate_snapshot` (which itself imports `coord.ci_store` —
+    the reverse import would cycle) or duck-type on anything less stable
+    than the prose these three call sites already commit to.
     """
+    name = str(getattr(check, "name", ""))
     return (
         getattr(check, "conclusion", None) == "unknown"
-        and str(getattr(check, "name", "")).startswith("coord: ")
+        and name.startswith("coord: ")
+        and "read CI status" in name
     )
 
 
@@ -381,7 +404,7 @@ def wait_for_ci_settle(
 
     A "registering" read — no checks at all yet, or every check present is
     one of the #1525 synthetic unreadable stand-ins (see
-    :func:`_is_unreadable_check`) — never counts as settled, however many
+    :func:`is_unreadable_check`) — never counts as settled, however many
     times it's observed; only real, resolved checks do. Genuinely in-flight
     real checks (a run that registered and is now actually executing) also
     keep polling — that's the ordinary "wait for CI to finish" case this
@@ -409,7 +432,7 @@ def wait_for_ci_settle(
             except Exception:  # noqa: BLE001 — best-effort cache-bust only
                 pass
         checks = ci_store.list_checks_for_pr(repo, number)
-        registering = not checks or all(_is_unreadable_check(c) for c in checks)
+        registering = not checks or all(is_unreadable_check(c) for c in checks)
         if not registering and not in_flight_checks(checks):
             return CiSettleResult(
                 settled=True, checks=checks, waited_seconds=clock() - start,

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/commands/drive_queue.py

@@ -1837,11 +1837,21 @@ def _fetch_gate_a_pending(entries: list) -> dict[str, bool]:
 
 def _fetch_live_ci_gate(
     entries: list, config_path: Path | None
-) -> dict[str, bool]:
-    """``{entry_key: still_blocked}`` for every ``parked`` entry whose OWN
-    park reason is CI-shaped (#1891/#1892) — a FRESH, single-entry
-    re-derivation of the SAME gate ``coord merge --plan`` computes, taken
-    live, right now, this tick (#2182).
+) -> tuple[dict[str, bool], dict[str, str]]:
+    """``({entry_key: still_blocked}, {entry_key: reason})`` for every
+    ``parked`` entry whose OWN park reason is CI-shaped
+    (#1891/#1892/#2347) — a FRESH, single-entry re-derivation of the SAME
+    gate ``coord merge --plan`` computes, taken live, right now, this tick
+    (#2182).
+
+    The second dict (#2347) carries the reason text
+    :func:`coord.merge_queue.entry_gate_status` returned alongside each
+    still-blocked verdict — used ONLY to let :func:`coord.drive_queue.
+    plan_tick` rewrite a still-``parked`` entry's ``last_reason`` when the
+    fresh reading is specifically "GitHub unreachable"
+    (``is_ci_unreadable_reason``) and differs from what is currently stored;
+    see that function's ``live_ci_gate_reason`` parameter. Never consulted
+    to decide whether to resume — that remains the first dict's job alone.
 
     THE GAP THIS CLOSES. On the daemon host — the only machine that ever
     runs this tick (``docs/AGENT_OPERATIONS.md``) — ``_fetch_board_view``
@@ -1887,7 +1897,11 @@ def _fetch_live_ci_gate(
     have nothing to add — worse, ``coord.state.load_board()`` guards against
     being called from a thin client at all (#615).
     """
-    from coord.merge_queue import is_ci_infra_reason, is_ci_pending_reason  # noqa: PLC0415
+    from coord.merge_queue import (  # noqa: PLC0415
+        is_ci_infra_reason,
+        is_ci_pending_reason,
+        is_ci_unreadable_reason,
+    )
 
     targets = [
         e for e in entries
@@ -1895,15 +1909,16 @@ def _fetch_live_ci_gate(
         and (
             is_ci_pending_reason(getattr(e, "last_reason", "") or "")
             or is_ci_infra_reason(getattr(e, "last_reason", "") or "")
+            or is_ci_unreadable_reason(getattr(e, "last_reason", "") or "")
         )
     ]
     if not targets:
-        return {}
+        return {}, {}
 
     from coord.board_service import resolve as resolve_board_service  # noqa: PLC0415
 
     if resolve_board_service() is not None:
-        return {}
+        return {}, {}
 
     try:
         from coord import github_ops as _gh_ops  # noqa: PLC0415
@@ -1919,19 +1934,22 @@ def _fetch_live_ci_gate(
             entry_key(q.repo_name, q.issue_number): q for q in _mq.load_queue()
         }
     except Exception:  # noqa: BLE001 — see the fail-soft note above
-        return {}
+        return {}, {}
 
     overrides: dict[str, bool] = {}
+    reasons: dict[str, str] = {}
     for e in targets:
         q = queue_by_key.get(e.key)
         if q is None or not q.pr_number:
             continue
         try:
-            status, _reason = _mq.entry_gate_status(q, board, cfg, ci_store, _gh_ops)
+            status, reason = _mq.entry_gate_status(q, board, cfg, ci_store, _gh_ops)
         except Exception:  # noqa: BLE001 — leave this one entry to the ceiling
             continue
         overrides[e.key] = status != _mq.PLAN_READY
-    return overrides
+        if reason:
+            reasons[e.key] = reason
+    return overrides, reasons
 
 
 def _fetch_live_blocked_gate(
@@ -2337,7 +2355,11 @@ def drive_queue_tick(
         # on the daemon-host tick could previously be released only by the
         # #2158 45-minute ceiling, never by CI actually reporting, because
         # this tick's board read never computes a live `merge_plan`).
-        live_ci_gate = _fetch_live_ci_gate(entries, config_path)
+        # #2347: the reason half — lets a still-parked entry's `last_reason`
+        # be rewritten when the real cause is "GitHub unreachable" rather
+        # than whatever it originally parked on; see `plan_tick`'s
+        # `live_ci_gate_reason` parameter.
+        live_ci_gate, live_ci_gate_reason = _fetch_live_ci_gate(entries, config_path)
 
         # #2230: the same live re-derivation, for RE-EVALUABLE `blocked`
         # entries — see `_fetch_live_blocked_gate`'s docstring for the gap
@@ -2384,6 +2406,7 @@ def drive_queue_tick(
             gate_a_pending=gate_a_pending,
             cordons=cordons,
             live_ci_gate=live_ci_gate,
+            live_ci_gate_reason=live_ci_gate_reason,
             live_blocked_gate=live_blocked_gate,
             editable_drift=editable_drift,
         )

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/db.py

@@ -191,7 +191,8 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
             ci_infra_reruns INTEGER NOT NULL DEFAULT 0,
             ci_stale_reruns INTEGER NOT NULL DEFAULT 0,
             ci_flaky_reruns INTEGER NOT NULL DEFAULT 0,
-            ci_flaky_pending TEXT NOT NULL DEFAULT ''
+            ci_flaky_pending TEXT NOT NULL DEFAULT '',
+            ci_unreadable_reruns INTEGER NOT NULL DEFAULT 0
         );
 
         CREATE TABLE IF NOT EXISTS plans (
@@ -909,6 +910,14 @@ def _migrate_add_columns(conn: sqlite3.Connection) -> None:
         # row predating this migration and for a non-stream-json / PTY
         # worker whose log carries no such field.
         "ALTER TABLE assignments ADD COLUMN stop_reason TEXT",
+        # #2347: count of automatic checks `merge_queue.process()` has made
+        # against this entry's CURRENT streak of bare check-list FETCH
+        # failures (GitHub unreachable, not a real CI verdict) — see
+        # `coord.merge_queue.MAX_CI_UNREADABLE_RERUNS` and
+        # `QueuedMerge.ci_unreadable_reruns`'s docstring. 0 for every row
+        # predating this column, same as the column's own default for a
+        # freshly-enqueued entry.
+        "ALTER TABLE merge_queue ADD COLUMN ci_unreadable_reruns INTEGER NOT NULL DEFAULT 0",
     ]
     for sql in migrations:
         try:

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/drive.py

@@ -133,6 +133,7 @@ from coord.merge_queue import (
     is_ci_flaky_reason,
     is_ci_infra_reason,
     is_ci_pending_reason,
+    is_ci_unreadable_reason,
     is_stale_smoke_reason as _mq_is_stale_smoke_reason,
 )
 
@@ -2539,8 +2540,8 @@ def _effective_merge_gate_reason(
       own resolution path (#1474/#241's conflict-fix dispatch, reached
       through the bounded retry below). A re-test does not rebase a branch,
       and diverting to one is the same stall this issue is about, inverted.
-    - a CI reason (#1891/#1892/#2252) — `merge_reason` already carries a
-      live, recognised signal whose only resolution is more real time.
+    - a CI reason (#1891/#1892/#2252/#2347) — `merge_reason` already carries
+      a live, recognised signal whose only resolution is more real time.
       These bare waits sit right after the divergence check and must keep
       winning.
 
@@ -2559,6 +2560,7 @@ def _effective_merge_gate_reason(
         is_ci_pending_reason(state.merge_reason)
         or is_ci_infra_reason(state.merge_reason)
         or is_ci_flaky_reason(state.merge_reason)
+        or is_ci_unreadable_reason(state.merge_reason)
     ):
         return state.merge_reason, False
     fallback = _extract_gate_refusal_reason(counters.last_merge_diagnostic)
@@ -2864,6 +2866,24 @@ def _decide_merge(
             )
         )
 
+    # #2347: the sibling case checked right after #1891 — the check-list
+    # FETCH itself failed (GitHub unreachable: a transient `gh pr checks`
+    # HTTP 5xx, an auth blip), so there is no CI verdict of ANY shape yet,
+    # not even a real "still running" one. `coord merge`'s own live attempt
+    # already tracks a bounded count of consecutive fetch failures for this
+    # (`coord.merge_queue.MAX_CI_UNREADABLE_RERUNS`) and keeps waiting
+    # either way — there is no CI to rerun and no gate to re-test, only more
+    # real time (GitHub answering again). Retrying `coord merge` here would
+    # just re-observe the identical transport failure and spend an attempt
+    # for nothing.
+    if is_ci_unreadable_reason(state.merge_reason):
+        return _wait(
+            label=(
+                "MERGE: GitHub could not be reached to read CI status — "
+                f"waiting, not retrying (#2347): {state.merge_reason}"
+            )
+        )
+
     # #1892: the sibling case — a CI verdict DID arrive, but every failing
     # check said nothing about the code (never assigned a runner, or died
     # before checkout). `coord merge`'s own live attempt is already

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/drive_queue.py

@@ -96,6 +96,7 @@ from coord.merge_queue import (
     is_ci_flaky_reason,
     is_ci_infra_reason,
     is_ci_pending_reason,
+    is_ci_unreadable_reason,
 )
 from coord.models import is_policy_refusal_reason
 
@@ -154,6 +155,15 @@ STATE_FAILED = "failed"
 # today) on the very next tick. Same reasoning as #1892 for why this parks
 # rather than spends: relaunching right now would just observe the same
 # re-run-in-progress and wait again.
+#
+# #2347 extends the SAME state to a FOURTH trigger:
+# `coord.merge_queue.is_ci_unreadable_reason` — the check-list FETCH itself
+# failed (GitHub unreachable: a transient `gh pr checks` HTTP 5xx, an auth
+# blip), not a CI verdict of any shape. The "more real time" that un-parks
+# the entry is simply GitHub answering again on a later read — there is no
+# in-flight rerun to wait on, unlike #1892/#2252, only another attempt to
+# read. Same queue-level treatment as the other three: relaunching right now
+# would just observe the identical transport failure and wait again.
 STATE_PARKED = "parked"
 
 TERMINAL_QUEUE_STATES: frozenset[str] = frozenset(
@@ -959,10 +969,18 @@ def build_board_view(
         elif is_ci_flaky_reason(raw_reason) and not is_ci_flaky_reason(plan_reason):
             reason = raw_reason
             reason_is_live = False
+        # #2347: NO raw-row recovery needed here, unlike #1892/#2252 above —
+        # `coord.merge_queue._ci_unreadable_reason` needs no extra `CiStore`
+        # call (see that function's docstring), so `_entry_gate_status`
+        # computes the CI_UNREADABLE_PREFIX classification directly at
+        # board-build time. `plan_reason` already carries it whenever it
+        # applies; the live plan reading and a live `coord merge` attempt's
+        # raw reading can never disagree about this one.
         if not (
             is_ci_pending_reason(reason)
             or is_ci_infra_reason(reason)
             or is_ci_flaky_reason(reason)
+            or is_ci_unreadable_reason(reason)
         ):
             continue
         # #2158: the same plan row that came back with NO reason of its own
@@ -1059,6 +1077,13 @@ class Reconcile:
       every tick by the pre-pass in :func:`plan_tick`, which flips it back
       to ``waiting`` — no human, no escalation — the moment the board shows
       the gate has cleared.
+    * ``reparked``  — #2347: an ALREADY-``parked`` entry, still CONFIRMED
+      blocked by this tick's own fresh re-check — but that fresh check found
+      the real cause has become "GitHub could not be reached", distinct from
+      whatever reason the entry originally parked on. State does not change
+      (stays :data:`STATE_PARKED`), no attempt spent — only ``last_reason``
+      is rewritten, so an operator reading ``coord drive-queue list``/
+      ``status`` sees the true cause instead of a frozen, misleading one.
     * ``retry``     — genuinely dead: no session, no active work, and past the
       startup grace window.  Costs one attempt.
     * ``exhausted`` — as ``retry``, but out of attempts; pairs with a
@@ -2528,6 +2553,7 @@ def plan_tick(
     gate_a_pending: Mapping[str, bool] | None = None,
     cordons: Mapping[str, str] | None = None,
     live_ci_gate: Mapping[str, bool] | None = None,
+    live_ci_gate_reason: Mapping[str, str] | None = None,
     live_blocked_gate: Mapping[str, bool] | None = None,
     editable_drift: tuple[str, str] | None = None,
 ) -> TickPlan:
@@ -2635,6 +2661,21 @@ def plan_tick(
     side, which computes this ONLY for the bounded set of entries currently
     `parked` on a CI reason, never the whole queue.
 
+    *live_ci_gate_reason* (#2347) is *live_ci_gate*'s companion: the reason
+    text the SAME fresh `entry_gate_status` call returned, for entries whose
+    reading is STILL blocked. Never used to decide whether to resume (that
+    remains `live_ci_gate`'s job) — only to rewrite a still-parked entry's
+    `last_reason` when the fresh reading is `CI_UNREADABLE_PREFIX`-shaped and
+    differs from what is currently stored, so `coord drive-queue list`/
+    `status` shows "GitHub could not be reached" the moment that becomes the
+    real cause, instead of silently keeping whatever reason the entry
+    happened to park on originally (which #1891/#1892/#2252's "still shut ⇒
+    no reconcile, no write" rule would otherwise leave frozen indefinitely —
+    see the issue for the observed incident: a stale "CI running: ..."
+    reason surviving a run of transient GitHub API 503s for most of
+    `PARK_STALE_SECONDS` with no operator-visible signal of the real cause).
+    A key ABSENT here changes nothing — same as an absent `live_ci_gate` key.
+
     *live_blocked_gate* is #2230's counterpart, for `blocked` instead of
     `parked`: maps a RE-EVALUABLE `blocked` entry's key (never one
     :func:`is_permanent_block_reason` recognises — the shell never even
@@ -2882,6 +2923,36 @@ def plan_tick(
         live_override = (live_ci_gate or {}).get(entry.key)
         if live_override is not None:
             if live_override:
+                # #2347: CONFIRMED still blocked — but if the FRESH reading
+                # taken THIS tick says the real cause is "GitHub could not
+                # be reached" (not a real CI verdict) and that differs from
+                # whatever reason is currently stored, rewrite `last_reason`
+                # so `coord drive-queue list`/`status` says so — rather than
+                # silently re-confirming whatever reason this entry
+                # happened to park on originally, unboundedly, the way
+                # #1891/#1892/#2252's "still shut ⇒ no reconcile, no write"
+                # rule does for every other still-blocked reading. State
+                # stays `parked`, no attempt spent — this changes only what
+                # the operator is told, never the decision.
+                live_reason = (live_ci_gate_reason or {}).get(entry.key)
+                if (
+                    live_reason
+                    and is_ci_unreadable_reason(live_reason)
+                    and live_reason != entry.last_reason
+                ):
+                    reason = (
+                        f"{live_reason} — still parked; the live re-check "
+                        "this tick could not reach GitHub either (#2347)"
+                    )
+                    reconciles.append(
+                        Reconcile(
+                            entry.key,
+                            "reparked",
+                            reason,
+                            occupies=False,
+                            updates={"last_reason": reason},
+                        )
+                    )
                 continue
             reason = (
                 f"live re-check of {entry.key}'s gate this tick reads READY "

{code_coordinator-0.5.124 → code_coordinator-0.5.125}/coord/drive_state.py

@@ -597,6 +597,14 @@ def _merge_entry(
         # branch can ever legitimately fire for a given raw_reason.
         elif is_ci_flaky_reason(raw_reason) and not is_ci_flaky_reason(reason):
             reason = raw_reason
+        # #2347: deliberately NO third `elif` here for
+        # `is_ci_unreadable_reason` — unlike CI_INFRA_PREFIX/CI_FLAKY_PREFIX
+        # above, that classification needs no extra `CiStore` I/O (see
+        # `coord.merge_queue._ci_unreadable_reason`'s docstring), so
+        # `_entry_gate_status` already computes it directly at board-build
+        # time. `plan_entry["reason"]` (i.e. `reason` here) already carries
+        # it whenever it applies — there is nothing for the raw row to
+        # recover that the fresh plan reading doesn't already have.
 
     return {
         "status": status,