code-coordinator 0.5.655__tar.gz → 0.5.657__tar.gz

{code_coordinator-0.5.655 → code_coordinator-0.5.657}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.655",
+  "tag": "0.5.657",
   "distance": 0,
-  "node": "g8f314f82888f9fbb19e3afbb2d2715b02cc648a0",
+  "node": "gf275c3f61cfa7748dc86e4d8adec06eac343ac8d",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-19"

{code_coordinator-0.5.655 → code_coordinator-0.5.657}/coord/agent.py

@@ -1165,11 +1165,11 @@ class AssignmentSpec:
     # agent reason (docs/EPHEMERAL_WORKERS.md).
     runtime_ceiling_s: float | None = None
     # #3673: "make the Test stage a plain runner by default" — when True AND
-    # ``type == "smoke"`` AND ``smoke_needs_judgement`` is False AND
-    # ``smoke_command`` is set, ``_spawn`` runs ``smoke_command`` directly as
-    # a subprocess (:func:`run_plain_runner_command`) instead of spawning a
-    # ``claude -p`` session, and derives the Test-stage verdict from its exit
-    # code alone — an LLM session is spawned only to SUMMARISE a failure
+    # ``type == "smoke"`` AND ``smoke_command`` is set, ``_spawn`` runs
+    # ``smoke_command`` directly as a subprocess
+    # (:func:`run_plain_runner_command`) instead of spawning a ``claude -p``
+    # session, and derives the Test-stage verdict from its exit code alone —
+    # an LLM session is spawned only to SUMMARISE a failure
     # (:func:`AgentServer._spawn_plain_runner_failure_summary`), never to
     # decide pass/fail. Defaults to ``False`` — the same "unrecognized kwarg
     # 400s a config-free/older agent" discipline every other optional field
@@ -1178,6 +1178,10 @@ class AssignmentSpec:
     # actual default-on policy) opts a leg into this path; every other
     # assignment type, and any caller that predates this field, is
     # completely unaffected.
+    #
+    # #3736: ``smoke_needs_judgement`` is no longer a second gate on this —
+    # see that field's own docstring below for why every plain-runner leg,
+    # judgement-needing or not, now takes this subprocess path.
     plain_runner: bool = False
     # #3673: the resolved shell command a plain-runner leg executes
     # (``coord.smoke.resolve_smoke_command``'s result, carried structurally
@@ -1199,10 +1203,17 @@ class AssignmentSpec:
     smoke_timeout_s: float | None = None
     # #3673: True when this leg's required capabilities need genuine
     # judgement rather than a bare exit code (GUI/real-host drivers — see
-    # ``coord.smoke.smoke_needs_judgement``). ``_spawn`` falls through to
-    # the ordinary ``claude -p`` chat path whenever this is True, even if
-    # ``plain_runner`` is also True — the opt-out, not a second on/off
-    # switch of its own.
+    # ``coord.smoke.smoke_needs_judgement``). Still carried on the wire and
+    # still read by ``coord.smoke``'s own dispatch bookkeeping, but #3736
+    # removed its use as a SECOND gate in ``_spawn``: it no longer routes a
+    # leg to the ordinary ``claude -p`` chat path on its own.
+    # ``SMOKE_SYSTEM_PROMPT`` (``coord.smoke``) has no actual GUI/real-host
+    # judgement logic beyond polling the same command and reading its exit
+    # code, so a judgement-needing leg gains nothing from that path that the
+    # plain-runner subprocess doesn't already do — while losing the Bash
+    # tool's 600s ceiling, which a long judgement-needing build (e.g. a cold
+    # Windows cross-compile) can exceed and get backgrounded-and-abandoned
+    # into a #2244 no-verdict park (see ``_spawn``'s own comment for detail).
     smoke_needs_judgement: bool = False
     # #3681: opts a ``type="work"`` leg into running as a Claude Code
     # *workflow* — multiple agents (implement → adversarial review → fix)
@@ -6462,8 +6473,10 @@ def _user_message_line(text: str) -> bytes:
 # session) and derives the verdict from the exit code alone. An LLM session
 # is spawned only to SUMMARISE a failure for a human-readable report — never
 # to decide pass/fail — via `AgentServer._spawn_plain_runner_failure_summary`.
-# `coord.smoke.smoke_needs_judgement` is the opt-out for GUI/real-host-driver
-# specs that genuinely need more than an exit code.
+# #3736: every `plain_runner` leg takes this path, including one
+# `coord.smoke.smoke_needs_judgement` flags as GUI/real-host-driver — see
+# `AgentServer._spawn`'s routing comment for why that stopped being a
+# second gate.
 
 #: How much of a plain-runner command's combined stdout+stderr survives into
 #: the leg's log (and, on failure, the summary request) — generous enough to
@@ -10439,6 +10452,25 @@ class AgentServer:
             _log.exception(
                 "plain-runner smoke %s: execute_plain_runner_smoke raised", assignment.id,
             )
