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

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

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

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

{code_coordinator-0.5.295 → 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.295 → code_coordinator-0.5.297}/coord/drive_queue.py

@@ -3759,18 +3759,29 @@ def _reconcile_blocked(
     except a CONFIRMED-clear reading OR a probe that came back unreadable
     (#2806), which is deliberate: a `blocked` entry this sweep cannot say
     anything new about must render EXACTLY as it did before #2230 existed.
-    Three ways to land there:
+    Four ways to land there:
 
     * the block is PERMANENT (:func:`is_permanent_block_reason`) — #1844's
       guard refusal or #2019's dead end — neither of which any amount of
       re-checking can ever change;
+    * the block is `_resolve_prereqs`'s own unsatisfiable ``after=`` verdict
+      (:func:`_is_unsatisfiable_prereq_reason`, #2935) — a `waiting` entry
+      that never reached `running` has no assignment and no branch, so
+      there is categorically no merge-queue row for THIS sweep to have any
+      opinion about; the entry's fate is `_reconcile_blocked_after`'s alone
+      to decide, from the ``after=`` graph, on this or a later tick. Checked
+      — and returned from — before :func:`_blocked_gate_reading` even runs,
+      specifically so :func:`_reconcile_blocked_unreadable` never gets the
+      chance to overwrite `last_reason` with a merge-gate "could not read"
+      sentence and clobber the one marker `_reconcile_blocked_after` needs
+      to recognise this row again next tick — see #2935 for the incident a
+      missing version of this branch caused;
     * there is no evidence either way (:func:`_blocked_gate_reading` returns
       ``None``) AND :func:`_reconcile_blocked_unreadable` also has nothing
-      to add — an entry that never reached the merge queue at all (a
-      dispatch-time failure, an unsatisfiable ``after=``) has nothing this
-      sweep can cheaply re-check, and guessing would be exactly the "worse
-      than nothing" sweep the issue warns a naive "retry everything" pass
-      would be;
+      to add — a dispatch-time failure (#2589's two per-run shapes) has
+      nothing this sweep can cheaply re-check, and guessing would be
+      exactly the "worse than nothing" sweep the issue warns a naive
+      "retry everything" pass would be;
     * the gate is CONFIRMED still shut — the common, honest outcome for a
       `blocked` entry that has not in fact recovered yet.
 
@@ -3801,6 +3812,58 @@ def _reconcile_blocked(
     """
     if is_permanent_block_reason(entry.last_reason):
         return None
+    if _is_unsatisfiable_prereq_reason(entry.last_reason):
+        # #2935: this entry's ONLY `blocked` cause is `_resolve_prereqs`'s
+        # own after= verdict (step 4's launch walk, or its #2362/#2756
+        # sibling `_reconcile_blocked_after`, called immediately before this
+        # function in the same per-tick loop) — a `waiting` entry that never
+        # reached `running` at all (see `_resolve_prereqs`'s own comment:
+        # "attempts is deliberately NOT incremented: nothing was ever
+        # launched for this entry"). A never-dispatched entry has no
+        # assignment and no branch, so there is no merge-queue row for
+        # #2230's gate sweep to have ANY opinion about — a merge gate cannot
+        # exist for something that was never built, and probing for one
+        # anyway is a category error, not a failed probe.
+        #
+        # This must be checked BEFORE `_blocked_gate_reading`/
+        # `_reconcile_blocked_unreadable` below, not folded into their "no
+        # evidence" handling: `_reconcile_blocked_unreadable` WRITES
+        # `last_reason` the instant the shell's live probe was attempted and
+        # came back with no key (`live_blocked_unreadable`) — and doing that
+        # here would CLOBBER this exact marker text, which is the ONLY
+        # signal `_reconcile_blocked_after` uses (both here and on every
+        # future tick) to recognise this row as an after=-caused block worth
+        # re-diagnosing at all. The claude-coordinator#2935 incident: five
+        # dependents whose prerequisite had already landed stayed `blocked`
+        # for 178-207 consecutive ticks apiece, because the FIRST tick after
+        # they became re-evaluable this way overwrote their own "will never
+        # satisfy"/"not queued, not merged and not open" text with this
+        # sweep's "no merge-queue row ... could not be read" sentence —
+        # after which `_reconcile_blocked_after`'s guard could never
+        # recognise the row again, even once the prerequisite genuinely
+        # landed. Bailing out here, before any write, keeps the marker
+        # intact for as many ticks as it takes the after= graph to actually
+        # clear — the entry's fate stays entirely `_reconcile_blocked_
+        # after`'s to decide, exactly as the issue's "Expected behaviour"
+        # asks: answered from the after= graph, never from a merge-gate
+        # probe.
+        #
+        # Deliberately a text match on the SAME two verdict shapes
+        # `_reconcile_blocked_after` itself already trusts to gate its own
+        # resume — not the #2589/#2635 per-run dispatch markers
+        # (`is_dispatch_failure_reason`/`is_empty_branch_death_reason`),
+        # which stay OUT of this function on purpose (see
+        # `test_a_pre_dispatch_reason_text_does_not_suppress_a_real_
+        # unreadable_note`): those two describe what ONE launch attempt
+        # dispatched, which can go stale the moment an earlier attempt on
+        # the SAME entry left real evidence behind, so only the shell's live
+        # re-check (`live_blocked_unreadable`) is trusted to suppress them.
+        # `_resolve_prereqs`'s unsatisfiable verdict carries no such
+        # per-run ambiguity: it is only ever written for a `waiting` entry
+        # that has NEVER reached `running`, so the "nothing was ever
+        # dispatched" reading it encodes cannot be contradicted by an
+        # earlier attempt the way a per-run marker can.
+        return None
     reading = _blocked_gate_reading(entry, facts, live_blocked_gate)
     if reading is None:
         return _reconcile_blocked_unreadable(entry, live_blocked_unreadable)

{code_coordinator-0.5.295 → 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.295 → 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.295 → code_coordinator-0.5.297}/tests/test_drive_queue.py

@@ -3355,6 +3355,105 @@ def test_a_blocked_entry_that_has_hit_the_resume_ceiling_stays_blocked_and_says_
     assert plan.launch is None
 
 
+# ── #2935: a never-dispatched after=-blocked entry must never reach the ────
+# merge-gate sweep at all
+#
+# claude-coordinator#2935: a `waiting` entry blocked by `_resolve_prereqs`'s
+# own unsatisfiable `after=` verdict has no assignment and no branch — there
+# is categorically no merge-queue row for #2230's sweep to have an opinion
+# about, "unreadable" or otherwise. Before this fix, `_reconcile_blocked`
+# never special-cased this shape: it fell through to `_blocked_gate_reading`
+# (which correctly finds no evidence) and then to `_reconcile_blocked_
+# unreadable`, which — whenever the shell's live probe had actually been
+# attempted (`live_blocked_unreadable` carrying a note, exactly what
+# `coord.commands.drive_queue._fetch_live_blocked_gate`'s #2806 self-heal
+# produces for a row with no merge-queue row) — WROTE `last_reason` to a
+# "could not be read" sentence. That overwrite destroyed the only marker
+# `_reconcile_blocked_after` uses to recognise this row as after=-caused at
+# all, so every later tick — even long after the prerequisite landed — took
+# the SAME "no evidence, probe unreadable" branch forever: a permanent
+# block, never resumed. These pin the fix: the merge-gate sweep must bail
+# out before ever consulting `live_blocked_unreadable` for this shape, and
+# the entry must still resume once its prereq actually lands.
+
+
+def test_a_never_dispatched_after_blocked_entry_never_reports_gate_unreadable():
+    """The shell's live probe (a real `live_blocked_unreadable` note, the
+    exact shape `_fetch_live_blocked_gate` emits for a row with no
+    merge-queue row) must not produce a `gate_unreadable` reconcile — or any
+    write at all — for an entry whose only cause is an unsatisfiable
+    `after=` verdict with its prereq still not landed."""
+    dep_key = entry_key(REPO, 2897)
+    entries = [
+        entry(2897, position=0, state=STATE_BLOCKED),
+        _blocked_entry(
+            2899,
+            position=1,
+            after=(dep_key,),
+            last_reason=f"pre-req {dep_key} is queued but blocked — it will never satisfy",
+        ),
+    ]
+    plan = plan_tick(
+        entries,
+        board(),
+        capacity=1,
+        live_blocked_gate={},
+        live_blocked_unreadable={
+            entry_key(REPO, 2899): "no merge-queue row for this entry, even "
+            "after the self-heal enqueue attempt"
+        },
+    )
+    assert plan.reconciles == ()
+    assert plan.launch is None
+
+
+def test_a_never_dispatched_after_blocked_entry_still_resumes_once_its_prereq_lands():
+    """End-to-end regression for the #2935 incident: a tick where the
+    prereq has NOT yet landed and the shell's probe comes back unreadable
+    must leave `last_reason` untouched (nothing in `plan.reconciles` to
+    write) — so a LATER tick, once the prereq lands, still recognises the
+    original marker and resumes normally, exactly as it would have if the
+    spurious probe had never run."""
+    dep_key = entry_key(REPO, 2897)
+    blocked_dep = entry(2897, position=0, state=STATE_BLOCKED)
+    dependent = _blocked_entry(
+        2899,
+        position=1,
+        after=(dep_key,),
+        resumes=0,
+        last_reason=f"pre-req {dep_key} is queued but blocked — it will never satisfy",
+    )
+
+    # Tick 1: prereq still blocked, shell's probe comes back unreadable —
+    # must be a total no-op (the #2935 fix).
+    tick1 = plan_tick(
+        [blocked_dep, dependent],
+        board(),
+        capacity=1,
+        live_blocked_gate={},
+        live_blocked_unreadable={
+            entry_key(REPO, 2899): "no merge-queue row for this entry, even "
+            "after the self-heal enqueue attempt"
+        },
+    )
+    assert tick1.reconciles == ()
+
+    # Tick 2: the prereq has since landed. `dependent`'s `last_reason` is
+    # STILL the original unsatisfiable-prereq marker — untouched by tick 1 —
+    # so `_reconcile_blocked_after` recognises it and resumes it, even
+    # though a merge-gate probe against it failed in between.
+    tick2 = plan_tick(
+        [entry(2897, position=0, state=STATE_DONE), dependent],
+        board(merged=(2897,)),
+        capacity=1,
+    )
+    reconcile = next(r for r in tick2.reconciles if r.key == entry_key(REPO, 2899))
+    assert reconcile.outcome == "resumed"
+    assert reconcile.updates["state"] == STATE_WAITING
+    assert reconcile.updates["attempts"] == 0
+    assert tick2.launch is not None and tick2.launch.issue == 2899
+
+
 # ── #2362: a blocked entry resumes once its unsatisfiable after= lands ─────
 #
 # `_resolve_prereqs` blocks a `waiting` entry the instant one of its named