code-coordinator 0.5.224__tar.gz → 0.5.226__tar.gz

{code_coordinator-0.5.224 → code_coordinator-0.5.226}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.224",
+  "tag": "0.5.226",
   "distance": 0,
-  "node": "gcb4f4b8b669bb9319880ac1b1b10496b1131b557",
+  "node": "g5d9d29d644034da774ad69d43b80e31f9a89bcfc",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.224 → code_coordinator-0.5.226}/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.224 → code_coordinator-0.5.226}/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.224 → code_coordinator-0.5.226}/coord/reconcile.py

@@ -203,6 +203,7 @@ def reconcile_completed_assignments(
     agent_status_fn=_query_agent,
     update_state_fn=None,
     capture_plan: bool = True,
+    commits_ahead_fn=None,
 ) -> list[dict]:
     """Dispatch-free passive completion reconcile (#625).
 
@@ -275,9 +276,22 @@ def reconcile_completed_assignments(
     The fix is a positive disproof: ``/status`` carries both ``active`` and
     ``completed``, and an id in NEITHER is a statement about the agent's state,
     not an inference from its silence.  Those — and only those — are
-    reconciled, to ``failed`` (never ``done``) with :data:`NO_AGENT_RECORD_
-    REASON`.  See :func:`agent_has_no_record` and
-    :func:`_reconcile_no_agent_record`.
+    reconciled, never to ``done``, with :data:`NO_AGENT_RECORD_REASON`.  See
+    :func:`agent_has_no_record` and :func:`_reconcile_no_agent_record`.
+
+    **#2553 — "the agent forgot" is not "the work is gone".** The arm above
+    used to record ``failed`` unconditionally, but "the agent has no record"
+    is evidence about the agent's memory, not about the work: a
+    :data:`~coord.models.WORK_LIKE_TYPES` row's own ``branch`` is the one
+    artifact in this path that survives an agent restart, a machine reboot,
+    and the 25-entry completion-history cap, and the board row already has
+    its name. :func:`_reconcile_no_agent_record` now consults it
+    (``commits_ahead_fn``, defaulting to :func:`coord.github_ops.
+    branch_commits_ahead_for_assignment`) before choosing ``failed`` — a
+    branch with real commits ahead of its base lands on ``advisory`` instead
+    (work exists, provenance unverified, needs a human or a verify pass),
+    naming the branch in the reason so an operator doesn't have to go
+    spelunking for it.
 
     Three guards, because **this arm reaps** and #1658 is what getting that
     wrong looks like in production:
@@ -301,6 +315,12 @@ def reconcile_completed_assignments(
     #1421's handler) — and there the workers really are gone, so reconciling
     every row on that machine is the correct answer rather than an accident.
 
+    ``commits_ahead_fn`` (#2553) is the injectable seam for the branch check
+    above — ``fn(assignment, config) -> int | None`` — defaulting to
+    :func:`coord.github_ops.branch_commits_ahead_for_assignment`.  Tests stub
+    it to avoid a real ``gh`` call, exactly like ``agent_status_fn`` stubs the
+    real agent poll.
+
     Returns one dict per reconciled assignment (empty when nothing changed).
     """
     if update_state_fn is None:
