code-coordinator 0.5.53__tar.gz → 0.5.55__tar.gz

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/.github/workflows/test.yml

@@ -115,6 +115,55 @@ jobs:
       - run: pip install -e ".[dev]"
       - run: scripts/run_tests_without_gh.sh python -m pytest tests/ -q
 
+  # #2170: run the full suite in the environment of a REAL FLEET MACHINE — a
+  # populated `~/.coord/` (thin-client shaped), no `sqlite3` on PATH, and a
+  # `$TMPDIR` under an ancestor pytest config.
+  #
+  # This job exists because the `test` matrix above is structurally incapable
+  # of catching the class it covers. Six tests failed on `origin/main` on every
+  # fleet machine while `ubuntu-latest` stayed green on 3.12 AND 3.13 — the
+  # INVERSE of the familiar "passes locally, fails only in CI ⇒ ambient $HOME"
+  # pattern. They passed in CI *precisely because* CI's `$HOME` is empty, and a
+  # matrix whose only environment is the empty one can never see that.
+  #
+  # What it cost while invisible: the Test stage on `precision` could not
+  # produce a green verdict for this repo on ANY branch. Every dispatch there
+  # returned `SMOKE: fail`, the branch was blamed for breakage it did not
+  # cause, and a human read the log and adjudicated — 11m36s and $0.61 for zero
+  # signal about the branch, repeatedly, for months (claude-coordinator#2158).
+  #
+  # SAME SHAPE AS `no-gh-on-path` ABOVE, AND FOR THE SAME REASON. That job
+  # (#1484) exists because a host-dependent `gh` made the suite's result depend
+  # on the machine rather than the code; this one exists because a
+  # host-dependent `$HOME`/`$PATH`/`$TMPDIR` did the same thing in the opposite
+  # direction. Both mask by NAME rather than by dropping PATH directories — see
+  # `scripts/run_tests_in_populated_home.sh`'s header for why
+  # `PATH=/usr/bin:/bin` is the wrong recipe here.
+  #
+  # `tests/test_ambient_home_isolation.py` pins the specific affected targets
+  # on every run everywhere (including this job, and including a fleet
+  # machine's own Test leg) — that is the always-on gate, and it is what fails
+  # first if one of the three regresses. THIS job is the whole-suite sweep: it
+  # is what finds the NEXT test of this class before a fleet machine does.
+  # Verified at authoring time: 9590 passed, 13 skipped under these three knobs.
+  populated-home:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[dev]"
+      - run: scripts/run_tests_in_populated_home.sh python -m pytest tests/ -q
+      - name: What a red result here means
+        if: failure()
+        run: |
+          echo "::error::The suite is red under a POPULATED \$HOME (thin-client ~/.coord/, no sqlite3 on PATH, \$TMPDIR under an ancestor pytest config) while the plain 'test' job may well be green."
+          echo "That difference IS the finding, not noise: a test that needs an empty \$HOME cannot pass on any fleet machine, so the Test stage there can never go green and every dispatch costs a human adjudication (#2170)."
+          echo "Fix the TEST's isolation -- redirect \$HOME/XDG at tmp_path, drop COORD_SERVICE_URL/COORD_TOKEN/COORD_CONFIG, skip-guard an unprovisioned system binary, pin a nested pytest's --rootdir."
+          echo "Do NOT fix it by making the product trust an ambient path: 'coord config --config' is deliberately NOT authoritative on a thin client (CLAUDE.md, docs/EPHEMERAL_WORKERS.md)."
+          echo "Reproduce locally: scripts/run_tests_in_populated_home.sh python -m pytest tests/ -q"
+
   # #906: run the test suite in thin-client mode with COORD_STRICT_LOCAL_BOARD=1
   # so any board touch reachable from a thin-client path raises RuntimeError
   # instead of silently no-oping against an empty local DB.  This job catches

{code_coordinator-0.5.53/code_coordinator.egg-info → code_coordinator-0.5.55}/PKG-INFO

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

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

@@ -385,6 +385,7 @@ scripts/coord-test-runner.sh
 scripts/drive-batch.sh
 scripts/gen_board_fixture.py
 scripts/next_release_tag.py
+scripts/run_tests_in_populated_home.sh
 scripts/run_tests_without_gh.sh
 scripts/smoke_437_interactive.py
 scripts/verify_878_review_capture.py
