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

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

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

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

{code_coordinator-0.5.534 → 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.534 → 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.534 → 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")