code-coordinator 0.5.524__tar.gz → 0.5.526__tar.gz

{code_coordinator-0.5.524 → code_coordinator-0.5.526}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.524",
+  "tag": "0.5.526",
   "distance": 0,
-  "node": "g0e924a9e07fea9e3ea943a45cd49b370575ca40c",
+  "node": "g693a401ada00646a0a947757928045708b6bde77",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-27"

{code_coordinator-0.5.524 → code_coordinator-0.5.526}/coord/ci_fix.py

@@ -37,6 +37,7 @@ import logging
 
 import httpx
 
+from coord import github_ops
 from coord.ci_store import CIFailureDetail
 from coord.config import Config
 from coord.merge_queue import QueuedMerge, _chain_work_ids
@@ -144,12 +145,87 @@ def _format_ci_failure_detail(detail: CIFailureDetail) -> list[str]:
     return lines
 
 
+# #3456: cap on the issue body threaded into a ci-fix briefing. Large
+# enough that a typical issue description plus an operator's follow-up
+# diagnosis both fit without truncation in the common case — only a
+# genuinely long body (or a long back-and-forth of appended notes) hits
+# the cap at all.
+ISSUE_BODY_MAX_CHARS = 6000
+
+
+def _bound_issue_body(body: str) -> tuple[str, bool]:
+    """Truncate *body* to the last :data:`ISSUE_BODY_MAX_CHARS` characters
+    when it exceeds that cap (#3456).
+
+    Keeps the TAIL, not the head: an operator's diagnosis on a CI-fix
+    streak is written INTO the issue body after the failure is understood
+    — i.e. appended below the original description (see the issue's own
+    evidence: "After the root cause was written into the issue body,
+    requeueing would have routed the next attempt through the same ci-fix
+    path"). Keeping the tail is what makes sure that operator-added
+    content survives a cut; the cost is that the original description
+    (often already echoed by the issue title anyway) is what gets dropped
+    for a body long enough to need cutting at all.
+
+    Returns ``(text, truncated)`` — mirrors
+    :func:`coord.ci_github._bound_log_excerpt`'s contract: *truncated* is
+    ``True`` iff the cut actually removed content, so the caller can make
+    the cut visible in the briefing text rather than silently handing over
+    a partial body.
+    """
+    if len(body) <= ISSUE_BODY_MAX_CHARS:
+        return body, False
+    return body[-ISSUE_BODY_MAX_CHARS:], True
+
+
+def _format_issue_body(issue_body: str) -> list[str]:
+    """Render *issue_body* into briefing lines (#3456) — see
+    :func:`_bound_issue_body` for the truncation contract.
+    """
+    body, truncated = _bound_issue_body(issue_body)
+    lines: list[str] = ["## Issue body", ""]
+    if truncated:
+        lines.append(
+            f"(truncated to the last {ISSUE_BODY_MAX_CHARS} characters — "
+            "operator notes are typically appended below the original "
+            "description, so keeping the tail keeps those over the part "
+            "already echoed by the issue title)"
+        )
+        lines.append("")
+    lines.append(body)
+    lines.append("")
+    return lines
+
+
+def _fetch_issue_body(entry: QueuedMerge) -> str:
+    """Best-effort fetch of *entry*'s issue body for the ci-fix briefing
+    (#3456) — the same body a Work-stage dispatch already auto-includes
+    (``coord.commands.dispatch``'s auto-briefing, ``coord.commands.
+    dispatch_workers``' smoke briefing) but a ci-fix dispatch never did:
+    any diagnosis an operator records on the issue (e.g. after reading the
+    real CI logs by hand) was invisible to the worker most likely to need
+    it, since workers can't run ``gh`` themselves to read it any other way.
+
+    Fails soft to ``""`` on any read failure (``gh`` missing, rate-limited,
+    a network blip, a malformed response) — same posture as
+    :func:`coord.ci_github.build_ci_failure_detail`: this is enrichment,
+    never a dispatch precondition, and a body fetch failure must never
+    block or delay the actual fix dispatch.
+    """
+    try:
+        issue_data = github_ops.get_issue(entry.repo_github, entry.issue_number)
+    except Exception:  # noqa: BLE001 — best-effort, see docstring
+        return ""
+    return str(issue_data.get("body") or "")
+
+
 def build_ci_fix_briefing(
     *,
     entry: QueuedMerge,
     checks_summary: str,
     attempt: int,
     detail: CIFailureDetail | None = None,
+    issue_body: str | None = None,
 ) -> str:
     """Assemble the CI-fix worker's briefing. Pure function — testable.
 
@@ -159,6 +235,11 @@ def build_ci_fix_briefing(
     empty of anything beyond the check name (see :func:`_detail_has_content`),
     the briefing is byte-identical to before #3114, still carrying
     ``checks_summary``.
+
+    *issue_body* (#3456) is the issue's current body, fetched by
+    :func:`_fetch_issue_body` at dispatch time — optional and additive,
+    same shape as *detail*: ``None`` or blank leaves the briefing
+    byte-identical to before #3456.
     """
     lines: list[str] = [
         f"# CI failure fix: {entry.repo_github} branch `{entry.branch}`",
@@ -172,6 +253,8 @@ def build_ci_fix_briefing(
         f"    {checks_summary}",
         "",
     ]
+    if issue_body is not None and issue_body.strip():
+        lines.extend(_format_issue_body(issue_body))
     if detail is not None and _detail_has_content(detail):
         lines.extend(_format_ci_failure_detail(detail))
     lines += [
@@ -353,9 +436,10 @@ def dispatch_ci_fix(
         return None
 
     summary = checks_summary or entry.error or "CI checks failed"
+    issue_body = _fetch_issue_body(entry)
     briefing = build_ci_fix_briefing(
         entry=entry, checks_summary=summary, attempt=entry.ci_fix_dispatches + 1,
-        detail=detail,
+        detail=detail, issue_body=issue_body,
     )
 
     from coord.auto_loop import _dispatch_fix  # noqa: PLC0415

{code_coordinator-0.5.524 → code_coordinator-0.5.526}/coord/ci_github.py

@@ -120,19 +120,50 @@ _RUST_ERROR_RE = re.compile(r"\berror(\[E\d+\])?:")
 _RUST_LOCATION_RE = re.compile(r"-->")
 _RUST_WARNING_RE = re.compile(r"\bwarning:")
 
+# #3456: GitHub Actions appends this EXACT line to every failing step's log,
+# regardless of what actually failed — it is the annotation `_ERROR_
+# ANNOTATION_RE` would otherwise happily match as tier-1 signal, and on a
+# job whose real failure produces no OTHER `##[error]` line (e.g. a `cargo
+# test` failure — rustc's own test-harness panic output carries no `##[
+# error]` prefix at all), this generic wrapper line was the ONLY thing
+# selected: "exit code 1", not the failing test. Excluded from the
+# `annotation` tier entirely so the more specific `rust_test_failure` tier
+# below (or, failing that, `no_diagnostics_matched`) wins instead.
+_EXIT_CODE_ANNOTATION_RE = re.compile(r"##\[error\]Process completed with exit code \d+\.?\s*$")
+
+# #3456: a rust test-harness failure never carries a `##[error]` prefix, so
+# none of it was reachable by any tier before this — the harness prints a
+# per-test `---- <test path> stdout ----` header immediately followed by the
+# `panicked at ...` message, then (once every test has run) a `failures:`
+# roll-up naming every failing test, then a final `test result: FAILED. ...`
+# summary line. All four are treated as one priority tier: whichever of
+# them shows up is unambiguously more useful than the generic exit-code
+# annotation above.
+_RUST_TEST_STDOUT_HEADER_RE = re.compile(r"^-+\s.*\sstdout\s-+\s*$")
+_RUST_PANICKED_RE = re.compile(r"panicked at")
+_RUST_TEST_RESULT_RE = re.compile(r"\btest result: FAILED\b")
+_RUST_FAILURES_HEADER_RE = re.compile(r"^failures:\s*$")
+
 # How many lines past a matched rust-diagnostic line to look for its `-->`
 # location before giving up — rustc always emits it on the very next
 # non-blank line; a small window tolerates the odd blank line without
 # accidentally stealing a `-->` that belongs to a LATER diagnostic.
 _RUST_LOCATION_LOOKAHEAD = 4
 
+# How many lines past a `---- <test> stdout ----` header to sweep into the
+# same unit — enough to capture the `thread '...' panicked at ...:LINE:COL:`
+# line plus a short assertion message, without running so far that a SECOND
+# test's header (or unrelated harness noise) gets swept in too.
+_RUST_TEST_FAILURE_LOOKAHEAD = 6
+
 
 def _select_diagnostic_units(lines: list[str]) -> tuple[
-    list[list[str]], list[list[str]], list[list[str]]
+    list[list[str]], list[list[str]], list[list[str]], list[list[str]]
 ]:
-    """Classify *lines* into (annotation, rust_diagnostic, warning) unit
-    lists, each unit a small list of original line strings kept atomic so
-    budget truncation never splits an `error:`/`-->` pair apart (#3245).
+    """Classify *lines* into (annotation, rust_test_failure, rust_diagnostic,
+    warning) unit lists, each unit a small list of original line strings
+    kept atomic so budget truncation never splits an `error:`/`-->` pair —
+    or a rust test panic header/message pair — apart (#3245, #3456).
 
     Each source line is claimed by at most one bucket, checked in priority
     order, so a line matching a higher-priority pattern is never
@@ -142,10 +173,47 @@ def _select_diagnostic_units(lines: list[str]) -> tuple[
 
     annotation: list[list[str]] = []
     for i, line in enumerate(lines):
+        # #3456: the generic "step failed" wrapper line is deliberately
+        # never claimed here (see `_EXIT_CODE_ANNOTATION_RE`'s comment) —
+        # left unclaimed (not even added to `claimed`) since nothing else
+        # matches it anyway.
+        if _EXIT_CODE_ANNOTATION_RE.search(line):
+            continue
         if _ERROR_ANNOTATION_RE.search(line):
             annotation.append([line])
             claimed.add(i)
 
+    # #3456: rust test-harness failures — a stdout header sweeps in the
+    # panic message that follows it; a bare `panicked at`/`test result:
+    # FAILED`/`failures:` line (no preceding header, e.g. a `cargo run`
+    # panic outside the test harness) stands alone as its own unit.
+    rust_test_failure: list[list[str]] = []
+    for i, line in enumerate(lines):
+        if i in claimed:
+            continue
+        if _RUST_TEST_STDOUT_HEADER_RE.match(line.strip()):
+            claimed.add(i)
+            unit = [line]
+            end = min(i + 1 + _RUST_TEST_FAILURE_LOOKAHEAD, len(lines))
+            for j in range(i + 1, end):
+                if j in claimed:
+                    break
+                candidate = lines[j]
+                if not candidate.strip() or _RUST_TEST_STDOUT_HEADER_RE.match(candidate.strip()):
+                    # Blank line or the next test's header — stop before
+                    # sweeping in unrelated content.
+                    break
+                unit.append(candidate)
+                claimed.add(j)
+            rust_test_failure.append(unit)
+        elif (
+            _RUST_PANICKED_RE.search(line)
+            or _RUST_TEST_RESULT_RE.search(line)
+            or _RUST_FAILURES_HEADER_RE.match(line.strip())
+        ):
+            claimed.add(i)
+            rust_test_failure.append([line])
+
     rust_diag: list[list[str]] = []
     for i, line in enumerate(lines):
         if i in claimed or not _RUST_ERROR_RE.search(line):
@@ -173,7 +241,7 @@ def _select_diagnostic_units(lines: list[str]) -> tuple[
         claimed.add(i)
         warning.append([line])
 
-    return annotation, rust_diag, warning
+    return annotation, rust_test_failure, rust_diag, warning
 
 
 def _extract_relevant_log_lines(text: str) -> tuple[str, bool, bool]:
@@ -189,30 +257,42 @@ def _extract_relevant_log_lines(text: str) -> tuple[str, bool, bool]:
     Extraction is by relevance, in priority order, matching the issue's fix
     shape:
 
-    1. ``##[error]`` GitHub Actions annotation lines
-    2. Rust diagnostics — ``error[E....]:``/``error:`` paired with the
-       ``-->`` file:line that follows
-    3. ``warning:`` lines, only if budget remains after 1-2
+    1. ``##[error]`` GitHub Actions annotation lines — EXCEPT the generic
+       ``Process completed with exit code N.`` wrapper GitHub Actions
+       appends to every failing step regardless of cause (#3456): it
+       carries zero diagnostic value, and on a job whose real failure
+       never emits any OTHER ``##[error]`` line (a rust test panic, say),
+       it used to be the ONLY thing this function ever surfaced.
+    2. Rust test-harness failures (#3456) — a ``---- <test> stdout ----``
+       header (with the ``panicked at ...`` message that follows it), a
+       bare ``panicked at`` line, a ``failures:`` roll-up, or the final
+       ``test result: FAILED`` summary line
+    3. Rust compiler diagnostics — ``error[E....]:``/``error:`` paired with
+       the ``-->`` file:line that follows
+    4. ``warning:`` lines, only if budget remains after 1-3
 
     Everything else — including the runner's own echo of a script step's
-    source and post-job cleanup — is never a candidate, because it can
-    only ever match one of these patterns by (extremely unlikely)
-    coincidence.
+    source and post-job cleanup, and the excluded exit-code wrapper line —
+    is never a candidate, because it can only ever match one of these
+    patterns by (extremely unlikely) coincidence.
 
     Returns ``(excerpt, truncated, matched)``:
 
     - *matched* is ``False`` when nothing in any tier matched anywhere in
       *text* — the caller renders an explicit "no diagnostics" note rather
-      than a misleadingly-empty excerpt.
+      than a misleadingly-empty excerpt. Note this can now be ``False`` for
+      a log whose ONLY `##[error]` line was the excluded exit-code wrapper —
+      correctly so, since that line alone told the caller nothing a
+      "no diagnostics matched" note doesn't already convey just as well.
     - *truncated* is ``True`` when the matched units together exceed
       :data:`CI_FIX_LOG_MAX_LINES`/:data:`CI_FIX_LOG_MAX_BYTES` and lower-
-      priority units (warnings first, then any tier-1/2 overflow) had to be
-      dropped to fit — same "make the cut visible" contract as
+      priority units (warnings first, then any earlier-tier overflow) had
+      to be dropped to fit — same "make the cut visible" contract as
       :func:`_bound_log_excerpt`.
     """
     lines = text.splitlines()
-    annotation, rust_diag, warning = _select_diagnostic_units(lines)
-    units = annotation + rust_diag + warning
+    annotation, rust_test_failure, rust_diag, warning = _select_diagnostic_units(lines)
+    units = annotation + rust_test_failure + rust_diag + warning
     if not units:
         return "", False, False
 

{code_coordinator-0.5.524 → code_coordinator-0.5.526}/coord/commands/drive_queue.py

@@ -4815,13 +4815,122 @@ def _index_merge_queue_by_key(rows: list, board: Any) -> dict[str, Any]:
     return indexed
 
 
+def _resolve_winning_work_row_for_blocked_entry(
+    board: Any, repo_name: str, issue_number: int
+) -> Any | None:
+    """The same-branch "winner" (:func:`coord.merge_queue.
+    group_branch_candidates`) among *board*'s completed work for
+    ``(repo_name, issue_number)`` — resolved the same way :func:`coord.gates.
+    build_gate_report`/:func:`_index_merge_queue_by_key` resolve an
+    acceptance-slice's epic-keyed row (#3012): a match on the row's own
+    ``issue_number`` OR its :func:`~coord.models.effective_issue_number`.
+
+    ``None`` when *board* carries no matching :data:`~coord.models.
+    WORK_LIKE_TYPES` ``done`` row at all — the caller's signal that there is
+    genuinely nothing here to evaluate (#3460).
+    """
+    from coord.models import WORK_LIKE_TYPES, effective_issue_number  # noqa: PLC0415
+
+    from coord import merge_queue as _mq  # noqa: PLC0415
+
+    completed = list(getattr(board, "completed", None) or [])
+    matches = [
+        a for a in completed
+        if getattr(a, "repo_name", None) == repo_name
+        and getattr(a, "type", None) in WORK_LIKE_TYPES
+        and getattr(a, "status", None) == "done"
+        and (
+            getattr(a, "issue_number", None) == issue_number
+            or effective_issue_number(a) == issue_number
+        )
+    ]
+    if not matches:
+        return None
+    groups = _mq.group_branch_candidates(matches)
+    if not groups:
+        return None
+    # #3460: matches are already scoped to one (repo, issue) pair, so every
+    # group here is on the SAME branch in the overwhelming common case; the
+    # rare "the issue's work moved branches across relaunches" shape just
+    # picks the first (oldest-seen) branch group's own winner rather than
+    # inventing a cross-branch tie-break this sweep has no stake in.
+    winner, _superseded = groups[0]
+    return winner
+
+
+def _evaluate_blocked_entry_without_a_queue_row(
+    e: Any, board: Any, cfg: Any, gh_ops: Any
+) -> tuple[bool, str] | None:
+    """#3460's no-queue-row fallback: when neither the queue nor the #2806
+    self-heal produced a row for *e*, this is the difference between an
+    honest "unreadable" (there is truly nothing to read) and the false one
+    the #3460 incident reported — a gate that was, in fact, genuinely still
+    shut (quadraui#1081: review request-changes outstanding, Test failed,
+    fix rounds exhausted, and — because ``enqueue_approved_work``'s own
+    self-heal drops any row that fails the review/smoke gates,
+    ``coord/merge_queue.py:4973`` — NO queue row will EVER exist for it).
+
+    Resolves the branch's winning work row directly
+    (:func:`_resolve_winning_work_row_for_blocked_entry`) and evaluates it
+    with the exact gates :func:`coord.merge_queue.enqueue_approved_work`
+    itself checks — :func:`coord.merge_queue.live_gate_entry` (the #2085
+    live-anchored synthetic entry) + :func:`coord.merge_queue.
+    merge_gate_failures` (the reason-carrying twin of ``passes_merge_gates``,
+    #946) — so this can never disagree with what ``enqueue_approved_work``
+    itself would have concluded.
+
+    Returns ``(True, reason)`` — CONFIRMED still shut, *reason* naming every
+    failing gate — when :func:`merge_gate_failures` finds any. Returns
+    ``(False, reason)`` when it finds none: the winning row clears every
+    gate this sweep can check without a PR (CI is per-PR only, #1150), which
+    mirrors exactly what would make ``enqueue_approved_work`` enqueue it —
+    confirmed CLEAR, not "unreadable" (there is nothing left unresolved).
+    Returns ``None`` — genuinely nothing to report — only when there is no
+    winning work row at all (:func:`_resolve_winning_work_row_for_blocked_entry`
+    returns ``None``) or this evaluation itself raises; the caller falls
+    back to its own "no merge-queue row" unreadable note for either.
+    """
+    from coord import merge_queue as _mq  # noqa: PLC0415
+
+    winner = _resolve_winning_work_row_for_blocked_entry(board, e.repo, e.issue)
+    if winner is None:
+        return None
+    repo_cfg = cfg.repo(e.repo)
+    if repo_cfg is None:
+        return None
+    from coord.branch_model import resolve_base_branch_for_issue_number  # noqa: PLC0415
+
+    target_branch = resolve_base_branch_for_issue_number(
+        repo_cfg, repo_cfg.github, getattr(winner, "issue_number", 0)
+    )
+    gate_entry = _mq.live_gate_entry(winner, repo_cfg.github, target_branch, gh_ops)
+    failures = _mq.merge_gate_failures(gate_entry, cfg, board, gh_ops=gh_ops)
+    if failures:
+        return True, _mq.describe_merge_gate_failures(failures)
+    return (
+        False,
+        "the branch's winning work row clears review/smoke/uat with no "
+        "merge-queue row yet to check CI against (#3460)",
+    )
+
+
 def _fetch_live_blocked_gate(
     entries: list, config_path: Path | None
-) -> tuple[dict[str, bool], dict[str, str]]:
-    """``({entry_key: still_blocked}, {entry_key: unreadable_reason})`` for
-    every RE-EVALUABLE ``blocked`` entry (#2230) — the counterpart of
-    :func:`_fetch_live_ci_gate` above: same mechanism, same bound, a
-    different queue state.
+) -> tuple[dict[str, bool], dict[str, str], dict[str, str]]:
+    """``({entry_key: still_blocked}, {entry_key: gate_reason},
+    {entry_key: unreadable_reason})`` for every RE-EVALUABLE ``blocked``
+    entry (#2230) — the counterpart of :func:`_fetch_live_ci_gate` above:
+    same mechanism, same bound, a different queue state.
+
+    THE SECOND DICT (#3460) is *live_ci_gate*/*live_ci_gate_reason*'s own
+    split, mirrored here: whatever reason text produced the first dict's
+    bool — from a direct :func:`coord.merge_queue.entry_gate_status` read
+    when a queue row exists, or from :func:`
+    _evaluate_blocked_entry_without_a_queue_row` when none does — so a
+    CONFIRMED still-shut reading is never reported gate-reason-less the way
+    the #3460 incident's "unconfirmed probe failure" text was. Present for
+    every key also present in the first dict (whichever way it reads);
+    absent otherwise, exactly like its CI-gate sibling.
 
     THE GAP THIS CLOSES. `blocked` used to be terminal: once
     `_reconcile_running` exhausted an entry's attempts, nothing ever asked
@@ -4872,32 +4981,49 @@ def _fetch_live_blocked_gate(
     every such target is looked up again against the refreshed queue before
     this function concedes it has nothing.
 
-    #2806 VISIBILITY. `_fetch_live_ci_gate`'s sibling docstring, and this
-    one before #2806, both describe "a key ABSENT" as if it were one thing —
-    it is actually at least four (no queue row even after the self-heal
-    above, no PR number yet, `entry_gate_status` raising, or the whole
-    fetch failing closed before any entry is even tried) and NONE of them
-    used to be logged anywhere, so a run of them looked, from the tick's own
-    output, identical to the gate genuinely still being shut. Every one is
-    now (a) logged here, so `journalctl` names the actual cause instead of
-    silence, and (b) surfaced in the second returned dict, keyed by entry,
-    with a short human-readable reason — :func:`coord.drive_queue.
-    _reconcile_blocked_unreadable` turns a present key there into a
-    distinct, operator-visible "could not read this gate" outcome instead
-    of folding it into "still shut" the way an absent key from the FIRST
-    dict alone always has and still does (see that function's docstring for
-    why the two must never render identically).
+    #2806/#3460 VISIBILITY. `_fetch_live_ci_gate`'s sibling docstring, and
+    this one before #2806, both described "a key ABSENT" as if it were one
+    thing — it is actually several (no work row at all behind a missing
+    queue row, that row's own evaluation raising, a queue row whose CI
+    can't be confirmed without a PR, `entry_gate_status` raising, or the
+    whole fetch failing closed before any entry is even tried) and NONE of
+    them used to be logged anywhere, so a run of them looked, from the
+    tick's own output, identical to the gate genuinely still being shut.
+    Every one is now (a) logged here, so `journalctl` names the actual
+    cause instead of silence, and (b) surfaced in the THIRD returned dict,
+    keyed by entry, with a short human-readable reason — :func:`coord.
+    drive_queue._reconcile_blocked_unreadable` turns a present key there
+    into a distinct, operator-visible "could not read this gate" outcome
+    instead of folding it into "still shut" the way an absent key from the
+    FIRST dict alone always has and still does (see that function's
+    docstring for why the two must never render identically).
+
+    #3460's fix is entirely about SHRINKING this third dict's population in
+    favour of the first two: the #3460 incident (quadraui#1081) was exactly
+    a confirmed-still-shut gate — review request-changes outstanding, Test
+    failed — reported as "unreadable" purely because ``enqueue_approved_
+    work``'s #2806 self-heal above can never produce a queue row for a work
+    row that fails the review/smoke gates (that self-heal enqueues ONLY
+    gate-clear work — `coord/merge_queue.py:4973`), and a queue row without
+    a PR number used to be conceded unreadable outright even though every
+    gate but CI is answerable without one. Both shapes now get a direct
+    evaluation first (:func:`_evaluate_blocked_entry_without_a_queue_row`
+    for the former; a direct :func:`coord.merge_queue.entry_gate_status`
+    call for the latter, since that function only *skips* its CI/epic-
+    keyword checks without a PR — #1150 — it doesn't refuse to run without
+    one) — "unreadable" is now reserved for when that evaluation itself
+    finds genuinely nothing, or raises.
 
     Same fail-open-per-entry, fail-closed-overall contract as
     `_fetch_live_ci_gate` otherwise: a key ABSENT from the FIRST dict (no
-    queue row, no PR yet, a `ci_store` that failed to build, any exception)
-    leaves that entry to `plan_tick`'s cheap board-only fallback
-    (`IssueFacts.merge_gate_status`, populated for free on a thin client's
-    live `/board`) — which on the daemon-host tick (the only host this
-    actually runs on, `docs/DRIVE_QUEUE.md` §2) has no `merge_plan` section
-    to read at all, so an absent key there means "no evidence, stays
-    blocked, but distinctly reported as unreadable when the second dict
-    says why" (`_reconcile_blocked` never guesses at a gate reading).
+    work row behind a missing queue row, a `ci_store` that failed to build,
+    any exception) leaves that entry to `plan_tick`'s cheap board-only
+    fallback (`IssueFacts.merge_gate_status`, populated for free on a thin
+    client's live `/board`) — which on the daemon-host tick (the only host
+    this actually runs on, `docs/DRIVE_QUEUE.md` §2) has no `merge_plan`
+    section to read at all, so an absent key there means "no evidence,
+    stays blocked, but distinctly reported as unreadable when the third
+    dict says why" (`_reconcile_blocked` never guesses at a gate reading).
     """
     targets = [
         e for e in entries
@@ -4905,12 +5031,12 @@ def _fetch_live_blocked_gate(
         and not is_permanent_block_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
@@ -4932,7 +5058,7 @@ def _fetch_live_blocked_gate(
             "back to the board-only reading, unreadable: %r",
             len(targets), "y" if len(targets) == 1 else "ies", exc,
         )
-        return {}, {}
+        return {}, {}, {}
 
     # #2806 self-heal: mirror `coord merge --only`'s #1845 fix — a target
     # with no queue row yet may simply not have been enqueued by
@@ -4950,10 +5076,38 @@ def _fetch_live_blocked_gate(
             )
 
     overrides: dict[str, bool] = {}
+    reasons: dict[str, str] = {}
     unreadable: dict[str, str] = {}
     for e in targets:
         q = queue_by_key.get(e.key)
         if q is None:
+            # #3460: the self-heal above never produces a row for a work row
+            # that fails the review/smoke gates (`enqueue_approved_work`
+            # only enqueues gate-clear work) — exactly the shape this sweep
+            # most needs to confirm. Evaluate the branch's winning work row
+            # directly before conceding "unreadable".
+            resolved = None
+            if not is_pre_dispatch_block_reason(getattr(e, "last_reason", "") or ""):
+                try:
+                    resolved = _evaluate_blocked_entry_without_a_queue_row(
+                        e, board, cfg, _gh_ops
+                    )
+                except Exception as exc:  # noqa: BLE001 — falls to "unreadable" below
+                    log.warning(
+                        "blocked-gate sweep (#3460): %s — evaluating the "
+                        "winning work row directly raised: %r", e.key, exc,
+                    )
+                    resolved = None
+            if resolved is not None:
+                shut, reason = resolved
+                overrides[e.key] = shut
+                reasons[e.key] = reason
+                log.info(
+                    "blocked-gate sweep (#3460): %s — no merge-queue row, "
+                    "but its winning work row evaluates directly: %s",
+                    e.key, reason,
+                )
+                continue
             reason = "no merge-queue row for this entry, even after the self-heal enqueue attempt"
             # #2589/#2635: a genuinely pre-dispatch cause (no branch/PR was
             # EVER created) will never have a merge-queue row, forever — that
@@ -4971,20 +5125,36 @@ def _fetch_live_blocked_gate(
                 unreadable[e.key] = reason
                 log.warning("blocked-gate sweep (#2806): %s — %s", e.key, reason)
             continue
-        if not q.pr_number:
-            reason = "merge-queue row has no PR number yet"
-            unreadable[e.key] = reason
-            log.warning("blocked-gate sweep (#2806): %s — %s", e.key, reason)
-            continue
         try:
-            status, _reason = _mq.entry_gate_status(q, board, cfg, ci_store, _gh_ops)
+            status, gate_reason = _mq.entry_gate_status(q, board, cfg, ci_store, _gh_ops)
         except Exception as exc:  # noqa: BLE001 — leave this one entry to the fallback
             reason = f"entry_gate_status raised: {exc!r}"
             unreadable[e.key] = reason
             log.warning("blocked-gate sweep (#2806): %s — %s", e.key, reason)
             continue
-        overrides[e.key] = status != _mq.PLAN_READY
-    return overrides, unreadable
+        if status == _mq.PLAN_BLOCKED:
+            # #3460: confirmed still shut regardless of whether *q* carries
+            # a PR yet — `entry_gate_status` only *skips* its CI/epic-
+            # keyword checks without one (#1150: CI is checked per-PR), it
+            # never refuses to evaluate the review/smoke/uat gates that
+            # already produced this BLOCKED verdict.
+            overrides[e.key] = True
+            if gate_reason:
+                reasons[e.key] = gate_reason
+            continue
+        # status == PLAN_READY. Confirmed clear only when a PR exists to
+        # confirm CI against — without one, "ready" only means "every gate
+        # this call could check without a PR is clear", which is NOT the
+        # same claim `_blocked_gate_reading`'s `False` makes to the resume
+        # path (#1150 applies to `enqueue_approved_work`'s own enqueue
+        # decision, not to promising a live merge would succeed).
+        if not q.pr_number:
+            reason = "merge-queue row has no PR number yet (CI unverifiable without a PR)"
+            unreadable[e.key] = reason
+            log.warning("blocked-gate sweep (#2806): %s — %s", e.key, reason)
+            continue
+        overrides[e.key] = False
+    return overrides, reasons, unreadable
 
 
 def _fetch_live_prereq_terminal(
@@ -6556,8 +6726,8 @@ def drive_queue_tick(
         # entries — see `_fetch_live_blocked_gate`'s docstring for the gap
         # this closes (quadraui#309 sat `blocked` ~11h on a merge that was
         # landable for most of that window, and nothing ever looked again).
-        live_blocked_gate, live_blocked_unreadable = _fetch_live_blocked_gate(
-            entries, config_path
+        live_blocked_gate, live_blocked_gate_reason, live_blocked_unreadable = (
+            _fetch_live_blocked_gate(entries, config_path)
         )
 
         # #2350: for every entry the two live re-checks above just found
@@ -6618,6 +6788,7 @@ def drive_queue_tick(
             live_ci_gate=live_ci_gate,
             live_ci_gate_reason=live_ci_gate_reason,
             live_blocked_gate=live_blocked_gate,
+            live_blocked_gate_reason=live_blocked_gate_reason,
             live_blocked_unreadable=live_blocked_unreadable,
             editable_drift=editable_drift,
             merge_only_ready=merge_only_ready,