+            # #3736: write the SAME `SMOKE:` marker vocabulary the normal
+            # path writes, even on this crash branch — `_fail` alone sets
+            # the assignment FAILED but writes nothing to the log, which
+            # left `coord.progress.parse_smoke_verdict_from_log` (read via
+            # `coord.notify._smoke_worker_verdict`) with no marker to find
+            # and the leg parked as a #2244 no-verdict rather than recorded
+            # as a failure a human can act on. `_SMOKE_VERDICT_RE` is a
+            # line-anchored `^SMOKE:\s*(pass|fail|baseline-red)\b\s*(.*)$`
+            # match, so the free-text reason after `fail` here is read back
+            # as the verdict's `reason` exactly like a `claude -p` worker's
+            # own `SMOKE: fail <reason>` line.
+            try:
+                with open(assignment.log_path, "a", encoding="utf-8") as fh:
+                    fh.write(f"\nSMOKE: fail plain-runner smoke crashed: {exc}\n")
+            except OSError:
+                _log.exception(
+                    "plain-runner smoke %s: failed to write crash marker to log %s",
+                    assignment.id, assignment.log_path,
+                )
             self._fail(assignment, f"plain-runner smoke crashed: {exc}")
             return
 
@@ -10544,16 +10576,35 @@ class AgentServer:
         # `_spawn` is ever reached.
         spec = assignment.spec
 
-        # #3673: the plain-runner path — a smoke leg this policy applies to
-        # never spawns `claude -p` for its verdict at all, so it must be
-        # checked before any provider resolution/argv-building below, which
-        # exists purely to build THAT spawn.
-        if (
-            spec.type == "smoke"
-            and spec.plain_runner
-            and not spec.smoke_needs_judgement
-            and spec.smoke_command
-        ):
+        # #3673/#3736: the plain-runner path — a smoke leg this policy
+        # applies to never spawns `claude -p` for its verdict at all, so it
+        # must be checked before any provider resolution/argv-building below,
+        # which exists purely to build THAT spawn.
+        #
+        # #3736: `smoke_needs_judgement` no longer excludes a leg from this
+        # path. It used to (the `and not spec.smoke_needs_judgement` clause
+        # that lived here routed a "judgement-needing" leg — in practice,
+        # every default-config `windows` capability leg, e.g. quadraui's
+        # win-msvc cross-compile smoke — through the ordinary `claude -p`
+        # chat session instead). That session runs `SMOKE_SYSTEM_PROMPT`
+        # (coord/smoke.py), which has no visual/interactive judgement logic
+        # of its own: it polls the SAME command this subprocess path runs and
+        # derives the SAME pass/fail from its exit code, just inside a
+        # `claude -p` turn bounded by the Bash tool's 600s ceiling — long
+        # enough for a cold cross-build that a worker then backgrounds and
+        # abandons when it ends its (one-shot, non-resumable) turn to "wait
+        # for a notification" that never arrives. The result was a #2244
+        # no-verdict park with no `SMOKE:` marker ever written (quadraui#1616)
+        # — exactly the failure mode `run_plain_runner_command`'s own
+        # `subprocess.run(..., timeout=...)` call cannot have, since it never
+        # runs inside a Claude Code tool call at all. This also closes the
+        # #2085 split-brain with `coord.notify._is_plain_runner_leg`, which
+        # already classified every leg here as plain-runner (`plain_runner`
+        # rides the wire unconditionally True, per `coord.smoke.
+        # _walk_candidates_and_dispatch`'s docstring) — that classification
+        # now matches how the leg actually executes, for every leg, with no
+        # change needed on the `coord.notify` side.
+        if spec.type == "smoke" and spec.plain_runner and spec.smoke_command:
             self._run_plain_runner_smoke(assignment, repo_path)
             return
 

{code_coordinator-0.5.655 → code_coordinator-0.5.657}/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.655 → code_coordinator-0.5.657}/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.655 → code_coordinator-0.5.657}/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.655 → code_coordinator-0.5.657}/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.655 → code_coordinator-0.5.657}/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
@@ -2775,8 +2843,13 @@ def _walk_candidates_and_dispatch(
     session) instead of the briefing-driven chat the SMOKE_SYSTEM_PROMPT
     above describes. `plain_runner` is unconditionally `True` on every
     dispatch this function makes — #3673's "make the Test stage a plain
-    runner by default" policy — with `smoke_needs_judgement` as the one
-    opt-out (GUI/real-host-driver specs, :func:`smoke_needs_judgement`); the
+    runner by default" policy. `smoke_needs_judgement` still rides along
+    (GUI/real-host-driver specs, :func:`smoke_needs_judgement`) and is still
+    read by this module's own dispatch bookkeeping, but #3736 removed its
+    use in `_spawn` as a second gate: every `plain_runner` leg takes the
+    subprocess path regardless, since `SMOKE_SYSTEM_PROMPT`'s chat path has
+    no judgement logic of its own beyond polling the same command's exit
+    code, and loses the Bash tool's 600s ceiling for nothing in return. The
     briefing text is sent either way so a plain-runner-ineligible agent (one
     whose `default_worker_command` predates #3673, or any OTHER assignment
     type reusing this wire shape) still gets a fully-formed `claude -p`
@@ -3636,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 = (
@@ -3650,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.655 → code_coordinator-0.5.657}/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 "