@@ -308,6 +328,11 @@ def reconcile_completed_assignments(
 
         update_state_fn = _update_local_state
 
+    if commits_ahead_fn is None:
+        from coord import github_ops  # noqa: PLC0415
+
+        commits_ahead_fn = github_ops.branch_commits_ahead_for_assignment
+
     if board is None:
         from coord.state import build_board  # noqa: PLC0415
 
@@ -352,7 +377,10 @@ def reconcile_completed_assignments(
                 and not is_attended_session(a)
                 and _no_record_grace_elapsed(a)
             ):
-                _reconcile_no_agent_record(a, aid, update_state_fn, reconciled)
+                _reconcile_no_agent_record(
+                    a, aid, update_state_fn, reconciled,
+                    config=config, commits_ahead_fn=commits_ahead_fn,
+                )
             continue
         # #1534: `effective_agent_status` refuses an agent-reported `done`
         # that also carries a usage-limit-kill reason — the daemon's passive
@@ -516,49 +544,123 @@ def reconcile_completed_assignments(
     return reconciled
 
 
+def _no_agent_record_branch_reason(branch: str, ahead: int) -> str:
+    """#2553's operator-facing reason for the "work is on the branch" half.
+
+    Distinct from :data:`NO_AGENT_RECORD_REASON` (the "nothing was pushed"
+    half) precisely so the two are told apart at a glance — the acceptance
+    bar for #2553 is that the reason NAMES the branch rather than making an
+    operator go looking for it, since that branch is the whole point: it is
+    the one artifact of this leg that survived the agent's amnesia.
+    """
+    return (
+        "agent has no record of this assignment (present in neither its "
+        "/status `active` nor `completed` list), but its branch "
+        f"`{branch}` has {ahead} commit(s) ahead of its base — the worker "
+        "pushed real work before the agent's record of it was lost. "
+        "Provenance is unverified (no worker ever reported a verdict), so "
+        "this is recorded as advisory rather than failed: it needs a human "
+        "or a verify pass, not to be discarded (#2553)"
+    )
+
+
 def _reconcile_no_agent_record(
     a: Assignment,
     aid: str,
     update_state_fn,
     reconciled: list[dict],
+    *,
+    config: Config,
+    commits_ahead_fn,
 ) -> None:
-    """#2275: flip a ``running`` row the agent has no record of to ``failed``.
+    """#2275: flip a ``running`` row the agent has no record of to a terminal
+    status — ``failed`` by default, or ``advisory`` when #2553's branch check
+    below finds the row's own branch outlived the agent's amnesia.
 
     Called from :func:`reconcile_completed_assignments` only, and only once
     all three guards there have passed (positive disproof, not attended, past
     the grace window).
 
-    **``failed``, never ``done``.** This leg never reported a verdict, so the
-    one thing that must not happen is a silent flip to ``done`` — that
-    manufactures a pass and every downstream gate (review dispatch, the
-    acceptance gate, the merge queue) then behaves as if a slice exists that
-    nobody ever produced.  A stall is bad; a manufactured pass is worse.
-    ``failure_reason`` is the pinned :data:`NO_AGENT_RECORD_REASON`, so
-    ``coord status``/the TUI/``coord drive`` all name the cause rather than
-    showing a failure with no explanation.
-
-    ``exit_code`` is deliberately left ``None``: there is no reap, so there is
-    no exit code, and writing a fake one would be the same class of lie as
-    writing ``done``.
+    **Never ``done``.** This leg never reported a verdict, so the one thing
+    that must not happen — regardless of which terminal status below fires —
+    is a silent flip to ``done``: that manufactures a pass and every
+    downstream gate (review dispatch, the acceptance gate, the merge queue)
+    then behaves as if a slice exists that nobody ever produced.  A stall is
+    bad; a manufactured pass is worse.
+
+    **#2553 — "the agent forgot" is evidence about the agent, not the work.**
+    Before this, every row reaching here was unconditionally recorded
+    ``failed`` with :data:`NO_AGENT_RECORD_REASON`, even when the row's own
+    ``branch`` carried real, pushed commits — stranding that work with no
+    second chance (most visible on ``test-author``, whose sealed-path rule
+    means nothing else will ever pick the branch back up; see
+    claude-coordinator#2553, ``coord-portal``#129 assignment
+    ``c2120f7206ec``). The branch is the one artifact in this whole path
+    that survives an agent restart, a machine reboot, and the 25-entry
+    completion-history cap, and the board row already names it — so this now
+    asks it directly via ``commits_ahead_fn(a, config)`` before choosing:
+
+    * Only for :data:`~coord.models.WORK_LIKE_TYPES` (``work``,
+      ``mock-author``, ``test-author``) — the types whose ``a.branch`` holds
+      commits THIS row itself produced.  A ``smoke``/``review`` row's
+      ``branch`` is inherited verbatim from the work it rides on (e.g.
+      ``coord.smoke.dispatch_pending_smoke`` stamps
+      ``branch=completed.branch``), so "commits ahead of base" there would
+      just be re-discovering the PARENT's diff, not anything this leg
+      produced — checking it would misfire the #2208 smoke path (a dead Test
+      leg on an already-green branch) into ``advisory`` instead of the
+      environmental clear it needs.
+    * A positive, known commit count (``ahead`` a plain ``int > 0``) is the
+      only thing that moves the needle, to ``advisory`` with
+      :func:`_no_agent_record_branch_reason` (which names the branch).
+      Anything else — no branch, a non-``WORK_LIKE_TYPES`` row, ``ahead ==
+      0``, or ``ahead is None`` (unknown: the repo isn't in ``config``, the
+      remote call failed, ...) — keeps the pre-#2553 behaviour: ``failed``
+      with :data:`NO_AGENT_RECORD_REASON`.  Unknown fails CLOSED toward
+      ``failed`` rather than guessing ``advisory``, matching this arm's
+      existing polarity: a stall is recoverable, a manufactured verdict of
+      either kind is not the thing to guess at.
+    * ``commits_ahead_fn`` is called defensively — a network hiccup querying
+      the remote must not crash the passive daemon tick any more than an
+      unreachable agent does elsewhere in this module.
+
+    ``exit_code`` is deliberately left ``None`` in both cases: there is no
+    reap, so there is no exit code, and writing a fake one would be the same
+    class of lie as writing ``done``.
 
     Kept passive, per this module's #1616 contract — it writes state through
-    the same ``update_state_fn`` seam and dispatches nothing.  The ONE thing
-    it does beyond the write is the #1605 Test-stage propagation, which is not
-    a new side effect: it is the same call the ordinary ``terminal ==
-    "failed"`` path already makes, and skipping it would leave the parent
-    work row's ``test_state="running"`` forever — i.e. it would fix half of
-    #2208 and leave the other half stranded.
+    the same ``update_state_fn`` seam and dispatches nothing.  The commits-
+    ahead check is a read, not a mutation, and it decides between two
+    non-dispatching terminal states — it does not advance the pipeline any
+    more than the write itself does.  The #1605 Test-stage propagation below
+    is not a new side effect either: it is the same call the ordinary
+    ``terminal == "failed"`` path already makes, and skipping it would leave
+    the parent work row's ``test_state="running"`` forever — i.e. it would
+    fix half of #2208 and leave the other half stranded.
     """
+    terminal_status = "failed"
+    reason = NO_AGENT_RECORD_REASON
+    branch = (a.branch or "").strip()
+
+    if branch and a.type in WORK_LIKE_TYPES:
+        try:
+            ahead = commits_ahead_fn(a, config)
+        except Exception:  # noqa: BLE001 — best-effort; unknown → failed below
+            ahead = None
+        if isinstance(ahead, int) and not isinstance(ahead, bool) and ahead > 0:
+            terminal_status = "advisory"
+            reason = _no_agent_record_branch_reason(branch, ahead)
+
     update_state_fn(
         assignment_id=aid,
-        terminal_status="failed",
+        terminal_status=terminal_status,
         branch=a.branch,
         review_state=None,
-        failure_reason=NO_AGENT_RECORD_REASON,
+        failure_reason=reason,
         exit_code=None,
     )
 
-    if a.type == "smoke":
+    if a.type == "smoke" and terminal_status == "failed":
         # #2275: environmental by construction, so state it rather than
         # letting `classify_failure` guess.  `NO_AGENT_RECORD_REASON` is
         # coordinator-authored prose with no wire token in it, so the
@@ -569,9 +671,12 @@ def _reconcile_no_agent_record(
         # vanished worker is the machine's fault, not the work's; clearing
         # the verdict lets `dispatch_pending_smoke` re-run the Test stage on
         # its next tick, which is exactly what a human did in 14 minutes.
+        # (`terminal_status` is always "failed" for `smoke` in practice — the
+        # branch check above only ever fires for WORK_LIKE_TYPES — but the
+        # guard keeps this correct even if that scoping ever changes.)
         propagate_smoke_terminal_failure(
             parent_assignment_id=a.review_of_assignment_id,
-            failure_reason=NO_AGENT_RECORD_REASON,
+            failure_reason=reason,
             environmental=True,
         )
 
@@ -581,9 +686,9 @@ def _reconcile_no_agent_record(
             "issue_number": a.issue_number,
             "repo": a.repo_name,
             "type": a.type,
-            "to_status": "failed",
+            "to_status": terminal_status,
             "plan_captured": False,
-            "reason": NO_AGENT_RECORD_REASON,
+            "reason": reason,
         }
     )
 

{code_coordinator-0.5.224 → code_coordinator-0.5.226}/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.224 → code_coordinator-0.5.226}/tests/test_drive.py

@@ -2557,6 +2557,12 @@ def test_a_dead_end_exit_code_reaches_the_drive_exited_audit_row(
     monkeypatch.setattr(
         "coord.drive.Driver._post_escalation_comment", lambda *a, **kw: None
     )
+    # Pin `coord_argv()`'s prefix to a single element so the `c[1:3]` slice
+    # below is decided by the code under test, not by whether `coord` is on
+    # the *host's* $PATH (#2564) — off-PATH, `coord_argv()`'s documented
+    # fallback is `[sys.executable, "-m", "coord.cli"]`, three elements, which
+    # shifts every recorded argv's ["escalate", "record"] out of [1:3].
+    monkeypatch.setenv("COORD_DRIVE_COORD_BIN", "coord")
     payload = board(status="done", test_state="passed")
     payload["assignments"].append({
         "repo_name": REPO,

{code_coordinator-0.5.224 → code_coordinator-0.5.226}/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", (