@@ -425,6 +426,7 @@ tests/test_agent_update.py
 tests/test_agent_update_bluegreen.py
 tests/test_agent_usage_limit.py
 tests/test_agent_zero_commit.py
+tests/test_ambient_home_isolation.py
 tests/test_approve_reject_plan.py
 tests/test_approve_usage_gate.py
 tests/test_assignment_already_recorded_daemon.py
@@ -513,6 +515,7 @@ tests/test_config_usage_gate.py
 tests/test_conflict_fix.py
 tests/test_conflict_fix_semantic.py
 tests/test_coord_test.py
+tests/test_coord_test_runner_baseline.py
 tests/test_coord_test_runner_routing.py
 tests/test_coord_test_runner_toolchain.py
 tests/test_coord_web_sse_restart_live.py

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/code_coordinator.egg-info/scm_file_list.json

@@ -375,6 +375,7 @@
     "scripts/drive-batch.sh",
     "scripts/gen_board_fixture.py",
     "scripts/next_release_tag.py",
+    "scripts/run_tests_in_populated_home.sh",
     "scripts/run_tests_without_gh.sh",
     "scripts/smoke_437_interactive.py",
     "scripts/verify_878_review_capture.py",
@@ -455,6 +456,7 @@
     "tests/test_agent_update_bluegreen.py",
     "tests/test_agent_usage_limit.py",
     "tests/test_agent_zero_commit.py",
+    "tests/test_ambient_home_isolation.py",
     "tests/test_approve_reject_plan.py",
     "tests/test_approve_usage_gate.py",
     "tests/test_assignment_already_recorded_daemon.py",
@@ -543,6 +545,7 @@
     "tests/test_conflict_fix.py",
     "tests/test_conflict_fix_semantic.py",
     "tests/test_coord_test.py",
+    "tests/test_coord_test_runner_baseline.py",
     "tests/test_coord_test_runner_routing.py",
     "tests/test_coord_test_runner_toolchain.py",
     "tests/test_coord_web_sse_restart_live.py",

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/code_coordinator.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.53",
+  "tag": "0.5.55",
   "distance": 0,
-  "node": "gfdb2b81a9b6878d9dd5c755ea92fbc5de7839f21",
+  "node": "g20ff70836aa359817f5f585fff5a5b9a075bb022",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-13"

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/coord/commands/test_gate.py

@@ -649,8 +649,40 @@ def test(assignment_id: str, config_path: Path, verdict: str | None, reason: str
 
     if repo and repo.test_command:
         click.echo(f"Running tests: {repo.test_command}")
-        result = subprocess.run(repo.test_command, shell=True, cwd=str(wt_path))
+        # #2170: capture (stdout+stderr merged, same as an unpiped terminal
+        # would show) so a failure can be checked for the runner's `RESULT:
+        # BASELINE-RED` marker below — a failure the runner itself has
+        # already confirmed also reproduces on the merge-base is a
+        # statement about THIS MACHINE, not this branch, and must not be
+        # nudged towards `coord test --fail`. Relayed to the terminal after
+        # the run finishes rather than streamed live — the trade-off that
+        # buys the marker check `subprocess.run` (not `Popen`) keeps this
+        # call mockable exactly like every other one in this function.
+        result = subprocess.run(
+            repo.test_command, shell=True, cwd=str(wt_path),
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+        )
+        if result.stdout:
+            click.echo(result.stdout, nl=False)
         if result.returncode != 0:
+            from coord.revalidate import is_baseline_red_failure  # noqa: PLC0415
+
+            if is_baseline_red_failure(result.returncode, result.stdout or ""):
+                click.echo(
+                    f"\nTests failed (exit {result.returncode}) — but the "
+                    "runner already confirmed every failure reproduces "
+                    "identically on the merge-base (#2170): this machine's "
+                    "BASELINE is red, not this branch.",
+                    err=True,
+                )
+                click.echo(f"  worktree kept for inspection: {wt_path}")
+                click.echo(
+                    "  run: coord test --skipped "
+                    f"{assignment_id} --reason \"baseline-red (#2170): "
+                    "pre-existing failures on this machine\"   "
+                    "# NOT --fail — the branch made nothing worse"
+                )
+                sys.exit(1)
             click.echo(f"Tests failed (exit {result.returncode})", err=True)
             click.echo(f"  worktree kept for inspection: {wt_path}")
             sys.exit(1)

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/coord/notify.py

@@ -1705,6 +1705,50 @@ def _capture_smoke_tests(transition: Transition, entry: dict) -> None:
         )
 
 
