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

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

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

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

{code_coordinator-0.5.654 → 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)
@@ -5886,6 +5897,27 @@ def _workflow_leg_system_prompt_suffix() -> str:
     hands a dispatched Review leg (see the ``elif spec.type == "review"``
     branch above) — never a second, hand-copied description of what a
     reviewer checks (#2096: one question, one answer).
+
+    #3730 adds three more guardrails on top of #3681's Workflow/Task
+    un-denial, each a system-prompt-level mitigation rather than a new CLI
+    flag (no documented, stable way to express any of the three as
+    ``--settings``/``--allowedTools`` was found):
+
+    * isolation — the leg already runs inside its own dedicated worktree;
+      a workflow subagent that additionally requests ``isolation:
+      "worktree"``/``"remote"`` would nest a second worktree inside it,
+      risking collision with the leg's own base-checkout guard and the
+      graphify symlink. Subagents must stay in the leg's own working
+      directory instead.
+    * fail-fast — a Workflow invocation that still gets denied (e.g. the
+      confirmation dialog auto-denies despite the --allowedTools grant)
+      must not be retried; retrying was observed to thrash into the
+      fleet's rapid-refill cost breaker. The leg must fall back to
+      performing the assignment directly, as a normal non-workflow leg
+      would.
+    * size — a small, bounded workflow (few agents/phases) keeps cost and
+      token usage predictable; ``WORK_AUTOCOMPACT_TOKENS`` is still the
+      hard backstop regardless.
     """
     from coord.review import REVIEWER_SYSTEM_PROMPT  # noqa: PLC0415
 
@@ -5906,7 +5938,24 @@ def _workflow_leg_system_prompt_suffix() -> str:
         "exactly the following as that review step's system prompt/lens "
         "(this is the identical text coord's own dispatched Review leg "
         "receives for this repo, byte for byte):\n\n"
-        "-----\n" + REVIEWER_SYSTEM_PROMPT + "\n-----\n"
+        "-----\n" + REVIEWER_SYSTEM_PROMPT + "\n-----\n\n"
+        "Three more rules for this workflow specifically (#3730):\n\n"
+        "1. Isolation: this leg already runs inside its own dedicated git "
+        "worktree. Do NOT give any agent in your workflow script "
+        "`isolation: \"worktree\"` or `isolation: \"remote\"` — that would "
+        "nest a second worktree inside the one you're already in, which is "
+        "unsupported here and risks colliding with this leg's own "
+        "base-checkout guard. Leave isolation unset (or `\"none\"`) so every "
+        "subagent shares this leg's own working directory.\n"
+        "2. Fail fast: if starting the workflow (or the Workflow tool call "
+        "itself) is ever denied, do NOT retry it — retrying has thrashed "
+        "other legs into the fleet's cost circuit breaker. Immediately fall "
+        "back to completing this assignment directly yourself, exactly as a "
+        "non-workflow leg would, and say so in your final message.\n"
+        "3. Keep it small: use the fewest agents/phases that can do the "
+        "job (e.g. implement, review, fix — not a long chain). This leg "
+        "still has its own hard context/cost caps regardless, but a small "
+        "workflow keeps you well inside them.\n"
     )
 
 
@@ -6272,6 +6321,16 @@ def default_worker_command(spec: AssignmentSpec, *, binary: str = DEFAULT_WORKER
         # the dedicated `elif spec.type == "smoke"` branch above, which
         # deliberately withholds it instead.
         allowed_tools = "Read,Edit,Write,Bash,Monitor"
+        # #3730: being absent from --disallowedTools (worker_disallowed_tools
+        # above) is not sufficient for Workflow/Task — the Workflow tool's
+        # own confirmation dialog still fires per invocation, and a headless
+        # `-p` leg has no TTY to answer it, so without an explicit
+        # --allowedTools grant it is auto-denied exactly like any other
+        # unconfirmed permission prompt. Granting it here is the same
+        # pre-approval mechanism `Bash` already relies on in this list to
+        # skip its own per-command confirmations.
+        if spec.workflow:
+            allowed_tools += ",Workflow,Task"
         # #3672: force earlier auto-compaction for work-shaped legs — see
         # `WORK_AUTOCOMPACT_TOKENS`'s docstring. These are exactly the legs
         # the cost analysis found running 200-450 turns with zero
@@ -6414,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
@@ -10391,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
 
@@ -10496,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.654 → code_coordinator-0.5.656}/coord/providers/claude.py

@@ -263,6 +263,14 @@ class ClaudeProvider(Provider):
                 # backgrounded long-running command. #2301: this grant is for
                 # work-shaped legs only — smoke has its own branch above.
                 _at = "Read,Edit,Write,Bash,Monitor"
+                # #3730: keep in sync with default_worker_command's identical
+                # `if spec.workflow:` branch — being absent from
+                # --disallowedTools is not enough to actually use Workflow/
+                # Task; its per-invocation confirmation dialog auto-denies
+                # with no TTY unless pre-approved via --allowedTools, the
+                # same mechanism `Bash` already relies on above.
+                if spec.workflow:
+                    _at += ",Workflow,Task"
                 # #3672: keep in sync with default_worker_command's identical
                 # branch — force earlier auto-compaction for work-shaped legs.
                 # #3697: fix/conflict-fix legs carry the review findings as

{code_coordinator-0.5.654 → 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.654 → code_coordinator-0.5.656}/tests/test_agent_reap.py

@@ -29,6 +29,7 @@ from coord.agent import (
     _workflow_leg_system_prompt_suffix,
     _PTY_RESULT_LINE_MARKER,
     _RESULT_LINE_MARKER,
+    default_worker_command,
     format_host_sleep_reason,
     format_runtime_ceiling_reason,
     is_host_sleep_reason,
@@ -561,6 +562,29 @@ def test_disallowed_tools_un_disallows_workflow_and_task_only_for_opted_in_leg()
         assert pattern in not_opted_in
 
 
+# ── workflow opt-in: --allowedTools (#3730) ──────────────────────────────────
+
+
+def test_allowed_tools_grants_workflow_and_task_only_for_opted_in_leg() -> None:
+    """#3730 item 2: merely absent from --disallowedTools is not enough to
+    actually use Workflow — its own per-invocation confirmation dialog
+    auto-denies with no TTY unless pre-approved via --allowedTools (the same
+    mechanism `Bash` already relies on in this list). A workflow leg's argv
+    must explicitly grant `Workflow`/`Task`; a non-opted-in leg must not."""
+    opted_in = default_worker_command(_make_spec(workflow=True))
+    not_opted_in = default_worker_command(_make_spec(workflow=False))
+
+    opted_in_allowed = opted_in[opted_in.index("--allowedTools") + 1].split(",")
+    not_opted_in_allowed = not_opted_in[
+        not_opted_in.index("--allowedTools") + 1
+    ].split(",")
+
+    assert "Workflow" in opted_in_allowed
+    assert "Task" in opted_in_allowed
+    assert "Workflow" not in not_opted_in_allowed
+    assert "Task" not in not_opted_in_allowed
+
+
 # ── in-workflow review system prompt (#3681 item 5) ──────────────────────────
 
 def test_workflow_system_prompt_suffix_embeds_the_real_reviewer_prompt_verbatim() -> None:
@@ -579,6 +603,32 @@ def test_workflow_system_prompt_suffix_embeds_the_real_reviewer_prompt_verbatim(
     assert suffix[start : start + len(REVIEWER_SYSTEM_PROMPT)] == REVIEWER_SYSTEM_PROMPT
 
 
+def test_workflow_system_prompt_suffix_tells_worker_not_to_nest_worktree_isolation() -> None:
+    """#3730 item 3: the leg already runs inside its own dedicated worktree;
+    a workflow subagent must not additionally request `isolation:
+    "worktree"`/`"remote"`, which would nest a second worktree inside it."""
+    suffix = _workflow_leg_system_prompt_suffix()
+    assert 'isolation: "worktree"' in suffix
+    assert 'isolation: "remote"' in suffix
+
+
+def test_workflow_system_prompt_suffix_tells_worker_to_fail_fast_on_denial() -> None:
+    """#3730 item 4: a denied Workflow invocation must not be retried — a
+    real leg thrashed into the fleet's rapid-refill cost breaker doing
+    exactly that — the worker must fall back to a direct, non-workflow
+    completion of the assignment instead."""
+    suffix = _workflow_leg_system_prompt_suffix()
+    assert "do NOT retry it" in suffix
+    assert "fall back to completing this assignment directly" in suffix
+
+
+def test_workflow_system_prompt_suffix_tells_worker_to_keep_workflow_small() -> None:
+    """#3730 item 5: guide the worker toward a small/bounded workflow rather
+    than shipping an unverified workflow-size settings flag."""
+    suffix = _workflow_leg_system_prompt_suffix()
+    assert "Keep it small" in suffix
+
+
 # ── _log_has_output ──────────────────────────────────────────────────────────
 
 def test_log_has_output_false_for_header_only(tmp_path: Path) -> None:

{code_coordinator-0.5.654 → 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()