code-coordinator 0.5.533__tar.gz → 0.5.535__tar.gz

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.533",
+  "tag": "0.5.535",
   "distance": 0,
-  "node": "g3ea458dbd41140d5bf4dca2f931046590f1b3fb0",
+  "node": "gb4633aa4d9fe33c39961caa7723f8214fa8b67d0",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/coord/client.py

@@ -763,18 +763,44 @@ def fetch_drive_escalations(
     return entries if isinstance(entries, list) else []
 
 
-def fetch_drive_queue(
+@dataclass(frozen=True)
+class DriveQueueRead:
+    """Result of one drive-queue read attempt (#2992).
+
+    Distinguishes "the daemon could not be read" from "the daemon answered
+    and the queue is genuinely empty" — a distinction :func:`fetch_drive_queue`
+    itself collapses on purpose (see its docstring), because most callers only
+    want best-effort rows. ``coord drive-queue list`` is the one caller that
+    must NOT collapse it: reporting "queue is empty" for a daemon that never
+    actually answered is exactly the false "nothing to see here" #2992 was
+    filed over.
+
+    ``ok=True`` — the daemon answered; ``entries`` is the real list, ``[]``
+    included for a genuinely drained queue.
+    ``ok=False`` — the read failed (network error, non-2xx, malformed JSON);
+    ``entries`` is always ``[]`` here too (never meaningful) and ``error``
+    carries a short human-readable reason.
+    """
+
+    ok: bool
+    entries: list[dict]
+    error: str | None = None
+
+
+def fetch_drive_queue_result(
     svc: ServiceConfig,
     repo_name: str | None = None,
     *,
     timeout: float = _DEFAULT_TIMEOUT,
-) -> list[dict]:
-    """GET the drive queue in run order, optionally filtered to one repo (#1753).
-
-    ``[]`` on ANY failure (404 from a daemon predating this route, network
-    error, bad JSON, or a genuinely empty queue) — fail-soft, mirrors
-    :func:`fetch_drive_escalations`. ``after_json`` arrives already decoded to
-    a list; this helper does not re-parse it.
+) -> DriveQueueRead:
+    """GET the drive queue — same request as :func:`fetch_drive_queue` — but
+    returning a :class:`DriveQueueRead` that keeps "could not read" and
+    "read fine, zero rows" apart (#2992).
+
+    This is the one place that decides what counts as a successful
+    drive-queue read; :func:`fetch_drive_queue` is now a thin fail-soft
+    wrapper around it, so there is exactly one answer to "did this read
+    succeed" rather than two implementations that could drift apart.
     """
     try:
         params = {"repo_name": repo_name} if repo_name else {}
@@ -786,10 +812,42 @@ def fetch_drive_queue(
         )
         resp.raise_for_status()
         data = resp.json()
-    except Exception:  # noqa: BLE001
-        return []
+    except httpx.HTTPStatusError as exc:
+        status = exc.response.status_code if exc.response is not None else "?"
+        return DriveQueueRead(
+            ok=False, entries=[], error=f"HTTP {status} from {svc.url}/drive-queue"
+        )
+    except Exception as exc:  # noqa: BLE001 — transport/JSON failure; reported, not swallowed
+        return DriveQueueRead(ok=False, entries=[], error=f"{type(exc).__name__}: {exc}")
     entries = data.get("entries") if isinstance(data, dict) else None
-    return entries if isinstance(entries, list) else []
+    if not isinstance(entries, list):
+        return DriveQueueRead(
+            ok=False, entries=[], error="malformed response (no 'entries' list)"
+        )
+    return DriveQueueRead(ok=True, entries=entries)
+
+
+def fetch_drive_queue(
+    svc: ServiceConfig,
+    repo_name: str | None = None,
+    *,
+    timeout: float = _DEFAULT_TIMEOUT,
+) -> list[dict]:
+    """GET the drive queue in run order, optionally filtered to one repo (#1753).
+
+    ``[]`` on ANY failure (404 from a daemon predating this route, network
+    error, bad JSON, or a genuinely empty queue) — fail-soft, mirrors
+    :func:`fetch_drive_escalations`. ``after_json`` arrives already decoded to
+    a list; this helper does not re-parse it.
+
+    Deliberately still collapses "failed" and "genuinely empty" to the same
+    ``[]`` — most callers (``coord.state.list_drive_queue``'s daemon route,
+    the auto-loop tick) only want best-effort rows and must keep degrading
+    quietly. A caller that needs to tell the two apart — ``coord
+    drive-queue list`` (#2992) — should call :func:`fetch_drive_queue_result`
+    instead, of which this is now a thin wrapper.
+    """
+    return fetch_drive_queue_result(svc, repo_name, timeout=timeout).entries
 
 
 def fetch_leg_counts(

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/coord/commands/drive_queue.py

@@ -132,6 +132,7 @@ from coord.overlap_predict import (
 )
 
 if TYPE_CHECKING:  # pragma: no cover — typing only
+    from coord.client import DriveQueueRead
     from coord.config import Config
     from coord.merge_queue import QueuedMerge
 
@@ -1460,15 +1461,64 @@ def _board_for_list_diagnosis() -> BoardView | None:
         return None
 
 
+def _drive_queue_list_read(
+    repo: str | None,
+) -> tuple[list[dict], DriveQueueRead | None, str | None]:
+    """Fetch the rows `list` renders, distinguishing "daemon unreachable"
+    from "genuinely empty" on a thin client (#2992).
+
+    Returns ``(rows, failure, service_url)`` — ``failure`` is ``None`` on a
+    successful read (rows may still be ``[]``, a genuinely drained queue)
+    and a :class:`coord.client.DriveQueueRead` with ``ok=False`` when the
+    daemon could not be read at all; ``service_url`` names the daemon the
+    failed read targeted (``None`` in host mode). Host mode (no
+    ``board_service`` configured) has no daemon to fail against, so it
+    always reads the local DB and never returns a failure here — out of
+    scope per #2992's own issue body (``coord/state.py``'s local-DB
+    fallback is a separate seam).
+    """
+    from coord.client import fetch_drive_queue_result, resolve_board_service  # noqa: PLC0415
+    from coord.state import list_drive_queue  # noqa: PLC0415
+
+    svc = resolve_board_service()
+    if svc is None:
+        return list_drive_queue(repo), None, None
+    result = fetch_drive_queue_result(svc, repo)
+    if not result.ok:
+        return [], result, svc.url
+    return result.entries, None, svc.url
+
+
+def _drive_queue_list_failure_text(service_url: str, error: str | None) -> str:
+    """The `list` failure line — must read as unmistakably NOT "empty"
+    (#2992's acceptance bar: never contains the words "queue is empty")."""
+    return (
+        f"(drive queue UNREADABLE — could not reach board daemon at "
+        f"{service_url}: {error})"
+    )
+
+
+def _drive_queue_list_failure_json(service_url: str, error: str | None) -> str:
+    """The `--json` failure payload — never a bare `[]` a caller could
+    mistake for zero entries (#2992)."""
+    return _json.dumps({"error": error, "service_url": service_url, "ok": False})
+
+
 @drive_queue_group.command("list")
 @click.option("--repo", "repo", default=None, help="Restrict to one repo (default: every repo).")
 @click.option("--json", "output_json", is_flag=True, default=False, help="Emit the raw rows as JSON.")
 @_CONFIG_OPTION
 def drive_queue_list(repo: str | None, output_json: bool, config_path: Path) -> None:
     """Show the queue in run order."""
-    from coord.state import list_drive_queue  # noqa: PLC0415
+    rows, failure, service_url = _drive_queue_list_read(repo)
+    if failure is not None:
+        import sys as _sys  # noqa: PLC0415
 
-    rows = list_drive_queue(repo)
+        if output_json:
+            click.echo(_drive_queue_list_failure_json(service_url, failure.error))
+        else:
+            click.echo(_drive_queue_list_failure_text(service_url, failure.error))
+        _sys.exit(1)
     if output_json:
         click.echo(_json.dumps(rows))
         return

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/coord/diagnose.py

@@ -1234,7 +1234,57 @@ def _recover_test(
     — exactly the #1598 incident's "nothing to reconcile" symptom, and
     exactly why the daemon restart mentioned in that report didn't clear it
     either: nothing was ever looking at the CHILD row.
+
+    #3332: the same catch-all mis-files ``test_state="blocked"`` too — the
+    dead-end marker ``coord.dead_end`` (shape 2) and ``coord.smoke`` both
+    already know is terminal-and-unactionable (``dispatch_smoke`` gives up
+    and never re-probes it; ``dispatch_pending_smoke`` skips the row on
+    every tick). ``latest.status`` is ``"done"`` for that row too, so
+    without an explicit check it falls through exactly like the ``running``
+    case did before #1605. Checked here, not just left to ``coord.dead_end``,
+    because that module only runs from the ``drive``/auto-loop path —
+    ``coord diagnose --stage test`` is a separate entry point an operator
+    runs by hand, and it must not disagree with the driver about whether the
+    same row is wedged.
     """
+    from coord.smoke import TEST_STATE_BLOCKED  # noqa: PLC0415
+
+    if latest.test_state == TEST_STATE_BLOCKED:
+        from coord.smoke import mute_smoke_legs  # noqa: PLC0415
+
+        # Same predicate `coord.dead_end`'s shape 2 uses to tell #1672
+        # (unroutable fleet) apart from #2272 (mute Test-stage legs) — #2235
+        # exists to keep those two REASONS from blurring together, so this
+        # reuses the identical function rather than re-deriving the split
+        # (#2096 "one question, one answer").
+        mute_legs = mute_smoke_legs(latest.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 (#2272) — nothing is known to be wrong with the "
+                "branch; the commonest cause is the smoke command exceeding "
+                "the worker's 600s Bash ceiling. Check the last Test-stage "
+                "transcript for a backgrounded command before blaming 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. Fix the fleet (or the capability rules), then "
+                "clear the marker."
+            )
+        res.findings.append(
+            f"⚠ test_state='blocked': "
+            f"{latest.test_reason or 'no reason recorded'} — {cause} This "
+            "is a permanent dead end (coord.dead_end shape 2) — no amount "
+            "of waiting produces a verdict. `--reset` clears the marker so "
+            "the row re-enters the Test-stage scan."
+        )
+        res.recovered = False
+        res.needs_reset = True
+        return
     if latest.test_state == "running":
         smoke = next(
             (
@@ -1901,17 +1951,61 @@ def _reset_test_stage(
     to touch a ``test-author``/``mock-author`` row, since those share
     ``issue_number`` across sibling JIT-slice assignments for the same
     milestone tracking issue.
+
+    #3332: itemizes which rows were actually cleared, using
+    ``state.test_reset_candidates`` — the same predicate
+    ``reset_work_test_state`` writes against (#2096 "one question, one
+    answer") — read BEFORE the write to see what carries a ``test_state``,
+    then again AFTER to verify the clear persisted rather than trusting the
+    UPDATE's bare ``rowcount``. A report of "cleared 3 work row(s)" with no
+    way to tell which 3 (of however many share the issue) is exactly the gap
+    #3332 flagged.
     """
     from coord import state  # noqa: PLC0415
 
+    before = state.test_reset_candidates(
+        repo_name, issue_number, assignment_id=assignment_id
+    )
+    had_state = [(aid, typ) for aid, typ, ts in before if ts]
+
     if dry_run:
-        res.findings.append("(dry-run) would clear test_state → re-testable")
+        if had_state:
+            listed = ", ".join(f"{aid} ({typ})" for aid, typ in had_state)
+            res.findings.append(
+                f"(dry-run) would clear test_state → re-testable on "
+                f"{len(had_state)} row(s): {listed}"
+            )
+        else:
+            res.findings.append(
+                "(dry-run) would clear test_state → re-testable (no matching "
+                "row currently carries one — this would be a no-op)"
+            )
         res.needs_reset = True
         return
+
     updated = state.reset_work_test_state(
         repo_name, issue_number, assignment_id=assignment_id
     )
-    res.actions_taken.append(f"cleared Test verdict on {updated} work row(s) (re-testable)")
+    after = state.test_reset_candidates(
+        repo_name, issue_number, assignment_id=assignment_id
+    )
+    still_set = [(aid, typ) for aid, typ, ts in after if ts]
+    cleared = [pair for pair in had_state if pair not in still_set]
+    if still_set:
+        listed = ", ".join(f"{aid} ({typ})" for aid, typ in still_set)
+        res.actions_taken.append(
+            f"reset requested for {updated} row(s), but test_state is still "
+            f"set on re-read for: {listed} — the clear did NOT persist for "
+            "these (#2096)"
+        )
+    if cleared:
+        listed = ", ".join(f"{aid} ({typ})" for aid, typ in cleared)
+        res.actions_taken.append(
+            f"cleared Test verdict on {len(cleared)} work row(s) "
+            f"(re-testable): {listed}"
+        )
+    elif not still_set:
+        res.actions_taken.append(f"cleared Test verdict on {updated} work row(s) (re-testable)")
     res.reset_performed = True
     res.recovered = True
     res.branch_preserved = True

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/coord/state.py

@@ -3650,6 +3650,64 @@ def reset_work_review_state(
     return cur.rowcount
 
 
+def _test_reset_where(
+    repo_name: str, issue_number: int, assignment_id: str | None
+) -> tuple[str, tuple]:
+    """The WHERE clause + params identifying the rows a Test-gate reset
+    touches for ``(repo_name, issue_number, assignment_id)`` — shared by
+    :func:`reset_work_test_state` and :func:`test_reset_candidates` (#3332)
+    so the two can never answer "which rows would this touch" differently
+    (#2096 "one question, one answer"). See :func:`reset_work_test_state`'s
+    docstring for why ``test-author``/``mock-author`` additionally require
+    *assignment_id* to match.
+    """
+    if assignment_id is not None:
+        where = (
+            "repo_name=? AND issue_number=? AND ("
+            "type IN ('work','plan','epic-decompose') OR "
+            "(type IN ('test-author','mock-author') AND assignment_id=?)"
+            ")"
+        )
+        params: tuple = (repo_name, issue_number, assignment_id)
+    else:
+        where = "repo_name=? AND issue_number=? AND type IN ('work','plan','epic-decompose')"
+        params = (repo_name, issue_number)
+    return where, params
+
+
+def test_reset_candidates(
+    repo_name: str, issue_number: int, *, assignment_id: str | None = None
+) -> list[tuple[str, str, str | None]]:
+    """The rows :func:`reset_work_test_state` would touch for the same
+    arguments, as ``(assignment_id, type, test_state)`` triples.
+
+    #3332: lets a caller report WHICH rows a reset cleared instead of a bare
+    count — ``coord diagnose --stage test --reset`` used to report e.g.
+    "cleared Test verdict on 3 work row(s)" for a branch with 4 work-like
+    rows with no way to tell which 3, or whether the 4th was a deliberate
+    skip or a miss. Calling this again *after* the write (comparing which
+    rows still carry a ``test_state``) is also the re-read #2096 asks for —
+    the same pattern :func:`coord.diagnose._reset_review_stage` already uses
+    (#3206's ``still_present`` check) rather than trusting the UPDATE's
+    ``rowcount`` alone.
+    """
+    conn = get_connection()
+    where, params = _test_reset_where(repo_name, issue_number, assignment_id)
+    rows = sql.execute(
+        conn,
+        f"SELECT assignment_id, type, test_state FROM assignments WHERE {where} "
+        "ORDER BY assignment_id",
+        params,
+    ).fetchall()
+    result: list[tuple[str, str, str | None]] = []
+    for row in rows:
+        if hasattr(row, "keys"):
+            result.append((row["assignment_id"], row["type"], row["test_state"]))
+        else:
+            result.append((row[0], row[1], row[2]))
+    return result
+
+
 def reset_work_test_state(
     repo_name: str, issue_number: int, *, assignment_id: str | None = None
 ) -> int:
@@ -3689,17 +3747,7 @@ def reset_work_test_state(
     reset itself.
     """
     conn = get_connection()
-    if assignment_id is not None:
-        where = (
-            "repo_name=? AND issue_number=? AND ("
-            "type IN ('work','plan','epic-decompose') OR "
-            "(type IN ('test-author','mock-author') AND assignment_id=?)"
-            ")"
-        )
-        params: tuple = (repo_name, issue_number, assignment_id)
-    else:
-        where = "repo_name=? AND issue_number=? AND type IN ('work','plan','epic-decompose')"
-        params = (repo_name, issue_number)
+    where, params = _test_reset_where(repo_name, issue_number, assignment_id)
 
     try:
         from coord.smoke import _parse_fanout_manifest  # noqa: PLC0415

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/tests/test_client.py

@@ -204,3 +204,125 @@ class TestFetchBoardPayloadConditionalGet:
         cc.reset_board_payload_cache()
 
         assert cc._board_payload_cache == {}
+
+
+class TestFetchDriveQueueResult:
+    """#2992: a daemon read failure must be distinguishable from a
+    genuinely empty queue — ``fetch_drive_queue_result`` is the function
+    that carries that distinction; ``fetch_drive_queue`` stays a fail-soft
+    wrapper around it for callers that don't want it (unchanged contract).
+    """
+
+    def test_populated_queue_is_ok_with_the_real_rows(self, monkeypatch) -> None:
+        rows = [{"repo_name": "cc", "issue_number": 1}, {"repo_name": "cc", "issue_number": 2}]
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": rows})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is True
+        assert result.entries == rows
+        assert result.error is None
+
+    def test_genuinely_empty_queue_is_ok_with_zero_rows(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": []})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is True
+        assert result.entries == []
+        assert result.error is None
+
+    def test_transport_error_is_not_ok_and_names_the_reason(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            raise httpx.ConnectError("connection refused")
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert result.error is not None
+        assert "refused" in result.error or "ConnectError" in result.error
+
+    def test_5xx_is_not_ok_and_names_the_status(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(status_code=503)
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert "503" in result.error
+
+    def test_malformed_json_is_not_ok(self, monkeypatch) -> None:
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"not_entries_at_all": True})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        result = cc.fetch_drive_queue_result(_svc())
+
+        assert result.ok is False
+        assert result.entries == []
+        assert result.error
+
+    def test_the_three_shapes_are_mutually_distinguishable(self, monkeypatch) -> None:
+        """Empty / transport-error / populated must never collapse to the
+        same result — the whole point of #2992."""
+
+        def get_for(shape: str):
+            def fake_get(url, *, headers=None, params=None, **kw):
+                if shape == "populated":
+                    return _FakeResponse(json_body={"entries": [{"issue_number": 1}]})
+                if shape == "empty":
+                    return _FakeResponse(json_body={"entries": []})
+                raise httpx.ConnectError("refused")
+
+            return fake_get
+
+        monkeypatch.setattr(cc.httpx, "get", get_for("populated"))
+        populated = cc.fetch_drive_queue_result(_svc())
+        monkeypatch.setattr(cc.httpx, "get", get_for("empty"))
+        empty = cc.fetch_drive_queue_result(_svc())
+        monkeypatch.setattr(cc.httpx, "get", get_for("error"))
+        errored = cc.fetch_drive_queue_result(_svc())
+
+        assert (populated.ok, empty.ok, errored.ok) == (True, True, False)
+        assert populated.entries != empty.entries
+        assert errored.error is not None
+        assert populated.error is None
+        assert empty.error is None
+
+    def test_fetch_drive_queue_stays_fail_soft_to_empty_list_on_failure(
+        self, monkeypatch
+    ) -> None:
+        """The pre-existing, unchanged contract: `fetch_drive_queue` itself
+        never raises and never exposes the failure — only
+        `fetch_drive_queue_result` does."""
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            raise httpx.ConnectError("refused")
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        assert cc.fetch_drive_queue(_svc()) == []
+
+    def test_fetch_drive_queue_returns_the_real_rows_on_success(self, monkeypatch) -> None:
+        rows = [{"repo_name": "cc", "issue_number": 7}]
+
+        def fake_get(url, *, headers=None, params=None, **kw):
+            return _FakeResponse(json_body={"entries": rows})
+
+        monkeypatch.setattr(cc.httpx, "get", fake_get)
+
+        assert cc.fetch_drive_queue(_svc()) == rows

{code_coordinator-0.5.533 → code_coordinator-0.5.535}/tests/test_diagnose.py

@@ -1780,6 +1780,95 @@ def test_stuck_test_state_with_a_live_smoke_child_is_not_a_contradiction(monkeyp
     assert res.recovered is True
 
 
+# ── #3332: test_state='blocked' is a dead end, not "stage looks healthy" ────
+
+
+def test_blocked_test_state_reported_as_wedged_with_needs_reset(monkeypatch, config) -> None:
+    """#3332: a `done` work row wedged at `test_state='blocked'` — the marker
+    `dispatch_smoke` stamps when it gives up on a Test-stage dispatch and
+    never re-probes (#1672) — must be reported as wedged, not "stage looks
+    healthy". `--reset` is the documented remedy; the diagnostic must point
+    at it, and `needs_reset` (the field automation branches on) must say so
+    too."""
+    _stub(monkeypatch, session="dead")
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "blocked"
+    work.test_reason = "no capability-matched machine available"
+    board = Board(completed=[work])
+
+    res = diagnose.diagnose_stage(board, config, "api", 42, "test", dry_run=True)
+
+    assert res.recovered is False
+    assert res.needs_reset is True
+    assert not any("stage looks healthy" in f for f in res.findings)
+    assert any("blocked" in f and "--reset" in f for f in res.findings)
+
+
+def test_blocked_test_state_names_unroutable_fleet_cause(monkeypatch, config) -> None:
+    """#1672 shape: no capability-matched machine — `mute_smoke_legs` finds
+    no tally marker in the reason, so this must name the fleet cause, not
+    the #2272 mute-legs one (#2235: the two need different remedies)."""
+    _stub(monkeypatch, session="dead")
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "blocked"
+    work.test_reason = "no capability-matched machine available"
+    board = Board(completed=[work])
+
+    res = diagnose.diagnose_stage(board, config, "api", 42, "test", dry_run=True)
+
+    assert any("#1672" in f and "capability-matched" in f for f in res.findings)
+    assert not any("#2272" in f for f in res.findings)
+
+
+def test_blocked_test_state_names_mute_legs_cause(monkeypatch, config) -> None:
+    """#2272 shape: N Test-stage legs finished mute in a row and the retry
+    budget ran out — `mute_smoke_legs` (the exact function `coord.dead_end`
+    shape 2 uses, #2096 "one question, one answer") finds the tally marker,
+    so this must name THAT cause instead."""
+    _stub(monkeypatch, session="dead")
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "blocked"
+    work.test_reason = "no-verdict (#2244) x3"
+    board = Board(completed=[work])
+
+    res = diagnose.diagnose_stage(board, config, "api", 42, "test", dry_run=True)
+
+    assert any("#2272" in f for f in res.findings)
+    assert not any("#1672" in f for f in res.findings)
+
+
+def test_reset_test_reports_which_rows_were_cleared(monkeypatch, config, coord_db) -> None:
+    """#3332: the reset report must name which rows it cleared, not just a
+    bare count — an operator reading "cleared Test verdict on 3 work
+    row(s)" for a branch with 4 work-like rows can't tell a deliberate skip
+    from a miss."""
+    from coord import state
+
+    _stub(monkeypatch, session="dead")
+    state.record_dispatched_assignment(
+        assignment=Assignment(
+            machine_name="precision", repo_name="api", issue_number=42,
+            issue_title="t", assignment_id="w1", type="work", status="done",
+        ),
+        repo_github="acme/api",
+    )
+    state.record_test_verdict(
+        assignment_id="w1", test_state="blocked", test_reason="no machine"
+    )
+
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "blocked"
+    board = Board(completed=[work])
+
+    res = diagnose.diagnose_stage(board, config, "api", 42, "test", reset=True)
+
+    assert res.reset_performed is True
+    assert any(
+        "cleared Test verdict" in a and "w1" in a for a in res.actions_taken
+    )
+    assert state.load_assignment_test_state("w1") is None
+
+
 def test_reset_dry_run_does_nothing(monkeypatch, config) -> None:
     calls = _stub(monkeypatch, session="live")
     a = _assign(aid="w1", typ="work", status="running")