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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.121
+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.121 → 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.121
+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.121 → code_coordinator-0.5.125}/code_coordinator.egg-info/SOURCES.txt

@@ -784,7 +784,9 @@ tests/acceptance/ms-51/home-active.spec.ts
 tests/acceptance/ms-51/manifest.yml
 tests/acceptance/ms-51/tsconfig.json
 tests/acceptance/ms-51/mocks/home-active.html
+tests/acceptance/ms-65/board_tabs_2282.rs
 tests/acceptance/ms-65/contract.md
+tests/acceptance/ms-65/manifest.yml
 tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen
 tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen
 tests/acceptance/ms-65/mocks/board-preview-tab.screen

{code_coordinator-0.5.121 → code_coordinator-0.5.125}/code_coordinator.egg-info/scm_file_list.json

@@ -429,7 +429,9 @@
     "tests/acceptance/ms-51/manifest.yml",
     "tests/acceptance/ms-51/mocks/home-active.html",
     "tests/acceptance/ms-51/tsconfig.json",
+    "tests/acceptance/ms-65/board_tabs_2282.rs",
     "tests/acceptance/ms-65/contract.md",
+    "tests/acceptance/ms-65/manifest.yml",
     "tests/acceptance/ms-65/mocks/board-baseline-no-tabs.screen",
     "tests/acceptance/ms-65/mocks/board-pinned-3-tabs.screen",
     "tests/acceptance/ms-65/mocks/board-preview-tab.screen",

{code_coordinator-0.5.121 → code_coordinator-0.5.125}/code_coordinator.egg-info/scm_version.json

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

{code_coordinator-0.5.121 → code_coordinator-0.5.125}/coord/agent.py

@@ -3186,6 +3186,17 @@ not apply to it.
 - If even the scoped run genuinely cannot finish in time, follow the \
 background-and-poll pattern in the ONE-SHOT section above — do not invent \
 a chunk-and-loop workaround.
