code-coordinator 0.5.96__tar.gz → 0.5.97__tar.gz

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.96",
+  "tag": "0.5.97",
   "distance": 0,
-  "node": "g312293364325c98de0888c4de55e3f5f168662dd",
+  "node": "g2c2fb9bb30187ab30ecfca32a852de69332b37e9",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-15"

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/coord/dead_end.py

@@ -232,26 +232,55 @@ def detect_dead_end(state, *, can_waive_test_gate: bool = False) -> DeadEnd | No
             gates=_gates(state),
         )
 
-    # ── shape 2: the Test stage is BLOCKED (#1672) ─────────────────────────
+    # ── shape 2: the Test stage is BLOCKED (#1672/#2272) ───────────────────
     # `dispatch_smoke` stamps `test_state="blocked"` when no capability-
     # matched machine could run the suite, and then REFUSES to re-probe on
     # every tick — deliberately, that spin is what #1672 closed.  So the
     # driver polling for a verdict is polling for something the dispatcher
     # has already decided not to produce.  vimcode#635's shape, in the one
     # variant the board makes provable.
+    #
+    # #2272 parks the SAME value for a second, unrelated cause: N Test-stage
+    # legs in a row finished without printing a `SMOKE:` marker and the retry
+    # budget ran out.  Both are "no verdict is coming", which is why they
+    # share a state — but the recovery is completely different (fix the fleet
+    # vs. find out why the worker went mute, usually the 600s Bash ceiling),
+    # so they must not share a REASON.  Telling the operator "no capability-
+    # matched machine" about a row whose machines were fine all along is the
+    # symptom-not-cause failure #2235 exists to measure, and it is one
+    # `mute_smoke_legs` call away from being avoided.
     if state.work_test_state == TEST_STATE_BLOCKED:
