code-coordinator 0.5.296__tar.gz → 0.5.297__tar.gz

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.296
+Version: 0.5.297
 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.296 → code_coordinator-0.5.297}/code_coordinator.egg-info/SOURCES.txt

@@ -508,6 +508,7 @@ tests/test_conflict_fix.py
 tests/test_conflict_fix_semantic.py
 tests/test_coord_log_daemon_fallback_2547.py
 tests/test_coord_test.py
+tests/test_coord_test_runner_acceptance_toolchain_2936.py
 tests/test_coord_test_runner_baseline.py
 tests/test_coord_test_runner_populated_home.py
 tests/test_coord_test_runner_routing.py

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/code_coordinator.egg-info/scm_file_list.json

@@ -534,6 +534,7 @@
     "tests/test_conflict_fix_semantic.py",
     "tests/test_coord_log_daemon_fallback_2547.py",
     "tests/test_coord_test.py",
+    "tests/test_coord_test_runner_acceptance_toolchain_2936.py",
     "tests/test_coord_test_runner_baseline.py",
     "tests/test_coord_test_runner_populated_home.py",
     "tests/test_coord_test_runner_routing.py",

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.296",
+  "tag": "0.5.297",
   "distance": 0,
-  "node": "ga711fc248f5a8207d97fdc8ec5709d04beb8f505",
+  "node": "g47fe3ff98db0a0f6549b080e1a59c60423ff2df8",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-29"

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/coord/agent.py

