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

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

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

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

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

{code_coordinator-0.5.661 → code_coordinator-0.5.663}/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.663}/coord/db.py

@@ -1155,7 +1155,16 @@ def retry_on_locked(
 # request-changes rates between workflow and single legs over a sample of
 # issues BEFORE anyone considers relaxing Test/Review for workflow legs —
 # a separate, later decision this column only supplies the data for.
-_DB_SCHEMA_VERSION = 24
+#
+# #3754: bumped 24 -> 25 for the new `merge_queue.ci_rerun_budget_sha` column
+# appended to `_MIGRATE_ADD_COLUMNS` below — the `branch_head_sha` that
+# `ci_infra_reruns`/`ci_flaky_reruns`/`ci_unreadable_reruns`/`ci_flaky_pending`
+# were last accrued against, same pairing shape as #3263's `ci_seen_checks_
+# sha`. Lets a new commit landing while CI is still red (a ci-fix leg's own
+# push, most commonly) re-arm those budgets for its own fair rerun-once
+# chance instead of inheriting an already-exhausted count from an unrelated
+# prior commit. See `coord.merge_queue.QueuedMerge.ci_rerun_budget_sha`.
+_DB_SCHEMA_VERSION = 25
 
 
 def _read_schema_version(conn: sqlite3.Connection) -> int:
@@ -1403,7 +1412,8 @@ _SCHEMA_SQL = """
             ci_fix_detail_sha TEXT NOT NULL DEFAULT '',
             ci_fix_detail_json TEXT,
             ci_seen_checks_sha TEXT NOT NULL DEFAULT '',
-            ci_seen_check_names_json TEXT
+            ci_seen_check_names_json TEXT,
+            ci_rerun_budget_sha TEXT NOT NULL DEFAULT ''
         );
 
         CREATE TABLE IF NOT EXISTS plans (
@@ -2640,6 +2650,16 @@ _MIGRATE_ADD_COLUMNS: list[str] = [
     # commit" by `coord.merge_queue._ci_seen_check_names`.
     "ALTER TABLE merge_queue ADD COLUMN ci_seen_checks_sha TEXT NOT NULL DEFAULT ''",
     "ALTER TABLE merge_queue ADD COLUMN ci_seen_check_names_json TEXT",
+    # #3754: the `branch_head_sha` that `ci_infra_reruns`/`ci_flaky_reruns`/
+    # `ci_unreadable_reruns`/`ci_flaky_pending` were last accrued against --
+    # see `coord.merge_queue.QueuedMerge.ci_rerun_budget_sha`'s docstring.
+    # Lets a new commit landing while CI is still red (a ci-fix leg's own
+    # push, most commonly) re-arm those rerun budgets for its own fair
+    # rerun-once chance instead of inheriting an already-exhausted count
+    # from an unrelated prior commit. '' for every row predating this
+    # migration, read identically to "no live CI-failure read yet" by
+    # `coord.merge_queue.MergeQueue.process`.
+    "ALTER TABLE merge_queue ADD COLUMN ci_rerun_budget_sha TEXT NOT NULL DEFAULT ''",
     # #3339: the explicit operator assertion that clears a terminal
     # `refused_premise` row — see `coord.state.mark_premise_rechecked` and
     # `coord drive-queue clear-refusal`. Unlike `refused_policy`, a premise

{code_coordinator-0.5.661 → code_coordinator-0.5.663}/coord/merge_queue.py

@@ -4897,6 +4897,23 @@ class QueuedMerge:
     # is nothing to contradict on the very first read of a fresh SHA.
     ci_seen_checks_sha: str = ""
     ci_seen_check_names_json: str | None = None
+    # #3754: `branch_head_sha` (see the field above) that `ci_infra_reruns`/
+    # `ci_flaky_reruns`/`ci_unreadable_reruns`/`ci_flaky_pending` were last
+    # accrued against. Those four durable fields used to be reset ONLY in
+    # the "genuinely resolved" block below (reached only once CI reads
+    # fully green) — so a NEW commit landing while CI is STILL red (most
+    # commonly a ci-fix leg's own push) inherited whatever was left of the
+    # PRIOR commit's budget instead of getting its own fair rerun-once
+    # chance. That silently turned a single flaky required check into two
+    # consecutive `checks_failed` verdicts back to back, burning the
+    # #2972 fix-round ceiling on a PR nothing was actually wrong with.
+    # Compared against `branch_head_sha` at the top of the `if failed:`
+    # block below: a mismatch re-arms all four fields for the new commit
+    # before any of #2347/#1892/#2252's own budget checks run, mirroring
+    # the `ci_seen_checks_sha` pairing immediately above. '' for every
+    # entry that has never had a live CI-failure read, and for rows
+    # predating this column.
+    ci_rerun_budget_sha: str = ""
 
 
 class GhOps(Protocol):
@@ -5308,6 +5325,9 @@ def load_queue() -> list[QueuedMerge]:
             # ci_fix_detail_json above, for rows predating this migration.
             ci_seen_checks_sha=row["ci_seen_checks_sha"] or "",
             ci_seen_check_names_json=row["ci_seen_check_names_json"],
+            # #3754: same NULL-to-'' decoding as ci_seen_checks_sha above,
+            # for rows predating this migration.
+            ci_rerun_budget_sha=row["ci_rerun_budget_sha"] or "",
         )
         for row in rows
     ]
@@ -5332,8 +5352,9 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         ci_unreadable_reruns, ci_fix_dispatches,
                         ci_fix_head_sha, ci_fix_noop_streak,
                         ci_fix_detail_sha, ci_fix_detail_json,
-                        ci_seen_checks_sha, ci_seen_check_names_json
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                        ci_seen_checks_sha, ci_seen_check_names_json,
+                        ci_rerun_budget_sha
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                     (
                         item.assignment_id, item.repo_name, item.repo_github,
                         item.branch, item.target_branch, item.issue_number,
@@ -5346,6 +5367,7 @@ def save_queue(items: list[QueuedMerge]) -> None:
                         item.ci_fix_head_sha, item.ci_fix_noop_streak,
                         item.ci_fix_detail_sha, item.ci_fix_detail_json,
                         item.ci_seen_checks_sha, item.ci_seen_check_names_json,
+                        item.ci_rerun_budget_sha,
                     ),
                 )
 
@@ -9036,6 +9058,25 @@ def process(
                     summary = ", ".join(
                         f"{c.name} ({c.conclusion})" for c in failed
                     )
+                    # #3754: a NEW commit landing while CI is still red
+                    # (most commonly a ci-fix leg's own push) must get its
+                    # own fair rerun-once chance, not inherit whatever is
+                    # left of a DIFFERENT, prior commit's budget — the
+                    # "genuinely resolved" reset later in this function only
+                    # fires once CI reads fully green, which a still-broken
+                    # (or still-flaky) new commit never reaches. Guarded on
+                    # `branch_head_sha` being known at all: an unknown SHA
+                    # carries no information either way, so leave the
+                    # existing budget alone rather than reset against "".
+                    if (
+                        entry.branch_head_sha
+                        and entry.branch_head_sha != entry.ci_rerun_budget_sha
+                    ):
+                        entry.ci_infra_reruns = 0
+                        entry.ci_flaky_reruns = 0
+                        entry.ci_flaky_pending = ""
+                        entry.ci_unreadable_reruns = 0
+                        entry.ci_rerun_budget_sha = entry.branch_head_sha
                     # #2347: classify a bare check-list FETCH failure
                     # BEFORE #1892's infra classifier gets a chance — a
                     # synthetic unreadable check always carries `run_id ==
@@ -9320,6 +9361,12 @@ def process(
                 # failures the budget was tracking is over. A LATER,
                 # unrelated fetch failure starts its own count from zero.
                 entry.ci_unreadable_reruns = 0
+                # #3754: keep `ci_rerun_budget_sha` in lockstep with the
+                # three counters above — harmless if it's already current
+                # (the `if failed:` guard above is idempotent), but keeps a
+                # later failure on this SAME sha (a flaky green-then-read)
+                # from being misread as stale tracking.
+                entry.ci_rerun_budget_sha = entry.branch_head_sha or ""
                 # #1851: a green CI result can itself be stale relative to the
                 # base — see `_ci_checks_are_stale`'s docstring. Named
                 # distinctly (`checks_stale`) from checks_failed/

{code_coordinator-0.5.661 → code_coordinator-0.5.663}/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.663}/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.663}/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.663}/tests/test_db.py

@@ -2508,7 +2508,11 @@ class TestUatStateAndReasonColumns:
 # `review_claims` / #3333's `smoke_claims` bumps above. Closes the race where
 # the live review-completion path and the orphan sweep both see
 # `review_posted_at IS NULL` and both post the identical GitHub comment.
-_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (24, 100)
+# #3754 bumped this to (25, 101): `merge_queue.ci_rerun_budget_sha` — the
+# `branch_head_sha` the CI-flaky/infra/unreadable rerun budgets were last
+# accrued against, so a new commit landing while CI is still red gets its
+# own fair rerun-once chance instead of inheriting an exhausted budget.
+_PINNED_SCHEMA_VERSION_AND_MIGRATION_COUNT = (25, 101)
 
 
 class TestMigrateAddColumnsVersionGuard:

{code_coordinator-0.5.661 → code_coordinator-0.5.663}/tests/test_merge_queue.py

@@ -11703,6 +11703,109 @@ class TestProcessCiFlakyAutoRerun:
         assert "ci_flaky_rerun" not in kinds
 
 
+# ── #3754: rerun budgets are scoped to the commit they were accrued for ─────
+
+class TestProcessCiRerunBudgetScopedToCommit:
+    """A NEW ``branch_head_sha`` (a ci-fix leg's own push, most commonly)
+    must get its own fair #2252 rerun-once chance rather than inherit
+    whatever is left of a DIFFERENT, prior commit's exhausted budget —
+    the repro in #3754 is exactly a ci-fix leg landing at the fix-round
+    ceiling because its fresh push inherited an already-spent streak."""
+
+    def test_new_commit_after_exhausted_budget_gets_its_own_rerun(self) -> None:
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        # Commit A: budget already exhausted and confirmed real (mirrors
+        # `test_fails_again_spends_the_attempt_identical_to_today` above).
+        entry.branch_head_sha = "sha_a"
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_infra_reruns = mq.MAX_CI_INFRA_RERUNS
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_unreadable_reruns = mq.MAX_CI_UNREADABLE_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        # Commit A still red -> budget exhausted, plain checks_failed,
+        # no rerun attempted -- unchanged from today's behaviour.
+        events = process(items, gh, ci_store=ci)
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert ci.rerun_failed_calls == []
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+
+        # A new commit lands (e.g. a ci-fix leg's own push) and ALSO
+        # fails CI -- it must get its own fresh rerun-once chance rather
+        # than being immediately confirmed as broken from A's exhausted
+        # budget.
+        entry.branch_head_sha = "sha_b"
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "ci_flaky_rerun" in kinds
+        assert "checks_failed" not in kinds
+        assert ci.rerun_failed_calls == [("acme/api", 99)]
+        assert entry.ci_infra_reruns == 0
+        assert entry.ci_flaky_reruns == 1
+        assert entry.ci_unreadable_reruns == 0
+        assert entry.ci_flaky_pending
+        assert entry.ci_rerun_budget_sha == "sha_b"
+
+    def test_same_commit_failing_again_keeps_the_exhausted_budget(self) -> None:
+        """Control: without a NEW sha, the existing exhausted-budget
+        behaviour (today's `checks_failed` on a repeat failure) is
+        unchanged — the reset is scoped to a genuinely new commit, not
+        every tick."""
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        entry.branch_head_sha = "sha_a"
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert ci.rerun_failed_calls == []
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+        assert entry.ci_rerun_budget_sha == "sha_a"
+
+    def test_unknown_branch_head_sha_does_not_reset_the_budget(self) -> None:
+        """An unknown sha (``board=None``, the dry-preview path with no
+        live `gh` fetch) carries no information either way -- leave the
+        existing budget alone rather than reset against ``""``."""
+        items = [_q("w1", pr=99)]
+        entry = items[0]
+        entry.branch_head_sha = None
+        entry.ci_rerun_budget_sha = "sha_a"
+        entry.ci_flaky_reruns = mq.MAX_CI_FLAKY_RERUNS
+        entry.ci_flaky_pending = ""
+
+        gh = FakeGh()
+        ci = TestProcessCiFlakyAutoRerun._Ci(
+            checks=TestProcessCiFlakyAutoRerun._genuine_failure()
+        )
+
+        events = process(items, gh, ci_store=ci)
+
+        kinds = [e.kind for e in events]
+        assert "checks_failed" in kinds
+        assert "ci_flaky_rerun" not in kinds
+        assert entry.ci_flaky_reruns == mq.MAX_CI_FLAKY_RERUNS
+        assert entry.ci_rerun_budget_sha == "sha_a"
+
+
 # ── #778: staging_items() ─────────────────────────────────────────────────────
 
 class TestStagingItems:

{code_coordinator-0.5.661 → code_coordinator-0.5.663}/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.663}/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(