code-coordinator 0.5.534__tar.gz → 0.5.536__tar.gz

{code_coordinator-0.5.534 → code_coordinator-0.5.536}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.534",
+  "tag": "0.5.536",
   "distance": 0,
-  "node": "ga57e6a4b749192d9ac4e31c24b5ad4b9fa5a2e13",
+  "node": "g88b4c49256bda59316741a2cfccb7ac352b3e665",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.534 → code_coordinator-0.5.536}/coord/commands/merge.py

@@ -137,7 +137,6 @@ def _apply_revalidation(items, board, config, gh_ops, *, dry_run: bool, skip_rev
 
 def _apply_ci_revalidation(
     items, board, config, ci_store, gh_ops, *, dry_run: bool,
-    poll_sleep=None, poll_clock=None,
 ) -> set[str]:
     """#1851: the ``--revalidate`` arm for CI staleness — the CI analogue of
     :func:`_apply_revalidation`'s stale-local-verdict arm, resolving a
@@ -147,64 +146,35 @@ def _apply_ci_revalidation(
     outlive the base it actually validated even when the local Test verdict
     is perfectly fresh).
 
-    Unlike :func:`_apply_revalidation` there is nothing to compose and no
-    local suite to run — the remedy is :meth:`coord.ci_store.CiStore.
-    rerun_for_pr`, a ``gh run rerun`` that costs CI minutes on GitHub's own
-    runners, not a routed Test-stage agent. Strictly cheaper than what
-    :func:`_apply_revalidation` does for the same reason CI should always be
-    preferred when both would establish the same fact (#1851's "Cost
-    framing").
+    #3276: every candidate :func:`coord.merge_queue.ci_revalidation_candidates`
+    returns is, by that function's own contract, blocked *solely* on CI
+    staleness — and the remedy that would have been here,
+    :meth:`coord.ci_store.CiStore.rerun_for_pr`, is a same-base ``gh run
+    rerun`` that a staleness reading (the base moved; the check didn't) can
+    never satisfy. #3266 already established exactly that and fixed the two
+    unattended call sites (``merge_queue.process()``'s own #2197 auto-rerun
+    and ``coord.commands.drive_queue._run_auto_revalidate_checks_stale``) to
+    stop spending a CI cycle on it — see ``MAX_CI_STALE_RERUNS``'s comment in
+    ``coord/merge_queue.py``. This CLI arm was left as a disclosed scope cut
+    (opt-in, human-invoked, no budget counter) with a docstring promising a
+    "tracked follow-up" that was never filed as an issue — #3276 is that
+    follow-up. So: no candidate here is ever handed to ``rerun_for_pr``
+    anymore. Each one gets the rebase remedy on stdout instead, both under
+    ``--dry-run`` and for real — the two cases are identical now because
+    nothing is actually triggered either way (#3276's acceptance: ``--dry-
+    run`` must say the same thing it would do).
 
     Opt-in behind ``--revalidate`` exactly like :func:`_apply_revalidation`
-    — never called from auto-drain (see ``docs/DRIVE_QUEUE.md``). Under
-    ``--dry-run`` this only *names* what it would trigger; no ``gh`` mutation
-    runs.
-
-    #1925: triggering a rerun and then handing the entry straight to
-    ``merge_queue.process()`` used to fail-close on the rerun's OWN
-    registration gap — ``gh pr checks`` errors for the few seconds before
-    GitHub has created any check-run record, which reads as the #1525
-    synthetic ``unknown`` conclusion and blocks exactly like a genuinely
-    broken CI would. :func:`coord.ci_store.wait_for_ci_settle` closes that
-    gap with a bounded poll right here, so the caller's subsequent
-    ``process()`` call sees a real, resolved result — pass or fail — for the
-    common case.
-
-    Returns the ``assignment_id``s whose wait ran out the budget while STILL
-    only seeing the registration-gap symptom (never a real check) —
-    :func:`wait_for_ci_settle`'s ``registering=True`` case. The caller must
-    exclude these from the ``process()`` call that follows: evaluating the
-    gate against that exact symptom is the bug this fixes, so it must not
-    reappear at the timeout edge just because the wait gave up. The entry
-    stays ``PENDING`` with an explanatory ``entry.error`` instead — legible
-    as "come back shortly", never as "checks failed" (#1925's acceptance:
-    an ``unknown`` this command caused must not be presented identically to
-    an ``unknown`` from genuinely broken CI).
-
-    #3266 — KNOWN FOLLOW-UP, not fixed here: every candidate this selects
-    (via :func:`coord.merge_queue.ci_revalidation_candidates`) is blocked
-    *solely* on CI staleness, and the ``rerun_for_pr`` call below is a
-    same-base ``gh run rerun`` that a staleness reading, by definition,
-    can never satisfy — see ``MAX_CI_STALE_RERUNS``'s comment in
-    ``coord/merge_queue.py``, which #3266 fixed identically at
-    ``merge_queue.process()`` and at ``coord.commands.drive_queue.
-    _run_auto_revalidate_checks_stale`` (the unattended periodic call
-    site). This CLI arm is the one remaining caller still spending a real
-    CI cycle on that guaranteed no-op. Left unfixed here on purpose for
-    this round — it is opt-in and human-invoked, unlike the unattended
-    drive-queue path, and the misleading ``ci_stale_reason`` remedy text
-    that used to point an operator at ``--revalidate`` *for this specific
-    condition* was already removed by #3266 — but an operator who runs
-    ``--revalidate`` for an unrelated reason (a genuine infra-failure
-    retry) on a PR that also happens to be ``checks_stale`` still silently
-    burns a no-op CI cycle for that PR. Tracked as a follow-up: the fix
-    would be to drop this entry from *candidates* (or from what gets
-    rerun) whenever the ONLY reason it is here is staleness, so
-    ``--revalidate`` never fires `rerun_for_pr` for a condition it cannot
-    clear.
+    — never called from auto-drain (see ``docs/DRIVE_QUEUE.md``).
+
+    Returns an empty set always now — kept as a ``set[str]`` return (rather
+    than ``None``) so the two call sites' "entries this arm deferred, exclude
+    them from this pass's ``process()`` call" plumbing (#1925's ``registering``
+    case, from when this arm still triggered a rerun and had to wait out its
+    own registration gap) needs no change; there is simply never anything to
+    defer any more, since nothing is triggered.
     """
     from coord import merge_queue as _mq  # noqa: PLC0415
-    from coord.ci_store import wait_for_ci_settle  # noqa: PLC0415
 
     deferred: set[str] = set()
     if ci_store is None or not ci_store.is_available:
@@ -218,61 +188,31 @@ def _apply_ci_revalidation(
         return deferred
     for entry in candidates:
         label = f"{entry.repo_name} #{entry.issue_number} ({entry.branch})"
-        if dry_run:
-            click.echo(
-                f"  --revalidate: would re-run CI for {label} "
-                f"(PR #{entry.pr_number}) — checks predate the current base"
-            )
-            continue
-        ok = ci_store.rerun_for_pr(entry.repo_github, entry.pr_number)
-        if not ok:
-            click.echo(
-                f"  --revalidate: could not trigger a CI re-run for {label} "
-                f"(PR #{entry.pr_number}) — see gh output above",
-                err=True,
-            )
-            continue
         click.echo(
-            f"  --revalidate: triggered a CI re-run for {label} "
-            f"(PR #{entry.pr_number})"
-        )
-        result = wait_for_ci_settle(
-            ci_store, entry.repo_github, entry.pr_number,
-            echo=click.echo, sleep=poll_sleep, clock=poll_clock,
+            f"  --revalidate: skipping {label} (PR #{entry.pr_number}) — "
+            "blocked solely on stale CI checks; a re-run replays the same "
+            "run against the same base it already ran against and can "
+            "never clear this (#3276). Rebase (or push a new commit) to "
+            "get a check against the current base."
         )
-        if result.settled:
-            click.echo(
-                f"  --revalidate: CI re-run for {label} settled after "
-                f"{result.waited_seconds:.0f}s — the merge gate will "
-                "evaluate the fresh result"
-            )
-        elif result.registering:
-            entry.error = (
-                f"{label}: the CI re-run --revalidate just triggered "
-                f"(PR #{entry.pr_number}) has not registered on GitHub yet "
-                f"after {result.waited_seconds:.0f}s — this is the re-run "
-                "THIS command started, not a CI failure; re-run `coord "
-                "merge --revalidate` (or plain `coord merge`) shortly (#1925)"
-            )
-            deferred.add(entry.assignment_id)
-            click.echo(f"  --revalidate: {entry.error}")
-        else:
-            click.echo(
-                f"  --revalidate: CI re-run for {label} is still running "
-                f"after {result.waited_seconds:.0f}s — leaving it to the "
-                "merge gate this pass (will report as CI still running)"
-            )
     return deferred
 
 
 def _reload_board_after_wait(board, *, dry_run: bool):
-    """#2143: force a fresh board read after ``_apply_ci_revalidation``'s
-    ``wait_for_ci_settle`` poll — which, like ``_apply_revalidation``'s
-    composite/solo suite runs, can hold the caller for minutes.
+    """#2143: force a fresh board read after ``--revalidate``'s CI-staleness
+    arm (:func:`_apply_ci_revalidation`) — which, like
+    :func:`_apply_revalidation`'s composite/solo suite runs, used to be able
+    to hold the caller for minutes via a post-rerun settle poll.
+
+    #3276: that poll is gone — :func:`_apply_ci_revalidation` no longer
+    triggers a rerun at all (see its own docstring), so it returns quickly.
+    This reload stays anyway: :func:`_apply_revalidation`'s local-suite arm,
+    called just before this in both callers, can still run for minutes, and
+    the same staleness argument below applies to it too.
 
     ``_apply_revalidation`` already refreshes the board it hands back, but
-    only when *it* recorded a new verdict; it has no way to know a CI-settle
-    wait ran afterwards. Real state can change on GitHub during that wait —
+    only when *it* recorded a new verdict; it has no way to know what ran
+    after it. Real state can change on GitHub while either arm is running —
     most dangerously a review approval landing, or a concurrent merge driver
     (the drive-queue timer, another operator) merging the exact branch this
     run is about to act on — and `merge_queue.process()` must not evaluate
@@ -283,9 +223,9 @@ def _reload_board_after_wait(board, *, dry_run: bool):
     Unconditional (not "only when something looks stale"): the risk here is
     a stale *read*, and there's no cheap way to tell "nothing changed" from
     "something changed but we didn't notice" without just re-reading. One
-    extra ``load_board()`` is a rounding error next to the suite run(s) or
-    the CI-settle poll that just happened. Under ``--dry-run`` nothing was
-    triggered (no wait actually ran), so the board is left untouched.
+    extra ``load_board()`` is a rounding error next to the suite run(s) that
+    just happened. Under ``--dry-run`` nothing was triggered (no suite run
+    actually ran), so the board is left untouched.
     """
     if dry_run:
         return board
@@ -2392,15 +2332,16 @@ def merge(
                 only_items, board_only, cfg_only, ci_store_only, gh_ops,
                 dry_run=dry_run,
             )
-            # #2143: the CI-settle wait just above can run for minutes —
-            # re-read the board so the gates `process()` runs below see
-            # whatever landed on GitHub during it, not the pre-wait snapshot.
+            # #2143: `_apply_revalidation`'s local-suite run just above can
+            # run for minutes — re-read the board so the gates `process()`
+            # runs below see whatever landed on GitHub during it, not a
+            # pre-run snapshot. (#3276: `_apply_ci_revalidation` itself no
+            # longer triggers a rerun, so this is no longer also covering a
+            # CI-settle wait — see its own docstring.)
             board_only = _reload_board_after_wait(board_only, dry_run=dry_run)
-        # #1925: an entry deferred by the CI-settle wait above must not go
-        # through process() this pass — that would immediately re-derive the
-        # exact self-triggered "unknown" reading the wait was just trying to
-        # avoid handing to the gate. It stays PENDING with the explanatory
-        # `entry.error` _apply_ci_revalidation already set.
+        # #1925/#3276: `deferred_ci` is always empty now that
+        # `_apply_ci_revalidation` never triggers a rerun — kept so this
+        # exclusion needs no change if that ever stops being true.
         if only_entry.assignment_id in deferred_ci:
             events_only = []
         else:
@@ -2841,15 +2782,17 @@ def merge(
         deferred_ci = _apply_ci_revalidation(
             pending, board, cfg, ci_store, gh_ops, dry_run=dry_run,
         )
-        # #2143: the CI-settle wait just above can run for minutes —
-        # re-read the board so the gates `process()` runs below see
-        # whatever landed on GitHub during it, not the pre-wait snapshot.
+        # #2143: `_apply_revalidation`'s local-suite run just above can run
+        # for minutes — re-read the board so the gates `process()` runs
+        # below see whatever landed on GitHub during it, not a pre-run
+        # snapshot. (#3276: `_apply_ci_revalidation` itself no longer
+        # triggers a rerun, so this is no longer also covering a CI-settle
+        # wait — see its own docstring.)
         board = _reload_board_after_wait(board, dry_run=dry_run)
-    # #1925: entries the CI-settle wait above gave up on while still only
-    # seeing the registration-gap symptom must not go through process() this
-    # pass — see `_apply_ci_revalidation`'s docstring. They keep their
-    # PENDING state and the explanatory `entry.error` it already set; `items`
-    # (unfiltered) still carries them through to the save step below.
+    # #1925/#3276: `deferred_ci` is always empty now that
+    # `_apply_ci_revalidation` never triggers a rerun — kept so this
+    # exclusion needs no change if that ever stops being true. `items`
+    # (unfiltered) still carries every entry through to the save step below.
     process_items = (
         [x for x in items if x.assignment_id not in deferred_ci]
         if deferred_ci else items

{code_coordinator-0.5.534 → code_coordinator-0.5.536}/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.534 → code_coordinator-0.5.536}/coord/merge_queue.py

@@ -2539,9 +2539,12 @@ MAX_CI_INFRA_RERUNS = 2
 # all. Kept defined — rather than deleted — because `QueuedMerge.
 # ci_stale_reruns` still exists for rows written before this fix (see its
 # own comment) and because `coord.commands.merge._apply_ci_revalidation`
-# (the opt-in ``--revalidate`` CLI arm) still references it; that caller is
-# lower severity (opt-in, human-invoked) and is a tracked follow-up, not
-# something this fix's file scope covers.
+# (the opt-in ``--revalidate`` CLI arm) still references it in its own
+# docstring. #3276 closed the gap #3266 left open there: that caller now
+# reports the rebase remedy for a staleness-only candidate instead of
+# calling `rerun_for_pr` for it either — the third and last of this
+# primitive's call sites, so nothing left in this module calls `rerun_for_pr`
+# for a condition it can never clear.
 MAX_CI_STALE_RERUNS = 2
 
 # #2252: at most one auto-rerun per failure streak before a genuinely-
@@ -3804,12 +3807,12 @@ def ci_revalidation_candidates(
     `rerun_for_pr` replays the same run against the same base it already
     used, so it can never see the new one. `process()`'s OWN #2197
     auto-rerun for this trigger was dropped for that reason (see
-    `MAX_CI_STALE_RERUNS`'s comment). The one remaining caller that still
-    calls `rerun_for_pr` on what this returns is `coord.commands.merge
-    ._apply_ci_revalidation` (the opt-in ``--revalidate`` CI arm) — equally
-    unable to clear the block, but lower severity since a human has to
-    explicitly ask for it. Left as-is here: fixing it is a change to that
-    module, out of this function's/file's scope, and a tracked follow-up.
+    `MAX_CI_STALE_RERUNS`'s comment). `coord.commands.merge
+    ._apply_ci_revalidation` (the opt-in ``--revalidate`` CI arm) was the one
+    remaining caller that still called `rerun_for_pr` on what this returns —
+    #3276 fixed it too: it now reports the rebase remedy for every entry this
+    function returns (all of them are staleness-only, by this function's own
+    contract above) instead of spending a guaranteed no-op CI cycle.
 
     #3396: `coord.commands.drive_queue._run_auto_revalidate_checks_stale`
     (the unattended periodic call site) still calls this function to find
@@ -4099,12 +4102,13 @@ class QueuedMerge:
     # this column.
     #
     # `coord.commands.merge._apply_ci_revalidation` (the opt-in
-    # ``--revalidate`` CLI arm) is the one remaining caller of
-    # `ci_revalidation_candidates` that still calls `rerun_for_pr` for this
-    # exact condition — it does not touch this counter (no budget, no cap;
-    # a human invoked it once, on purpose), but it is equally unable to
-    # clear a staleness block for the reason above, and is a tracked,
-    # lower-severity follow-up (see its own docstring).
+    # ``--revalidate`` CLI arm) never touched this counter (no budget, no
+    # cap; a human invoked it once, on purpose) but, until #3276, was the
+    # one remaining caller of `ci_revalidation_candidates` that still called
+    # `rerun_for_pr` for this exact unclearable condition. #3276 fixed it:
+    # that arm now reports the rebase remedy for a staleness-only candidate
+    # instead of re-running, so nothing in the codebase calls `rerun_for_pr`
+    # for a block only a rebase can clear.
     ci_stale_reruns: int = 0
     # #2252: count of automatic `CiStore.rerun_failed_for_pr` calls
     # `process()` has issued for this entry's CURRENT streak of genuinely-

{code_coordinator-0.5.534 → code_coordinator-0.5.536}/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