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

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

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

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

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

{code_coordinator-0.5.124 → code_coordinator-0.5.126}/coord/block_log.py

@@ -70,7 +70,9 @@ from typing import Any
 
 from coord.drive_queue import (
     STATE_BLOCKED,
+    STATE_DONE,
     STATE_PARKED,
+    STATE_WAITING,
     QueueEntry,
     TickPlan,
 )
@@ -107,6 +109,8 @@ __all__ = [
     "episodes",
     "is_by_design",
     "log_location",
+    "merge_only_event",
+    "merge_only_fallback_event",
     "operator_resolution_event",
     "plan_events",
     "read_events",
@@ -221,6 +225,20 @@ _LANDED_CAUSE = (
     "already-landed — the work merged or closed while the entry sat in this "
     "state, so the stated reason had outlived the thing it described"
 )
+#: #2350: distinct from `_LANDED_CAUSE` on purpose — that one means "the entry
+#: sat here and something ELSE finished it while nobody was looking" (a human,
+#: an unrelated branch merge, `coord reconcile-merges`); this one means the
+#: QUEUE ITSELF, this same tick, ran `coord merge --only` and landed it —
+#: see `coord.commands.drive_queue._run_merge_only_candidates`'s success
+#: branch, the ONLY writer of the `outcome == "merged"` `_resolve_record`
+#: reads to pick this cause. Conflating the two into one `auto-released`-style
+#: bucket is exactly what #2350 was written to stop: #2235's corpus needs to
+#: tell "the mechanism did this" apart from "the state flipped and something
+#: unrelated did it".
+_AUTO_MERGED_CAUSE = (
+    "auto-merged — the queue completed the merge directly from the tick "
+    "(#2350), Test/Review already satisfied; Merge was the only gate left"
+)
 _OPERATOR_CAUSE = (
     "operator-intervened — no automatic release fired; a human cleared it by "
     "hand, and what they actually fixed is NOT recorded here"
@@ -405,7 +423,17 @@ def _resolve_record(
     now: float,
     outcome: str,
 ) -> dict[str, Any]:
-    if outcome == "done" or new_state == "done":
+    if outcome == "merged":
+        # #2350: checked BEFORE the "done" branch below — a successful
+        # Merge-only fast-path attempt also lands `new_state == "done"` (it
+        # skips the `waiting`/relaunch cycle entirely), so without this
+        # ordering the generic landed check would win the match and this
+        # episode would be indistinguishable from "something else merged it
+        # while it sat here" — exactly the conflation #2350 exists to split
+        # out of #2230's `auto-released`/#2055's `already-landed`.
+        true_cause, human = _AUTO_MERGED_CAUSE, False
+        resolution = "auto_merged"
+    elif outcome == "done" or new_state == "done":
         true_cause, human = _LANDED_CAUSE, False
         resolution = "landed"
     elif outcome == "resumed":
@@ -471,6 +499,81 @@ def enter_event(
     return record
 
 
+def merge_only_event(
+    entry: QueueEntry,
+    *,
+    host: str = "",
+    now: float | None = None,
+) -> dict[str, Any]:
+    """The ``resolve`` record for #2350's Merge-only fast path.
+
+    The other caller-constructed record besides :func:`enter_event`, and for
+    the identical structural reason: the transition happens OUTSIDE
+    :func:`plan_events`'s view. A `merge_only` :class:`~coord.drive_queue.
+    Reconcile` deliberately writes no `state` (see its docstring), so
+    `plan.writes()` never carries the `parked`/`blocked` → `done` move this
+    function records — it only happens once the shell's own live
+    ``coord merge --only`` attempt reports success, strictly after
+    ``_apply_writes`` has already run for the rest of the tick. *entry* is
+    the PRE-tick snapshot (its ``state`` is still `parked`/`blocked`); the
+    entry has already landed by the time this is called, so `new_state` is
+    unconditionally :data:`~coord.drive_queue.STATE_DONE`.
+    """
+    stamp = time.time() if now is None else now
+    record = _resolve_record(
+        entry.key,
+        entry.state,
+        STATE_DONE,
+        "",
+        entry,
+        host=host,
+        now=stamp,
+        outcome="merged",
+    )
+    record["source"] = "tick"
+    return record
+
+
+def merge_only_fallback_event(
+    entry: QueueEntry,
+    *,
+    reason: str,
+    host: str = "",
+    now: float | None = None,
+) -> dict[str, Any]:
+    """The ``resolve`` record for #2350's Merge-only fast path RACE case:
+    the live gate read clear enough to attempt a direct merge, but the
+    attempt itself did not confirm a landed merge, so
+    ``coord.commands.drive_queue._run_merge_only_candidates`` falls back to
+    exactly the pre-#2350 ``resumed`` shape (``STATE_WAITING``) — OUTSIDE
+    ``plan.writes()``, the same reason :func:`merge_only_event` exists for
+    the success case: without this, the episode :func:`plan_events` already
+    opened for *entry* would never see a matching close, and
+    ``coord drive-queue block-log`` would show it stuck ``(unresolved)``
+    forever even though the entry plainly left `parked`/`blocked` this tick.
+
+    Classified as an ordinary ``resumed`` outcome — not a new #2350 cause —
+    on purpose: unlike the success case, this genuinely IS "state flipped,
+    cause a plain gate re-clear" (:func:`_resume_cause`'s fallback,
+    ``auto-released``), the same honest non-answer a bare board-signal
+    resume already gets. #2350's distinct cause is reserved for the tick
+    actually landing the merge itself.
+    """
+    stamp = time.time() if now is None else now
+    record = _resolve_record(
+        entry.key,
+        entry.state,
+        STATE_WAITING,
+        reason,
+        entry,
+        host=host,
+        now=stamp,
+        outcome="resumed",
+    )
+    record["source"] = "tick"
+    return record
+
+
 def operator_resolution_event(
     entry: QueueEntry,
     *,

{code_coordinator-0.5.124 → code_coordinator-0.5.126}/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.126}/coord/commands/drive_queue.py

@@ -53,6 +53,7 @@ from coord.drive_queue import (
     QUEUE_ALERT_STAGE,
     RESUME_PROBE_TIMEOUT_SECONDS,
     STATE_BLOCKED,
+    STATE_DONE,
     STATE_FAILED,
     STATE_PARKED,
     STATE_RUNNING,
@@ -98,6 +99,33 @@ from coord.overlap_predict import (
 # budget.
 _LAUNCH_TIMEOUT_SECONDS = 120.0
 
+# Wall-clock ceiling for the tick's own `coord merge --only` attempt
+# (#2350's fast path, `_run_merge_only_candidates`).  Deliberately its OWN
+# constant, not a reuse of `_LAUNCH_TIMEOUT_SECONDS` above: that one is
+# scoped to a `coord drive --tmux` launch, which only ever blocks on #1606's
+# bounded liveness check, so 120s is already generous there.  `coord merge
+# --only` is a different animal — elsewhere in the codebase
+# (`Driver._spawn` in `coord/drive.py`) the SAME subcommand runs under NO
+# subprocess timeout at all, nested inside up to a 1800s merge-lock
+# acquisition, i.e. the existing precedent treats its runtime as
+# unbounded/long, not launch-fast.  This call site does still want a
+# backstop — unlike `_spawn`'s fire-and-forget, this one runs synchronously
+# inside `drive_queue_tick`, in a loop over every `merge_only` candidate
+# this tick found (typically 0-2, see `_fetch_merge_only_ready`, but not
+# hard-capped), and a wedge here stalls the whole tick — so it gets a wider
+# ceiling than the launch check instead of no ceiling at all, without going
+# fully unbounded: `coord-drive-queue.service` (the deployed timer unit)
+# gives the ENTIRE `coord drive-queue tick` invocation only 300s
+# (`TimeoutStartSec`) before systemd kills it outright, which is a harder
+# and less graceful stop than this subprocess's own SIGKILL. 240s leaves
+# room for one slow `gh pr merge`/git round trip on a bad network day
+# without letting a single candidate alone consume the whole tick's outer
+# budget (this PR's invocation never passes `--revalidate`, so
+# `wait_for_ci_settle`'s up to 360s doesn't even apply today, but the argv
+# could grow that flag later — revisit this ceiling together with
+# `coord-drive-queue.service`'s `TimeoutStartSec` if it does).
+_MERGE_ONLY_TIMEOUT_SECONDS = 240.0
+
 # Counts are rendered in pipeline order, not alphabetically, so
 # `coord drive-queue status` reads as "1 running · 1 waiting". `parked`
 # (#1891) sits between `waiting` and `blocked` — closer to "nothing wrong"
@@ -1837,11 +1865,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 +1925,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 +1937,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 +1962,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(
@@ -2019,6 +2065,82 @@ def _fetch_live_blocked_gate(
     return overrides
 
 
+def _fetch_merge_only_ready(
+    entries: list,
+    live_ci_gate: Mapping[str, bool],
+    live_blocked_gate: Mapping[str, bool],
+) -> dict[str, bool]:
+    """``{entry_key: True}`` for #2350's Merge-only fast path: every entry
+    THIS tick's live gate re-check just found clear — a `parked` entry with
+    ``live_ci_gate[key] is False``, a `blocked` one with
+    ``live_blocked_gate[key] is False`` — whose board-recorded pipeline
+    state ALSO shows Test already `passed` and Review already `approve`,
+    meaning Merge was the only gate that was ever still shut.
+
+    Scoped to exactly the entries about to reconcile `resumed` this tick —
+    typically 0-2, the same bound :func:`_fetch_live_ci_gate`/
+    :func:`_fetch_live_blocked_gate` already keep — so this never re-derives
+    a gate reading of its own (that authority stays with *live_ci_gate*/
+    *live_blocked_gate*, computed moments earlier in the same tick): it only
+    adds two board-only reads (:func:`coord.merge_queue.has_approved_review`,
+    :func:`coord.merge_queue.has_passed_test`) against the SAME local board
+    those callers already loaded. Almost always cheap and I/O-free — but not
+    unconditionally: ``has_approved_review`` can fall through to
+    ``scan_approved_reviews``'s ``_backfill_branch_patch_id``, which does a
+    live ``gh api compare`` round trip via *_gh_ops* when a stale-SHA review
+    needs its patch-id computed on demand. That path is exception-guarded
+    below and fails closed to the pre-#2350 `resumed` path like everything
+    else here, so it is not unsafe — just not the zero-I/O read the rest of
+    this docstring describes.
+
+    Takes no *config_path*, unlike both siblings: neither board-only read
+    needs a :class:`~coord.config.Config` (no ``ci_store``, no live gate
+    re-derivation), so there is nothing to load here.
+
+    Same fail-open-per-entry, fail-closed-overall contract as its siblings:
+    a key ABSENT from the result (no queue row, an unreadable board or
+    merge queue, any exception) simply takes the pre-#2350 `resumed` path —
+    never a wrongly skipped relaunch.
+    """
+    targets = [
+        e for e in entries
+        if (e.state == STATE_PARKED and live_ci_gate.get(e.key) is False)
+        or (e.state == STATE_BLOCKED and live_blocked_gate.get(e.key) is False)
+    ]
+    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.state import load_board as _load_board  # noqa: PLC0415
+
+        board = _load_board()
+        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 {}
+
+    ready: dict[str, bool] = {}
+    for e in targets:
+        q = queue_by_key.get(e.key)
+        if q is None:
+            continue
+        try:
+            ready[e.key] = _mq.has_approved_review(
+                q, board, _gh_ops
+            ) and _mq.has_passed_test(q, board)
+        except Exception:  # noqa: BLE001 — leave this one entry to the ordinary path
+            continue
+    return ready
+
+
 def _launch_argv(entry: QueueEntry, config_path: Path | None) -> list[str]:
     """The ``coord drive --tmux`` argv for *entry*.
 
@@ -2050,6 +2172,136 @@ def _launch_argv(entry: QueueEntry, config_path: Path | None) -> list[str]:
     return argv
 
 
+def _merge_only_argv(entry: QueueEntry, config_path: Path | None) -> list[str]:
+    """The ``coord merge --only <repo>#<issue>`` argv for *entry* (#2350).
+
+    Mirrors :func:`_launch_argv`'s exact shape — same ``coord_argv()`` base,
+    same ``--config`` passthrough — for the direct-merge fast path instead
+    of a fresh drive session. ``--only`` accepts the durable ``repo#issue``
+    form (#1477), which is exactly ``entry.key``, so no assignment_id lookup
+    is needed here.
+    """
+    from coord.drive import coord_argv  # noqa: PLC0415
+
+    argv = coord_argv() + ["merge", "--only", entry.key]
+    if config_path:
+        argv += ["--config", str(config_path)]
+    return argv
+
+
+def _merge_only_landed(entry: QueueEntry) -> bool:
+    """Did *entry* actually MERGE, per the merge-queue's own row — the one
+    ground truth ``coord merge --only``'s exit code alone cannot supply.
+
+    #2350: a ``--only`` run against an already-PENDING entry exits 0
+    whether the attempt landed it, left it blocked on a gate, or routed it
+    into a conflict-fix — see ``coord.commands.merge``'s ``--only`` handler,
+    which prints a summary and returns unconditionally once ``process()``
+    has run. Exit code alone is therefore not evidence of a landed merge;
+    the queue row's own resulting state is.
+    """
+    from coord import merge_queue as _mq  # noqa: PLC0415
+
+    try:
+        rows = _mq.load_queue()
+    except Exception:  # noqa: BLE001 — unreadable queue is not proof of a landed merge
+        return False
+    for q in rows:
+        if entry_key(q.repo_name, q.issue_number) == entry.key:
+            return q.state == _mq.MERGED
+    return False
+
+
+def _run_merge_only_candidates(plan: TickPlan, config_path: Path | None) -> None:
+    """#2350: attempt ``coord merge --only`` directly, THIS tick, for every
+    entry :func:`coord.drive_queue.plan_tick` marked ``merge_only`` — no
+    relaunch, no capacity slot spent. Called AFTER ``_apply_writes(plan)``,
+    same posture as the launch subprocess below it: the entry's real next
+    state is decided from the live outcome of THIS attempt, not from
+    anything ``plan_tick`` could have known when it returned — see
+    :class:`~coord.drive_queue.Reconcile`'s ``merge_only`` outcome for why
+    that Reconcile itself writes nothing.
+
+    On success (the queue's own row now reads ``MERGED`` — see
+    :func:`_merge_only_landed`): writes ``STATE_DONE`` directly, skipping
+    the ``waiting``/relaunch cycle a NEXT tick's ordinary ``landed``
+    re-check would otherwise need, and records a distinct #2350 block-log
+    ``resolve`` (:func:`coord.block_log.merge_only_event`) so #2235's corpus
+    can tell "the queue itself finished this" apart from "the state flipped
+    and something else finished it" (``already-landed``/``auto-released``).
+
+    On failure (the gate flipped shut again between the read and the
+    attempt — a genuine race, not the common case; or the attempt itself hit
+    something a single bounded try cannot resolve): falls back to EXACTLY
+    the pre-#2350 ``resumed`` shape — ``STATE_WAITING``, ``attempts`` reset
+    to 0, ``resumes`` bumped for a ``blocked``-origin entry (mirroring
+    ``_reconcile_blocked``'s own formula, so the #2230 oscillation ceiling
+    still sees every chance this entry got, fast-path or not) — never worse
+    than the status quo, and never a `coord drive --tmux` launch attempt
+    spent retrying a race this bounded attempt already ruled out.
+    """
+    if not plan.merge_only:
+        return
+
+    from coord.block_log import merge_only_event, merge_only_fallback_event  # noqa: PLC0415
+    from coord.state import update_drive_queue_entry  # noqa: PLC0415
+
+    for target in plan.merge_only:
+        argv = _merge_only_argv(target, config_path)
+        try:
+            result = subprocess.run(  # noqa: S603 — argv built from coord_argv + typed row
+                argv,
+                capture_output=True,
+                text=True,
+                timeout=_MERGE_ONLY_TIMEOUT_SECONDS,
+            )
+            returncode = result.returncode
+            detail = (result.stderr or result.stdout or "").strip().splitlines()
+            message = detail[-1] if detail else ""
+        except (subprocess.SubprocessError, OSError) as exc:
+            returncode, message = 1, str(exc)
+
+        if returncode == 0 and _merge_only_landed(target):
+            update_drive_queue_entry(
+                target.repo,
+                target.issue,
+                state=STATE_DONE,
+                last_reason=(
+                    "merged directly from the tick — Test/Review were "
+                    "already satisfied, Merge was the only gate left (#2350)"
+                ),
+                session_name=None,
+            )
+            _record_block_log([merge_only_event(target, host=_local_host_id())])
+            click.echo(f"merge-only: {target.key} merged directly from the tick")
+            continue
+
+        # #2350: the race case — fall back to exactly today's `resumed`
+        # shape, never a consumed drive-queue attempt (this was never a
+        # `coord drive --tmux` launch).
+        reason = f"merge-only attempt for {target.key} did not land it this tick"
+        if message:
+            reason += f" ({message})"
+        reason += " — falling back to an ordinary relaunch (#2350)"
+        updates: dict[str, Any] = {
+            "state": STATE_WAITING,
+            "attempts": 0,
+            "last_reason": reason,
+        }
+        if target.state == STATE_BLOCKED:
+            updates["resumes"] = target.resumes + 1
+        update_drive_queue_entry(target.repo, target.issue, **updates)
+        # #2350: this write bypassed `plan.writes()` entirely, so the
+        # `plan_events` call below (keyed off the ORIGINAL plan) can never
+        # see it — without recording it here, the episode `plan_events`
+        # already opened for `target` when it first went `parked`/`blocked`
+        # would never see a matching close.
+        _record_block_log(
+            [merge_only_fallback_event(target, reason=reason, host=_local_host_id())]
+        )
+        click.echo(f"merge-only: {reason}")
+
+
 def _run_resume_probe(entry: QueueEntry) -> ProbeResult:
     """Run one entry's ``--resume-when`` probe with a hard timeout.
 
@@ -2201,7 +2453,8 @@ def _requeue_command(entry: QueueEntry | None, key: str) -> str:
         "Update the queue's view of reality and launch nothing (#2110). "
         "Every `running` entry is still checked against the board "
         "(done/blocked/parked/retry, exactly as a normal tick would), but no "
-        "new `coord drive` is ever started this run — equivalent to "
+        "new `coord drive` is ever started this run, and no `coord merge "
+        "--only` fast-path attempt (#2350) runs either — equivalent to "
         "`--max-parallel 0`. This is the missing primitive for the "
         "stop-the-timer-to-roll-the-fleet sequence: with the timer stopped, "
         "nothing reconciles a finished drive's `running` row, and that stale "
@@ -2337,7 +2590,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
@@ -2345,6 +2602,15 @@ def drive_queue_tick(
         # landable for most of that window, and nothing ever looked again).
         live_blocked_gate = _fetch_live_blocked_gate(entries, config_path)
 
+        # #2350: for every entry the two live re-checks above just found
+        # clear, also confirm — from the board's own recorded Test/Review
+        # verdicts — that Merge was the only gate ever still shut, so
+        # `plan_tick` can attempt it directly this tick instead of spending
+        # a relaunch. See `_fetch_merge_only_ready`'s docstring.
+        merge_only_ready = _fetch_merge_only_ready(
+            entries, live_ci_gate, live_blocked_gate
+        )
+
         # #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
@@ -2384,8 +2650,10 @@ 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,
+            merge_only_ready=merge_only_ready,
         )
 
         if reconcile_only:
@@ -2404,6 +2672,16 @@ def drive_queue_tick(
 
         _apply_writes(plan)
 
+        # #2350: attempt the direct merges `plan_tick` marked `merge_only`,
+        # right after the rest of the plan's writes have landed. Skipped
+        # under `--reconcile-only` (also forced by `--max-parallel 0`, see
+        # `effective_capacity` above) — that mode's whole contract is
+        # "update queue state, launch nothing", and a live `coord merge
+        # --only` attempt is exactly the external action it promises not to
+        # take, same posture as the launch subprocess further down.
+        if not reconcile_only:
+            _run_merge_only_candidates(plan, config_path)
+
         # #2235 Phase 0: record every entry this tick moved INTO or OUT OF
         # `blocked`/`parked`, with the reason the queue stated and — for a
         # release — what the release itself reveals about the true cause.

{code_coordinator-0.5.124 → code_coordinator-0.5.126}/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: