code-coordinator 0.5.67__tar.gz → 0.5.69__tar.gz

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.67",
+  "tag": "0.5.69",
   "distance": 0,
-  "node": "g24273de7c436f9fc913f05fd3536c014eca80c25",
+  "node": "g9207e64664c53099584e448cecb53206429b6a9c",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/coord/agent.py

@@ -747,6 +747,43 @@ def _graphify_update(repo_path: Path, *, timeout: float = 600.0) -> tuple[bool,
     return True, (result.stdout or "").strip()
 
 
+# #2212: count how many Bash commands in a worker's leg invoked `graphify` —
+# the measurable half of the graph-first navigation rule in
+# WORKER_SYSTEM_PROMPT above. The rule has lapsed into disuse before (see
+# #2212's issue body) because nothing tracked whether workers actually
+# queried the graph; this is written into every reaped worker's log (see
+# the "# reap: done" line in `_reap`) as a plain `grep`-able counter — zero
+# across N consecutive legs means the prompt instruction isn't landing.
+# Deliberately NOT a DB column: this is a cheap, best-effort signal, not a
+# gate anything blocks on, so it stays out of the Assignment schema/migrations.
+# Separators recognized before a command token: `;`, `&`, `|` (covers `&&`
+# and `||` too, since `\s*` after the class soaks up the second char) and a
+# bare newline — Claude Code's Bash tool very commonly emits multi-line
+# command strings (e.g. `cd repo\ngraphify query "foo"`) that aren't joined
+# with `;`/`&&`, so newline must count as a separator or those legs
+# undercount to 0 (#2212 review).
+_GRAPHIFY_INVOCATION_RE = re.compile(r"(?:^|[\n;&|]\s*)graphify(?:\s|$)")
+
+
+def _count_graphify_invocations(bash_commands: list[str]) -> int:
+    """Count *bash_commands* entries that invoke the ``graphify`` CLI.
+
+    Matches ``graphify`` as a command token — at the start of the string,
+    after a shell separator (``;``, ``&&``, ``||``, ``|``), or after a bare
+    newline (multi-line Bash tool calls, e.g. ``cd repo\\ngraphify query
+    "..."``) — so ``graphify query "..."`` counts but a path or string that
+    merely contains the substring ``graphify`` (e.g. ``cat
+    graphify-out/graph.json``, where ``graphify`` is a path component rather
+    than a command) does not.
+
+    Note this counts matching *entries* in ``bash_commands``, not individual
+    invocations: a single command like ``"graphify query a && graphify query
+    b"`` counts once, not twice. Treat the result as an "at least one graph
+    query this leg" signal, not an exact invocation tally.
+    """
+    return sum(1 for cmd in bash_commands if cmd and _GRAPHIFY_INVOCATION_RE.search(cmd))
+
+
 def _infer_repo_github_slug(repo_path: str) -> str | None:
     """Best-effort ``owner/repo`` slug for *repo_path*'s ``origin`` remote (#1492).
 
@@ -2878,6 +2915,11 @@ absolute path outside your cwd). That shared checkout is not yours: edits \
 there are lost, or collide with other workers running at the same time. If \
 your worktree looks unexpectedly empty or unwritable, STOP and report it — \
 do not fall back to editing the base checkout and copying files over.
+- For "where is X handled" / "what calls this" / architecture questions, \
+query the codebase graph first: `graphify query "<question>"` via Bash. \
+Grep/Read are for confirming an exact string or line, not for discovering \
+structure. No `graphify-out/graph.json` in this worktree? Skip straight to \
+grep, silently — do not stop to build one (#2212).
 
 This session is ONE-SHOT and non-interactive (#1394):
 - There is no next turn and no human to reply to you. Background-task \
@@ -7440,7 +7482,20 @@ class AgentServer:
         try:
             with open(assignment.log_path, "a") as reopen:
                 final_status = assignment.status if assignment else "unknown"
-                reopen.write(f"# reap: done (exit_code={exit_code} status={final_status})\n")
+                # #2212: log a plain `graphify_invocations=N` counter alongside
+                # the existing reap line — this is the measurable half of the
+                # graph-first navigation rule (see WORKER_SYSTEM_PROMPT and
+                # `_count_graphify_invocations`). `_worker_summary` is `None`
+                # for a non-stream-json log or a parse failure; counting 0 in
+                # that case is the honest answer, not a lie — best-effort like
+                # everything else in this function.
+                _graphify_invocations = _count_graphify_invocations(
+                    _worker_summary.bash_commands if _worker_summary is not None else []
+                )
+                reopen.write(
+                    f"# reap: done (exit_code={exit_code} status={final_status} "
+                    f"graphify_invocations={_graphify_invocations})\n"
+                )
         except (OSError, AttributeError):
             pass
 

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/coord/commands/drive_queue.py

@@ -1006,6 +1006,105 @@ def _fetch_gate_a_pending(entries: list) -> dict[str, bool]:
     return pending
 
 
+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).
+
+    THE GAP THIS CLOSES. On the daemon host — the only machine that ever
+    runs this tick (``docs/AGENT_OPERATIONS.md``) — ``_fetch_board_view``
+    reads the local DB directly and never populates ``merge_plan`` at all
+    (see ``_local_merge_queue_rows``'s docstring): it is *computed*, not
+    stored, and computing it needs a live ``ci_store``/``gh_ops`` this
+    read-only board fetch deliberately does not build. So
+    ``IssueFacts.merge_ci_pending_live`` is unconditionally ``False`` on
+    every parked entry this tick ever sees, and the ONLY thing that used to
+    release such a park was :data:`coord.drive_queue.PARK_STALE_SECONDS` —
+    up to 45 minutes — even at the instant CI actually reports, because
+    nothing on the read path ever re-checked. claude-coordinator#2159 is
+    that gap caught live: at 03:25:46 UTC, ``coord merge --dry-run`` for the
+    entry read READY (no gate objection) while ``coord drive-queue list``,
+    reading the SAME board a moment later, still read ``parked`` — the two
+    surfaces disagreeing about the exact same fact.
+
+    THE FIX. Scoped to the bounded few entries actually sitting in
+    ``parked`` on a CI reason right now (typically 0-1, never the whole
+    merge queue — see :func:`coord.merge_queue.entry_gate_status`'s
+    docstring for why this deliberately does NOT call the whole-queue
+    :func:`coord.merge_queue.plan` instead), so paying for a live
+    ``gh``-backed check per entry, every ~3-minute tick, is the same
+    "small and predictable" cost an operator's own ``coord merge --plan``
+    already pays on demand — not the unbounded per-tick GitHub polling
+    #1344 removed from the read path.
+
+    Fails OPEN per entry and CLOSED overall in the sense that matters: a key
+    simply ABSENT from the returned dict (an unreadable config, a
+    ``ci_store`` that failed to build, an entry ``coord.merge_queue.
+    load_queue()`` no longer carries, or any other exception) leaves that
+    entry to :func:`coord.drive_queue.plan_tick`'s pre-#2182 fallback — the
+    #2158 :data:`~coord.drive_queue.PARK_STALE_SECONDS` ceiling — exactly as
+    if this function had never run. A transient failure here degrades to
+    the OLD (already-shipped, already-bounded) behaviour, never to a wedge
+    and never to a wrongly-forced resume.
+
+    Gated on ``resolve_board_service() is None`` (the daemon-host tick,
+    same guard :func:`_fetch_board_view` uses for its own local-DB top-up):
+    on a thin client the daemon's real ``GET /board`` already carries a live
+    ``merge_plan`` section, so ``build_board_view`` already resolves
+    ``merge_ci_pending_live=True`` there on its own and this function would
+    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
+
+    targets = [
+        e for e in entries
+        if e.state == STATE_PARKED
+        and (
+            is_ci_pending_reason(getattr(e, "last_reason", "") or "")
+            or is_ci_infra_reason(getattr(e, "last_reason", "") or "")
+        )
+    ]
+    if not targets:
+        return {}
+
+    from coord.board_service import resolve as resolve_board_service  # noqa: PLC0415
+
+    if resolve_board_service() is not None:
+        return {}
+
+    try:
+        from coord import github_ops as _gh_ops  # noqa: PLC0415
+        from coord import merge_queue as _mq  # noqa: PLC0415
+        from coord.ci_store import build_ci_store  # noqa: PLC0415
+        from coord.commands._common import _load_config  # noqa: PLC0415
+        from coord.state import load_board as _load_board  # noqa: PLC0415
+
+        cfg = _load_config(config_path)
+        board = _load_board()
+        ci_store = build_ci_store(cfg.ci_store.type)
+        queue_by_key = {
+            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 {}
+
+    overrides: dict[str, bool] = {}
+    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)
+        except Exception:  # noqa: BLE001 — leave this one entry to the ceiling
+            continue
+        overrides[e.key] = status != _mq.PLAN_READY
+    return overrides
+
+
 def _launch_argv(entry: QueueEntry, config_path: Path | None) -> list[str]:
     """The ``coord drive --tmux`` argv for *entry*.
 
@@ -1318,6 +1417,14 @@ def drive_queue_tick(
         # tick when no entry is parked that way — which is the common case.
         gate_a_pending = _fetch_gate_a_pending(entries)
 
+        # #2182: for every entry parked on a CI reason, a fresh single-entry
+        # re-derivation of its gate, taken live THIS tick — see
+        # `_fetch_live_ci_gate`'s docstring for the gap this closes (a park
+        # 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)
+
         # #2101: release cordons. THIS is the hole the issue names — the
         # queue's launcher had zero pause awareness (`coord/drive.py` checks
         # pause only when routing a *worker*), so a cordoned host kept getting
@@ -1349,6 +1456,7 @@ def drive_queue_tick(
             exit_dead_end=exit_dead_end,
             gate_a_pending=gate_a_pending,
             cordons=cordons,
+            live_ci_gate=live_ci_gate,
         )
 
         if reconcile_only:

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/coord/drive_queue.py

@@ -1932,6 +1932,7 @@ def plan_tick(
     exit_dead_end: Mapping[str, bool] | None = None,
     gate_a_pending: Mapping[str, bool] | None = None,
     cordons: Mapping[str, str] | None = None,
+    live_ci_gate: Mapping[str, bool] | None = None,
 ) -> TickPlan:
     """Decide one tick.  Pure; the caller executes the returned plan.
 
@@ -2008,6 +2009,21 @@ def plan_tick(
     #2110 deadlock, re-created by the very mechanism meant to end it.  A
     cordoned tick is exactly `--reconcile-only`.
 
+    *live_ci_gate* maps a `parked` entry's key to whether a FRESH,
+    single-entry re-derivation of its gate — computed by the shell THIS
+    tick, via :func:`coord.merge_queue.entry_gate_status` with a live
+    ``ci_store``/``gh_ops``, the same backend ``coord merge --plan`` builds
+    — still finds it blocked (#2182). A key present here is authoritative
+    over both the cached board's `merge_ci_pending` and the #2158 staleness
+    ceiling below: there is no ceiling to apply to a reading taken just now.
+    A key ABSENT (the entry isn't CI-parked, or the shell's live check
+    itself couldn't be made — no PR yet, an unreadable config, a `ci_store`
+    that failed to build) falls through unchanged to the pre-#2182 path,
+    the #2158 ceiling included — see
+    :func:`coord.commands.drive_queue._fetch_live_ci_gate` for the shell
+    side, which computes this ONLY for the bounded set of entries currently
+    `parked` on a CI reason, never the whole queue.
+
     The algorithm, from #1754, plus #1757's step 2, #1891's step 1b, and
     #2055's extension of it:
 
@@ -2164,6 +2180,39 @@ def plan_tick(
             # relaunch a gave-up entry outside the `blocked`/`failed`
             # attempt-tracking this function's docstring describes (#2055).
             continue
+        # #2182: a FRESH, single-entry re-derivation of this exact entry's
+        # gate, taken by the shell THIS tick (see the `live_ci_gate`
+        # parameter doc above) — authoritative over both the cached board
+        # reading below and the #2158 staleness ceiling, because there is no
+        # staleness to a reading computed just now. Bypasses that whole
+        # apparatus entirely rather than layering on top of it: a `True`
+        # here means the SAME check `coord merge --plan` would run still
+        # finds this entry blocked (stay parked, no ceiling needed — held
+        # for as long as the live check keeps saying so, exactly like a
+        # live `merge_plan` reason always was); a `False` means the plan
+        # reads READY right now (resume immediately). A MISSING key — the
+        # entry isn't CI-parked, or the shell's live check itself could not
+        # be made — falls through unchanged to the pre-#2182 path.
+        live_override = (live_ci_gate or {}).get(entry.key)
+        if live_override is not None:
+            if live_override:
+                continue
+            reason = (
+                f"live re-check of {entry.key}'s gate this tick reads READY "
+                "(coord merge --plan agrees) — resuming from parked without "
+                "spending an attempt (#1891, #2182)"
+            )
+            reconciles.append(
+                Reconcile(
+                    entry.key,
+                    "resumed",
+                    reason,
+                    occupies=False,
+                    updates={"state": STATE_WAITING, "last_reason": reason},
+                )
+            )
+            states[entry.key] = STATE_WAITING
+            continue
         # #2158: a park whose CI reading can still refresh itself is held for
         # as long as it keeps saying so. One that CANNOT — the reading came
         # only from the raw `merge_queue` row's frozen `error`, which is

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/coord/merge_queue.py

@@ -3244,6 +3244,45 @@ def _entry_gate_status(
     return PLAN_READY, None
 
 
+def entry_gate_status(
+    entry: "QueuedMerge",
+    board,
+    config,
+    ci_store: "CiStore | None" = None,
+    gh_ops: "GhOps | None" = None,
+) -> tuple[str, str | None]:
+    """Public seam onto :func:`_entry_gate_status`, for callers outside this
+    module that need a fresh, SINGLE-entry re-derivation of the gate — not
+    the whole-queue :func:`plan`.
+
+    #2182: ``coord.drive_queue``'s park/resume machinery (#1891/#1892) used
+    to release a `parked` entry only two ways — the cached board's own
+    `merge_plan` reason re-deriving itself (only true off a live daemon
+    `/board`, never on the daemon-host tick itself, which reads the local DB
+    directly and never computes `merge_plan` at all — see
+    ``coord.commands.drive_queue._local_merge_queue_rows``), or
+    :data:`coord.drive_queue.PARK_STALE_SECONDS` ageing the frozen reading
+    out after 45 minutes. Both leave a genuinely-clear gate undetected for
+    up to the ceiling, even though ``coord merge --plan`` can answer correctly on
+    demand at any moment — the same disagreement claude-coordinator#2159
+    surfaced (the queue read `parked` while `--plan` read READY, at the SAME
+    instant, off the SAME board).
+
+    ``coord.commands.drive_queue._fetch_live_ci_gate`` calls this directly,
+    once per currently-`parked` entry, with a LIVE ``ci_store``/``gh_ops`` —
+    the same live backend ``coord merge --plan``'s local branch builds — so
+    the two readings can no longer disagree. Deliberately NOT routed through
+    :func:`plan`: that function evaluates *every* PENDING queue entry with a
+    PR, so handing it a live backend would pay for a `gh` call per entry in
+    the whole merge queue on every 3-minute tick, not just the bounded
+    handful currently parked — reintroducing the unbounded-`gh`-polling
+    shape #1344 removed from the read path. A single-entry call, made only
+    for entries already sitting in `parked`, keeps the cost exactly where
+    the issue says it should be: small and predictable.
+    """
+    return _entry_gate_status(entry, board, config, ci_store, gh_ops)
+
+
 # ── Merge plan (#776) ────────────────────────────────────────────────────────
 
 @dataclass

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/tests/test_agent.py

@@ -1572,6 +1572,66 @@ def test_reap_captures_claude_session_id(tmp_path: Path) -> None:
     server.shutdown()
 
 
+def test_reap_logs_graphify_invocation_count(tmp_path: Path) -> None:
+    """#2212: `_reap` writes a plain `graphify_invocations=N` counter into
+    the worker's log alongside the existing "# reap: done" line — the
+    measurable half of the graph-first navigation rule in
+    WORKER_SYSTEM_PROMPT. A worker whose transcript shows one `graphify
+    query ...` Bash call and one unrelated Bash call must be counted 1, not
+    2 or 0, end-to-end through the real reap path (not just the
+    `_count_graphify_invocations` unit)."""
+    repo = _init_repo(tmp_path / "repo")
+
+    graphify_call = json.dumps({
+        "type": "assistant",
+        "message": {
+            "model": "claude-sonnet-4-6",
+            "content": [{
+                "type": "tool_use",
+                "name": "Bash",
+                "id": "tu_1",
+                "input": {"command": 'graphify query "where is X handled"'},
+            }],
+        },
+    })
+    unrelated_call = json.dumps({
+        "type": "assistant",
+        "message": {
+            "model": "claude-sonnet-4-6",
+            "content": [{
+                "type": "tool_use",
+                "name": "Bash",
+                "id": "tu_2",
+                "input": {"command": "grep -rn foo ."},
+            }],
+        },
+    })
+    result_line = json.dumps({"type": "result", "subtype": "success", "is_error": False})
+    worker_sh = (
+        f"echo '{graphify_call}'; echo '{unrelated_call}'; echo '{result_line}'; exit 0"
+    )
+    server = AgentServer(
+        machine_name="test",
+        repos=["api"],
+        repo_paths={"api": str(repo)},
+        state_dir=tmp_path / "state",
+        worker_command=lambda spec: ["/bin/sh", "-c", worker_sh],
+    )
+    spec = AssignmentSpec(
+        repo_name="api",
+        repo_path=str(repo),
+        issue_number=2212,
+        issue_title="t",
+        briefing="b",
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    log_text = Path(final.log_path).read_text()
+    assert "graphify_invocations=1" in log_text
+    server.shutdown()
+
+
 def test_assignment_spec_accepts_resume_session_id() -> None:
     """AssignmentSpec round-trips resume_session_id through to_dict / from dict."""
     spec = AssignmentSpec(

{code_coordinator-0.5.67 → code_coordinator-0.5.69}/tests/test_cli_drive_queue.py

@@ -1297,6 +1297,233 @@ def test_a_park_younger_than_the_ceiling_is_left_alone(
     assert len(launches) == 1, launches
 
 
+# ── #2182: a park is bounded (#2158) but was never RE-CHECKED — a cleared
+# gate waited up to the 45-minute ceiling even though `coord merge --plan`
+# could answer correctly on demand the whole time.
+#
+# claude-coordinator#2159, 2026-08-13: at 03:25:46 UTC, `coord merge
+# --dry-run` for a parked entry read READY (no gate objection) while `coord
+# drive-queue list`, reading the SAME board a moment later, still read
+# `parked`. The root cause (confirmed by reading the tick's own board-fetch
+# path, not merely suspected): the daemon host — the ONLY machine that ever
+# runs this tick (`docs/AGENT_OPERATIONS.md`) — reads the local DB directly
+# and never computes a `merge_plan` section at all (see
+# `coord.commands.drive_queue._local_merge_queue_rows`'s docstring), so
+# `IssueFacts.merge_ci_pending_live` is unconditionally `False` there and
+# only the #2158 ceiling could ever have released the park — never CI
+# actually reporting.
+#
+# These tests exercise the REAL live re-check (`coord.merge_queue.
+# entry_gate_status`, called by `_fetch_live_ci_gate`), not a pre-injected
+# `merge_plan` row the way `board_merge_plan` above stands in for the
+# daemon-fronted lane — this suite's default lane (no daemon, no
+# `board_service`) IS the exact lane #2159 hit.
+
+
+_NO_GATES_CONFIG_YAML = f"""\
+repos:
+  - name: {REPO}
+    github: john/claude-coordinator
+    default_branch: main
+  - name: {OTHER_REPO}
+    github: john/quadraui
+    default_branch: main
+machines:
+  - name: dellserver
+    host: dellserver
+    repos: [{REPO}, {OTHER_REPO}]
+reviews:
+  enabled: false
+pipeline:
+  default_gates: []
+"""
+
+
+@pytest.fixture
+def cli_no_gates(tmp_path: Path):
+    """Same shape as `cli` above, but review/smoke are OFF.
+
+    #2182's live re-check calls the REAL `coord.merge_queue.
+    entry_gate_status` — the same function `coord merge --plan` uses — which
+    evaluates review/smoke BEFORE it ever reaches the CI gate under test
+    here. `config_file`'s default gate list (`["test", "review", "merge"]`,
+    `reviews.enabled: true` by default) would block every re-check on a
+    verdict these tests never seed — a different, real gate, just not the
+    one #2182 is about. A genuinely-parked entry in production already
+    cleared review/smoke to reach the CI block in the first place (that is
+    the gate order `entry_gate_status` evaluates in); these tests start
+    past that point on purpose, same as `_seed_ci_pending_merge_row` above
+    already does for the pre-#2182 machinery.
+    """
+    path = tmp_path / "coordinator-no-gates.yml"
+    path.write_text(_NO_GATES_CONFIG_YAML)
+
+    def run(*args: str):
+        return CliRunner().invoke(main, ["drive-queue", *args, "--config", str(path)])
+
+    return run
+
+
+class _FakeLiveCi:
+    """Stands in for the live backend `coord.ci_store.build_ci_store` would
+    normally construct (`coord.ci_github.GitHubCi`) — a real `gh` client,
+    which these tests must never touch."""
+
+    def __init__(self, state: dict) -> None:
+        self._state = state
+
+    @property
+    def is_available(self) -> bool:
+        return True
+
+    def list_checks_for_pr(self, repo: str, number: int) -> list:
+        return list(self._state["checks"])
+
+    def expects_checks(self, repo: str, number: int) -> bool:
+        return True
+
+
+@pytest.fixture
+def live_ci_backend(monkeypatch):
+    """Fake the live `ci_store`/`github_ops` seam #2182's re-check calls.
+
+    Patches `coord.ci_store.build_ci_store` (what constructs the live
+    backend) and the two `coord.github_ops` functions the CI gate reaches
+    for once the checks themselves resolve (`get_branch_commit_timestamp`
+    for the #1851 staleness check, `get_pr_commit_messages` for the #1318
+    epic-closing-keyword gate) — the same seams `tests/test_board_read_
+    path.py` fakes for the equivalent `/board`-side gate. Returns a setter,
+    `live_ci_backend(checks)`.
+    """
+    import coord.ci_store as ci_store_module
+    import coord.github_ops as github_ops
+
+    state: dict = {"checks": []}
+    monkeypatch.setattr(
+        ci_store_module, "build_ci_store", lambda t: _FakeLiveCi(state)
+    )
+    # A small, fixed base-commit timestamp: every check below starts well
+    # after it, so the #1851 staleness gate reads "fresh", not "stale".
+    monkeypatch.setattr(
+        github_ops, "get_branch_commit_timestamp", lambda repo, branch: 1.0
+    )
+    monkeypatch.setattr(github_ops, "get_pr_commit_messages", lambda repo, n: [])
+
+    def _set(checks: list) -> None:
+        state["checks"] = checks
+
+    return _set
+
+
+def _green_check(name: str = "test (3.12)"):
+    from coord.ci_store import CheckRun
+
+    return CheckRun(
+        name=name, status="completed", conclusion="success",
+        url="", run_id="1", started_at=100.0, completed_at=160.0,
+    )
+
+
+def _running_check(name: str = "test (3.12)"):
+    from coord.ci_store import CheckRun
+
+    return CheckRun(
+        name=name, status="in_progress", conclusion=None,
+        url="", run_id="1", started_at=100.0, completed_at=None,
+    )
+
+
+def _park_with_pr(
+    cli, seed, coord_db, issue: int = 2159, pr_number: int = 42
+) -> None:
+    """`_park` above, plus a `pr_number` on the raw row.
+
+    #2182's live re-check (unlike the pre-#2182 machinery it falls back to)
+    needs a PR to ask the CI backend about — exactly what a real `coord
+    merge` attempt would already have set on this row before ever parking
+    it (the CI gate only writes a `CI running:`/`CI infra:` error when
+    `entry.pr_number` is truthy in the first place).
+    """
+    seed(issues={issue: "open"})
+    cli("add", REPO, str(issue))
+    cli("tick")
+    _seed_ci_pending_merge_row(coord_db, issue, reason="CI running: test (3.12)")
+    coord_db.execute(
+        "UPDATE merge_queue SET pr_number = ? WHERE issue_number = ?",
+        (pr_number, issue),
+    )
+    coord_db.commit()
+    _backdate(issue, DRIVE_STARTUP_GRACE_SECONDS + 60)
+    cli("tick")
+    assert queued(issue)["state"] == "parked"
+
+
+def test_a_parked_entry_resumes_on_a_live_gate_recheck_well_inside_the_ceiling(
+    cli_no_gates, seed, launches, coord_db, live_ci_backend,
+):
+    """THE #2182 regression, reproduced rather than injected.
+
+    CI reports green seconds after the park — nowhere near
+    `PARK_STALE_SECONDS` — and no live `coord merge` runs in between. Before
+    #2182 this entry would sit `parked` until the 45-minute ceiling; now the
+    very next tick asks the live gate itself (the same call `coord merge
+    --plan` makes) and resumes immediately.
+    """
+    _park_with_pr(cli_no_gates, seed, coord_db)
+    assert len(launches) == 1, launches
+
+    live_ci_backend([_green_check()])
+
+    result = cli_no_gates("tick")
+    assert result.exit_code == 0, result.output
+    entry = queued(2159)
+    assert entry["state"] == "running"  # resumed straight into a fresh launch
+    assert entry["attempts"] == 0  # #1891: still free — no attempt spent
+    assert len(launches) == 2, launches
+
+    status = cli_no_gates("status")
+    assert "parked" not in status.output
+
+
+def test_a_parked_entry_with_ci_still_genuinely_running_stays_parked(
+    cli_no_gates, seed, launches, coord_db, live_ci_backend,
+):
+    """The #1891 property must survive #2182 unchanged: CI genuinely still
+    running is not evidence against the park — the live re-check agrees
+    with it, every tick, with no hot-loop relaunch."""
+    _park_with_pr(cli_no_gates, seed, coord_db)
+    live_ci_backend([_running_check()])
+
+    for _ in range(3):
+        result = cli_no_gates("tick")
+        assert result.exit_code == 0, result.output
+        assert queued(2159)["state"] == "parked"
+        assert len(launches) == 1, launches  # no second launch, ever
+
+    assert "1 parked" in cli_no_gates("status").output
+
+
+def test_a_live_ready_wins_even_over_a_stale_cached_plan_reading(
+    cli_no_gates, seed, launches, coord_db, live_ci_backend, board_merge_plan,
+):
+    """#2182's acceptance bar, stated directly: the live re-check is
+    authoritative over the CACHED board reading, not merely over its
+    absence. The board's own `merge_plan` section here still says pending
+    (not yet refreshed since the park — the #2158 unrefreshable case this
+    suite's `board_merge_plan` fixture stands in for), which pre-#2182
+    would hold the park for the full ceiling regardless of what a live
+    check would say. The live gate — the same one `coord merge --plan`
+    reads on demand — wins anyway: the queue must never report `parked`
+    once it agrees."""
+    _park_with_pr(cli_no_gates, seed, coord_db)
+    board_merge_plan(_plan_row(2159, reason="CI running: test (3.12)", running=1))
+    live_ci_backend([_green_check()])
+
+    result = cli_no_gates("tick")
+    assert result.exit_code == 0, result.output
+    assert queued(2159)["state"] == "running"
+
+
 def test_a_repeatedly_dead_drive_still_reaches_blocked_and_escalates(
     cli, seed, launches
 ):