+- #2192: check your own diff now — does it change user-visible behavior \
+AND add/modify zero test files? That exact pattern was 18.5% of this \
+repo's blocking reviews (#2132): the code was correct, but CLAUDE.md's \
+"Testing — black-box coverage is the acceptance bar" rule was skipped, so \
+the adversarial reviewer rejected it — costing a paid review leg plus a \
+fix + re-review round trip to catch something you can see for free right \
+now, in this same already-running session. If it fires, add the test \
+before declaring done. If this genuinely is a pure refactor / \
+internal-only change (CLAUDE.md's existing exemption), say so explicitly \
+in your final message instead — that already satisfies the reviewer, no \
+test required.
 
 #252: before exiting, emit a SMOKE_TESTS block telling the human what to \
 manually verify.  You changed the code; you know what's worth poking.

{code_coordinator-0.5.121 → 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.121 → 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.121 → code_coordinator-0.5.125}/coord/commands/plan_followup.py

@@ -787,8 +787,9 @@ def _fix_from_review(
 @click.command(
     help=(
         "Dispatch a headless same-branch fix worker.\n\n"
-        "ASSIGNMENT_ID is either a WORK assignment whose test gate FAILED (or "
-        "whose PR has red CI), or a REVIEW assignment whose verdict was "
+        "ASSIGNMENT_ID is either a WORK assignment whose test gate FAILED "
+        "(or whose PR has red CI, or whose oracle-loop acceptance trust "
+        "gate FAILED — #2344), or a REVIEW assignment whose verdict was "
         "request-changes. Either way the fix lands on the ORIGINAL branch and "
         "updates the ORIGINAL PR — no new issue-N-* branch, no orphan PR."
     )
@@ -802,12 +803,12 @@ def _fix_from_review(
     help=(
         "Override the #555 interactive-work exclusion when fixing a review of "
         "work that ran under claude-pty, or (#2051) dispatch a WORK-row fix "
-        "when neither the test verdict nor a live CI read shows a failure — "
-        "for when the caller knows the PR is red but the check missed it "
-        "(ci_store not configured, a transient read error). Since #2091 the "
-        "refusal names which of those it was, so check the `note:` line "
-        "before reaching for this. Does NOT override max_review_iterations "
-        "or the #522 terminal-work guard."
+        "when neither the test verdict, a live CI read, nor the acceptance "
+        "trust gate shows a failure — for when the caller knows the PR is red "
+        "but the check missed it (ci_store not configured, a transient read "
+        "error). Since #2091 the refusal names which of those it was, so "
+        "check the `note:` line before reaching for this. Does NOT override "
+        "max_review_iterations or the #522 terminal-work guard."
     ),
 )
 def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> None:
@@ -837,10 +838,27 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     # `smoke_test=NULL` and must still be fixable.
     test_failed = assignment.test_state == "failed" or assignment.smoke_test == "fail"
 
+    # #2344: the oracle-loop TRUST GATE (docs/ORACLE_LOOP.md, #2199) is a
+    # fourth door onto this command. `_decide_acceptance_gate`
+    # (coord/drive.py) dispatches `coord fix <work_aid>` the instant the
+    # gate's coordinator-run re-run of the sealed suite comes back red — the
+    # same shape as `_decide_test` dispatching on a failed Test verdict.
+    # Before this, nothing here recognized that door: a milestone whose
+    # trust gate failed in isolation (Test not yet run, or already passed;
+    # CI green) hit the #2051 "expected a failed test verdict" refusal on
+    # every attempt — structurally unwinnable, not a transient miss — until
+    # the drive-queue entry parked after burning its retry budget (ms-65 /
+    # #2282, observed live 2026-08-17).
+    acceptance_failed = assignment.acceptance_state == "failed"
+
     # #1622 (part 3): red CI is the third trigger.  Only consulted when the
     # local test gate has NOT already failed, so the cheap in-DB path stays
-    # zero-I/O and the existing failure story keeps priority.
-    ci_read = CiRead() if test_failed else _read_ci(cfg, assignment)
+    # zero-I/O and the existing failure story keeps priority. #2344: same
+    # treatment for a failed trust gate — it is definitive evidence on its
+    # own, so skip the live CI read entirely rather than let a green CI read
+    # (which says nothing about the trust gate's sealed-suite re-run) shadow
+    # it below.
+    ci_read = CiRead() if (test_failed or acceptance_failed) else _read_ci(cfg, assignment)
     ci_story = ci_read.story
 
     # #2091: the stored Test verdict says PASSED while the branch's live CI
@@ -876,8 +894,9 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
             err=True,
         )
 
-    # #2051: none of the three doors (failed test verdict, red CI, or the
-    # review-id door handled above) is open.  `_read_ci` is read-only and
+    # #2051 (extended by #2344): none of the four doors (failed test
+    # verdict, red CI, a failed acceptance trust gate, or the review-id door
+    # handled above) is open.  `_read_ci` is read-only and
     # fail-quiet (see :class:`CiRead`) — a missing story means "no CI
     # evidence of a failure", never "CI is green" — so a caller who KNOWS
     # the PR is red (ci_store not configured for this repo, a transient
@@ -886,15 +905,16 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     # that caller's release valve; it is NOT a way to skip the #555 / #522 /
     # max_review_iterations guards, which sit elsewhere.
     forced_without_evidence = False
-    if not test_failed and ci_story is None:
+    if not test_failed and not acceptance_failed and ci_story is None:
         if not force:
             click.echo(
                 f"error: assignment {assignment_id} test_state is "
                 f"{assignment.test_state!r} / smoke_test is "
-                f"{assignment.smoke_test!r}, expected a failed test verdict "
-                "(or red CI on its PR, or a request-changes review id). If "
-                "the PR is actually red and this check missed it, re-run "
-                "with --force.",
+                f"{assignment.smoke_test!r} / acceptance_state is "
+                f"{assignment.acceptance_state!r}, expected a failed test "
+                "verdict (or red CI on its PR, a failed acceptance trust "
+                "gate, or a request-changes review id). If the PR is "
+                "actually red and this check missed it, re-run with --force.",
                 err=True,
             )
             # #2091: say WHY there is no CI evidence.  Before this, six
@@ -940,6 +960,14 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
     test_output_file = COORD_DIR / "test_output" / f"{assignment_id}.txt"
     if ci_story is not None:
         test_output = ci_story
+    elif acceptance_failed and not test_failed:
+        # #2344: the trust gate's own recorded reason is the evidence for
+        # this door — `coord acceptance record` writes it to
+        # `acceptance_reason` at the same time it flips `acceptance_state`
+        # to "failed" (coord/state.py). Neither the CI-story nor the
+        # smoke/test-reason fallbacks below apply here: this door fires
+        # precisely when Test/CI are NOT what's red.
+        test_output = assignment.acceptance_reason or ""
     elif test_output_file.exists():
         test_output = test_output_file.read_text()
     elif assignment.smoke_test_reason or assignment.test_reason:
@@ -965,6 +993,9 @@ def fix(assignment_id: str, config_path: Path, guidance: str, force: bool) -> No
             "red)"
         )
         _failure_heading = "Reported failure (--force, unverified)"
+    elif acceptance_failed and not test_failed and ci_story is None:
+        _what = "a failed oracle-loop acceptance trust gate (#2199)"
+        _failure_heading = "Acceptance trust-gate failure"
     else:
         _what = "red CI" if ci_story is not None else "a failed smoke test"
         _failure_heading = "CI failure" if ci_story is not None else "Test failure"

{code_coordinator-0.5.121 → 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.121 → 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.121 → 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.121 → 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,