-        return DeadEnd(
-            kind="test_stage_blocked",
-            stage="test",
-            reason=(
-                f"the Test stage for {state.work_aid} is BLOCKED: "
-                f"{state.work_test_reason or 'no reason recorded'} — "
+        from coord.smoke import mute_smoke_legs  # noqa: PLC0415
+
+        mute_legs = mute_smoke_legs(state.work_test_reason)
+        if mute_legs:
+            cause = (
+                f"{mute_legs} Test-stage leg(s) in a row finished without "
+                "printing a `SMOKE:` verdict marker, exhausting the retry "
+                "budget, so coord.notify parked the row rather than "
+                "re-dispatching a cause that had already repeated identically "
+                "every lap (#2272). Nothing is known to be wrong with the "
+                "BRANCH — the commonest cause is the smoke command exceeding "
+                "the worker's 600s Bash ceiling, which backgrounds the run "
+                "and leaves the session with no exit status to report. Check "
+                "the last Test-stage transcript for a backgrounded command "
+                "before you blame the diff."
+            )
+        else:
+            cause = (
                 "coord.smoke.dispatch_smoke found no capability-matched "
                 "machine and recorded 'blocked' rather than re-probing a "
                 "broken fleet on every tick (#1672). It will not try again "
                 "on its own, so waiting for a verdict here waits forever "
                 "(#2019). Fix the fleet (or the capability rules), then "
                 "clear the marker."
+            )
+        return DeadEnd(
+            kind="test_stage_blocked",
+            stage="test",
+            reason=(
+                f"the Test stage for {state.work_aid} is BLOCKED: "
+                f"{state.work_test_reason or 'no reason recorded'} — {cause}"
             ),
             recovery=(
                 f"coord diagnose {state.repo} {state.issue} --stage test --reset"

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/coord/notify.py

@@ -52,6 +52,16 @@ from coord.dispatch import (
     post_refused_policy,
 )
 from coord.progress import parse_progress
+
+# #2272: the mute-Test-stage retry budget. Canonically in `coord.smoke`
+# because `dispatch_smoke` is the writer that has to carry the tally across
+# its own `running` stamp — a second definition here is exactly how the
+# counter and the thing that clobbers it drift apart again. Safe as a
+# module-level import: `coord.smoke` reaches config/dispatch/models/revalidate
+# and none of them import this module.
+from coord.smoke import MUTE_SMOKE_LEG_BUDGET, TEST_STATE_BLOCKED
+from coord.smoke import NO_SMOKE_VERDICT_MARKER as _NO_SMOKE_VERDICT_MARKER
+from coord.smoke import mute_smoke_legs, mute_smoke_tally
 from coord.state import (
     load_dispatched,
     load_done_reviews_needing_post,
@@ -1776,7 +1786,12 @@ def _smoke_worker_verdict(
 #: ``test_reason`` when a headless smoke produced no parseable verdict. Read
 #: back on the NEXT such reap to decide between "park for one automatic
 #: re-dispatch" and "block, an operator has to look" — see below.
-NO_SMOKE_VERDICT_MARKER = "no-verdict (#2244)"
+#:
+#: #2272: canonically defined in :mod:`coord.smoke` (imported at the top of
+#: this module), next to `dispatch_smoke` — the function that has to carry the
+#: tally across its own ``running`` stamp for this counter to survive at all.
+#: Re-bound here because this is the name the reap path has always used.
+NO_SMOKE_VERDICT_MARKER = _NO_SMOKE_VERDICT_MARKER
 
 
 def _record_smoke_verdict(
@@ -1885,50 +1900,70 @@ def _record_smoke_verdict(
         return
 
     # No verdict line, clean session exit. NOT a pass.
+    #
+    # #2272: count the legs, don't just test for the marker's presence. The
+    # tally lives at the FRONT of `test_reason` so a bounded `/board` preview
+    # still carries it, and `dispatch_smoke` re-states it across the `running`
+    # stamp that used to erase it. Together those two make this a real budget
+    # rather than the never-firing one #2244 intended.
     previous_reason = load_assignment_test_reason(parent_id) or ""
-    already_mute_once = NO_SMOKE_VERDICT_MARKER in previous_reason
+    legs = mute_smoke_legs(previous_reason) + 1
     reason = (
-        f"{NO_SMOKE_VERDICT_MARKER}: the Test-stage worker "
+        f"{mute_smoke_tally(legs)}: the Test-stage worker "
         f"{transition.assignment_id} ended without printing a verdict marker "
         "line, and a `claude -p` exit code says only that the session ended — "
         "it is not a suite result."
     )
-    if already_mute_once:
+    if legs >= MUTE_SMOKE_LEG_BUDGET:
         # The same park value `dispatch_smoke` uses for an unroutable stage
         # (#1672): every gate that wants "passed"/"skipped" keeps the merge
         # shut, `dispatch_pending_smoke` stops re-dispatching, and no fix
         # round is burned on a branch nothing has found fault with.
-        from coord.smoke import TEST_STATE_BLOCKED  # noqa: PLC0415
-
+        #
+        # #2272: the terminal reason NAMES the cause and the count. "N smoke
+        # legs produced no verdict" is a statement an operator can act on; the
+        # five-lap incident presented as "the branch is slow" precisely
+        # because nothing on the row ever said how many legs had gone mute.
         record_test_verdict(
             assignment_id=parent_id,
             test_state=TEST_STATE_BLOCKED,
             test_reason=(
-                f"{reason} Second consecutive mute Test stage — parked instead "
-                "of re-dispatched. Recover with `coord diagnose <repo> <issue> "
-                "--stage test --reset`, or record the verdict by hand with "
-                f"`coord test --passed|--fail {parent_id}`."
+                f"{reason} {legs} smoke legs produced no verdict — the "
+                f"Test-stage retry budget ({MUTE_SMOKE_LEG_BUDGET}) is "
+                "exhausted, so the row is parked instead of re-dispatched "
+                "(#2272). A mute leg is not a failing branch: check whether "
+                "the smoke command is exceeding the worker's 600s Bash "
+                "ceiling before you blame the diff. Recover with `coord "
+                "diagnose <repo> <issue> --stage test --reset`, or record the "
+                f"verdict by hand with `coord test --passed|--fail "
+                f"{parent_id}`."
             ),
         )
         log.warning(
-            "smoke %s: no SMOKE: verdict in the transcript for the SECOND "
-            "time on parent %s — parking test_state='blocked' (#2244).",
-            transition.assignment_id, parent_id,
+            "smoke %s: no SMOKE: verdict in the transcript — that is %d mute "
+            "Test-stage leg(s) on parent %s and the retry budget (%d) is "
+            "exhausted, so parking test_state=%r instead of re-dispatching "
+            "(#2272). Check the worker's 600s Bash ceiling first.",
+            transition.assignment_id, legs, parent_id, MUTE_SMOKE_LEG_BUDGET,
+            TEST_STATE_BLOCKED,
         )
         return
 
+    remaining = MUTE_SMOKE_LEG_BUDGET - legs
     record_test_verdict(
         assignment_id=parent_id,
         test_state=None,
         test_reason=(
-            f"{reason} Cleared for one automatic Test-stage re-dispatch; a "
-            "second mute run parks the row instead."
+            f"{reason} Cleared for a Test-stage re-dispatch; {remaining} of "
+            f"{MUTE_SMOKE_LEG_BUDGET} legs left in the budget before the row "
+            "parks instead (#2272)."
         ),
     )
     log.warning(
         "smoke %s: no SMOKE: verdict in the transcript — recording NO verdict "
-        "for parent %s (cleared for re-dispatch), never 'passed' (#2244).",
-        transition.assignment_id, parent_id,
+        "for parent %s (mute leg %d of %d, cleared for re-dispatch), never "
+        "'passed' (#2244).",
+        transition.assignment_id, parent_id, legs, MUTE_SMOKE_LEG_BUDGET,
     )
 
 

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/coord/reconcile.py

@@ -365,15 +365,33 @@ def propagate_smoke_terminal_failure(
     if not parent_assignment_id:
         return
     from coord.failure_class import classify_failure  # noqa: PLC0415
-    from coord.state import record_test_verdict  # noqa: PLC0415
+    from coord.smoke import mute_smoke_legs, mute_smoke_tally  # noqa: PLC0415
+    from coord.state import (  # noqa: PLC0415
+        load_assignment_test_reason,
+        record_test_verdict,
+    )
 
     classification = classify_failure(failure_reason=failure_reason)
     if classification.is_environmental:
+        # #2272: this clear must CARRY the mute-leg tally, for exactly the
+        # reason `dispatch_smoke`'s `running` stamp must. `test_reason` is the
+        # only field that survives between Test-stage legs, so any writer that
+        # replaces it wholesale silently hands the row a fresh retry budget —
+        # and a row that alternates "mute leg" / "worker died environmentally"
+        # would then never reach the bound from either side. The tally is not
+        # incremented here (an environmental death is a different, genuinely
+        # self-healing cause and #1605's unbounded re-dispatch of it is
+        # deliberate) — it is only preserved, so mute legs keep counting
+        # across it.
+        carried = mute_smoke_legs(
+            load_assignment_test_reason(parent_assignment_id)
+        )
+        prefix = f"{mute_smoke_tally(carried)} — " if carried else ""
         record_test_verdict(
             assignment_id=parent_assignment_id,
             test_state=None,
             test_reason=(
-                "Test stage worker died environmentally "
+                f"{prefix}Test stage worker died environmentally "
                 f"({classification.reason}) — cleared for automatic "
                 "re-dispatch, not recorded as a work failure (#1605)"
             ),

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/coord/smoke.py

@@ -46,6 +46,7 @@ from __future__ import annotations
 
 import json
 import logging
+import re
 import time
 import uuid
 from dataclasses import dataclass
@@ -102,6 +103,21 @@ session — the coordinator sees exit 0 either way, so a run whose suite failed
 and whose marker is missing is recorded as NO verdict (never a pass) and the \
 Test stage has to be re-run. Exit with the matching code as well, for the \
 non-headless lanes that do read it.
+- NEVER END YOUR TURN WITH THE SUITE STILL RUNNING (#2272). Your smoke \
+command can easily exceed the ~600s Bash ceiling; when it does, the harness \
+moves it to the BACKGROUND and hands you a task id instead of an exit status. \
+That is not a result — it is "no answer yet". Narrating that you kicked the \
+suite off and stopping there prints no marker, so the Test stage records NO \
+verdict and re-dispatches; because the ceiling is deterministic, every \
+re-dispatch does exactly the same thing, which is why this loop bills \
+indefinitely. Instead: POLL the backgrounded task to completion from THIS \
+same session, in bounded steps (`BashOutput`/`TaskOutput` with the id, or \
+`Monitor`), and read its REAL exit status before you report anything. Do NOT \
+use a foreground `until ! pgrep ...; do sleep ...; done` wait — it hits the \
+identical 600s wall. If you genuinely cannot obtain an exit status before you \
+run out of room, print `SMOKE: fail <the smoke command never returned an exit \
+status within this session>` rather than ending mute: a stated verdict is \
+recoverable, silence is not.
 
 Where you are:
 - You are in a dedicated git worktree created for this run. Every git command \
@@ -114,7 +130,10 @@ fail (#1694).
 Steps:
 1. `git fetch origin && git checkout <branch>` (the branch is in your \
 briefing) — in your worktree, never in the base checkout.
-2. Run the smoke command from the briefing. Capture stdout/stderr.
+2. Run the smoke command from the briefing. Capture stdout/stderr. If the \
+harness backgrounds it for exceeding the 600s Bash ceiling, poll that task to \
+completion and use ITS exit status below — "I started it" is not an outcome \
+(#2272).
 3. If it exits 0 → print `SMOKE: pass` and exit 0.
 4. If it exits {RUNNER_BASELINE_RED_EXIT} AND its output contains a line \
 starting with literal text `{BASELINE_RED_OUTPUT_MARKER}` (#2170) — the smoke \
@@ -524,6 +543,33 @@ def build_smoke_briefing(
     lines.append(smoke_command)
     lines.append("```")
     lines.append("")
+    # #2272: the ceiling is the deterministic cause of a mute Test stage. A
+    # suite this size routinely runs past 600s, the harness backgrounds it,
+    # and an agent that narrates "I kicked it off" and stops prints no marker
+    # — so the stage records NO verdict and re-dispatches, forever, at ~$0.12
+    # a lap. Say it in the briefing as well as the system prompt: the briefing
+    # is what the worker re-reads while it is deciding what to do next.
+    lines.append("## If the suite runs past the 600s Bash ceiling (#2272)")
+    lines.append("")
+    lines.append(
+        "Claude Code moves any Bash call past ~600s to the **background** and "
+        "hands you a task id instead of an exit status. That is not a result. "
+        "**Do not end your turn there** — poll the backgrounded task to "
+        "completion from this same session (`BashOutput`/`TaskOutput` with "
+        "the id, in bounded steps) and read its real exit status before "
+        "reporting. A foreground `until ! pgrep ...; do sleep ...; done` wait "
+        "hits the identical wall, so don't."
+    )
+    lines.append("")
+    lines.append(
+        "A turn that ends with the suite still running prints no marker, the "
+        "Test stage records NO verdict, and it re-dispatches — and since the "
+        "ceiling is deterministic, every re-dispatch stalls identically. If "
+        "you truly cannot get an exit status, print `SMOKE: fail <the smoke "
+        "command never returned an exit status within this session>` rather "
+        "than ending mute."
+    )
+    lines.append("")
     lines.append(
         "## Reporting the verdict (#2244)"
     )
@@ -619,6 +665,91 @@ def _fetch_touched_files(repo_github: str, branch: str) -> list[str]:
 TEST_STATE_BLOCKED = "blocked"
 
 
+# ── Mute Test-stage legs: the retry budget (#2244/#2272) ────────────────────
+#
+# A Test-stage leg that finishes without printing a `SMOKE:` marker records NO
+# verdict — never a pass (#2244). That is the right call, and it assumes
+# re-running is USEFUL. #2272 is the case where it is not: on 2026-08-15 five
+# consecutive legs against one work row each ran the suite past Claude Code's
+# 600s Bash ceiling, got backgrounded, and ended mute. Deterministic cause,
+# identical every lap, ~$0.12 and ~10 minutes each, and the board showed a
+# healthy `running` Test stage throughout. It was stopped by hand.
+#
+# #2244 already intended a bound — "a SECOND mute run parks the row" — but it
+# stored the evidence in the parent's `test_reason` and `dispatch_smoke`'s own
+# `running` stamp overwrote that field on the very next dispatch. The counter
+# was reset by the retry it was supposed to be counting, so the bound never
+# fired. Hence two things here rather than one:
+#
+#   * a TALLY that is explicit and parseable (`no-verdict (#2244) x2`) rather
+#     than a bare marker whose presence is the whole signal, and
+#   * `dispatch_smoke` carrying that tally ACROSS its `running` stamp, so the
+#     count survives the thing that kept destroying it.
+#
+# The generalisation matters more than the ceiling: whatever future cause
+# leaves a Test stage mute — a dead harness, a machine that reboots mid-run, a
+# prompt regression — it now costs a bounded number of legs and then names
+# itself on the row, instead of billing forever. A cause the system cannot
+# diagnose must still be a cause the system stops paying for.
+
+#: The marker left in the parent work row's ``test_reason`` when a headless
+#: Test stage produced no parseable verdict. Suffixed with `` xN`` from the
+#: second leg on (see :func:`mute_smoke_tally`).
+NO_SMOKE_VERDICT_MARKER = "no-verdict (#2244)"
+
+#: How many CONSECUTIVE mute Test-stage legs one work row may burn before the
+#: row is parked terminally instead of re-dispatched (#2272). Two — one lap of
+#: genuine self-heal (the #1605 environmental-death shape really does clear on
+#: a retry), then stop. Pinned by test: raising it raises the unattended spend
+#: ceiling for every no-verdict cause at once, which is exactly the decision
+#: that should be deliberate.
+MUTE_SMOKE_LEG_BUDGET = 2
+
+#: Matches the marker with or without its `` xN`` tally, so a reason written by
+#: a pre-#2272 coordinator (bare marker, no count) still reads back as one leg
+#: rather than zero — an upgrade mid-loop must not hand the row a fresh budget.
+_MUTE_TALLY_RE = re.compile(
+    re.escape(NO_SMOKE_VERDICT_MARKER) + r"(?:\s*x\s*(\d+))?", re.IGNORECASE
+)
+
+
+def mute_smoke_legs(test_reason: str | None) -> int:
+    """How many mute Test-stage legs *test_reason* records (0 if none).
+
+    Reads the tally back out of the parent work row's ``test_reason`` — the
+    one field that survives from one Test-stage leg to the next. Tolerates:
+
+    * ``None``/empty — no legs (the ordinary first dispatch),
+    * the bare pre-#2272 marker with no count — one leg,
+    * a truncated ``test_reason`` — the ``/board`` wire carries only a bounded
+      preview (:func:`coord.state.load_assignment_test_reason`), so the tally
+      is written at the FRONT of the reason where a preview still shows it.
+    """
+    if not test_reason:
+        return 0
+    match = _MUTE_TALLY_RE.search(test_reason)
+    if match is None:
+        return 0
+    raw = match.group(1)
+    if raw is None:
+        return 1
+    try:
+        return max(1, int(raw))
+    except ValueError:  # pragma: no cover — regex only matches digits
+        return 1
+
+
+def mute_smoke_tally(count: int) -> str:
+    """The marker for *count* mute legs — ``"no-verdict (#2244) x2"``.
+
+    A single leg renders as the bare marker, so an operator reading a row
+    mid-loop sees a count only once there is a count worth seeing.
+    """
+    if count <= 1:
+        return NO_SMOKE_VERDICT_MARKER
+    return f"{NO_SMOKE_VERDICT_MARKER} x{count}"
+
+
 #: Soft (transient) unroutable reports already logged this process, keyed by
 #: ``(assignment_id, message)``. Transient conditions — a machine that is
 #: merely unreachable right now — are left re-dispatchable so the stage
@@ -1095,17 +1226,46 @@ def dispatch_smoke(
     # `running` → the merge never fires → repeat. Dispatching a *fresh* run
     # must never, by itself, retract the previous answer; the new verdict
     # replaces the old one when it actually lands.
+    #
+    # #2272: ...and this stamp must CARRY THE MUTE-LEG TALLY FORWARD. That is
+    # the whole bug behind the five-lap loop: `test_reason` is the only field
+    # that survives between Test-stage legs, `_record_smoke_verdict` stores the
+    # "this leg came back mute" evidence there, and this write used to replace
+    # it with a flat literal. So the counter was erased by the very retry it
+    # existed to count, `already_mute_once` read False forever, and #2244's
+    # "a second mute run parks the row" bound could never fire. Re-reading and
+    # re-stating the tally here also keeps the retry VISIBLE on the board:
+    # before this, a row on its fifth mute lap rendered identically to one
+    # whose Test stage had just started for the first time, which is why five
+    # identical laps looked like progress.
     if completed.assignment_id is not None and completed.test_state not in (
         "passed", "skipped", "failed",
     ):
-        from coord.state import record_test_verdict
+        from coord.state import load_assignment_test_reason, record_test_verdict
+
+        # Belt and braces: the authoritative single-row read, falling back to
+        # the board-carried value when it is unavailable (thin client, remote
+        # read failure). Both are bounded previews at worst and the tally is
+        # written at the front of the reason, so either still carries it.
+        prior_legs = max(
+            mute_smoke_legs(load_assignment_test_reason(completed.assignment_id)),
+            mute_smoke_legs(getattr(completed, "test_reason", None)),
+        )
+        running_reason = "dispatched: Test stage running (#1426)"
+        if prior_legs:
+            running_reason = (
+                f"{mute_smoke_tally(prior_legs)} — {running_reason}; "
+                f"retry {prior_legs + 1} of {MUTE_SMOKE_LEG_BUDGET} after "
+                f"{prior_legs} Test-stage leg(s) produced no verdict (#2272)"
+            )
 
         record_test_verdict(
             assignment_id=completed.assignment_id,
             test_state="running",
-            test_reason="dispatched: Test stage running (#1426)",
+            test_reason=running_reason,
         )
         completed.test_state = "running"
+        completed.test_reason = running_reason
 
     return smoke_assignment
 

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/coord/stage_projection.py

@@ -276,6 +276,16 @@ def test_stage_status_for(
     # blocked reason reaches the operator through `test_reason` instead —
     # rendered by `coord gates` and, since no smoke row exists in this case,
     # by the TUI Summary tab's `board_assignment_reason` on the work row.
+    #
+    # #2272 parks the same ``"blocked"`` for a second cause — N Test-stage
+    # legs finished without printing a `SMOKE:` marker and the retry budget
+    # ran out — and it maps here for the identical reason: a mute leg says
+    # nothing about the branch, so FAILED would be a lie about the diff and
+    # would offer the operator a Work re-dispatch that fixes nothing. The
+    # count and the cause travel in `test_reason` (`coord.smoke.
+    # mute_smoke_legs` reads them back), which is what keeps a row on its
+    # last retry distinguishable from one whose Test stage never started —
+    # the confusion that let five identical mute laps look like progress.
     return PENDING
 
 

{code_coordinator-0.5.96 → code_coordinator-0.5.97}/tests/test_dead_end.py

@@ -261,6 +261,44 @@ def test_a_blocked_test_stage_is_a_dead_end() -> None:
     assert found.recovery == (
         f"coord diagnose {REPO} {ISSUE} --stage test --reset"
     )
+    # The #1672 cause, stated as the #1672 cause.
+    assert "no capability-matched" in found.reason
+
+
+def test_a_mute_exhausted_test_stage_names_its_own_cause() -> None:
+    """#2272: the mute-leg budget parks the SAME ``blocked`` value as #1672's
+    unroutable stage — both mean "no verdict is coming" — but the recovery is
+    completely different, so they must not share a reason.
+
+    Telling an operator "no capability-matched machine could run the suite"
+    about a row whose machines were healthy all along is the symptom-not-cause
+    failure #2235 exists to measure: the real answer is "N legs went mute,
+    almost certainly the 600s Bash ceiling".
+    """
+    from coord.smoke import mute_smoke_tally  # noqa: PLC0415
+
+    found = detect_dead_end(
+        state(
+            work_aid="w2272",
+            work_status="done",
+            work_branch="issue-2272",
+            work_test_state=TEST_STATE_BLOCKED,
+            work_test_reason=(
+                f"{mute_smoke_tally(2)}: the Test-stage worker 9214dcb25204 "
+                "ended without printing a verdict marker line. 2 smoke legs "
+                "produced no verdict."
+            ),
+            active_count=0,
+        )
+    )
+    assert found is not None
+    assert found.kind == "test_stage_blocked"
+    assert "2 Test-stage leg(s)" in found.reason
+    assert "600s Bash ceiling" in found.reason
+    # It must NOT misattribute this to the fleet — the machines were fine.
+    assert "no capability-matched" not in found.reason
+    # And it must not read as a statement about the branch.
+    assert "Nothing is known to be wrong with the BRANCH" in found.reason
 
 
 def test_gates_carry_the_readings_that_proved_the_dead_end() -> None: