code-coordinator 0.5.524__tar.gz → 0.5.525__tar.gz

{code_coordinator-0.5.524 → code_coordinator-0.5.525}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.524",
+  "tag": "0.5.525",
   "distance": 0,
-  "node": "g0e924a9e07fea9e3ea943a45cd49b370575ca40c",
+  "node": "g055bba5413e260e4e732234df5915c68b3c23459",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-27"

{code_coordinator-0.5.524 → code_coordinator-0.5.525}/coord/ci_fix.py

@@ -37,6 +37,7 @@ import logging
 
 import httpx
 
+from coord import github_ops
 from coord.ci_store import CIFailureDetail
 from coord.config import Config
 from coord.merge_queue import QueuedMerge, _chain_work_ids
@@ -144,12 +145,87 @@ def _format_ci_failure_detail(detail: CIFailureDetail) -> list[str]:
     return lines
 
 
+# #3456: cap on the issue body threaded into a ci-fix briefing. Large
+# enough that a typical issue description plus an operator's follow-up
+# diagnosis both fit without truncation in the common case — only a
+# genuinely long body (or a long back-and-forth of appended notes) hits
+# the cap at all.
+ISSUE_BODY_MAX_CHARS = 6000
+
+
+def _bound_issue_body(body: str) -> tuple[str, bool]:
+    """Truncate *body* to the last :data:`ISSUE_BODY_MAX_CHARS` characters
+    when it exceeds that cap (#3456).
+
+    Keeps the TAIL, not the head: an operator's diagnosis on a CI-fix
+    streak is written INTO the issue body after the failure is understood
+    — i.e. appended below the original description (see the issue's own
+    evidence: "After the root cause was written into the issue body,
+    requeueing would have routed the next attempt through the same ci-fix
+    path"). Keeping the tail is what makes sure that operator-added
+    content survives a cut; the cost is that the original description
+    (often already echoed by the issue title anyway) is what gets dropped
+    for a body long enough to need cutting at all.
+
+    Returns ``(text, truncated)`` — mirrors
+    :func:`coord.ci_github._bound_log_excerpt`'s contract: *truncated* is
+    ``True`` iff the cut actually removed content, so the caller can make
+    the cut visible in the briefing text rather than silently handing over
+    a partial body.
+    """
+    if len(body) <= ISSUE_BODY_MAX_CHARS:
+        return body, False
+    return body[-ISSUE_BODY_MAX_CHARS:], True
+
+
+def _format_issue_body(issue_body: str) -> list[str]:
+    """Render *issue_body* into briefing lines (#3456) — see
+    :func:`_bound_issue_body` for the truncation contract.
+    """
+    body, truncated = _bound_issue_body(issue_body)
+    lines: list[str] = ["## Issue body", ""]
+    if truncated:
+        lines.append(
+            f"(truncated to the last {ISSUE_BODY_MAX_CHARS} characters — "
+            "operator notes are typically appended below the original "
+            "description, so keeping the tail keeps those over the part "
+            "already echoed by the issue title)"
+        )
+        lines.append("")
+    lines.append(body)
+    lines.append("")
+    return lines
+
+
+def _fetch_issue_body(entry: QueuedMerge) -> str:
+    """Best-effort fetch of *entry*'s issue body for the ci-fix briefing
+    (#3456) — the same body a Work-stage dispatch already auto-includes
+    (``coord.commands.dispatch``'s auto-briefing, ``coord.commands.
+    dispatch_workers``' smoke briefing) but a ci-fix dispatch never did:
+    any diagnosis an operator records on the issue (e.g. after reading the
+    real CI logs by hand) was invisible to the worker most likely to need
+    it, since workers can't run ``gh`` themselves to read it any other way.
+
+    Fails soft to ``""`` on any read failure (``gh`` missing, rate-limited,
+    a network blip, a malformed response) — same posture as
+    :func:`coord.ci_github.build_ci_failure_detail`: this is enrichment,
+    never a dispatch precondition, and a body fetch failure must never
+    block or delay the actual fix dispatch.
+    """
+    try:
+        issue_data = github_ops.get_issue(entry.repo_github, entry.issue_number)
+    except Exception:  # noqa: BLE001 — best-effort, see docstring
+        return ""
+    return str(issue_data.get("body") or "")
+
+
 def build_ci_fix_briefing(
     *,
     entry: QueuedMerge,
     checks_summary: str,
     attempt: int,
     detail: CIFailureDetail | None = None,
+    issue_body: str | None = None,
 ) -> str:
     """Assemble the CI-fix worker's briefing. Pure function — testable.
 
@@ -159,6 +235,11 @@ def build_ci_fix_briefing(
     empty of anything beyond the check name (see :func:`_detail_has_content`),
     the briefing is byte-identical to before #3114, still carrying
     ``checks_summary``.
+
+    *issue_body* (#3456) is the issue's current body, fetched by
+    :func:`_fetch_issue_body` at dispatch time — optional and additive,
+    same shape as *detail*: ``None`` or blank leaves the briefing
+    byte-identical to before #3456.
     """
     lines: list[str] = [
         f"# CI failure fix: {entry.repo_github} branch `{entry.branch}`",
@@ -172,6 +253,8 @@ def build_ci_fix_briefing(
         f"    {checks_summary}",
         "",
     ]
+    if issue_body is not None and issue_body.strip():
+        lines.extend(_format_issue_body(issue_body))
     if detail is not None and _detail_has_content(detail):
         lines.extend(_format_ci_failure_detail(detail))
     lines += [
@@ -353,9 +436,10 @@ def dispatch_ci_fix(
         return None
 
     summary = checks_summary or entry.error or "CI checks failed"
+    issue_body = _fetch_issue_body(entry)
     briefing = build_ci_fix_briefing(
         entry=entry, checks_summary=summary, attempt=entry.ci_fix_dispatches + 1,
-        detail=detail,
+        detail=detail, issue_body=issue_body,
     )
 
     from coord.auto_loop import _dispatch_fix  # noqa: PLC0415

{code_coordinator-0.5.524 → code_coordinator-0.5.525}/coord/ci_github.py

@@ -120,19 +120,50 @@ _RUST_ERROR_RE = re.compile(r"\berror(\[E\d+\])?:")
 _RUST_LOCATION_RE = re.compile(r"-->")
 _RUST_WARNING_RE = re.compile(r"\bwarning:")
 
+# #3456: GitHub Actions appends this EXACT line to every failing step's log,
+# regardless of what actually failed — it is the annotation `_ERROR_
+# ANNOTATION_RE` would otherwise happily match as tier-1 signal, and on a
+# job whose real failure produces no OTHER `##[error]` line (e.g. a `cargo
+# test` failure — rustc's own test-harness panic output carries no `##[
+# error]` prefix at all), this generic wrapper line was the ONLY thing
+# selected: "exit code 1", not the failing test. Excluded from the
+# `annotation` tier entirely so the more specific `rust_test_failure` tier
+# below (or, failing that, `no_diagnostics_matched`) wins instead.
+_EXIT_CODE_ANNOTATION_RE = re.compile(r"##\[error\]Process completed with exit code \d+\.?\s*$")
+
+# #3456: a rust test-harness failure never carries a `##[error]` prefix, so
+# none of it was reachable by any tier before this — the harness prints a
+# per-test `---- <test path> stdout ----` header immediately followed by the
+# `panicked at ...` message, then (once every test has run) a `failures:`
+# roll-up naming every failing test, then a final `test result: FAILED. ...`
+# summary line. All four are treated as one priority tier: whichever of
+# them shows up is unambiguously more useful than the generic exit-code
+# annotation above.
+_RUST_TEST_STDOUT_HEADER_RE = re.compile(r"^-+\s.*\sstdout\s-+\s*$")
+_RUST_PANICKED_RE = re.compile(r"panicked at")
+_RUST_TEST_RESULT_RE = re.compile(r"\btest result: FAILED\b")
+_RUST_FAILURES_HEADER_RE = re.compile(r"^failures:\s*$")
+
 # How many lines past a matched rust-diagnostic line to look for its `-->`
 # location before giving up — rustc always emits it on the very next
 # non-blank line; a small window tolerates the odd blank line without
 # accidentally stealing a `-->` that belongs to a LATER diagnostic.
 _RUST_LOCATION_LOOKAHEAD = 4
 
+# How many lines past a `---- <test> stdout ----` header to sweep into the
+# same unit — enough to capture the `thread '...' panicked at ...:LINE:COL:`
+# line plus a short assertion message, without running so far that a SECOND
+# test's header (or unrelated harness noise) gets swept in too.
+_RUST_TEST_FAILURE_LOOKAHEAD = 6
+
 
 def _select_diagnostic_units(lines: list[str]) -> tuple[
-    list[list[str]], list[list[str]], list[list[str]]
+    list[list[str]], list[list[str]], list[list[str]], list[list[str]]
 ]:
-    """Classify *lines* into (annotation, rust_diagnostic, warning) unit
-    lists, each unit a small list of original line strings kept atomic so
-    budget truncation never splits an `error:`/`-->` pair apart (#3245).
+    """Classify *lines* into (annotation, rust_test_failure, rust_diagnostic,
+    warning) unit lists, each unit a small list of original line strings
+    kept atomic so budget truncation never splits an `error:`/`-->` pair —
+    or a rust test panic header/message pair — apart (#3245, #3456).
 
     Each source line is claimed by at most one bucket, checked in priority
     order, so a line matching a higher-priority pattern is never
@@ -142,10 +173,47 @@ def _select_diagnostic_units(lines: list[str]) -> tuple[
 
     annotation: list[list[str]] = []
     for i, line in enumerate(lines):
+        # #3456: the generic "step failed" wrapper line is deliberately
+        # never claimed here (see `_EXIT_CODE_ANNOTATION_RE`'s comment) —
+        # left unclaimed (not even added to `claimed`) since nothing else
+        # matches it anyway.
+        if _EXIT_CODE_ANNOTATION_RE.search(line):
+            continue
         if _ERROR_ANNOTATION_RE.search(line):
             annotation.append([line])
             claimed.add(i)
 
+    # #3456: rust test-harness failures — a stdout header sweeps in the
+    # panic message that follows it; a bare `panicked at`/`test result:
+    # FAILED`/`failures:` line (no preceding header, e.g. a `cargo run`
+    # panic outside the test harness) stands alone as its own unit.
+    rust_test_failure: list[list[str]] = []
+    for i, line in enumerate(lines):
+        if i in claimed:
+            continue
+        if _RUST_TEST_STDOUT_HEADER_RE.match(line.strip()):
+            claimed.add(i)
+            unit = [line]
+            end = min(i + 1 + _RUST_TEST_FAILURE_LOOKAHEAD, len(lines))
+            for j in range(i + 1, end):
+                if j in claimed:
+                    break
+                candidate = lines[j]
+                if not candidate.strip() or _RUST_TEST_STDOUT_HEADER_RE.match(candidate.strip()):
+                    # Blank line or the next test's header — stop before
+                    # sweeping in unrelated content.
+                    break
+                unit.append(candidate)
+                claimed.add(j)
+            rust_test_failure.append(unit)
+        elif (
+            _RUST_PANICKED_RE.search(line)
+            or _RUST_TEST_RESULT_RE.search(line)
+            or _RUST_FAILURES_HEADER_RE.match(line.strip())
+        ):
+            claimed.add(i)
+            rust_test_failure.append([line])
+
     rust_diag: list[list[str]] = []
     for i, line in enumerate(lines):
         if i in claimed or not _RUST_ERROR_RE.search(line):
@@ -173,7 +241,7 @@ def _select_diagnostic_units(lines: list[str]) -> tuple[
         claimed.add(i)
         warning.append([line])
 
-    return annotation, rust_diag, warning
+    return annotation, rust_test_failure, rust_diag, warning
 
 
 def _extract_relevant_log_lines(text: str) -> tuple[str, bool, bool]:
@@ -189,30 +257,42 @@ def _extract_relevant_log_lines(text: str) -> tuple[str, bool, bool]:
     Extraction is by relevance, in priority order, matching the issue's fix
     shape:
 
-    1. ``##[error]`` GitHub Actions annotation lines
-    2. Rust diagnostics — ``error[E....]:``/``error:`` paired with the
-       ``-->`` file:line that follows
-    3. ``warning:`` lines, only if budget remains after 1-2
+    1. ``##[error]`` GitHub Actions annotation lines — EXCEPT the generic
+       ``Process completed with exit code N.`` wrapper GitHub Actions
+       appends to every failing step regardless of cause (#3456): it
+       carries zero diagnostic value, and on a job whose real failure
+       never emits any OTHER ``##[error]`` line (a rust test panic, say),
+       it used to be the ONLY thing this function ever surfaced.
+    2. Rust test-harness failures (#3456) — a ``---- <test> stdout ----``
+       header (with the ``panicked at ...`` message that follows it), a
+       bare ``panicked at`` line, a ``failures:`` roll-up, or the final
+       ``test result: FAILED`` summary line
+    3. Rust compiler diagnostics — ``error[E....]:``/``error:`` paired with
+       the ``-->`` file:line that follows
+    4. ``warning:`` lines, only if budget remains after 1-3
 
     Everything else — including the runner's own echo of a script step's
-    source and post-job cleanup — is never a candidate, because it can
-    only ever match one of these patterns by (extremely unlikely)
-    coincidence.
+    source and post-job cleanup, and the excluded exit-code wrapper line —
+    is never a candidate, because it can only ever match one of these
+    patterns by (extremely unlikely) coincidence.
 
     Returns ``(excerpt, truncated, matched)``:
 
     - *matched* is ``False`` when nothing in any tier matched anywhere in
       *text* — the caller renders an explicit "no diagnostics" note rather
-      than a misleadingly-empty excerpt.
+      than a misleadingly-empty excerpt. Note this can now be ``False`` for
+      a log whose ONLY `##[error]` line was the excluded exit-code wrapper —
+      correctly so, since that line alone told the caller nothing a
+      "no diagnostics matched" note doesn't already convey just as well.
     - *truncated* is ``True`` when the matched units together exceed
       :data:`CI_FIX_LOG_MAX_LINES`/:data:`CI_FIX_LOG_MAX_BYTES` and lower-
-      priority units (warnings first, then any tier-1/2 overflow) had to be
-      dropped to fit — same "make the cut visible" contract as
+      priority units (warnings first, then any earlier-tier overflow) had
+      to be dropped to fit — same "make the cut visible" contract as
       :func:`_bound_log_excerpt`.
     """
     lines = text.splitlines()
-    annotation, rust_diag, warning = _select_diagnostic_units(lines)
-    units = annotation + rust_diag + warning
+    annotation, rust_test_failure, rust_diag, warning = _select_diagnostic_units(lines)
+    units = annotation + rust_test_failure + rust_diag + warning
     if not units:
         return "", False, False
 

{code_coordinator-0.5.524 → code_coordinator-0.5.525}/tests/test_ci_fix.py

@@ -25,6 +25,7 @@ from coord.ci_fix import (
     dispatch_was_noop,
     refund_noop_ci_fix,
 )
+from coord.ci_github import _extract_relevant_log_lines
 from coord.ci_store import CheckRun, CIFailureDetail, JobRun, JobStep
 from coord.config import Config, ReviewsConfig
 from coord.merge_queue import HUMAN_REQUIRED, PENDING, MergeEvent, QueuedMerge
@@ -247,6 +248,114 @@ class TestBuildBriefingWithDetail:
         assert "no diagnostic lines matched" in briefing.lower()
 
 
+class TestBuildBriefingWithIssueBody:
+    """#3456: the CI-fix briefing must carry the issue body — the only way
+    an operator's diagnosis (recorded on the issue after reading the real
+    CI logs by hand) ever reaches a ci-fix worker, since workers can't run
+    `gh` themselves to read it any other way."""
+
+    def test_no_issue_body_is_byte_identical_to_pre_3456(self) -> None:
+        """`issue_body=None` (the default) must not change the briefing at
+        all — every pre-#3456 caller (and every un-updated call site) keeps
+        getting exactly what it always got."""
+        without_kw = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1,
+        )
+        with_explicit_none = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1, issue_body=None,
+        )
+        assert without_kw == with_explicit_none
+
+    def test_blank_issue_body_adds_no_section(self) -> None:
+        briefing = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1, issue_body="   ",
+        )
+        assert "## Issue body" not in briefing
+
+    def test_issue_body_appears_in_briefing(self) -> None:
+        briefing = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1,
+            issue_body="## Root cause\n\nDirectWrite word-wrap/clip bug in "
+            "dialog.rs — see panic at dialog.rs:236:9.",
+        )
+        assert "## Issue body" in briefing
+        assert "DirectWrite word-wrap/clip bug" in briefing
+        assert "dialog.rs:236:9" in briefing
+
+    def test_long_issue_body_is_truncated_keeping_the_tail(self) -> None:
+        """Operator diagnosis is appended to the BOTTOM of the issue body
+        after the original description — truncation must keep the tail so
+        that diagnosis survives, even if the (often title-redundant)
+        original description at the top gets cut."""
+        from coord.ci_fix import ISSUE_BODY_MAX_CHARS
+
+        original = "x" * (ISSUE_BODY_MAX_CHARS + 500)
+        diagnosis = "\n\n## Root cause\n\nThe actual bug is a DirectWrite clip issue."
+        body = original + diagnosis
+
+        briefing = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1, issue_body=body,
+        )
+        assert "The actual bug is a DirectWrite clip issue." in briefing
+        assert "truncated" in briefing.lower()
+
+    def test_short_issue_body_is_not_marked_truncated(self) -> None:
+        briefing = build_ci_fix_briefing(
+            entry=_entry(), checks_summary="x", attempt=1, issue_body="short body",
+        )
+        assert "## Issue body" in briefing
+        assert "truncated to the last" not in briefing.lower()
+
+
+class TestDispatchCiFixFetchesIssueBody:
+    """#3456: `dispatch_ci_fix` fetches the issue body itself (best-effort)
+    and threads it into the briefing — a worker has no other path to an
+    operator's diagnosis recorded on the issue."""
+
+    def test_fetched_issue_body_lands_in_the_dispatched_briefing(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        board = Board()
+        board.completed.append(_work_assignment())
+        client = _FakeHTTPClient({"id": "ci-fix-body"})
+
+        with patch(
+            "coord.ci_fix.github_ops.get_issue",
+            return_value={"body": "## Root cause\n\nDirectWrite clip bug."},
+        ) as get_issue:
+            dispatch_ci_fix(
+                _entry(), board, two_machine_config,
+                checks_summary="acceptance (failure)", http_client=client,
+            )
+
+        get_issue.assert_called_once_with("acme/api", 1)
+        _, payload = client.calls[0]
+        assert "DirectWrite clip bug" in payload["briefing"]
+
+    def test_issue_fetch_failure_is_fail_soft(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        """A failed issue-body fetch (rate-limited, `gh` unreachable, ...)
+        must never block the dispatch — same posture as the #3114 detail
+        fetch."""
+        board = Board()
+        board.completed.append(_work_assignment())
+        client = _FakeHTTPClient({"id": "ci-fix-body-fail"})
+
+        with patch(
+            "coord.ci_fix.github_ops.get_issue",
+            side_effect=RuntimeError("gh throttled"),
+        ):
+            result = dispatch_ci_fix(
+                _entry(), board, two_machine_config,
+                checks_summary="acceptance (failure)", http_client=client,
+            )
+
+        assert result is not None
+        _, payload = client.calls[0]
+        assert "## Issue body" not in payload["briefing"]
+
+
 # ── #3011: no-op leg detection/refund ────────────────────────────────────────
 
 
@@ -975,3 +1084,73 @@ class TestDispatchCiFixesWithCiStore:
             )
             second_detail = dispatch.call_args.kwargs["detail"]
             assert second_detail == first_detail
+
+
+# ── #3456: excerpt selection prefers the failing rust test over the ─────────
+# ── generic "exit code" wrapper line ─────────────────────────────────────────
+
+
+class TestExcerptPrefersFailingRustTestOverExitCode:
+    """quadraui#1077: both ci-fix legs were briefed with nothing but
+    `##[error]Process completed with exit code 1.` — the least useful line
+    in the log — instead of the failing test name and panic message
+    (`panicked at ... dialog.rs:236:9: tinted button label should paint
+    ...`). `_extract_relevant_log_lines` must prefer the rust test-harness
+    failure lines over that generic wrapper."""
+
+    def test_exit_code_line_alone_is_not_matched(self) -> None:
+        """The generic wrapper line carries no diagnostic value on its
+        own — it must not be treated as a match at all (#3456), so the
+        caller renders the explicit "no diagnostics matched" note instead
+        of a briefing that looks substantive but says nothing."""
+        text = (
+            "running tests...\n"
+            "##[error]Process completed with exit code 1.\n"
+        )
+        excerpt, truncated, matched = _extract_relevant_log_lines(text)
+        assert matched is False
+        assert excerpt == ""
+
+    def test_panic_and_test_result_preferred_over_exit_code(self) -> None:
+        text = "\n".join([
+            "running 42 tests",
+            "---- dialog::tests::tinted_button_label_paints stdout ----",
+            "thread 'main' panicked at dialog.rs:236:9:",
+            "tinted button label should paint with the theme's accent color",
+            "",
+            "failures:",
+            "    dialog::tests::tinted_button_label_paints",
+            "",
+            "test result: FAILED. 41 passed; 1 failed; 0 ignored",
+            "##[error]Process completed with exit code 1.",
+        ])
+        excerpt, truncated, matched = _extract_relevant_log_lines(text)
+        assert matched is True
+        assert "panicked at dialog.rs:236:9" in excerpt
+        assert "tinted button label should paint" in excerpt
+        assert "test result: FAILED" in excerpt
+        assert "Process completed with exit code" not in excerpt
+
+    def test_bare_panic_line_without_test_harness_header_still_matches(self) -> None:
+        text = (
+            "starting up...\n"
+            "thread 'main' panicked at src/main.rs:10:5:\n"
+            "index out of bounds\n"
+            "##[error]Process completed with exit code 101.\n"
+        )
+        excerpt, truncated, matched = _extract_relevant_log_lines(text)
+        assert matched is True
+        assert "panicked at src/main.rs:10:5" in excerpt
+        assert "Process completed with exit code" not in excerpt
+
+    def test_real_error_annotation_still_takes_priority(self) -> None:
+        """A genuinely diagnostic `##[error]` line (not the generic exit-
+        code wrapper) is still top priority, unaffected by this change."""
+        text = (
+            "##[error]coord-tui fails to compile against this PR's quadraui\n"
+            "##[error]Process completed with exit code 1.\n"
+        )
+        excerpt, truncated, matched = _extract_relevant_log_lines(text)
+        assert matched is True
+        assert "coord-tui fails to compile" in excerpt
+        assert "Process completed with exit code" not in excerpt