+def _smoke_baseline_red_reason(transition: Transition, entry: dict) -> str | None:
+    """#2170: look for a `SMOKE: baseline-red <reason>` line in the smoke
+    worker's transcript and return its reason text, or ``None`` if absent.
+
+    Same local-log-first, agent-endpoint-fallback discipline as
+    :func:`_capture_smoke_tests` — this is read-only (nothing persisted here;
+    the caller decides what to do with the reason), and best-effort: any
+    lookup failure is logged and treated as "no baseline-red line found",
+    which routes the caller to the ordinary `failed` verdict rather than
+    silently swallowing a genuine branch failure.
+    """
+    from coord.progress import (  # noqa: PLC0415
+        parse_smoke_baseline_red_from_agent,
+        parse_smoke_baseline_red_from_log,
+    )
+
+    reason: str | None = None
+    log_path = entry.get("log_path")
+    if log_path:
+        try:
+            reason = parse_smoke_baseline_red_from_log(Path(log_path))
+        except Exception as exc:  # noqa: BLE001
+            log.debug(
+                "_smoke_baseline_red_reason: failed to parse local log for %s: %s",
+                transition.assignment_id, exc,
+            )
+
+    if reason is None:
+        host = _agent_host(transition.machine_name)
+        if host:
+            try:
+                reason = parse_smoke_baseline_red_from_agent(
+                    host, transition.assignment_id
+                )
+            except Exception as exc:  # noqa: BLE001
+                log.debug(
+                    "_smoke_baseline_red_reason: failed to fetch from agent "
+                    "%s for %s: %s",
+                    host, transition.assignment_id, exc,
+                )
+
+    return reason
+
+
 def _capture_cost(transition: Transition, entry: dict, record: dict | None = None) -> None:
     """#208/#546: parse the worker's final cost+tokens and persist them.
 
@@ -2332,17 +2376,52 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 transition.repo_name, transition.issue_number
             )
             if test_mode != "smoke":
-                succeeded = (transition.exit_code or 0) == 0
-                # #1384: no `smoke_test=` argument needed — the writer
-                # (`state._record_test_verdict_local`) derives the legacy
-                # mirror from `test_state`, so a headless smoke FAILURE lands
-                # as test_state='failed' AND smoke_test='fail' and stays
-                # reachable from `coord fix`.
-                record_test_verdict(
-                    assignment_id=parent_id,
-                    test_state="passed" if succeeded else "failed",
-                    test_reason="headless smoke",
-                )
+                exit_code = transition.exit_code or 0
+                if exit_code == 0:
+                    record_test_verdict(
+                        assignment_id=parent_id,
+                        test_state="passed",
+                        test_reason="headless smoke",
+                    )
+                else:
+                    # #2170: a non-zero smoke exit is not automatically the
+                    # branch's fault — check whether the dispatched agent
+                    # reported that the machine's own BASELINE is red (every
+                    # failure reproduces identically on the merge-base; see
+                    # `SMOKE_SYSTEM_PROMPT` step 4 in `coord.smoke`). The
+                    # marker is the signal, not the exit code, mirroring
+                    # `coord.revalidate.is_baseline_red_failure`'s discipline
+                    # — an arbitrary non-zero exit proves nothing on its own.
+                    baseline_red_reason = _smoke_baseline_red_reason(
+                        transition, entry
+                    )
+                    if baseline_red_reason is not None:
+                        # `skipped`, not `failed`: the merge gate treats a
+                        # skipped Test stage as satisfied, and neither
+                        # `coord fix` nor `coord drive` burns an attempt on
+                        # breakage this branch did not cause.
+                        record_test_verdict(
+                            assignment_id=parent_id,
+                            test_state="skipped",
+                            test_reason=(
+                                f"baseline-red (#2170): {baseline_red_reason}"
+                                if baseline_red_reason
+                                else "baseline-red (#2170): every failure "
+                                "reproduces identically on the merge-base"
+                            ),
+                        )
+                    else:
+                        # #1384: no `smoke_test=` argument needed — the
+                        # writer (`state._record_test_verdict_local`)
+                        # derives the legacy mirror from `test_state`, so a
+                        # headless smoke FAILURE lands as
+                        # test_state='failed' AND smoke_test='fail' and
+                        # stays reachable from `coord fix`.
+                        record_test_verdict(
+                            assignment_id=parent_id,
+                            test_state="failed",
+                            test_reason="headless smoke",
+                        )
     elif transition.event == EVENT_FAILURE and assignment_type == "smoke":
         # #1605: the Test-stage WORKER itself died (a dead agent, a killed
         # process group, a terminal API error — anything short of the

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/coord/progress.py

@@ -46,6 +46,17 @@ _SMOKE_NONE_RE = re.compile(
 )
 _SMOKE_BULLET_RE = re.compile(r"^\s*[-*]\s+(.+?)\s*$")
 
+# #2170: the headless Test-stage smoke agent (`coord.smoke.SMOKE_SYSTEM_PROMPT`)
+# prints this line instead of `SMOKE: fail` when the smoke command's own
+# failures reproduce identically on the merge-base — a red BASELINE, not a
+# branch failure. Line-anchored, mirroring `coord.revalidate`'s
+# `is_baseline_red_failure` marker discipline: never a bare substring search,
+# so an unrelated line that merely mentions "SMOKE: baseline-red" mid-sentence
+# doesn't false-positive.
+_SMOKE_BASELINE_RED_RE = re.compile(
+    r"^SMOKE:\s*baseline-red[ \t]*(.*)$", re.MULTILINE | re.IGNORECASE,
+)
+
 
 @dataclass
 class WorkerProgress:
@@ -411,6 +422,112 @@ def parse_completion_summary_from_agent(
     return _extract_completion_summary_from_text(text)
 
 
+def _extract_smoke_baseline_red_from_text(text: str) -> str | None:
+    """#2170: pull the last `SMOKE: baseline-red <reason>` line out of *text*.
+
+    Returns the reason string (possibly ``""`` if the agent gave none), or
+    ``None`` if no such line is present — the same "None means absent"
+    contract as :func:`_extract_completion_summary_from_text`. Picks the LAST
+    match, matching every other block-extraction parser in this module, in
+    case the agent restates its verdict.
+    """
+    matches = list(_SMOKE_BASELINE_RED_RE.finditer(text))
+    if not matches:
+        return None
+    return matches[-1].group(1).strip()
+
+
+def parse_smoke_baseline_red_from_log(
+    log_path: str | Path, tail_bytes: int = 65_536,
+) -> str | None:
+    """#2170: read the tail of *log_path* and extract a `SMOKE: baseline-red`
+    verdict line, if the worker printed one.
+
+    Handles both stream-json logs (decodes assistant text events first) and
+    legacy plain-text logs, exactly like :func:`parse_smoke_tests_from_log`.
+    """
+    p = Path(log_path)
+    if not p.exists():
+        return None
+
+    from coord.worker_events import is_stream_json  # noqa: PLC0415
+
+    if is_stream_json(p):
+        from coord.worker_events import _assistant_text, parse_event  # noqa: PLC0415
+        texts: list[str] = []
+        try:
+            with open(p, encoding="utf-8", errors="replace") as f:
+                for line in f:
+                    event = parse_event(line.rstrip("\n"))
+                    if event is None or event.type != "assistant":
+                        continue
+                    t = _assistant_text(event)
+                    if t:
+                        texts.append(t)
+        except OSError:
+            return None
+        return _extract_smoke_baseline_red_from_text("\n".join(texts))
+
+    try:
+        size = p.stat().st_size
+        with open(p, encoding="utf-8", errors="replace") as f:
+            if size > tail_bytes:
+                f.seek(size - tail_bytes)
+                f.readline()  # skip partial line
+            text = f.read()
+    except OSError:
+        return None
+    return _extract_smoke_baseline_red_from_text(text)
+
+
+def parse_smoke_baseline_red_from_agent(
+    host: str,
+    assignment_id: str,
+    port: int = 7433,
+    timeout: float = 15.0,
+) -> str | None:
+    """#2170: fetch a worker's log via the agent's ``/logs/<id>`` endpoint and
+    extract a `SMOKE: baseline-red` verdict line.
+
+    Use this instead of :func:`parse_smoke_baseline_red_from_log` when the
+    worker ran on a remote agent and the log isn't on the coordinator's local
+    filesystem. Mirrors :func:`parse_smoke_tests_from_agent`.
+    """
+    import httpx  # noqa: PLC0415
+
+    url = f"http://{host}:{port}/logs/{assignment_id}"
+    try:
+        resp = httpx.get(url, timeout=timeout)
+        resp.raise_for_status()
+        text = resp.text
+    except (httpx.HTTPError, httpx.TimeoutException):
+        return None
+    if not text:
+        return None
+
+    stream_json = False
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#"):
+            continue
+        stream_json = stripped.startswith("{")
+        break
+
+    if stream_json:
+        from coord.worker_events import _assistant_text, parse_event  # noqa: PLC0415
+        decoded: list[str] = []
+        for line in text.splitlines():
+            event = parse_event(line.rstrip("\n"))
+            if event is None or event.type != "assistant":
+                continue
+            t = _assistant_text(event)
+            if t:
+                decoded.append(t)
+        return _extract_smoke_baseline_red_from_text("\n".join(decoded))
+
+    return _extract_smoke_baseline_red_from_text(text)
+
+
 def _detect_warnings(progress: WorkerProgress, all_updates: list[str]) -> None:
     if progress.stuck:
         progress.warnings.append("worker is STUCK and waiting for guidance")

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/coord/revalidate.py

@@ -193,6 +193,12 @@ KIND_BUILD = "build"
 KIND_SUITE = "suite"
 KIND_TIMEOUT = "timeout"
 KIND_INFRA = "infra"
+#: The suite RAN and failed, but identically on the merge-base (#2170) — so it
+#: is a statement about the machine's baseline, not about any branch. Distinct
+#: from :data:`KIND_INFRA` (where the suite never ran at all) and from
+#: :data:`KIND_SUITE` (where the branch broke something): the operator action is
+#: "fix the baseline", not "fix the runner environment" or "fix the branch".
+KIND_BASELINE_RED = "baseline_red"
 
 #: Composite failure kinds a per-entry pass can actually narrow (#1715).
 NARROWABLE_KINDS = frozenset({
@@ -221,6 +227,20 @@ SHELL_NOT_FOUND_EXIT = 127
 #: relabel real red builds as infrastructure — the dangerous direction.
 INFRA_OUTPUT_MARKERS = ("TOOLCHAIN MISSING", "RESULT: INFRA")
 
+#: What ``coord-test-runner.sh`` prints when every failure in a suite reproduces
+#: on the merge-base (#2170), and the exit code it pairs with it.
+#:
+#: Same "the marker, not the number" discipline as :data:`INFRA_OUTPUT_MARKERS`
+#: above, and the same line-start anchoring: an arbitrary repo's command is free
+#: to exit 4 for a real failure (pytest itself uses 4 for a usage error), so the
+#: number alone must never be enough to excuse a red suite.
+BASELINE_RED_OUTPUT_MARKER = "RESULT: BASELINE-RED"
+
+#: Exit code ``scripts/coord-test-runner.sh`` reserves for baseline-red.
+#: Documented, and — like :data:`RUNNER_INFRA_EXIT` — deliberately not trusted
+#: on its own.
+RUNNER_BASELINE_RED_EXIT = 4
+
 
 def is_infrastructure_failure(returncode: int, output: str) -> bool:
     """True when a build/test command never actually ran the suite (#1814).
@@ -270,6 +290,53 @@ def is_infrastructure_failure(returncode: int, output: str) -> bool:
     )
 
 