@@ -1742,6 +1742,53 @@ def _worker_subprocess_env(
     return env
 
 
+def worker_coord_reachable(base_env: dict[str, str] | None = None) -> tuple[bool, str]:
+    """#2936: does ``coord`` resolve on a WORKER's PATH — not this agent
+    process's own?
+
+    Built on the exact env a real worker is spawned into
+    (:func:`_worker_subprocess_env`, whose #402/#2569 strip removes the
+    fleet's pinned ``~/.coord-venv/bin`` from PATH). A worker that cannot
+    resolve ``coord`` can run its entire suite, PASS, and be structurally
+    unable to record that verdict (``coord test <id> --passed``) — the
+    missing verdict then reads as a TEST FAILURE and walks the
+    ``models.escalation`` ladder, re-dispatching already-correct work on a
+    more expensive model for a PATH gap, not a weak one (#2897 cost one
+    instance of this an extra opus rerun on top of an already-passing
+    sonnet leg).
+
+    Before this, the gap was discovered only when a smoke worker's own
+    final-turn transcript happened to mention it (as #2897's did) — this
+    function exists so the agent can say so ITSELF, at startup, in
+    ``journalctl --user -u coord-agent``, mirroring #1671's PATH diagnostics
+    for capability probes.
+
+    Returns ``(ok, message)`` rather than logging directly, so the check is
+    testable with a synthetic *base_env* with no mocking of ``shutil.which``
+    or the logging module required. ``base_env=None`` (the production
+    default) resolves against this process's real ``os.environ``, exactly
+    like :func:`_worker_subprocess_env` itself.
+    """
+    worker_path = _worker_subprocess_env(base_env).get("PATH", "")
+    resolved = shutil.which("coord", path=worker_path)
+    if resolved:
+        return True, (
+            f"coord agent: worker PATH check OK — 'coord' resolves at {resolved} "
+            "(a smoke/test worker on this machine can record its verdict, #2936)"
+        )
+    return False, (
+        "coord agent: WARNING 'coord' does NOT resolve on a WORKER's PATH — "
+        f"searched: {worker_path!r}. A smoke/test worker on this machine can "
+        "run its whole suite, PASS, and be structurally unable to record the "
+        "verdict via `coord test <id> --passed`; the missing verdict then "
+        "reads as a TEST FAILURE and escalates the model for an "
+        "infrastructure gap, not a weak one (#2936). Fix: re-run "
+        "install-agent.sh on this machine so ~/.local/bin/coord exists and "
+        "symlinks to $HOME/.coord-venv/bin/coord (the blue/green symlink "
+        "itself, never a resolved .blue/.green path)."
+    )
+
+
 def _slugify(text: str, max_len: int = 40) -> str:
     """Convert *text* to a URL/branch-safe slug."""
     slug = re.sub(r"[^a-z0-9]+", "-", text.lower()).strip("-")
@@ -5444,6 +5491,18 @@ class AgentServer:
         self.log_dir.mkdir(parents=True, exist_ok=True)
         self._load_state()
 
+        # #2936: verify AT STARTUP — not a suite-run later — that a worker
+        # this agent spawns will be able to resolve `coord` on its own PATH
+        # to record a test/smoke verdict. Only the failure case is logged:
+        # this file configures no logging handler of its own (`coord agent`
+        # never calls `configure_daemon_logging`, unlike `coord serve` —
+        # #2862), so a bare `_log.info` here would be a silent no-op on the
+        # real daemon while `_log.warning` reaches `journalctl` via Python's
+        # stderr handler-of-last-resort with zero configuration needed.
+        _coord_reachable, _coord_reachable_msg = worker_coord_reachable()
+        if not _coord_reachable:
+            _log.warning(_coord_reachable_msg)
+
     # ── #2299: hot config reload ────────────────────────────────────────────
 
     #: Config-derived state that a reload refreshes, versus the state it must

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/install-agent.sh

@@ -109,14 +109,52 @@ echo "Installed: $("$VENV_DIR/bin/coord" version)"
 
 # The venv is now fully installed and verified working (coord version printed
 # above). Disarm the cleanup trap here: everything from this point on
-# (machine-name detection, the systemd unit, node shims, systemctl,
-# loginctl) is unrelated to venv creation, and a failure in any of it must
-# NOT delete a venv that already works — that would poison the retry with a
-# from-scratch pip re-install just to get back to the same later failure
-# (#2911 review).
+# (machine-name detection, the systemd unit, the coord CLI shim, node shims,
+# systemctl, loginctl) is unrelated to venv creation, and a failure in any of
+# it must NOT delete a venv that already works — that would poison the retry
+# with a from-scratch pip re-install just to get back to the same later
+# failure (#2911 review).
 trap - EXIT
 CREATED_VENV=0
 
+# --- coord CLI shim (#2936) --------------------------------------------------
+# Workers are spawned with THIS agent's own venv stripped from PATH (#402,
+# hardened by #2569's PIP_REQUIRE_VIRTUALENV after an 11h fleet outage — see
+# coord/agent.py's `_worker_subprocess_env`). That strip is correct and must
+# stay: a worker's bare `pip install -e .` must never land in the fleet's
+# live $VENV_DIR. But nothing else guarantees a worker's PATH resolves
+# `coord` itself — and when it doesn't, a smoke/test worker can run its
+# whole suite, pass, and be structurally unable to record the verdict via
+# `coord test <id> --passed`. The missing verdict then reads as a TEST
+# FAILURE and walks the model-escalation ladder for an infrastructure gap,
+# never a weak model (#2936; one instance cost an extra opus rerun of an
+# already-passing sonnet leg).
+#
+# $HOME/.local/bin is (a) already put on the coord-agent unit's PATH below
+# and (b) NOT stripped from a worker's PATH — #2569's strip matches
+# $VENV_DIR/bin by name/realpath only, never $HOME/.local/bin. A plain
+# symlink there closes the gap for every worker this agent spawns.
+#
+# MUST point at $VENV_DIR itself — the blue/green symlink `coord agent
+# update` repoints atomically on every release (docs/AGENT_OPERATIONS.md) —
+# NOT at a `readlink -f`-resolved `.blue`/`.green` path. Resolving it here
+# would freeze the shim on whichever side happens to be live at install
+# time and silently go stale on the very next blue/green swap.
+COORD_SHIM_DIR="$HOME/.local/bin"
+COORD_SHIM_TARGET="$VENV_DIR/bin/coord"
+COORD_SHIM_LINK="$COORD_SHIM_DIR/coord"
+mkdir -p "$COORD_SHIM_DIR"
+if [ -L "$COORD_SHIM_LINK" ] && [ "$(readlink "$COORD_SHIM_LINK")" = "$COORD_SHIM_TARGET" ]; then
+    : # already ours, and already pointed at the unresolved blue/green symlink
+elif [ -e "$COORD_SHIM_LINK" ] || [ -L "$COORD_SHIM_LINK" ]; then
+    echo "warning: $COORD_SHIM_LINK exists and is not the coord shim — left as-is"
+    echo "  A smoke/test worker on this machine cannot record its verdict via"
+    echo "  'coord test <id> --passed' unless 'coord' resolves on ITS PATH (#2936)."
+else
+    ln -s "$COORD_SHIM_TARGET" "$COORD_SHIM_LINK"
+    echo "Installed coord shim: $COORD_SHIM_LINK -> $COORD_SHIM_TARGET"
+fi
+
 # Detect machine name if not provided
 if [ -z "$MACHINE_NAME" ]; then
     MACHINE_NAME=$(hostname -s)

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/scripts/coord-test-runner.sh

@@ -648,15 +648,33 @@ run_python_acceptance_ci() {
     local ci_home="$WT/.coord-ci-home"
     mkdir -p "$ci_home"
     log "running: coord acceptance run --all --ci (cli-pytest route, ms-37)"
-    if (env -u COORD_SERVICE_URL -u COORD_TOKEN -u COORD_CONFIG \
+    local rc=0
+    (env -u COORD_SERVICE_URL -u COORD_TOKEN -u COORD_CONFIG \
             HOME="$ci_home" PATH="$venv/bin:$PATH" \
             "$venv/bin/coord" acceptance run \
             --repo claude-coordinator --all --ci \
             --config "$WT/.github/coord-ci-acceptance.yml" \
-            --for-path coord/cli.py --path "$WT") >"$acc_out" 2>&1; then
+            --for-path coord/cli.py --path "$WT") >"$acc_out" 2>&1 || rc=$?
+    if [[ "$rc" -eq 0 ]]; then
         say "PASS(python): ordinary suite + sealed acceptance suite (ms-37, cli-pytest) both green"
         return 0
     fi
+    # #2936: 127 is the shell's "command not found" for `$venv/bin/coord`
+    # itself — the SAME infrastructure class as the missing-python3/missing-
+    # fallback-command cases above (#1814), NOT a red suite. This venv is the
+    # one `run_python` just built (or found already usable) and successfully
+    # ran the ordinary pytest suite from moments ago, so a missing
+    # `$venv/bin/coord` here means this package's own console-script entry
+    # point never landed in it — an environment problem, not something the
+    # branch under test can be blamed for. Before this check, "coord:
+    # command not found" (#2936 — a smoke worker unable to resolve `coord` at
+    # all) and a genuinely red sealed suite were indistinguishable here, and
+    # the missing binary silently laundered into `RESULT: FAIL`.
+    if [[ "$rc" -eq 127 ]]; then
+        toolchain_missing coord python-acceptance-cli "\$venv/bin ($venv/bin), then \$PATH"
+        tail -n 20 "$acc_out" | sed 's/^/      /'
+        return 1
+    fi
     say "FAIL(python): sealed acceptance suite (cli-pytest route, ms-37) failed under --ci — either a test-id NOT listed in expected_red failed for real, or one listed in expected_red unexpectedly passed (see .github/workflows/test.yml's 'A red result here is attributable, not a mystery' step for the two-cause triage)"
     tail -n 40 "$acc_out" | sed 's/^/      /'
     return 1

code_coordinator-0.5.297/tests/test_coord_test_runner_acceptance_toolchain_2936.py

@@ -0,0 +1,181 @@
+"""Regression tests for #2936 — `run_python_acceptance_ci`'s ``coord`` call
+in scripts/coord-test-runner.sh must never launder "the binary could not run
+at all" into a red sealed-acceptance suite.
+
+BACKGROUND. #2897's smoke worker on dell64 could not resolve `coord` on ITS
+OWN path at all (no `~/.local/bin/coord` shim on that machine) and said so in
+its own final turn — it printed the PASS marker but had no way to record the
+verdict via `coord test <id> --passed`. The missing verdict then read as a
+TEST FAILURE and walked the model-escalation ladder for a PATH gap, not a
+weak model: an already-correct sonnet leg was re-run on opus for no reason.
+
+THIS FILE'S SLICE OF #2936. `run_python_acceptance_ci` (the ms-37 cli-pytest
+acceptance route, #2180) is the one place left in this script that shells out
+to `coord` at all — the Rust/cargo arm that used to carry a similar risk left
+with the crate in #2899. Before this fix, that call's `if ... ; then PASS
+... fi` collapsed exit 127 ("$venv/bin/coord: No such file or directory" —
+the shell's own "command not found", the same class #1814 already guards for
+python3/cargo/the fallback command) into the same `FAIL(python)` a genuinely
+red sealed suite gets. The two must never share a verdict: one says "the
+branch broke something", the other says "the environment could not tell us
+anything" (#1814's whole point).
+
+HOW THIS RUNS IN MILLISECONDS. Same technique as
+`tests/test_coord_test_runner_populated_home.py`: fake interpreters are
+planted at the exact paths the runner probes (`$WT/.venv/bin/python`,
+`$WT/.venv/bin/coord`) so no real venv is built and no real pytest/coord CLI
+runs. The fake `coord` exits with whatever `FAKE_COORD_EXIT` says, which is
+indistinguishable to the runner (and to a real "command not found") from
+`$?` alone — the runner never looks past the exit code, so faking THAT is a
+faithful stand-in for a truly-missing binary.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from .conftest import POSIX_BASH
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = REPO_ROOT / "scripts" / "coord-test-runner.sh"
+
+#: Answers just enough pytest invocation shapes to get the ordinary suite to
+#: PASS and reach `run_python_post_arms` — `-c` probes (xdist detection) and
+#: the full-suite `-m pytest ... --ignore=tests/acceptance` run. Nothing here
+#: needs to answer a flake/baseline re-run (`::` node ids) or the
+#: populated-home arm's bare test-file invocation: the fixture repo's diff
+#: touches no python test files, so that arm SKIPs on its own before either
+#: shape would be needed.
+_FAKE_PYTHON = r"""#!/usr/bin/env bash
+if [[ "$1" == "-c" ]]; then
+    exit 1  # no xdist -> serial
+fi
+if [[ "$1" == "-m" && "$2" == "pytest" ]]; then
+    printf '1 passed\n'
+    exit 0
+fi
+exit 0
+"""
+
+#: A stand-in for `coord` at `$WT/.venv/bin/coord`, where
+#: `run_python_acceptance_ci` looks for it once the ordinary suite is green.
+#: `FAKE_COORD_EXIT` stands in for whatever exit code a real invocation would
+#: have produced — 127 for "command not found", anything else for a real
+#: pass/fail.
+_FAKE_COORD = r"""#!/usr/bin/env bash
+exit "${FAKE_COORD_EXIT:-0}"
+"""
+
+
+def _git(cwd: Path, *args: str) -> str:
+    return subprocess.run(
+        ["git", *args],
+        cwd=str(cwd),
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        check=True,
+    ).stdout.strip()
+
+
+def _executable(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+    path.chmod(path.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+
+@pytest.fixture
+def repo(tmp_path: Path) -> Path:
+    """A repo shaped like an ordinary code-coordinator Test leg: the diff
+    touches only ``coord/**`` (routes to pytest, no python test files, so the
+    populated-home arm SKIPs itself and does not need its own fake)."""
+    r = tmp_path / "repo"
+    (r / "coord").mkdir(parents=True)
+    _git(r, "init", "-q", "-b", "main")
+    _git(r, "config", "user.email", "t@t.com")
+    _git(r, "config", "user.name", "Test")
+    (r / "coord" / "foo.py").write_text("x = 1\n", encoding="utf-8")
+    (r / "README.md").write_text("init\n", encoding="utf-8")
+    _git(r, "add", "-A")
+    _git(r, "commit", "-qm", "initial")
+    _git(r, "tag", "base")
+
+    (r / "coord" / "foo.py").write_text("x = 2\n", encoding="utf-8")
+    _git(r, "add", "-A")
+    _git(r, "commit", "-qm", "branch change")
+
+    _executable(r / ".venv" / "bin" / "python", _FAKE_PYTHON)
+    _executable(r / ".venv" / "bin" / "coord", _FAKE_COORD)
+    return r
+
+
+def _run(repo: Path, **fake_env: str) -> subprocess.CompletedProcess[str]:
+    env = dict(os.environ)
+    env.update(fake_env)
+    return subprocess.run(
+        [POSIX_BASH, str(SCRIPT), str(repo), "--base-ref", "base", "--repo", "code-coordinator"],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        timeout=120,
+        env=env,
+    )
+
+
+def test_a_green_acceptance_run_still_passes(repo: Path) -> None:
+    """Sanity baseline: with no injected fault, the branch is green end to end."""
+    result = _run(repo, FAKE_COORD_EXIT="0")
+
+    assert result.returncode == 0, (result.stdout, result.stderr)
+    assert "RESULT: PASS" in result.stdout
+
+
+def test_missing_coord_binary_is_infrastructure_not_a_failed_suite(repo: Path) -> None:
+    """The #2936 core guard: exit 127 ("command not found") from the `coord`
+    call must read as INFRA, never as a red sealed suite.
+
+    Asserting the ABSENCE of the failure wording matters as much as the
+    presence of the new one — `RESULT: FAIL` here is exactly what would
+    walk the model-escalation ladder for a PATH gap (#2897's dell64 cost).
+    """
+    result = _run(repo, FAKE_COORD_EXIT="127")
+
+    out = result.stdout + result.stderr
+    assert result.returncode == 3, out
+    assert "TOOLCHAIN MISSING(python-acceptance-cli)" in out
+    assert "coord" in out
+    assert "RESULT: INFRA" in out
+
+    assert "FAIL(python)" not in out
+    assert "RESULT: FAIL" not in out
+    assert "sealed acceptance suite (cli-pytest route, ms-37) failed" not in out
+
+
+def test_missing_coord_binary_message_is_actionable(repo: Path) -> None:
+    """Matches the #1814 bar every other TOOLCHAIN MISSING message meets:
+    which tool, where it looked, and that this is not a test verdict."""
+    result = _run(repo, FAKE_COORD_EXIT="127")
+    out = result.stdout + result.stderr
+
+    assert "INFRASTRUCTURE failure" in out
+    assert "python-acceptance-cli suite never ran" in out
+
+
+def test_a_genuinely_failing_acceptance_suite_is_still_a_failure(repo: Path) -> None:
+    """The other half of the distinction: a real red sealed suite (any
+    non-127 non-zero exit) must not be laundered into an infrastructure
+    error by this change."""
+    result = _run(repo, FAKE_COORD_EXIT="3")
+
+    out = result.stdout + result.stderr
+    assert result.returncode == 1, out
+    assert "FAIL(python)" in out
+    assert "sealed acceptance suite (cli-pytest route, ms-37) failed" in out
+    assert "RESULT: FAIL" in out
+    assert "TOOLCHAIN MISSING" not in out
+    assert "RESULT: INFRA" not in out

{code_coordinator-0.5.296 → code_coordinator-0.5.297}/tests/test_worker_env_venv_isolation.py

@@ -24,6 +24,7 @@ from coord.agent import (
     _pinned_venv_bin_dirs,
     _strip_venv_bins_from_path,
     _worker_subprocess_env,
+    worker_coord_reachable,
 )
 
 # #2684: every PATH fixture below must be joined/split on `os.pathsep`
@@ -179,3 +180,89 @@ def test_no_worker_env_ever_carries_pinned_venv_on_path(path_value: str) -> None
         base_prefix="/usr",
     )
     assert "/home/john/.coord-venv/bin" not in env["PATH"].split(os.pathsep)
+
+
+# ── #2936: `worker_coord_reachable` — the shim gap, caught at agent startup ──
+#
+# #402/#2569's strip above is correct and must stay (the whole point of this
+# file). But it also means a worker's PATH no longer carries `coord` unless
+# SOMETHING ELSE puts it there (the `~/.local/bin/coord` shim install-agent.sh
+# now installs). dell64 had no such shim: a smoke worker there ran its whole
+# suite, passed, and had no way to call `coord test <id> --passed` — the
+# missing verdict read as a TEST FAILURE and escalated the model for a PATH
+# gap (#2897). These tests are about the DETECTION this function adds, not
+# the strip itself — see the tests above for that.
+
+
+def _touch_executable(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8")
+    path.chmod(0o755)
+
+
+def test_worker_coord_reachable_true_when_a_shim_is_on_the_stripped_path(
+    tmp_path: Path,
+) -> None:
+    """The success case: `~/.local/bin/coord` (install-agent.sh's shim, or
+    any other non-pinned-venv location) survives the #2569 strip and is what
+    a real worker would resolve `coord` to."""
+    home = tmp_path
+    shim_dir = home / ".local" / "bin"
+    _touch_executable(shim_dir / "coord")
+
+    ok, msg = worker_coord_reachable(
+        {
+            "HOME": str(home),
+            "PATH": _path(f"{home}/.coord-venv/bin", str(shim_dir), "/usr/bin"),
+        }
+    )
+
+    assert ok is True
+    assert str(shim_dir / "coord") in msg
+    assert "WARNING" not in msg
+
+
+def test_worker_coord_reachable_false_when_only_the_pinned_venv_has_it(
+    tmp_path: Path,
+) -> None:
+    """The #2936/dell64 failure mode: `coord` exists ONLY inside the fleet's
+    pinned venv, which #2569's strip removes from every worker's PATH — so a
+    worker can never resolve it at all, exactly like dell64 with no
+    `~/.local/bin/coord` shim."""
+    home = tmp_path
+    pinned_bin = home / ".coord-venv" / "bin"
+    _touch_executable(pinned_bin / "coord")
+
+    ok, msg = worker_coord_reachable(
+        {"HOME": str(home), "PATH": _path(str(pinned_bin), "/usr/bin")}
+    )
+
+    assert ok is False
+    assert "WARNING" in msg
+    assert "does NOT resolve on a WORKER's PATH" in msg
+    assert "/usr/bin" in msg  # the (stripped) PATH actually searched
+    assert "#2936" in msg
+
+
+def test_worker_coord_reachable_false_message_names_the_fix(tmp_path: Path) -> None:
+    """The message must be actionable, matching the bar #1671's PATH
+    diagnostics already set for this codebase: what broke, and how to fix
+    it — not just that it broke."""
+    home = tmp_path
+    ok, msg = worker_coord_reachable({"HOME": str(home), "PATH": "/usr/bin"})
+
+    assert ok is False
+    assert "coord test <id> --passed" in msg
+    assert "install-agent.sh" in msg
+    assert "~/.local/bin/coord" in msg
+    assert "blue/green" in msg
+
+
+def test_worker_coord_reachable_defaults_to_this_processs_environ() -> None:
+    """`base_env=None` (the production call shape) must resolve against the
+    real environment, exactly like `_worker_subprocess_env` itself — not
+    silently no-op or require a caller to always pass one explicitly."""
+    ok, msg = worker_coord_reachable()
+
+    assert isinstance(ok, bool)
+    assert "coord agent:" in msg