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

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

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

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

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

{code_coordinator-0.5.655 → code_coordinator-0.5.656}/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.656}/coord/smoke.py

@@ -2775,8 +2775,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`

{code_coordinator-0.5.655 → code_coordinator-0.5.656}/tests/test_plain_runner_smoke_3673.py

@@ -10,8 +10,9 @@ no real `claude -p`. The end-to-end tests drive the real
 :class:`coord.agent.AgentServer` (reusing the ``_server``/``_spec``/
 ``_init_repo`` fixtures from :mod:`tests.test_agent`) through
 ``server.assign(...)`` and confirm no `claude` binary is ever invoked for a
-plain-runner leg's verdict, while a judgement-needing leg still gets the
-ordinary `claude -p` path unchanged.
+plain-runner leg's verdict — including a judgement-needing leg (#3736:
+`smoke_needs_judgement` no longer routes a `plain_runner` leg to the
+ordinary `claude -p` chat path; see `coord.agent.AgentServer._spawn`).
 """
 
 from __future__ import annotations
@@ -20,8 +21,10 @@ import subprocess
 import sys
 from pathlib import Path
 
+import coord.agent as agent_mod
 from coord.agent import (
     DONE,
+    FAILED,
     AssignmentSpec,
     PlainRunnerVerdict,
     execute_plain_runner_smoke,
@@ -290,12 +293,15 @@ def test_agent_plain_runner_leg_failure_spawns_a_claude_summariser(
     server.shutdown()
 
 
-def test_agent_smoke_needing_judgement_falls_through_to_the_claude_path(
+def test_agent_smoke_needing_judgement_also_takes_the_plain_runner_path(
     tmp_path: Path,
 ) -> None:
-    """``smoke_needs_judgement=True`` is the opt-out — even with
-    ``plain_runner=True``, this leg must get the ordinary `claude -p`
-    chat session, not the plain-runner subprocess path (#3673)."""
+    """#3736: ``smoke_needs_judgement=True`` no longer opts a ``plain_runner``
+    leg out of the subprocess path — the ordinary `claude -p` chat session
+    (`SMOKE_SYSTEM_PROMPT`) has no judgement logic beyond polling the same
+    command's exit code, and is bounded by the Bash tool's 600s ceiling that
+    this fix exists to route around. The leg must get a `SMOKE:` verdict
+    from the subprocess, with no `claude` binary ever invoked."""
     repo = _init_repo(tmp_path / "repo")
     server = _server(
         tmp_path, repo_path=repo,
@@ -308,7 +314,75 @@ def test_agent_smoke_needing_judgement_falls_through_to_the_claude_path(
     a = server.assign(spec)
     final = server.wait_for(a.id, timeout=10)
 
+    assert final.status == DONE
+    assert final.exit_code == 0
     log = Path(final.log_path).read_text()
-    assert "claude-path-ran" in log
-    assert "plain-runner (#3673)" not in log
+    assert "SMOKE: pass" in log
+    assert "plain-runner (#3673)" in log
+    assert "claude-path-ran" not in log
+    server.shutdown()
+
+
+def test_agent_plain_runner_smoke_exceeding_the_bash_tool_ceiling_still_verdicts(
+    tmp_path: Path,
+) -> None:
+    """#3736: a smoke command that would run well past the Bash tool's 600s
+    ceiling still yields a recorded ``SMOKE:`` verdict — because it never
+    runs inside a `claude -p` turn that could background-and-abandon it. A
+    short ``smoke_timeout_s`` stands in for "exceeds the ceiling" so the
+    test itself stays fast; what matters is that the command runs to
+    completion (or is reaped by ITS OWN timeout) as a bare subprocess, with
+    no `claude` binary ever invoked and no #2244 no-verdict park."""
+    repo = _init_repo(tmp_path / "repo")
+    server = _server(
+        tmp_path, repo_path=repo,
+        argv=[sys.executable, "-c", "print('claude-path-ran')"],
+    )
+    spec = _spec(
+        repo, type="smoke", plain_runner=True, smoke_needs_judgement=True,
+        smoke_command=f"{sys.executable} -c \"import time; time.sleep(0.3)\"",
+        smoke_timeout_s=30,
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    assert final.status == DONE
+    assert final.exit_code == 0
+    log = Path(final.log_path).read_text()
+    assert "SMOKE: pass" in log
+    assert "claude-path-ran" not in log
+    server.shutdown()
+
+
+def test_agent_plain_runner_smoke_crash_still_writes_a_smoke_marker(
+    tmp_path: Path, monkeypatch,
+) -> None:
+    """#3736: if :func:`execute_plain_runner_smoke` itself raises (not a
+    smoke-command failure — an infra crash in the executor), the leg must
+    still get a parseable ``SMOKE: fail`` line in its log, not just a FAILED
+    status with nothing for `coord.progress.parse_smoke_verdict_from_log` to
+    find — the same #2244 no-verdict park this whole fix targets, reachable
+    from a second angle."""
+    repo = _init_repo(tmp_path / "repo")
+    server = _server(
+        tmp_path, repo_path=repo,
+        argv=[sys.executable, "-c", "print('claude-path-ran')"],
+    )
+
+    def fake_execute(*args, **kwargs):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(agent_mod, "execute_plain_runner_smoke", fake_execute)
+
+    spec = _spec(
+        repo, type="smoke", plain_runner=True, smoke_command="exit 0",
+    )
+    a = server.assign(spec)
+    final = server.wait_for(a.id, timeout=10)
+
+    assert final.status == FAILED
+    log = Path(final.log_path).read_text()
+    assert "SMOKE: fail" in log
+    assert "boom" in log
+    assert "claude-path-ran" not in log
     server.shutdown()