code-coordinator 0.5.506__tar.gz → 0.5.507__tar.gz

{code_coordinator-0.5.506 → code_coordinator-0.5.507}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.506",
+  "tag": "0.5.507",
   "distance": 0,
-  "node": "g10b3e0961d928aad40e02740533266e5814d0edd",
+  "node": "g77eaf6af7d9e29387584dbfe661ea201eb62e524",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-20"

{code_coordinator-0.5.506 → code_coordinator-0.5.507}/coord/notify.py

@@ -2477,6 +2477,114 @@ def _confirmed_pass_verdict(
     )
 
 
+def _mechanical_mute_verdict(
+    transition: Transition, entry: dict, parent_id: str,
+) -> tuple[str, str, str] | None:
+    """#3415: for a MUTE Test-stage leg (no `SMOKE:` marker at all, clean
+    session exit), attempt the same out-of-band mechanical re-run #2464 uses
+    to double-check a *claimed* pass — except here there is no claim to
+    confirm, so a decisive result becomes the verdict directly.
+
+    Why this exists: sampling every #3376 "reached done with no verdict"
+    alarm found the identical shape 7 times out of 7 — a headless Test-stage
+    worker backgrounds a suite that exceeds the Bash ceiling, correctly
+    states the rule ("I'll poll with bounded waits"), and then ends its turn
+    anyway. That is not a coord bug to patch around with a sterner prompt;
+    ending a one-shot `claude -p` turn ends the session permanently, so no
+    notification the backgrounded suite eventually produces can ever reach
+    it. The prompt already spends two capitalized bullets on this (#2272,
+    #2301) and the observed compliance rate is 0/7 — more emphasis cannot
+    raise a structural non-starter to a rate the Test gate can depend on.
+
+    `coord.confirm_test.confirm_branch` needs no LLM and no waiting: it
+    re-runs the repo's own build/test command in a throwaway worktree and
+    reads the real exit code. Reusing it here — instead of only as the
+    pass-claim backstop — deletes the mute leg's reason to exist for every
+    repo whose suite this machine can actually run, rather than bounding it
+    with a bigger retry budget.
+
+    Returns ``None`` when the run is inconclusive or unavailable (disabled,
+    no local checkout, no test_command, a timeout, ...) — the existing
+    mute-leg tally (count the leg, clear for one retry, then park at the
+    budget) is exactly the right fallback for "still no answer either way",
+    and this never invents one it doesn't have.
+    """
+    from coord.confirm_test import (  # noqa: PLC0415
+        BASELINE_RED_REASON_PREFIX,
+        TEST_CONFIRMATION_BASELINE_RED,
+        TEST_CONFIRMATION_CONFIRMED,
+        TEST_CONFIRMATION_REFUTED,
+        write_confirmation_output,
+    )
+    from coord.state import load_assignment_review_verdict  # noqa: PLC0415
+
+    result = _run_pass_confirmation(transition, entry)
+    if result is None or result.inconclusive:
+        return None  # no decisive answer — fall back to the mute-leg tally
+
+    try:
+        write_confirmation_output(parent_id, result)
+    except Exception as exc:  # noqa: BLE001
+        log.warning(
+            "smoke %s: could not persist mechanical confirmation output for "
+            "parent %s (%s) — a later fix briefing will fall back to the "
+            "one-line reason (#2563/#3415).",
+            transition.assignment_id, parent_id, exc,
+        )
+
+    if result.refuted:
+        log.warning(
+            "smoke %s: mute Test-stage leg for %s — the mechanical fallback "
+            "re-run (#3415) says FAILED: %s\n%s",
+            transition.assignment_id, transition.repo_name, result.reason,
+            result.output,
+        )
+        # #2579: same race as `_confirmed_pass_verdict` — a review can
+        # approve before this out-of-band run lands (review dispatch gates
+        # on `test_state`, not on confirmation). Plain "failed" would then
+        # be indistinguishable from an ordinary Test-stage failure and
+        # silently bounce an already-approved branch to a fix worker.
+        _review_state, _review_verdict = load_assignment_review_verdict(parent_id)
+        if _review_verdict == "approve":
+            return (
+                TEST_STATE_CONTESTED,
+                f"CONTESTED (#2579/#3415): the Test-stage worker "
+                f"{transition.assignment_id} ended mute (no verdict marker "
+                "line), and the mechanical fallback re-run REFUTED the "
+                f"branch AFTER its review had already approved it "
+                f"(review_state={_review_state!r}) — {result.reason}. The "
+                "merge gate stays shut, but no fix round is auto-dispatched "
+                f"— recover with `coord fix --force --guidance <what's "
+                f"broken> {parent_id}` or re-dispatch the Test stage by "
+                "hand.",
+                TEST_CONFIRMATION_REFUTED,
+            )
+        return (
+            "failed",
+            "headless smoke ended mute (no verdict marker line) — the "
+            f"mechanical fallback re-run (#3415) ran the real suite and it "
+            f"FAILED: {result.reason}",
+            TEST_CONFIRMATION_REFUTED,
+        )
+
+    if result.baseline_red:
+        return (
+            "skipped",
+            f"{BASELINE_RED_REASON_PREFIX}, found by the mechanical fallback "
+            f"re-run after a mute Test-stage leg (#3415): {result.reason}",
+            TEST_CONFIRMATION_BASELINE_RED,
+        )
+
+    # result.confirmed
+    return (
+        "passed",
+        "headless smoke ended mute (no verdict marker line), but the "
+        f"mechanical fallback re-run (#3415) independently ran the real "
+        f"suite and it passed: {result.reason}",
+        TEST_CONFIRMATION_CONFIRMED,
+    )
+
+
 def _record_smoke_verdict(
     transition: Transition, entry: dict, parent_id: str,
 ) -> None:
