code-coordinator 0.5.661__tar.gz → 0.5.662__tar.gz

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.661",
+  "tag": "0.5.662",
   "distance": 0,
-  "node": "g1152ba357daaa2b42b64f3ba32ee103d459ff668",
+  "node": "ge117a8cdf2f43c28be0be40fec94a54767d63259",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-22"

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/coord/confirm_test.py

@@ -788,6 +788,41 @@ class ConfirmationResult:
         return self.kind in INCONCLUSIVE_KINDS
 
 
+def write_test_output_file(assignment_id: str, output: str) -> Path | None:
+    """Best-effort persist of *output* to ``COORD_DIR/test_output/<assignment_id>.txt``.
+
+    This is the one dedicated channel for quoting raw worker-/suite-authored
+    text back to a fix worker: ``coord fix`` (:mod:`coord.commands.plan_followup`)
+    prefers reading this file over every other evidence source, and —
+    critically — ``test_reason`` does not: that column is scanned by several
+    unanchored regex readers (:func:`coord.state.classify_failure` on every
+    ``test_state="failed"`` write, the smoke budget tallies in
+    :mod:`coord.smoke`) that must never see raw log prose, only the
+    coordinator's own one-line summaries. Anything longer than a headline
+    belongs here, not in ``test_reason``.
+
+    *assignment_id* is the parent **work** row's id (the one a fix leg is
+    spawned from), not a confirming/smoke transition's id — the same key
+    :func:`coord.commands.plan_followup.fix` reads back by.
+
+    A no-op, returning ``None``, when there is nothing to write or when the
+    write itself fails (a read-only ``COORD_DIR``, a full disk, ...); callers
+    treat this as best-effort and must never let it break verdict recording.
+    """
+    if not 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(output)
+    except OSError:
+        return None
+    return stored
+
+
 def write_confirmation_output(assignment_id: str, result: ConfirmationResult) -> Path | None:
     """Persist a confirmation run's captured output tail for the fix briefing (#2563).
 
@@ -802,29 +837,13 @@ def write_confirmation_output(assignment_id: str, result: ConfirmationResult) ->
     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.
+    itself fails; see :func:`write_test_output_file`, which does the actual
+    work.
     """
-    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
+    return write_test_output_file(assignment_id, result.output)
 
 
 def confirmation_enabled(config=None) -> bool:

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/coord/notify.py

