code-coordinator 0.5.223__tar.gz → 0.5.225__tar.gz

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.223",
+  "tag": "0.5.225",
   "distance": 0,
-  "node": "g744223e42f4d266aef3954a9aaed09de74827289",
+  "node": "g58cb8cb15dcd2273e9500a56722b2430b3601848",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/coord/confirm_test.py

@@ -333,6 +333,45 @@ class ConfirmationResult:
         return self.kind in INCONCLUSIVE_KINDS
 
 
+def write_confirmation_output(assignment_id: str, result: ConfirmationResult) -> Path | None:
+    """Persist a confirmation run's captured output tail for the fix briefing (#2563).
+
+    ``coord fix`` (:mod:`coord.commands.plan_followup`) already prefers
+    ``COORD_DIR/test_output/<assignment_id>.txt`` over every other evidence
+    source when it composes an escalated fix worker's briefing — `coord test
+    --fail --output` (:mod:`coord.commands.test_gate`) has written it there
+    since #1337. Before this function existed, a #2464 refutation captured
+    ``result.output`` (already bounded to a tail by :func:`_tail` in
+    :func:`_classify_failure` / :func:`_timeout_output`) and then only ever
+    handed it to ``log.warning`` — the fix worker got a one-line reason and no
+    failing test names, no tracebacks, and had to re-derive the diagnosis the
+    daemon already held in memory.
+
+    *assignment_id* is the parent **work** row's id (the one the fix leg is
+    spawned from), not the confirming smoke transition's id — same key
+    :func:`coord.commands.plan_followup.fix` reads back by.
+
+    A no-op, returning ``None``, when there is nothing to write (``KIND_OK``
+    and ``KIND_SETUP`` both carry an empty ``.output`` — the former because
+    nothing failed, the latter because no command ever ran) or when the write
+    itself fails (a read-only ``COORD_DIR``, a full disk, ...); this must
+    never break verdict recording, which is why the caller in
+    :mod:`coord.notify` treats it as best-effort.
+    """
+    if not result.output:
+        return None
+    from coord.state import COORD_DIR  # noqa: PLC0415
+
+    try:
+        test_output_dir = COORD_DIR / "test_output"
+        test_output_dir.mkdir(parents=True, exist_ok=True)
+        stored = test_output_dir / f"{assignment_id}.txt"
+        stored.write_text(result.output)
+    except OSError:
+        return None
+    return stored
+
+
 def confirmation_enabled(config=None) -> bool:
     """Whether Test-stage PASS claims get independently confirmed.
 
@@ -488,6 +527,29 @@ def unmet_confirmation_capabilities(
     return [cap for cap in match_rules(touched, rules) if cap not in have]
 
 
+def _timeout_output(exc: subprocess.TimeoutExpired) -> str:
+    """Partial stdout/stderr captured before a confirmation command timed out.
+
+    ``subprocess.run(..., capture_output=True, timeout=...)`` fills ``.stdout``
+    / ``.stderr`` in on `TimeoutExpired` — the child had already written
+    *something* by the deadline — but the two `except subprocess.TimeoutExpired`
+    arms in :func:`confirm_branch` discarded it entirely, so a TIMEOUT verdict
+    carried strictly less evidence than BASELINE_RED/SIGNAL did even though the
+    same partial output was sitting right there on the exception (#2563).
+    Guards for ``None``/bytes since a test's stand-in *runner* seam may raise a
+    bare ``TimeoutExpired(cmd, timeout)`` with neither attribute set.
+    """
+    out = getattr(exc, "stdout", None) or ""
+    err = getattr(exc, "stderr", None) or ""
+    if isinstance(out, bytes):
+        out = out.decode("utf-8", errors="replace")
+    if isinstance(err, bytes):
+        err = err.decode("utf-8", errors="replace")
+    if not out and not err:
+        return ""
+    return _tail(out + "\n" + err)
+
+
 def _classify_failure(
     stage: str, returncode: int, output: str, worktree: Path, command: str,
 ) -> ConfirmationResult:
@@ -741,7 +803,7 @@ def confirm_branch(
             echo(f"    confirming build: {build_command}")
             try:
                 built = run_cmd(build_command, wt_path, _left())
-            except subprocess.TimeoutExpired:
+            except subprocess.TimeoutExpired as exc:
                 return ConfirmationResult(
                     kind=KIND_TIMEOUT,
                     reason=(
@@ -749,6 +811,7 @@ def confirm_branch(
                         "suite that did not finish says nothing about the "
                         "branch"
                     ),
+                    output=_timeout_output(exc),
                     command=build_command,
                     worktree=wt_path,
                 )
@@ -780,13 +843,14 @@ def confirm_branch(
         echo(f"    confirming tests: {test_command}")
         try:
             tested = run_cmd(test_command, wt_path, _left())
-        except subprocess.TimeoutExpired:
+        except subprocess.TimeoutExpired as exc:
             return ConfirmationResult(
                 kind=KIND_TIMEOUT,
                 reason=(
                     f"confirmation suite timed out after {timeout}s — a "
                     "suite that did not finish says nothing about the branch"
                 ),
+                output=_timeout_output(exc),
                 command=test_command,
                 worktree=wt_path,
             )
@@ -835,4 +899,5 @@ __all__ = [
     "notify_client_timeout_seconds",
     "spend_confirmation_budget",
     "unmet_confirmation_capabilities",
+    "write_confirmation_output",
 ]

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/coord/notify.py

@@ -2011,7 +2011,7 @@ def _run_pass_confirmation(transition: Transition, entry: dict):
 
 
 def _confirmed_pass_verdict(
-    transition: Transition, entry: dict, *, claim_reason: str,
+    transition: Transition, entry: dict, parent_id: str, *, claim_reason: str,
 ) -> tuple[str, str]:
     """#2464: the ``(test_state, test_reason)`` to record for a *claimed* pass.
 
@@ -2033,7 +2033,19 @@ def _confirmed_pass_verdict(
       #2464, with ``UNCONFIRMED`` in the reason so the row says plainly that
       nobody checked. See :mod:`coord.confirm_test` on why a missing toolchain,
       a missing checkout or a timeout must never read as a failing branch.
+
+    #2563: whatever output the run captured — failing node ids, the
+    assertion, tracebacks — is also persisted to *parent_id*'s
+    ``test_output/<id>.txt`` (:func:`coord.confirm_test.write_confirmation_output`)
+    before this returns, so the escalated fix worker's briefing
+    (`coord/commands/plan_followup.py`, which already reads that file ahead of
+    every other evidence source) quotes the real failure instead of the
+    one-line *reason* alone. ``test_reason`` on the row stays exactly that
+    one-line summary — #1337 deliberately keeps unbounded free text out of the
+    board upsert, and this does not undo that; the file is the long form.
     """
+    from coord.confirm_test import write_confirmation_output  # noqa: PLC0415
+
     result = _run_pass_confirmation(transition, entry)
 
     if result is None:
@@ -2044,6 +2056,24 @@ def _confirmed_pass_verdict(
             "(#2464).",
         )
 
+    # Best-effort and unconditional on *kind*: REFUTED/BASELINE-RED/TIMEOUT/
+    # INFRA/SIGNAL all carry a captured tail (`ConfirmationResult.output`) worth
+    # keeping around; CONFIRMED and setup-stage inconclusives carry none, so
+    # this is simply a no-op for them (`write_confirmation_output` checks
+    # `.output` itself, and swallows `OSError`). Wrapped again here — this
+    # runs inside the reap loop, and this whole module's standing rule is that
+    # nothing in it may abandon a transition; a write failure must degrade to
+    # "no file", never to a dropped verdict.
+    try:
+        write_confirmation_output(parent_id, result)
+    except Exception as exc:  # noqa: BLE001
+        log.warning(
+            "smoke %s: could not persist confirmation output for parent %s "
+            "(%s) — the fix briefing will fall back to the one-line reason "
+            "(#2563).",
+            transition.assignment_id, parent_id, exc,
+        )
+
     if result.refuted:
         log.warning(
             "smoke %s: REFUTED the pass claim for %s — %s\n%s",
@@ -2153,7 +2183,7 @@ def _record_smoke_verdict(
             # claim would leave no trace it ever happened — including on the
             # next reap of the same already-passed parent.
             state, reason = _confirmed_pass_verdict(
-                transition, entry,
+                transition, entry, parent_id,
                 claim_reason="worker self-recorded via `coord test` (#2217)",
             )
             record_test_verdict(
@@ -2228,7 +2258,8 @@ def _record_smoke_verdict(
         # never finished polling (#2272/#2301). Confirm it against a real run
         # before it becomes a merge-gate-satisfying verdict.
         state, reason = _confirmed_pass_verdict(
-            transition, entry, claim_reason="headless smoke reported SMOKE: pass",
+            transition, entry, parent_id,
+            claim_reason="headless smoke reported SMOKE: pass",
         )
         record_test_verdict(
             assignment_id=parent_id,

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/scripts/coord-test-runner.sh

@@ -829,6 +829,32 @@ run_python() {
         return $?
     fi
 
+    # #2562: the isolation re-run above is not all-or-nothing evidence — its
+    # own `FAILED ` lines say EXACTLY which node ids survived. Rebuild
+    # $failed from those before doing anything else: a test that dropped out
+    # PASSED in isolation and is by definition the flake case this whole
+    # block exists to catch. Handing the ORIGINAL (unpruned) set to the
+    # baseline comparison below is the bug this closes — one genuine failure
+    # was keeping a flake in the set, and the baseline comparison is itself
+    # all-or-nothing (#2170's unanimity), so the flake alone could suppress a
+    # correct BASELINE-RED downgrade.
+    local still_failed
+    still_failed="$(grep '^FAILED ' "$rerun" | awk '{print $2}' | sort -u || true)"
+    if [[ -z "$still_failed" ]]; then
+        # Non-zero exit but no parseable FAILED lines — e.g. a collection/
+        # import error on the isolated re-run. Nothing to prune against;
+        # fall back to the original set rather than claim a pruning that
+        # did not happen.
+        still_failed="$failed"
+    fi
+    local pruned_count; pruned_count="$(printf '%s\n' "$still_failed" | grep -c . || true)"
+    if [[ "$pruned_count" -lt "$count" ]]; then
+        log "$((count - pruned_count)) of $count failing test(s) passed in isolation — treating as flakes, comparing the remaining $pruned_count against the baseline"
+        FLAKES+=("python:$((count - pruned_count))")
+    fi
+    failed="$still_failed"
+    count="$pruned_count"
+
     # Not a flake. Before calling it the branch's fault, ask the question the
     # Test gate is actually asked: is this worse than $BASE_REF on THIS machine?
     # (#2170 — see the baseline section above for why this only ever downgrades

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/tests/test_confirm_test.py

@@ -299,6 +299,30 @@ class TestConfirmBranch:
         assert result.refuted is False
         assert result.inconclusive is True
 
+    def test_timeout_captures_the_partial_output_before_the_kill(
+        self, checkout: Path
+    ) -> None:
+        """#2563: a timed-out suite still says SOMETHING — whatever it had
+        printed by the deadline. `subprocess.run(capture_output=True,
+        timeout=...)` fills `TimeoutExpired.stdout`/`.stderr` in on the way
+        out; before this, `confirm_branch` discarded both and a TIMEOUT
+        verdict carried strictly less evidence than a real failure did.
+        """
+        runner = _ScriptedRunner(
+            default=subprocess.TimeoutExpired(
+                cmd="run-the-suite", timeout=1,
+                output="tests/test_x.py::test_a PASSED\ntests/test_x.py::test_b ",
+                stderr="Traceback (hung mid-test)",
+            )
+        )
+        result = ct.confirm_branch(
+            "api", BRANCH, _StubConfig(repo_path=str(checkout)), runner=runner,
+        )
+
+        assert result.kind == KIND_TIMEOUT, result.reason
+        assert "test_a PASSED" in result.output
+        assert "Traceback (hung mid-test)" in result.output
+
     def test_signal_killed_suite_is_inconclusive_not_a_refutation(
         self, checkout: Path
     ) -> None:
@@ -592,6 +616,54 @@ class TestConfirmationEnabled:
         assert ct.confirmation_enabled(object()) is True
 
 
+class TestWriteConfirmationOutput:
+    """#2563: the missing write — a confirmation's captured tail must reach
+    ``COORD_DIR/test_output/<assignment_id>.txt``, the same file `coord fix`
+    (`coord/commands/plan_followup.py`) already prefers over every other
+    evidence source when composing an escalated fix worker's briefing.
+    """
+
+    def test_writes_the_output_tail_keyed_by_assignment_id(
+        self, isolated_coord_dir: Path
+    ) -> None:
+        result = ct.ConfirmationResult(
+            kind=KIND_SUITE,
+            reason="the independently-run suite command FAILED (exit 1)",
+            output="tests/test_x.py::test_a FAILED\nE   assert 0 == 1",
+            returncode=1,
+        )
+
+        stored = ct.write_confirmation_output("work-1", result)
+
+        expected = isolated_coord_dir / "test_output" / "work-1.txt"
+        assert stored == expected
+        assert expected.read_text() == result.output
+
+    def test_no_op_when_the_result_carries_no_output(
+        self, isolated_coord_dir: Path
+    ) -> None:
+        """`KIND_OK` (confirmed) and setup-stage inconclusives carry an empty
+        `.output` — nothing to persist, and nothing should be written."""
+        result = ct.ConfirmationResult(kind=KIND_OK, reason="passed", output="")
+
+        stored = ct.write_confirmation_output("work-1", result)
+
+        assert stored is None
+        assert not (isolated_coord_dir / "test_output").exists()
+
+    def test_a_write_failure_returns_none_rather_than_raising(
+        self, isolated_coord_dir: Path
+    ) -> None:
+        """This runs inside the reap path (`coord.notify`) — a read-only
+        `COORD_DIR`, a full disk, or any other `OSError` must degrade to "no
+        file", never abandon the verdict it is attached to."""
+        # A file sitting where the directory needs to go makes `mkdir` raise.
+        (isolated_coord_dir / "test_output").write_text("not a directory")
+        result = ct.ConfirmationResult(kind=KIND_SUITE, reason="x", output="boom")
+
+        assert ct.write_confirmation_output("work-1", result) is None
+
+
 # ── the wiring: end to end through post_transition ───────────────────────────
 
 
@@ -714,6 +786,51 @@ class TestSmokeVerdictIsConfirmed:
             f"guessing: {row['test_reason']!r}"
         )
 
+    def test_refutation_leaves_the_captured_tail_for_the_fix_briefing(
+        self, coord_db, tmp_path: Path, isolated_coord_dir: Path
+    ) -> None:
+        """#2563: before this, `result.output` reached `log.warning` and
+        nowhere else — the escalated fix worker got a one-line reason and no
+        failing test names, no tracebacks. `coord fix`
+        (`coord/commands/plan_followup.py:962`) reads
+        `COORD_DIR/test_output/<parent_work_id>.txt` ahead of every other
+        evidence source, so that is where the captured tail must land — keyed
+        by the WORK row's id (`work-1`), not the confirming smoke
+        transition's (`smoke-1`), since that is the assignment a fix leg is
+        spawned from.
+        """
+        self._record_work()
+        self._record_smoke()
+        transition, record, entry = self._transition(tmp_path, "SMOKE: pass")
+        captured_output = (
+            "tests/test_drive.py::test_a_dead_end_exit_code_reaches_the_"
+            "drive_exited_audit_row FAILED\n"
+            "tests/test_drive.py:2581: in "
+            "test_a_dead_end_exit_code_reaches_the_drive_exited_audit_row\n"
+            "    assert len(escalations) == 1\n"
+            "E   assert 0 == 1"
+        )
+
+        self._reap(
+            transition, record, entry,
+            ct.ConfirmationResult(
+                kind=KIND_SUITE,
+                reason="the independently-run suite command FAILED (exit 1)",
+                output=captured_output,
+                returncode=1,
+            ),
+        )
+
+        stored = isolated_coord_dir / "test_output" / "work-1.txt"
+        assert stored.exists(), (
+            "a refuted pass claim must leave the captured tail at "
+            f"{stored} for `coord fix` to read"
+        )
+        assert stored.read_text() == captured_output
+        # And nothing lands under the smoke leg's OWN id — `coord fix` is
+        # dispatched against the work row, not the smoke transition.
+        assert not (isolated_coord_dir / "test_output" / "smoke-1.txt").exists()
+
     def test_self_recorded_pass_is_overturned_by_a_failing_real_run(
         self, coord_db, tmp_path: Path
     ) -> None:
@@ -850,9 +967,14 @@ class TestSmokeVerdictIsConfirmed:
         )
 
     def test_baseline_red_confirmation_records_skipped(
-        self, coord_db, tmp_path: Path
+        self, coord_db, tmp_path: Path, isolated_coord_dir: Path
     ) -> None:
-        """#2170's convention: not the branch's fault, so no fix round burns."""
+        """#2170's convention: not the branch's fault, so no fix round burns.
+
+        #2563: a `skipped` verdict whose evidence is unreadable is only
+        marginally better than a bare one — the baseline-red tail gets the
+        same test_output-file treatment as a REFUTED one.
+        """
         self._record_work()
         self._record_smoke()
         transition, record, entry = self._transition(tmp_path, "SMOKE: pass")
@@ -860,7 +982,9 @@ class TestSmokeVerdictIsConfirmed:
         self._reap(
             transition, record, entry,
             ct.ConfirmationResult(
-                kind=KIND_BASELINE_RED, reason="every failure reproduces on the base",
+                kind=KIND_BASELINE_RED,
+                reason="every failure reproduces on the base",
+                output="tests/test_x.py::test_a FAILED (also red on main)",
             ),
         )
 
@@ -868,6 +992,8 @@ class TestSmokeVerdictIsConfirmed:
         assert row["test_state"] == "skipped", (
             f"expected 'skipped' for a red baseline, got {row['test_state']!r}"
         )
+        stored = isolated_coord_dir / "test_output" / "work-1.txt"
+        assert stored.read_text() == "tests/test_x.py::test_a FAILED (also red on main)"
 
     def test_a_fail_marker_does_not_spend_a_confirmation_run(
         self, coord_db, tmp_path: Path

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/tests/test_coord_test_runner_baseline.py

@@ -97,6 +97,15 @@ if [[ "$1" == "-m" && "$2" == "pytest" ]]; then
             printf '%s passed\n' "2"
             exit 0
         fi
+        # #2562: a PARTIAL isolation re-run — one node id genuinely still
+        # fails, the rest passed. Distinct from FAKE_RERUN_PASSES (all pass,
+        # exit 0) and from the "no override" default (everything in
+        # FAKE_BRANCH_FAILED fails again, as if isolation changed nothing).
+        if [[ "$_targeted" -eq 1 && -n "${FAKE_RERUN_STILL_FAILING:-}" ]]; then
+            _emit_failed "$FAKE_RERUN_STILL_FAILING"
+            printf '1 failed, 1 passed\n'
+            exit 1
+        fi
         _emit_failed "${FAKE_BRANCH_FAILED:-}"
         printf '2 failed\n'
         exit 1
@@ -393,6 +402,74 @@ def test_a_flake_is_still_a_flake_and_never_consults_the_baseline(repo: Path) ->
     assert "baseline:" not in result.stdout + result.stderr
 
 
+# ── #2562: partial-flake pruning feeds baseline comparison ──────────────────
+#
+# The all-or-nothing bug: `pytest $failed` re-ran the whole failing set
+# together, so ONE genuine failure alongside a flake kept the flake in
+# `$failed` — and that poisoned set then went to `python_baseline_is_red`,
+# itself unanimity-gated, where the flake (which passes on the baseline same
+# as everywhere else) short-circuited a correct BASELINE-RED downgrade. The
+# fix rebuilds `$failed` from the isolation re-run's own `FAILED ` lines
+# before doing anything else with it.
+
+
+def test_mixed_flake_and_genuine_prunes_to_baseline_red(repo: Path) -> None:
+    """{genuine, flake} prunes to {genuine}, and BASELINE-RED fires on just
+    that remainder — the exact CC#2556 shape from the issue: a real flake
+    sitting next to a test that fails identically on the merge-base must not
+    suppress the downgrade.
+    """
+    result = _run(
+        repo,
+        # Isolation re-run: test_one still fails, test_two (the flake) passed
+        # and dropped out.
+        FAKE_RERUN_STILL_FAILING="tests/test_ambient.py::test_one",
+        # Baseline reproduces the one that's left.
+        FAKE_BASELINE_FAILED="tests/test_ambient.py::test_one",
+    )
+
+    assert result.returncode == 4, (result.returncode, result.stdout, result.stderr)
+    assert "RESULT: BASELINE-RED (python)" in result.stdout
+    assert "1 of 2 failing test(s) passed in isolation" in result.stdout
+    assert "comparing the remaining 1 against the baseline" in result.stdout
+    assert "BASELINE-RED(python): all 1 failing test(s) fail identically" in result.stdout
+    # The pruned flake must not appear as part of the (now genuine-only) set.
+    assert "tests/test_ambient.py::test_one" in result.stdout
+    assert "RESULT: FAIL" not in result.stdout
+
+
+def test_mixed_flake_and_genuine_prunes_to_a_smaller_genuine_fail(repo: Path) -> None:
+    """Same pruning, but the remainder is NOT baseline-red: still a FAIL, but
+    for the pruned count and node id only — the reported list must match
+    what actually failed on the isolation re-run, not the original set.
+    """
+    result = _run(
+        repo,
+        FAKE_RERUN_STILL_FAILING="tests/test_ambient.py::test_one",
+        # FAKE_BASELINE_FAILED unset ⇒ baseline is green for test_one too.
+    )
+
+    assert result.returncode == 1
+    assert "RESULT: FAIL (python)" in result.stdout
+    assert "BASELINE-RED" not in result.stdout
+    assert "1 of 2 failing test(s) passed in isolation" in result.stdout
+    assert "FAIL(python): 1 test(s) fail on re-run — genuine" in result.stdout
+    assert "tests/test_ambient.py::test_one" in result.stdout
+    assert "tests/test_ambient.py::test_two" not in (
+        result.stdout.split("FAIL(python): 1 test(s) fail on re-run — genuine")[1]
+    )
+
+
+def test_all_genuine_failing_set_is_unaffected_by_pruning(repo: Path) -> None:
+    """Both failures still fail in isolation ⇒ nothing pruned, and behaviour
+    matches the pre-#2562 baseline-red path exactly (no pruning log line)."""
+    result = _run(repo, FAKE_BASELINE_FAILED=BRANCH_FAILED)
+
+    assert result.returncode == 4
+    assert "RESULT: BASELINE-RED (python)" in result.stdout
+    assert "passed in isolation" not in result.stdout
+
+
 # ── #2180 review fix: the Test stage must agree with CI on tests/acceptance ─
 #
 # Before this fix, `--ignore=tests/acceptance` dropped the sealed cli-pytest

{code_coordinator-0.5.223 → code_coordinator-0.5.225}/tests/test_notify.py

@@ -2689,7 +2689,7 @@ class TestConfirmedPassVerdictSignalKill:
             "coord.notify._run_pass_confirmation", return_value=killed,
         ):
             state, reason = _confirmed_pass_verdict(
-                self._transition(), entry, claim_reason="SMOKE: pass",
+                self._transition(), entry, "work-1", claim_reason="SMOKE: pass",
             )
 
         assert state == "passed", (