+def is_baseline_red_failure(returncode: int, output: str) -> bool:
+    """True when a test command failed but every failure also fails on the
+    merge-base (#2170) — i.e. the machine's baseline is red.
+
+    ONE signal only, and it is the runner's own explicit statement: a
+    :data:`BASELINE_RED_OUTPUT_MARKER` line. :data:`RUNNER_BASELINE_RED_EXIT` is
+    NOT a signal on its own, for the same reason exit 3 isn't for infrastructure
+    — an arbitrary repo's `test_command` may exit 4 for a perfectly genuine
+    failure (pytest's own usage-error code is 4), and keying on the number would
+    relabel real red suites as "not the branch's fault". That is the dangerous
+    direction: it is the one that could eventually launder a regression into a
+    merge, so it must require the runner to have said so in words.
+
+    Line-anchored rather than a bare substring search, exactly as
+    :func:`is_infrastructure_failure` documents at length: for this repo the
+    ``test_command`` IS that runner's pytest arm, so the suite contains tests
+    (``tests/test_coord_test_runner_baseline.py``, and this module's own) whose
+    assertion text and parametrize ids embed this marker verbatim. Those only
+    ever appear indented (``E   ``/spaces) or prefixed (``FAILED ``), never at
+    the start of a line.
+
+    ``returncode`` is accepted and ignored for signature symmetry with
+    :func:`is_infrastructure_failure`; callers pass what they have.
+    """
+    lines = (output or "").splitlines()
+    return any(line.startswith(BASELINE_RED_OUTPUT_MARKER) for line in lines)
+
+
+def _baseline_red_reason(stage: str, returncode: int) -> str:
+    """Operator-facing wording for a red baseline (#2170).
+
+    Must not say "SUITE FAILED" (the operator would debug a branch that is
+    fine), must not say "could not run" (it ran, and told us something), and
+    must name the BASELINE as the thing to fix. The failure that motivated it
+    read as a branch problem for months and was not one.
+    """
+    return (
+        f"revalidation reports a RED BASELINE — the {stage} command failed "
+        f"(exit {returncode}), but every failure reproduces on the merge-base "
+        "in this environment, so the branches made nothing worse and NONE of "
+        "them was judged. Nothing merged, nothing marked failed, no verdict "
+        "changed. Fix the baseline (or this machine's environment) and re-run: "
+        "a machine whose suite cannot go green cannot produce a Test verdict "
+        "for any branch (#2170)"
+    )
+
+
 @dataclass
 class RevalidationResult:
     """Outcome of one composite revalidation run.
@@ -698,12 +765,21 @@ def revalidate(
         if built.returncode != 0:
             build_output = (built.stdout or "") + "\n" + (built.stderr or "")
             infra = is_infrastructure_failure(built.returncode, build_output)
+            baseline_red = not infra and is_baseline_red_failure(
+                built.returncode, build_output
+            )
             return RevalidationResult(
                 ok=False,
-                kind=KIND_INFRA if infra else KIND_BUILD,
+                kind=(
+                    KIND_INFRA if infra
+                    else KIND_BASELINE_RED if baseline_red
+                    else KIND_BUILD
+                ),
                 reason=(
                     _infra_reason("build", built.returncode)
                     if infra
+                    else _baseline_red_reason("build", built.returncode)
+                    if baseline_red
                     else (
                         "revalidation BUILD FAILED against the current base "
                         f"(exit {built.returncode}) — every candidate stays "
@@ -729,12 +805,21 @@ def revalidate(
     if tested.returncode != 0:
         test_output = (tested.stdout or "") + "\n" + (tested.stderr or "")
         infra = is_infrastructure_failure(tested.returncode, test_output)
+        baseline_red = not infra and is_baseline_red_failure(
+            tested.returncode, test_output
+        )
         return RevalidationResult(
             ok=False,
-            kind=KIND_INFRA if infra else KIND_SUITE,
+            kind=(
+                KIND_INFRA if infra
+                else KIND_BASELINE_RED if baseline_red
+                else KIND_SUITE
+            ),
             reason=(
                 _infra_reason("suite", tested.returncode)
                 if infra
+                else _baseline_red_reason("suite", tested.returncode)
+                if baseline_red
                 else (
                     "revalidation SUITE FAILED against the current base "
                     f"(exit {tested.returncode}) — every candidate stays "
@@ -983,6 +1068,19 @@ def format_batch(batch: BatchRevalidationResult) -> list[str]:
         )
         return lines
 
+    if batch.composite.kind == KIND_BASELINE_RED:
+        # #2170: the OTHER failure mode that is not about the branches. Same
+        # stdout-as-well-as-stderr treatment as INFRA above and for the same
+        # reason — but a different instruction, because the fix is in the
+        # baseline (or this machine's environment), not the runner's toolchain.
+        lines.append(
+            "  --revalidate: RED BASELINE — the suite failed, but identically "
+            "on the merge-base, so no branch was judged. Nothing merged, "
+            "nothing marked failed, no verdict changed; every candidate is "
+            "exactly as it was. Fix the baseline, then re-run --revalidate."
+        )
+        return lines
+
     if not batch.fell_back:
         return lines
 
@@ -1075,6 +1173,7 @@ __all__ = [
     "DEFAULT_TIMEOUT_SECONDS",
     "KIND_BUILD",
     "KIND_COMPOSE",
+    "KIND_BASELINE_RED",
     "KIND_INFRA",
     "KIND_OK",
     "KIND_SETUP",
@@ -1083,6 +1182,7 @@ __all__ = [
     "MAX_REVALIDATION_BATCH",
     "NARROWABLE_KINDS",
     "NO_SUITE_RAN_KINDS",
+    "RUNNER_BASELINE_RED_EXIT",
     "RUNNER_INFRA_EXIT",
     "SHELL_NOT_FOUND_EXIT",
     "BatchRevalidationResult",
@@ -1093,6 +1193,7 @@ __all__ = [
     "format_batch",
     "format_failure",
     "group_candidates",
+    "is_baseline_red_failure",
     "is_infrastructure_failure",
     "local_repo_dir",
     "revalidate",

{code_coordinator-0.5.53 → code_coordinator-0.5.55}/coord/smoke.py

@@ -57,6 +57,12 @@ from coord import github_ops
 from coord.config import Config, SmokeRule, SmokeTestsConfig
 from coord.dispatch import AGENT_PORT
 from coord.models import WORK_LIKE_TYPES, Assignment, Board, Machine
+# #2170: the SAME marker/exit-code convention `scripts/coord-test-runner.sh`
+# and `coord.revalidate` use for a red baseline — imported (not re-literalled)
+# so the dispatched smoke agent's instructions can never drift from what the
+# runner actually emits, or from what `coord.notify` parses back out of the
+# agent's own transcript (see `_smoke_baseline_red_reason` there).
+from coord.revalidate import BASELINE_RED_OUTPUT_MARKER, RUNNER_BASELINE_RED_EXIT
 
 logger = logging.getLogger("coord.smoke")
 
@@ -75,7 +81,7 @@ logger = logging.getLogger("coord.smoke")
 _TEST_MODE_SKIP_LOGGED: set[str] = set()
 
 
-SMOKE_SYSTEM_PROMPT = """\
+SMOKE_SYSTEM_PROMPT = f"""\
 You are a smoke-test runner dispatched by the coordinator. \
 Your only job: pull the branch, run the smoke command, report pass/fail.
 
@@ -89,8 +95,9 @@ Rules:
 - Do NOT run `gh` commands. The coordinator owns GitHub interactions.
 - You MAY run git, build commands, and test commands.
 - Exit code is what the coordinator reads — exit 0 on pass, non-zero on \
-fail. Print a final line `SMOKE: pass` or `SMOKE: fail <one-line reason>` \
-before exiting so logs are readable.
+fail. Print a final line `SMOKE: pass`, `SMOKE: fail <one-line reason>`, or \
+`SMOKE: baseline-red <one-line reason>` (see step 4) before exiting so logs \
+are readable.
 
 Where you are:
 - You are in a dedicated git worktree created for this run. Every git command \
@@ -105,7 +112,19 @@ Steps:
 briefing) — in your worktree, never in the base checkout.
 2. Run the smoke command from the briefing. Capture stdout/stderr.
 3. If it exits 0 → print `SMOKE: pass` and exit 0.
-4. If it fails → print `SMOKE: fail <short reason>` and exit non-zero.
+4. If it exits {RUNNER_BASELINE_RED_EXIT} AND its output contains a line \
+starting with literal text `{BASELINE_RED_OUTPUT_MARKER}` (#2170) — the smoke \
+command already re-ran its own failures against the merge-base in this same \
+environment and found every one of them fails there too. That is a statement \
+about THIS MACHINE, not the branch: do NOT report it as `SMOKE: fail`, and do \
+NOT report it as `SMOKE: pass` either (that would hide a red baseline). Print \
+`SMOKE: baseline-red <one-line reason>` (reuse the runner's own \
+`{BASELINE_RED_OUTPUT_MARKER}` line as the reason) and exit \
+{RUNNER_BASELINE_RED_EXIT} yourself, matching the smoke command's own exit \
+code.
+5. Otherwise (any other non-zero exit, or a failure with no \
+`{BASELINE_RED_OUTPUT_MARKER}` line) → print `SMOKE: fail <short reason>` and \
+exit non-zero (any code other than 0 or {RUNNER_BASELINE_RED_EXIT}).
 """