@@ -2658,6 +2766,29 @@ def _record_smoke_verdict(
 
     # No verdict line, clean session exit. NOT a pass.
     #
+    # #3415: before treating this as "no answer, retry", ask the mechanical
+    # fallback (`coord.confirm_test.confirm_branch`, no LLM, no waiting) for
+    # a real one. 7/7 sampled mute legs backgrounded the suite, correctly
+    # stated the polling rule, and ended their turn anyway — that is a
+    # structural property of a one-shot session, not something a bigger
+    # retry budget fixes. A decisive mechanical result is recorded straight
+    # away, with no leg spent and no tally incremented.
+    mechanical = _mechanical_mute_verdict(transition, entry, parent_id)
+    if mechanical is not None:
+        state, reason, confirmation = mechanical
+        record_test_verdict(
+            assignment_id=parent_id,
+            test_state=state,
+            test_reason=reason,
+            test_confirmation=confirmation,
+        )
+        log.info(
+            "smoke %s: mute Test-stage leg — the #3415 mechanical fallback "
+            "reached a decisive verdict %r with no retry needed.",
+            transition.assignment_id, state,
+        )
+        return
+
     # #2272: count the legs, don't just test for the marker's presence. The
     # tally lives at the FRONT of `test_reason` so a bounded `/board` preview
     # still carries it, and `dispatch_smoke` re-states it across the `running`

{code_coordinator-0.5.506 → code_coordinator-0.5.507}/tests/test_notify.py

@@ -3404,6 +3404,158 @@ class TestSmokeVerdictFailsClosed(TestSmokeCompletionVerdict):
         assert row["test_reason"] == "worker: 5 failed"
 
 
+class TestMuteLegMechanicalFallback(TestSmokeVerdictFailsClosed):
+    """#3415: a MUTE Test-stage leg (no `SMOKE:` marker, clean exit) must
+    try the mechanical fallback (`coord.confirm_test.confirm_branch`, no LLM,
+    no waiting) BEFORE falling into the mute-leg retry/park tally — sampling
+    every #3376 alarm found 7/7 mute legs backgrounded the suite, stated the
+    polling rule correctly, and ended their turn anyway, which is a
+    structural property of a one-shot session no prompt wording fixes.
+
+    Reuses ``TestSmokeVerdictFailsClosed``'s ``_setup``/``_reap``/``_row``
+    helpers — the scenario (mute leg: ``exit_code=0``, ``log=None``) is
+    identical; only what the stubbed mechanical run reports differs.
+    """
+
+    def test_decisive_confirmed_result_records_passed_with_no_retry(
+        self, coord_db, tmp_path
+    ) -> None:
+        from coord import confirm_test as ct  # noqa: PLC0415
+
+        transition, record, entry = self._setup(
+            "work-3415a", "smoke-3415a", exit_code=0, log=None,
+        )
+        confirmed = ct.ConfirmationResult(
+            kind=ct.KIND_OK,
+            reason="independently re-ran `pytest -q` at origin/x and it passed",
+            command="pytest -q",
+            returncode=0,
+        )
+        with (
+            patch("coord.notify._agent_host", return_value=None),
+            patch("coord.notify._run_pass_confirmation", return_value=confirmed),
+        ):
+            self._reap(transition, record, entry)
+
+        row = self._row("work-3415a")
+        assert row["test_state"] == "passed", (
+            "a mute leg with a decisive mechanical PASS must record 'passed' "
+            f"directly, no retry — got {row['test_state']!r}"
+        )
+        assert row["test_confirmation"] == ct.TEST_CONFIRMATION_CONFIRMED
+        assert "mechanical fallback" in (row["test_reason"] or "")
+        assert "no-verdict" not in (row["test_reason"] or "").lower(), (
+            "a decisive mechanical result must not read like the old "
+            "unresolved mute-leg tally text"
+        )
+
+    def test_decisive_refuted_result_records_failed_with_no_retry(
+        self, coord_db, tmp_path
+    ) -> None:
+        from coord import confirm_test as ct  # noqa: PLC0415
+
+        transition, record, entry = self._setup(
+            "work-3415b", "smoke-3415b", exit_code=0, log=None,
+        )
+        refuted = ct.ConfirmationResult(
+            kind=ct.KIND_SUITE,
+            reason="`pytest -q` exited 1 at origin/x",
+            output="FAILED tests/test_thing.py::test_it",
+            command="pytest -q",
+            returncode=1,
+        )
+        with (
+            patch("coord.notify._agent_host", return_value=None),
+            patch("coord.notify._run_pass_confirmation", return_value=refuted),
+        ):
+            self._reap(transition, record, entry)
+
+        row = self._row("work-3415b")
+        assert row["test_state"] == "failed", (
+            "a mute leg with a decisive mechanical FAILURE must record "
+            f"'failed' directly, no retry — got {row['test_state']!r}"
+        )
+        assert row["test_confirmation"] == ct.TEST_CONFIRMATION_REFUTED
+        # #1384: the legacy `smoke_test` mirror is derived from `test_state`
+        # by the writer regardless of provenance — same as every other
+        # 'failed' write in this module.
+        assert row["smoke_test"] == "fail"
+
+    def test_decisive_baseline_red_result_records_skipped_with_no_retry(
+        self, coord_db, tmp_path
+    ) -> None:
+        from coord import confirm_test as ct  # noqa: PLC0415
+
+        transition, record, entry = self._setup(
+            "work-3415c", "smoke-3415c", exit_code=0, log=None,
+        )
+        baseline_red = ct.ConfirmationResult(
+            kind=ct.KIND_BASELINE_RED,
+            reason="every failure reproduces identically on the merge-base",
+            command="pytest -q",
+            returncode=1,
+        )
+        with (
+            patch("coord.notify._agent_host", return_value=None),
+            patch("coord.notify._run_pass_confirmation", return_value=baseline_red),
+        ):
+            self._reap(transition, record, entry)
+
+        row = self._row("work-3415c")
+        assert row["test_state"] == "skipped"
+        assert row["test_confirmation"] == ct.TEST_CONFIRMATION_BASELINE_RED
+
+    def test_inconclusive_mechanical_result_falls_back_to_mute_tally(
+        self, coord_db, tmp_path
+    ) -> None:
+        """The safety property: an inconclusive mechanical run (no checkout,
+        no test_command, a timeout, ...) must never invent an answer — it
+        falls back to exactly today's mute-leg tally/retry behaviour."""
+        from coord import confirm_test as ct  # noqa: PLC0415
+        from coord.smoke import mute_smoke_legs  # noqa: PLC0415
+
+        transition, record, entry = self._setup(
+            "work-3415d", "smoke-3415d", exit_code=0, log=None,
+        )
+        inconclusive = ct.ConfirmationResult(
+            kind=ct.KIND_SETUP,
+            reason="no local checkout of 'api' on this machine",
+        )
+        with (
+            patch("coord.notify._agent_host", return_value=None),
+            patch("coord.notify._run_pass_confirmation", return_value=inconclusive),
+        ):
+            self._reap(transition, record, entry)
+
+        row = self._row("work-3415d")
+        assert row["test_state"] is None, (
+            "an inconclusive mechanical run must fall back to the mute-leg "
+            f"tally (NO verdict, cleared for retry), got {row['test_state']!r}"
+        )
+        assert mute_smoke_legs(row["test_reason"]) == 1
+
+    def test_no_confirmation_available_falls_back_to_mute_tally(
+        self, coord_db, tmp_path
+    ) -> None:
+        """`_run_pass_confirmation` returning `None` (disabled, config
+        unloadable, budget exhausted) is exactly the pre-#3415 shape and must
+        degrade to the existing mute-leg tally, unchanged."""
+        from coord.smoke import mute_smoke_legs  # noqa: PLC0415
+
+        transition, record, entry = self._setup(
+            "work-3415e", "smoke-3415e", exit_code=0, log=None,
+        )
+        with (
+            patch("coord.notify._agent_host", return_value=None),
+            patch("coord.notify._run_pass_confirmation", return_value=None),
+        ):
+            self._reap(transition, record, entry)
+
+        row = self._row("work-3415e")
+        assert row["test_state"] is None
+        assert mute_smoke_legs(row["test_reason"]) == 1
+
+
 # ── #1176 review: fix-completion → re-review handoff type coverage ─────────