code-coordinator 0.5.656__tar.gz → 0.5.658__tar.gz

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.656
+Version: 0.5.658
 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.658/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.658",
+  "distance": 0,
+  "node": "g3abb395b595e582d48846dc682c318f7c71796b2",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-21"
+}

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/dead_end.py

@@ -250,10 +250,34 @@ def detect_dead_end(state, *, can_waive_test_gate: bool = False) -> DeadEnd | No
     # 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:
-        from coord.smoke import mute_smoke_legs  # noqa: PLC0415
+        from coord.smoke import (  # noqa: PLC0415
+            abandoned_background_smoke_legs,
+            mute_smoke_legs,
+        )
 
+        # #3737: a THIRD, unrelated cause parks the same value — N Test-stage
+        # legs in a row ended their one-shot turn with the smoke command
+        # still running in the background (no verdict marker, because the
+        # worker never came back to print one). Checked before the plain
+        # mute-leg tally since the two markers never co-occur in the same
+        # `test_reason`, but keeping the order explicit avoids depending on
+        # that.
+        abandoned_legs = abandoned_background_smoke_legs(state.work_test_reason)
         mute_legs = mute_smoke_legs(state.work_test_reason)
-        if mute_legs:
+        if abandoned_legs:
+            cause = (
+                f"{abandoned_legs} Test-stage leg(s) in a row ended their "
+                "turn with the smoke command still running in the "
+                "background instead of to completion, exhausting the "
+                "#3737 retry budget (a separate budget from #2272's mute-"
+                "leg one, so this is not a report of a mute suite). Nothing "
+                "is known to be wrong with the BRANCH or the suite's "
+                "result — the worker backgrounded the smoke command past "
+                "its own turn and never reported an outcome. Re-dispatch "
+                "with an instruction to run the smoke command "
+                "SYNCHRONOUSLY to completion rather than backgrounding it."
+            )
+        elif mute_legs:
             cause = (
                 f"{mute_legs} Test-stage leg(s) in a row finished without "
                 "printing a `SMOKE:` verdict marker, exhausting the retry "

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/diagnose.py

@@ -1363,19 +1363,44 @@ def _recover_test(
     ``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.
+
+    #3737: ``coord.dead_end`` shape 2 has a THIRD cause for the same
+    ``blocked`` value — N Test-stage legs in a row ended their one-shot turn
+    with the smoke command still running in the background, never printing a
+    verdict marker — checked here too, in the same order, so this entry
+    point never disagrees with the driver about why a row is wedged (#2096
+    "one question, one answer").
     """
     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
+        from coord.smoke import (  # noqa: PLC0415
+            abandoned_background_smoke_legs,
+            mute_smoke_legs,
+        )
 
-        # 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").
+        # Same predicates `coord.dead_end`'s shape 2 uses to tell #1672
+        # (unroutable fleet) apart from #2272 (mute Test-stage legs) and
+        # #3737 (abandoned-background legs) — #2235 exists to keep those
+        # REASONS from blurring together, so this reuses the identical
+        # functions, in the identical order, rather than re-deriving the
+        # split (#2096 "one question, one answer").
+        abandoned_legs = abandoned_background_smoke_legs(latest.test_reason)
         mute_legs = mute_smoke_legs(latest.test_reason)
-        if mute_legs:
+        if abandoned_legs:
+            cause = (
+                f"{abandoned_legs} Test-stage leg(s) in a row ended their "
+                "turn with the smoke command still running in the "
+                "background instead of to completion, exhausting the "
+                "#3737 retry budget (a separate budget from #2272's mute-"
+                "leg one, so this is not a report of a mute suite). Nothing "
+                "is known to be wrong with the BRANCH or the suite's "
+                "result — the worker backgrounded the smoke command past "
+                "its own turn and never reported an outcome. Re-dispatch "
+                "with an instruction to run the smoke command SYNCHRONOUSLY "
+                "to completion rather than backgrounding it."
+            )
+        elif mute_legs:
             cause = (
                 f"{mute_legs} Test-stage leg(s) in a row finished without "
                 "printing a `SMOKE:` verdict marker, exhausting the retry "

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/notify.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import re
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -66,6 +67,9 @@ from coord.progress import parse_progress
 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 (
+    ABANDONED_BACKGROUND_SMOKE_BUDGET,
+    abandoned_background_smoke_legs,
+    abandoned_background_smoke_tally,
     finalize_smoke_fanout,
     mute_smoke_legs,
     mute_smoke_tally,
@@ -3343,6 +3347,69 @@ def _record_smoke_verdict(
         )
         return
 
+    # #3737: a leg that ended its turn with the smoke command still running
+    # in the background is an infra abort — the worker backgrounded a build
+    # past its own turn and never came back to report it — not a genuinely
+    # mute suite, so don't let it eat the #2272 budget meant for the latter.
+    # `_is_plain_runner_leg` (#3693) legs have no `claude -p` session
+    # narrating a hand-off at all, so they are excluded rather than risk a
+    # false match against raw subprocess stdout.
+    smoke_log_path = entry.get("log_path")
+    if smoke_log_path and not _is_plain_runner_leg(entry):
+        from coord.review import detect_abandoned_background_leg  # noqa: PLC0415
+
+        if detect_abandoned_background_leg(smoke_log_path):
+            previous_reason = load_assignment_test_reason(parent_id) or ""
+            abandoned_legs = abandoned_background_smoke_legs(previous_reason) + 1
+            if abandoned_legs >= ABANDONED_BACKGROUND_SMOKE_BUDGET:
+                record_test_verdict(
+                    assignment_id=parent_id,
+                    test_state=TEST_STATE_BLOCKED,
+                    test_reason=(
+                        f"{abandoned_background_smoke_tally(abandoned_legs)}: "
+                        f"{abandoned_legs} Test-stage legs in a row ended "
+                        "their turn with the smoke command still running in "
+                        "the background instead of to completion — the "
+                        f"retry budget ({ABANDONED_BACKGROUND_SMOKE_BUDGET}) "
+                        "for that is exhausted, so the row is parked instead "
+                        "of re-dispatched (#3737). This is not a suite "
+                        "failure: the smoke command itself needs to finish "
+                        "inside the worker's one-shot turn (no backgrounding, "
+                        "no `run_in_background`). Recover with `coord "
+                        "diagnose <repo> <issue> --stage test --reset`, or "
+                        "record the verdict by hand with `coord test "
+                        f"--passed|--fail {parent_id}`."
+                    ),
+                )
+                log.warning(
+                    "smoke %s: #3737 abandoned-background retry budget "
+                    "(%d) exhausted for %s — parked %s.",
+                    transition.assignment_id, ABANDONED_BACKGROUND_SMOKE_BUDGET,
+                    parent_id, TEST_STATE_BLOCKED,
+                )
+                return
+            record_test_verdict(
+                assignment_id=parent_id,
+                test_state=None,
+                test_reason=(
+                    f"{abandoned_background_smoke_tally(abandoned_legs)}: the "
+                    f"Test-stage worker {transition.assignment_id} ended its "
+                    "turn with the smoke command still running in the "
+                    "background instead of to completion — an infra abort, "
+                    "not a verdict (#3737). Cleared for an automatic "
+                    "Test-stage re-dispatch; run the smoke command "
+                    "SYNCHRONOUSLY to completion this time rather than "
+                    "backgrounding it."
+                ),
+            )
+            log.info(
+                "smoke %s: #3737 abandoned-background leg %d/%d — cleared "
+                "for re-dispatch, not counted against the #2272 mute budget.",
+                transition.assignment_id, abandoned_legs,
+                ABANDONED_BACKGROUND_SMOKE_BUDGET,
+            )
+            return
+
     # #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`

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/review.py

@@ -1040,6 +1040,97 @@ def parse_test_verdict_from_log(log_path: str | Path) -> TestVerdictFindings | N
         return _parse_test_verdict_from_lines(text.splitlines(), stream_json=False)
 
 
+# ── Abandoned-background Test-stage legs (#3737) ────────────────────────────
+#
+# A Test-stage leg that ends its one-shot turn with the smoke command still
+# running in the background — session terminated, no `SMOKE:`/
+# `TEST_VERDICT:` marker printed — is an infra abort (the worker backgrounded
+# a run past its own turn and never came back to report it), not a genuine
+# "the suite won't speak". Left undetected it is indistinguishable from the
+# latter and charges the same #2272 mute-leg retry budget, so two
+# backgrounded legs in a row park a branch that was never actually silent.
+#
+# The signature is the worker's own hand-off sentence, which is always the
+# LAST assistant turn of a session that ends this way (quadraui#1616: "Smoke
+# suite is running in the background; I'll continue once the background
+# watcher notifies me", "still running in the background, will continue
+# when notified"). Scanning only the final turn — mirrors
+# :func:`coord.worker_events.detect_usage_limit_kill`'s "last meaningful
+# turn/line only" discipline — avoids false-positiving on a worker that
+# merely discusses backgrounding mid-session before going on to print a
+# real verdict later in the same transcript.
+#
+# Plain-text logs have no structured turn boundary to scan exactly, so
+# `detect_abandoned_background_leg` approximates "the final turn" with the
+# last `_ABANDONED_BACKGROUND_TAIL_LINES` non-blank, non-comment lines
+# instead (below) — wide enough to hold a multi-sentence hand-off without
+# reaching back far enough to catch an earlier, unrelated mention of
+# backgrounding. Stream-json logs (the common case) use the real turn
+# boundary via `coord.worker_events.latest_assistant_turn_text`.
+#
+# Deliberately narrow: this matches only the specific "running in the
+# background ... continue/notify/watcher/wait" hand-off shape quadraui#1616
+# actually produced, not every way a worker might phrase "I backgrounded
+# this". A differently-worded hand-off falls through to the #2272 mute-leg
+# accounting instead (an undercount, not a false positive) — acceptable
+# because #2272 still eventually parks the row, just under the wrong cause
+# text. Widen the pattern if a real transcript is seen phrasing this
+# differently, rather than guessing at alternate phrasings up front.
+_ABANDONED_BACKGROUND_RE = re.compile(
+    r"\brunning\s+in\s+the\s+background\b[\s\S]{0,200}?"
+    r"\b(?:continu\w*|notif\w*|watcher|wait\w*)\b",
+    re.IGNORECASE,
+)
+
+_ABANDONED_BACKGROUND_TAIL_LINES = 40
+
+
+def _is_abandoned_background_text(text: str | None) -> bool:
+    """``True`` if *text* — one assistant turn's worth of prose, or an
+    equivalent plain-text tail — is the hand-off a one-shot worker leaves
+    when its session ends with the smoke command still running in the
+    background rather than run to completion."""
+    if not text:
+        return False
+    return bool(_ABANDONED_BACKGROUND_RE.search(text))
+
+
+def detect_abandoned_background_leg(log_path: str | Path) -> bool:
+    """#3737: did this completed Test-stage leg end its turn with the smoke
+    command still running in the background, instead of to completion?
+
+    Sibling to :func:`parse_test_verdict_from_log`: same stream-json/
+    plain-text on-disk-shape detection (:func:`coord.worker_events.
+    is_stream_json`), so the two can never disagree about which parser a
+    given log needs. Returns ``False`` — never raises, never guesses "True"
+    — when the file is missing or unreadable, so a detection failure falls
+    through to the ordinary mute-leg accounting rather than silently
+    forgiving a genuinely mute suite.
+    """
+    from coord.worker_events import (  # noqa: PLC0415
+        is_stream_json,
+        latest_assistant_turn_text,
+    )
+
+    p = Path(log_path)
+    if not p.exists():
+        return False
+
+    if is_stream_json(p):
+        return _is_abandoned_background_text(latest_assistant_turn_text(p))
+
+    try:
+        text = p.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+    lines = [
+        line for line in text.splitlines()
+        if line.strip() and not line.strip().startswith("#")
+    ]
+    tail = "\n".join(lines[-_ABANDONED_BACKGROUND_TAIL_LINES:])
+    return _is_abandoned_background_text(tail)
+
+
 # #3676: cross-repo gaps are the coordinator's to file. A worker that hits a
 # capability missing from another repo emits a `BLOCKED_ON_UPSTREAM: <repo>:
 # <title>` marker in its final message (`coord.upstream_gaps`), and the

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/smoke.py

@@ -2333,6 +2333,74 @@ def environmental_smoke_tally_reset(test_reason: str | None) -> str:
     return _ENV_RETRY_TALLY_RE.sub("", test_reason).rstrip()
 
 
+# ── Abandoned-background Test-stage retries (#3737) ─────────────────────────
+#
+# A Test-stage leg that ends its one-shot turn with the smoke command still
+# running in the background — session terminated, no `SMOKE:` marker printed
+# — is an infra abort (the worker backgrounded a long build past its own
+# turn and never came back to report an outcome), not a genuinely mute
+# suite. `coord.notify._record_smoke_verdict` detects the hand-off
+# (`coord.review.detect_abandoned_background_leg`) and clears the leg for an
+# automatic re-dispatch without charging `MUTE_SMOKE_LEG_BUDGET` — but that
+# clear still needs its OWN bounded budget (below), for exactly the #2272/
+# #3315 reason: a cause the system cannot diagnose must still be a cause the
+# system stops paying for. Co-located here with `NO_SMOKE_VERDICT_MARKER`/
+# `ENVIRONMENTAL_SMOKE_MARKER` — not in `coord.notify`, where this used to
+# live — because `_dispatch_smoke_single_leg`'s `running` stamp just below is
+# the SAME writer that has to carry `mute_smoke_legs`/`environmental_smoke_
+# legs` forward across its own re-dispatch, and a marker read by that writer
+# but defined in a different module is exactly how the #2272 defect (the
+# tally erased by the very retry it existed to count) happened in the first
+# place.
+
+#: The marker left in the parent work row's ``test_reason`` when a Test-stage
+#: leg is cleared for re-dispatch because it ended with the smoke command
+#: still backgrounded, rather than because the suite was genuinely mute.
+#: Suffixed with `` xN`` from the second CONSECUTIVE leg on, mirroring
+#: :func:`mute_smoke_tally`.
+ABANDONED_BACKGROUND_SMOKE_MARKER = "abandoned-background (#3737)"
+
+#: Bounded separately from `MUTE_SMOKE_LEG_BUDGET` — a direct "run it
+#: synchronously" re-dispatch instruction is more likely to self-heal than a
+#: genuinely silent suite, so it gets a little more room, but a cause the
+#: system cannot diagnose must still be a cause the system stops paying for
+#: (#3315's own rationale, applied here to a different cause).
+ABANDONED_BACKGROUND_SMOKE_BUDGET = 3
+
+#: Matches the marker with or without its `` xN`` tally — mirrors
+#: :data:`_MUTE_TALLY_RE`.
+_ABANDONED_BACKGROUND_TALLY_RE = re.compile(
+    re.escape(ABANDONED_BACKGROUND_SMOKE_MARKER) + r"(?:\s*x\s*(\d+))?",
+    re.IGNORECASE,
+)
+
+
+def abandoned_background_smoke_legs(test_reason: str | None) -> int:
+    """How many CONSECUTIVE Test-stage legs in a row ended with the #3737
+    abandoned-background hand-off (0 if none) — mirrors
+    :func:`mute_smoke_legs`."""
+    if not test_reason:
+        return 0
+    match = _ABANDONED_BACKGROUND_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 abandoned_background_smoke_tally(count: int) -> str:
+    """The marker for *count* consecutive abandoned-background legs — mirrors
+    :func:`mute_smoke_tally`."""
+    if count <= 1:
+        return ABANDONED_BACKGROUND_SMOKE_MARKER
+    return f"{ABANDONED_BACKGROUND_SMOKE_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
@@ -3641,6 +3709,16 @@ def _dispatch_smoke_single_leg(
             environmental_smoke_legs(authoritative_reason),
             environmental_smoke_legs(board_reason),
         )
+        # #3737: ...and this stamp must ALSO carry the ABANDONED-BACKGROUND
+        # tally forward, for the identical #2272 reason above — without
+        # re-stating it here, this same "running" write erases it on every
+        # retry and the #3737 budget below (`_record_smoke_verdict`'s
+        # abandoned-background branch) can never be reached: the row would
+        # re-dispatch forever at full leg cost instead of eventually parking.
+        prior_abandoned_legs = max(
+            abandoned_background_smoke_legs(authoritative_reason),
+            abandoned_background_smoke_legs(board_reason),
+        )
         running_reason = "dispatched: Test stage running (#1426)"
         if prior_legs:
             running_reason = (
@@ -3655,6 +3733,13 @@ def _dispatch_smoke_single_leg(
                 f"{ENVIRONMENTAL_SMOKE_RETRY_BUDGET} consecutive "
                 "environmental Test-stage death(s) so far, #3315)"
             )
+        if prior_abandoned_legs:
+            running_reason = (
+                f"{abandoned_background_smoke_tally(prior_abandoned_legs)} — "
+                f"{running_reason} ({prior_abandoned_legs} of "
+                f"{ABANDONED_BACKGROUND_SMOKE_BUDGET} consecutive "
+                "abandoned-background Test-stage leg(s) so far, #3737)"
+            )
 
         record_test_verdict(
             assignment_id=completed.assignment_id,

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/coord/state.py

@@ -1501,10 +1501,13 @@ def _reclassify_infra_test_failure(
     a second, unbounded retry path. The tally is read back out of the row's
     OWN current ``test_reason`` (the one field that survives from leg to
     leg), exactly mirroring that function's non-fan-out branch, including
-    carrying the #2272 mute-leg tally forward (:func:`coord.smoke.
-    mute_smoke_legs`/``mute_smoke_tally``) so a row that alternates "mute
-    leg" / "infra death" keeps counting against both budgets instead of
-    resetting one every time the other fires.
+    carrying the #2272 mute-leg tally AND the #3737 abandoned-background
+    tally forward (:func:`coord.smoke.mute_smoke_legs`/``mute_smoke_tally``,
+    :func:`coord.smoke.abandoned_background_smoke_legs`/
+    ``abandoned_background_smoke_tally``) so a row that alternates between
+    any of "mute leg" / "infra death" / "abandoned background" keeps
+    counting against every applicable budget instead of resetting one every
+    time another fires.
 
     #3670 review: when *test_reason* is the #3182 fan-out PARENT's own
     write (:func:`coord.smoke.finalize_smoke_fanout` stamping the aggregate
@@ -1530,6 +1533,8 @@ def _reclassify_infra_test_failure(
         TEST_STATE_BLOCKED,
         _encode_fanout_manifest,
         _parse_fanout_manifest,
+        abandoned_background_smoke_legs,
+        abandoned_background_smoke_tally,
         environmental_smoke_legs,
         environmental_smoke_tally,
         mute_smoke_legs,
@@ -1579,13 +1584,25 @@ def _reclassify_infra_test_failure(
     carried = mute_smoke_legs(previous_reason)
     mute_prefix = f"{mute_smoke_tally(carried)} — " if carried else ""
 
+    # #3737: carry the abandoned-background tally forward too, for the
+    # identical #2272 reason the mute-leg tally is carried above — this
+    # reclassify path is a second writer of `test_reason` on the SAME row a
+    # #3737 budget is accruing against, and without re-stating it here it
+    # would be silently erased the next time an infra death reclassifies in
+    # between two abandoned-background legs.
+    abandoned_carried = abandoned_background_smoke_legs(previous_reason)
+    abandoned_prefix = (
+        f"{abandoned_background_smoke_tally(abandoned_carried)} — "
+        if abandoned_carried else ""
+    )
+
     env_legs = environmental_smoke_legs(previous_reason) + 1
 
     if env_legs >= ENVIRONMENTAL_SMOKE_RETRY_BUDGET:
         return (
             TEST_STATE_BLOCKED,
             (
-                f"{manifest_prefix}{mute_prefix}"
+                f"{manifest_prefix}{mute_prefix}{abandoned_prefix}"
                 f"{environmental_smoke_tally(env_legs)}: the Test-stage "
                 f"environmental retry budget "
                 f"({ENVIRONMENTAL_SMOKE_RETRY_BUDGET}) is exhausted after "
@@ -1602,7 +1619,7 @@ def _reclassify_infra_test_failure(
     return (
         None,
         (
-            f"{manifest_prefix}{mute_prefix}"
+            f"{manifest_prefix}{mute_prefix}{abandoned_prefix}"
             f"{environmental_smoke_tally(env_legs)}: Test-stage failure "
             f"reclassified as infrastructure, not a test result ({cause}) "
             "— cleared for automatic re-dispatch, not recorded as a work "
@@ -3085,6 +3102,12 @@ def review_claim_age_secs(of_assignment_id: str) -> float | None:
 
     Same local-DB-only caveat as :func:`has_review_claim` — reads the local
     connection, not the daemon, so it undercounts on a thin client.
+
+    Clamped to ``0.0``: ``_new_review_claim_stamp`` adds a sub-millisecond
+    positive jitter to ``time.time()`` for uniqueness, so a read taken
+    microseconds after the claim can land *before* that jittered stamp and
+    would otherwise go slightly negative — "age since claim" can never be
+    less than zero.
     """
     if not of_assignment_id:
         return None
@@ -3096,7 +3119,7 @@ def review_claim_age_secs(of_assignment_id: str) -> float | None:
     ).fetchone()
     if row is None or row[0] is None:
         return None
-    return time.time() - row[0]
+    return max(0.0, time.time() - row[0])
 
 
 def has_recorded_review_verdict(assignment_id: str) -> bool:

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/tests/test_dead_end.py

@@ -301,6 +301,37 @@ def test_a_mute_exhausted_test_stage_names_its_own_cause() -> None:
     assert "Nothing is known to be wrong with the BRANCH" in found.reason
 
 
+def test_an_abandoned_background_exhausted_test_stage_names_its_own_cause() -> None:
+    """#3737: the abandoned-background retry budget parks the SAME ``blocked``
+    value as #1672's unroutable stage and #2272's mute-leg budget, but it is a
+    THIRD, distinct cause — the worker backgrounded the smoke command past its
+    own turn — and must not be misreported as either of the other two.
+    """
+    from coord.notify import abandoned_background_smoke_tally  # noqa: PLC0415
+
+    found = detect_dead_end(
+        state(
+            work_aid="w3737",
+            work_status="done",
+            work_branch="issue-3737",
+            work_test_state=TEST_STATE_BLOCKED,
+            work_test_reason=(
+                f"{abandoned_background_smoke_tally(3)}: the Test-stage "
+                "worker dc91c2843872 ended its turn with the smoke command "
+                "still running in the background instead of to completion."
+            ),
+            active_count=0,
+        )
+    )
+    assert found is not None
+    assert found.kind == "test_stage_blocked"
+    assert "#3737" in found.reason
+    assert "running in the background" in found.reason
+    # It must NOT misattribute this to the fleet or to a genuinely mute suite.
+    assert "no capability-matched" not in found.reason
+    assert "verdict marker" not in found.reason
+
+
 def test_gates_carry_the_readings_that_proved_the_dead_end() -> None:
     """The escalation record has to answer "how did you conclude that?"
     without the tmux pane, which is gone. ``active=0`` in particular is the

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/tests/test_diagnose.py

@@ -1899,6 +1899,31 @@ def test_blocked_test_state_names_mute_legs_cause(monkeypatch, config) -> None:
     assert not any("#1672" in f for f in res.findings)
 
 
+def test_blocked_test_state_names_abandoned_background_cause(monkeypatch, config) -> None:
+    """#3737 shape: N Test-stage legs in a row ended their turn with the
+    smoke command still backgrounded, never printing a verdict —
+    `abandoned_background_smoke_legs` (the exact function `coord.dead_end`
+    shape 2 checks FIRST, ahead of the #2272 mute-leg one, #2235) finds the
+    tally marker, so this must name THAT cause instead of either sibling —
+    and must not misdiagnose this as an unroutable fleet (#1672)."""
+    from coord.smoke import abandoned_background_smoke_tally
+
+    _stub(monkeypatch, session="dead")
+    work = _assign(aid="w1", typ="work", status="done")
+    work.test_state = "blocked"
+    work.test_reason = f"{abandoned_background_smoke_tally(3)}: still backgrounded"
+    board = Board(completed=[work])
+
+    res = diagnose.diagnose_stage(board, config, "api", 42, "test", dry_run=True)
+
+    assert any("#3737" in f and "backgrounded" in f for f in res.findings)
+    assert not any("#1672" in f for f in res.findings)
+    # The mute-leg cause text is distinct ("printing a `SMOKE:` verdict
+    # marker") — must not be the one actually reported here even though
+    # #2272 is named in passing as the OTHER budget.
+    assert not any("verdict marker" 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

{code_coordinator-0.5.656 → code_coordinator-0.5.658}/tests/test_health_fix.py

@@ -477,14 +477,27 @@ def test_fix_cargo_targets_protects_a_repo_with_a_live_assignment(
     cap is tier-3 whole-directory eviction. With a live `running` assignment
     for ``repo1`` on this machine, that eviction must be skipped: the sweep
     stays over cap and the directory survives.
+
+    Mocks ``shutil.disk_usage`` to report ample free space, mirroring its
+    twin (``test_fix_cargo_targets_evicts_the_same_repo_once_it_goes_idle``)
+    so the two tests differ only in the live assignment — otherwise this
+    test's "still over cap" / surviving-blob assertions would also pass
+    vacuously on a runner with under 10GB free (`cargo_floor_unreachable`,
+    `coord/cargo_cache.py`), proving nothing about `protect_repos` either.
     """
     import coord.board_service as board_service
+    from coord import cargo_cache
     from coord.health.checks import release_cordon as check_mod
 
     coord_dir = tmp_path / ".coord"
     _write_bytes(coord_dir / "cargo-target" / "repo1" / "blob", 4096)
     _gc_status(coord_dir)
     monkeypatch.setenv("COORD_CARGO_CACHE_CAP_GB", "0.0000000001")
+    monkeypatch.setattr(
+        cargo_cache.shutil,
+        "disk_usage",
+        lambda _p: SimpleNamespace(total=1_000_000_000_000, used=0, free=1_000_000_000_000),
+    )
 
     monkeypatch.setattr(check_mod.socket, "gethostname", lambda: "precision")
     config = SimpleNamespace(
@@ -518,14 +531,29 @@ def test_fix_cargo_targets_evicts_the_same_repo_once_it_goes_idle(
 ) -> None:
     """Same fixture as the protection test above, minus the live assignment
     — proves the protection in that test is doing the work, not some other
-    difference between the two setups."""
+    difference between the two setups.
+
+    Mocks ``shutil.disk_usage`` to report ample free space: without it, the
+    free-space floor (default 10GB, ``COORD_CARGO_FREE_FLOOR_GB``) reads the
+    REAL disk free space of whatever machine runs this test. On a runner
+    with under 10GB free, the tiny 4096-byte fixture cache can never cover
+    the shortfall on its own, ``cargo_floor_unreachable`` fires, tier-3
+    eviction is skipped entirely, and the repo survives — flipping this
+    test's outcome based on the host's disk, not the code under test.
+    """
     import coord.board_service as board_service
+    from coord import cargo_cache
     from coord.health.checks import release_cordon as check_mod
 
     coord_dir = tmp_path / ".coord"
     _write_bytes(coord_dir / "cargo-target" / "repo1" / "blob", 4096)
     _gc_status(coord_dir)
     monkeypatch.setenv("COORD_CARGO_CACHE_CAP_GB", "0.0000000001")
+    monkeypatch.setattr(
+        cargo_cache.shutil,
+        "disk_usage",
+        lambda _p: SimpleNamespace(total=1_000_000_000_000, used=0, free=1_000_000_000_000),
+    )
 
     monkeypatch.setattr(check_mod.socket, "gethostname", lambda: "precision")
     config = SimpleNamespace(