@@ -3280,14 +3280,38 @@ def _record_smoke_verdict(
         # `test_state`, so a headless smoke FAILURE lands as
         # test_state='failed' AND smoke_test='fail' and stays reachable from
         # `coord fix`.
+        #
+        # A plain-runner's marker line (`SMOKE: fail exit=1`) carries nothing
+        # but an exit code — useless to a fix worker who can't tell its own
+        # diff from a red base from that alone. `verdict.context` is the
+        # bounded log tail that preceded the marker, which for the
+        # plain-runner is the captured failing-test output (panic/assertion
+        # lines, the `error: test failed, to rerun pass -p <crate> --test
+        # <name>` hint), and for a `claude -p` smoke worker is usually the
+        # turn where it identified the failure.
+        #
+        # That text is raw worker-/suite-authored prose, so it goes to the
+        # dedicated `test_output` file (`coord.confirm_test.
+        # write_test_output_file`), never into `test_reason` itself —
+        # `test_reason` is scanned unanchored by several readers
+        # (`coord.state.classify_failure` on every failed write,
+        # `coord.smoke`'s budget tallies) that must only ever see the
+        # coordinator's own short summary, not a worker's log output which
+        # could coincidentally contain one of their matched phrases.
+        # `plan_followup.fix()` already prefers this file over `test_reason`
+        # when composing the briefing.
+        from coord.confirm_test import write_test_output_file  # noqa: PLC0415
+
+        write_test_output_file(parent_id, verdict.context)
+        headline = (
+            f"headless smoke: {verdict.reason}"
+            if verdict.reason
+            else "headless smoke reported SMOKE: fail"
+        )
         record_test_verdict(
             assignment_id=parent_id,
             test_state="failed",
-            test_reason=(
-                f"headless smoke: {verdict.reason}"
-                if verdict.reason
-                else "headless smoke reported SMOKE: fail"
-            ),
+            test_reason=headline,
         )
         return
 

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/coord/progress.py

@@ -90,11 +90,22 @@ class SmokeVerdict:
     """#2244: a smoke worker's self-reported verdict line.
 
     ``kind`` is normalised to exactly one of ``"pass"``, ``"fail"`` or
-    ``"baseline-red"``; ``reason`` is the (possibly empty) trailing text.
+    ``"baseline-red"``; ``reason`` is the (possibly empty) trailing text on
+    the marker's own line.
+
+    ``context`` is a bounded tail (:func:`coord.revalidate._tail`) of
+    whatever text preceded the marker — a plain-runner writes its captured
+    test output immediately before `SMOKE: fail exit=N`, and a `claude -p`
+    smoke worker usually states the failing test/assertion in the same turn
+    it prints the marker. This is raw worker-authored text, not a short
+    summary: callers must route it to a channel meant for that (e.g.
+    `coord.confirm_test.write_test_output_file`), never append it to a
+    structured field like `test_reason`.
     """
 
     kind: str
     reason: str = ""
+    context: str = ""
 
 
 @dataclass
@@ -484,17 +495,27 @@ def _extract_smoke_verdict_from_text(text: str) -> "SmokeVerdict | None":
     itself — "I said baseline-red, but re-running shows a real failure")
     means the final line, not the first.
     """
+    from coord.revalidate import _tail  # noqa: PLC0415
+
     matches = list(_SMOKE_VERDICT_RE.finditer(text))
     if not matches:
         return None
-    raw_kind = matches[-1].group(1).lower()
+    last = matches[-1]
+    raw_kind = last.group(1).lower()
     if raw_kind.startswith("baseline"):
         kind = "baseline-red"
     elif raw_kind.startswith("pass"):
         kind = "pass"
     else:
         kind = "fail"
-    return SmokeVerdict(kind=kind, reason=matches[-1].group(2).strip())
+    # Whatever preceded the marker line, bounded the same way
+    # `coord.revalidate`'s own failure tails are. `text[:last.start()]` not
+    # `.end()` — the marker line itself (e.g. `SMOKE: fail exit=1`) is
+    # already captured as `reason` and would just duplicate here.
+    preceding = _tail(text[: last.start()])
+    return SmokeVerdict(
+        kind=kind, reason=last.group(2).strip(), context=preceding,
+    )
 
 
 def _smoke_verdict_texts_from_event(event: object) -> list[str]:

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/tests/test_cli_fix_headless_review.py

@@ -594,6 +594,46 @@ class TestFixFromRedCi:
 
         assert result.exit_code == 0, result.output
 
+    def test_test_output_file_content_reaches_the_rendered_briefing(
+        self, ci_config: Path, coord_dir: Path, monkeypatch
+    ) -> None:
+        """`fix()`'s `elif test_output_file.exists()` branch wins over
+        `test_reason` — pin that the file's content, not just its
+        existence, actually lands in the rendered `## Test failure`
+        section a fix worker reads."""
+        work = _work(test_state="failed", test_reason="exit=1")
+        state_mod.save_board(Board(completed=[work]))
+
+        def boom(*a, **k):
+            raise AssertionError("CI must not be consulted when the test gate failed")
+
+        monkeypatch.setattr("coord.ci_store.build_ci_store", boom)
+
+        test_output_dir = coord_dir / "test_output"
+        test_output_dir.mkdir(parents=True, exist_ok=True)
+        (test_output_dir / "work-abc.txt").write_text(
+            "FAILED tests/readme_truth.rs::version_matches\n"
+            "error: test failed, to rerun pass -p vimcode --test readme_truth\n"
+            "SMOKE: fail exit=1\n"
+        )
+
+        captured = {}
+
+        def fake_dispatch(proposal, config, **kwargs):
+            captured["briefing"] = proposal.briefing
+            return {"id": "fix-t"}
+
+        with patch("coord.dispatch.dispatch", side_effect=fake_dispatch), \
+             patch("coord.github_ops.post_issue_comment"):
+            result = CliRunner().invoke(
+                main, ["fix", "work-abc", "--config", str(ci_config)]
+            )
+
+        assert result.exit_code == 0, result.output
+        assert "## Test failure" in captured["briefing"]
+        assert "FAILED tests/readme_truth.rs::version_matches" in captured["briefing"]
+        assert "to rerun pass -p vimcode --test readme_truth" in captured["briefing"]
+
     def test_dispatch_refused_by_a_pre_dispatch_guard_exits_distinctly(
         self, ci_config: Path, coord_dir: Path, monkeypatch
     ) -> None:

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/tests/test_notify.py

@@ -3410,6 +3410,14 @@ class TestSmokeVerdictFailsClosed(TestSmokeCompletionVerdict):
         '{"type":"result","subtype":"success","result":"The suite failed."}\n'
     )
 
+    @pytest.fixture(autouse=True)
+    def _isolated_coord_dir(self, tmp_path, monkeypatch):
+        """A `fail` verdict with non-empty preceding context writes it to
+        `COORD_DIR/test_output/<assignment_id>.txt`
+        (`coord.confirm_test.write_test_output_file`) — point `COORD_DIR` at
+        this test's own `tmp_path` rather than a real one."""
+        monkeypatch.setattr("coord.state.COORD_DIR", tmp_path / "coord-dir")
+
     def _reap(self, transition, record, entry) -> None:
         from coord.notify import post_transition  # noqa: PLC0415
 
@@ -3473,6 +3481,52 @@ class TestSmokeVerdictFailsClosed(TestSmokeCompletionVerdict):
         assert row["smoke_test"] == "fail"
         assert "5 failed" in (row["test_reason"] or "")
 
+    def test_plain_runner_failure_threads_log_context_into_test_output_file(
+        self, coord_db, tmp_path,
+    ) -> None:
+        """A plain-runner log has NOTHING but `exit=N` on the `SMOKE: fail`
+        line itself — the failing test name and rerun hint are only in the
+        captured output that precedes it. That context must reach a fix
+        worker via `COORD_DIR/test_output/<assignment_id>.txt`
+        (`coord.commands.plan_followup.fix` reads this file ahead of
+        `test_reason`), not via `test_reason` itself — `test_reason` stays a
+        short, coordinator-authored headline because several readers
+        (`coord.state.classify_failure`, `coord.smoke`'s budget tallies)
+        scan it with unanchored regexes that must never see raw log text."""
+        plain_runner_log = (
+            "FAILED tests/readme_truth.rs::version_matches\n"
+            "error: test failed, to rerun pass -p vimcode --test readme_truth\n"
+            "SMOKE: fail exit=1\n"
+        )
+        transition, record, entry = self._setup(
+            "work-3741", "smoke-3741", exit_code=1,
+            log=plain_runner_log, tmp_path=tmp_path,
+        )
+        self._reap(transition, record, entry)
+
+        row = self._row("work-3741")
+        assert row is not None
+        assert row["test_state"] == "failed"
+        reason = row["test_reason"] or ""
+        assert "exit=1" in reason
+        assert "FAILED tests/readme_truth.rs::version_matches" not in reason, (
+            "raw log text must not land in test_reason — it is scanned "
+            f"unanchored by several readers; got {reason!r}"
+        )
+
+        from coord.state import COORD_DIR  # noqa: PLC0415
+
+        stored = COORD_DIR / "test_output" / "work-3741.txt"
+        assert stored.exists(), (
+            f"expected the captured context at {stored} for `coord fix` to read"
+        )
+        context = stored.read_text()
+        assert "FAILED tests/readme_truth.rs::version_matches" in context, (
+            "a bare 'headless smoke: exit=1' tells a fix worker nothing — "
+            f"the failing test name must survive into the file; got {context!r}"
+        )
+        assert "to rerun pass -p vimcode --test readme_truth" in context
+
     def test_clean_exit_without_verdict_records_no_verdict(
         self, coord_db, tmp_path
     ) -> None:

{code_coordinator-0.5.661 → code_coordinator-0.5.662}/tests/test_progress.py

@@ -584,6 +584,60 @@ class TestSmokeVerdictParser:
         assert v is not None and v.kind == "fail"
         assert v.reason == "5 failed + 3 errors"
 
+    def test_fail_captures_preceding_output_as_context(
+        self, tmp_path: Path,
+    ) -> None:
+        """A plain-runner's captured test output precedes its
+        `SMOKE: fail exit=N` marker — that's exactly what a fix briefing
+        needs quoted, not just the marker's own trailing text."""
+        from coord.progress import parse_smoke_verdict_from_log
+        v = parse_smoke_verdict_from_log(
+            self._log(
+                tmp_path,
+                "FAILED tests/readme_truth.rs::version_matches\n"
+                "error: test failed, to rerun pass -p vimcode "
+                "--test readme_truth\n"
+                "SMOKE: fail exit=1\n",
+            )
+        )
+        assert v is not None and v.kind == "fail"
+        assert v.reason == "exit=1"
+        assert "FAILED tests/readme_truth.rs::version_matches" in v.context
+        assert "to rerun pass -p vimcode --test readme_truth" in v.context
+        # The marker line itself is `reason`'s job, not duplicated here — for
+        # THIS single-marker fixture it also means the marker text itself
+        # doesn't appear in `.context`. That is not a general invariant: a
+        # stream-json log can carry the `SMOKE:` string multiple times (the
+        # tool_use command, the echoed literal, the tool_result), and an
+        # earlier copy legitimately ends up inside `.context`.
+        assert "SMOKE: fail" not in v.context
+
+    def test_context_is_truncated_from_the_front_when_oversized(
+        self, tmp_path: Path,
+    ) -> None:
+        """Mirrors `coord.revalidate._tail`'s bias: keep the END of the
+        preceding output (closest to the failure) and mark the cut."""
+        from coord.progress import parse_smoke_verdict_from_log
+        from coord.revalidate import _OUTPUT_TAIL_CHARS
+        huge = "x" * 5000 + "TAIL-MARKER-END"
+        v = parse_smoke_verdict_from_log(
+            self._log(tmp_path, f"{huge}\nSMOKE: fail exit=1\n")
+        )
+        assert v is not None and v.kind == "fail"
+        assert "…(truncated)…" in v.context
+        assert "TAIL-MARKER-END" in v.context
+        assert len(v.context) < _OUTPUT_TAIL_CHARS + 100
+
+    def test_pass_has_no_context_requirement(self, tmp_path: Path) -> None:
+        """A pass verdict doesn't need preceding output explained; just
+        confirm populating `.context` for `pass` doesn't break anything."""
+        from coord.progress import parse_smoke_verdict_from_log
+        v = parse_smoke_verdict_from_log(
+            self._log(tmp_path, "9911 passed in 662s\nSMOKE: pass\n")
+        )
+        assert v is not None and v.kind == "pass"
+        assert v.context == "9911 passed in 662s"
+
     def test_parses_baseline_red(self, tmp_path: Path) -> None:
         from coord.progress import parse_smoke_verdict_from_log
         v = parse_smoke_verdict_from_log(