code-coordinator 0.5.646__tar.gz → 0.5.647__tar.gz

{code_coordinator-0.5.646 → code_coordinator-0.5.647}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.646
+Version: 0.5.647
 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.647/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.647",
+  "distance": 0,
+  "node": "g60a9fa87d838723613ea07d8d30f1e8a08914471",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-17"
+}

{code_coordinator-0.5.646 → code_coordinator-0.5.647}/coord/agent.py

@@ -6425,10 +6425,24 @@ PLAIN_RUNNER_LOG_TAIL_CHARS = 8000
 
 
 def _tail_text(text: str, limit: int = PLAIN_RUNNER_LOG_TAIL_CHARS) -> str:
-    """The last *limit* characters of *text*, with a marker when truncated."""
+    """Keep the first and last portions of *text* when it exceeds *limit*.
+
+    Split 1/4 head + 3/4 tail: biased toward the tail (summary markers,
+    exit status) but enough head to capture the first test failure or
+    compiler error — which is the output that matters most for a fix
+    worker and is otherwise lost when later stages pile on compilation
+    noise (#3715).
+    """
     if len(text) <= limit:
         return text
-    return f"...[truncated, {len(text) - limit} earlier chars omitted]...\n{text[-limit:]}"
+    head_budget = limit // 4
+    tail_budget = limit - head_budget
+    omitted = len(text) - limit
+    return (
+        f"{text[:head_budget]}\n"
+        f"...[truncated, {omitted} chars omitted — first {head_budget} + last {tail_budget} shown]...\n"
+        f"{text[-tail_budget:]}"
+    )
 
 
 @dataclass(frozen=True)

{code_coordinator-0.5.646 → code_coordinator-0.5.647}/coord/drive.py

@@ -558,6 +558,19 @@ class DriveCounters:
     # another round" loop, and a drive that spends three rounds bouncing
     # between them has spent three rounds. Bounded by `opts.max_fix_rounds`.
     fix_rounds: int = 0
+    # #3713: branch SHA when the last fix round was dispatched.  If we
+    # re-enter `_decide_test` and the SHA is unchanged, the fix round
+    # pushed 0 commits (killed or otherwise empty) — undo the increment
+    # so an infra death doesn't spend the budget.
+    fix_round_dispatched_sha: str = ""
+    # #3713: SHA for which we already gave one free empty-fix-round retry.
+    # Prevents infinite undo→redispatch when a fix worker never pushes.
+    empty_fix_retried_sha: str = ""
+    # #3714: one-shot retry latch — the branch SHA for which we already
+    # retried the test stage before dispatching a fix round.  A first
+    # test failure at a given SHA retries the test; only the second
+    # failure at the same SHA proceeds to a fix round.
+    test_retry_sha: str = ""
     merge_attempts: int = 0
     review_dispatches: int = 0
     # #1584: bounded retry for a review WORKER that died (transient API
@@ -3190,7 +3203,7 @@ def decide(
             acceptance_gate, warnings=warnings + acceptance_gate.warnings
         )
 
-    test = _decide_test(state, opts, counters, machine)
+    test = _decide_test(state, opts, counters, machine, verifier=verifier)
     if test is not None:
         return replace(test, warnings=warnings + test.warnings)
 
@@ -3562,6 +3575,7 @@ def _decide_test(
     opts: DriveOptions,
     counters: DriveCounters,
     machine: str,
+    verifier: MergeVerifier | None = None,
 ) -> Action | None:
     """The TEST gate.  ``None`` means "passed/skipped, fall through".
 
@@ -3655,6 +3669,25 @@ def _decide_test(
                 f"   Recover: coord diagnose {state.repo} {state.issue} "
                 "--stage test --reset"
             )
+        # #3713: if we dispatched a fix round and the branch HEAD has not
+        # advanced, the fix worker pushed 0 commits (killed, timed out, or
+        # found nothing to do).  Undo the previous increment so an infra
+        # death doesn't spend the budget — but only once per SHA (the
+        # `empty_fix_retried_sha` latch prevents infinite undo→redispatch).
+        # `branch_head_sha` costs one GitHub API call — only invoked here
+        # (test failed + fix_rounds > 0), not on every poll.
+        current_sha: str | None = None
+        if (
+            counters.fix_rounds > 0
+            and counters.fix_round_dispatched_sha
+            and verifier is not None
+        ):
+            current_sha = verifier.branch_head_sha(state)
+            if current_sha and current_sha == counters.fix_round_dispatched_sha:
+                if counters.empty_fix_retried_sha != current_sha:
+                    counters.fix_rounds -= 1
+                    counters.empty_fix_retried_sha = current_sha
+
         if counters.fix_rounds >= opts.max_fix_rounds:
             return _die(
                 f"test still failing after {counters.fix_rounds} fix round(s) — "
@@ -3665,7 +3698,33 @@ def _decide_test(
                 f"   Continue by hand: coord assign --interactive --fix-of "
                 f"{state.work_aid}"
             )
+
+        # #3714: retry the test once before consuming a fix round.  A
+        # first failure at a given SHA gets one automatic retest; only the
+        # second failure at the same SHA dispatches the fix worker.  This
+        # avoids burning a fix slot on a transient / flaky failure.
+        branch_sha = current_sha or (
+            verifier.branch_head_sha(state) if verifier is not None else None
+        )
+        if branch_sha and counters.test_retry_sha != branch_sha:
+            counters.test_retry_sha = branch_sha
+            return Action(
+                kind=RUN,
+                label="TEST: failed — retrying once before fix round (#3714)",
+                command=(
+                    "diagnose", state.repo, str(state.issue),
+                    "--stage", "test", "--reset",
+                ),
+                error_message=(
+                    f"coord diagnose {state.repo} {state.issue} "
+                    "--stage test --reset failed."
+                ),
+                sleep_after=10.0,
+            )
+
         counters.fix_rounds += 1
+        # Record the branch SHA so #3713 can detect an empty fix round.
+        counters.fix_round_dispatched_sha = branch_sha or ""
         # `coord fix` gates on the assignment's legacy `smoke_test == "fail"`
         # field — which `coord test --fail` mirrors from `test_state` — and
         # dispatches a follow-up worker with `inherit_branch=True`, so the fix

{code_coordinator-0.5.646 → code_coordinator-0.5.647}/tests/test_drive.py

@@ -3271,28 +3271,94 @@ def test_a_done_smoke_child_with_lagging_test_state_still_just_waits():
     assert action.kind == WAIT
 
 
-def test_a_failed_test_loops_through_coord_fix_on_the_same_branch():
-    """`coord fix` gates on the legacy smoke_test field and dispatches with
-    inherit_branch=True — the same branch, model escalated (#1445)."""
+def test_a_failed_test_retries_once_before_fix_round():
+    """#3714: the first test failure at a given SHA retries the test stage
+    via ``coord diagnose --stage test --reset`` before consuming a fix round."""
     counters = DriveCounters()
-    action = step(
-        done_work(work_test_state="failed", work_test_reason="3 failed"),
-        counters=counters,
+    s = done_work(work_test_state="failed", work_test_reason="3 failed")
+    retry = step(s, counters=counters)
+    assert retry.command[0] == "diagnose"
+    assert "--reset" in retry.command
+    assert counters.fix_rounds == 0
+
+    # Second failure at the same SHA proceeds to the fix round.
+    fix = step(s, counters=counters)
+    assert fix.command == ("fix", "w1")
+    assert counters.fix_rounds == 1
+    assert "smoke_test" in fix.error_message
+    assert fix.on_error == "die"
+
+
+def test_empty_fix_round_does_not_spend_the_budget():
+    """#3713: if a fix worker pushes 0 commits (SHA unchanged), the fix_rounds
+    increment is undone so an infra death doesn't consume the budget."""
+    sha = "aaa"
+    v = FakeVerifier(head_sha=sha)
+    counters = DriveCounters(
+        test_retry_sha=sha,  # #3714 retry already spent
+        fix_rounds=1,
+        fix_round_dispatched_sha=sha,  # previous fix dispatched at this SHA
     )
+    s = done_work(work_test_state="failed", work_test_reason="3 failed")
+
+    # SHA unchanged → #3713 undoes the increment, then re-dispatches.
+    action = step(s, counters=counters, verifier=v)
     assert action.command == ("fix", "w1")
-    assert counters.fix_rounds == 1
-    assert "smoke_test" in action.error_message  # the diagnosis if it won't dispatch
-    assert action.on_error == "die"
+    assert counters.fix_rounds == 1  # net: undid 1→0, then dispatched 0→1
+    assert counters.empty_fix_retried_sha == sha
+
+
+def test_empty_fix_round_latch_prevents_infinite_undo():
+    """#3713: the empty_fix_retried_sha latch prevents a second undo at the
+    same SHA, so an infinitely-failing fix worker doesn't loop forever."""
+    sha = "aaa"
+    v = FakeVerifier(head_sha=sha)
+    counters = DriveCounters(
+        test_retry_sha=sha,
+        fix_rounds=1,
+        fix_round_dispatched_sha=sha,
+        empty_fix_retried_sha=sha,  # latch already set for this SHA
+    )
+    opts = DriveOptions(machine="precision", max_fix_rounds=2)
+    s = done_work(work_test_state="failed", work_test_reason="3 failed")
+
+    # SHA unchanged but latch is set → fix_rounds is NOT undone.
+    action = step(s, opts, counters=counters, verifier=v)
+    assert action.command == ("fix", "w1")
+    assert counters.fix_rounds == 2  # no undo: stayed at 1, then incremented to 2
+
+    # A third attempt at the same SHA hits the ceiling.
+    exhausted = step(s, opts, counters=counters, verifier=v)
+    assert exhausted.is_exit
+    assert "after 2 fix round(s)" in exhausted.message
 
 
 def test_the_test_fix_loop_is_bounded_by_max_fix_rounds():
     counters = DriveCounters()
     opts = DriveOptions(machine="precision", max_fix_rounds=2)
     s = done_work(work_test_state="failed", work_test_reason="3 failed")
+    v = FakeVerifier(head_sha="aaa")
 
-    assert step(s, opts, counters=counters).command == ("fix", "w1")
-    assert step(s, opts, counters=counters).command == ("fix", "w1")
-    exhausted = step(s, opts, counters=counters)
+    # #3714 retry fires first.
+    retry = step(s, opts, counters=counters, verifier=v)
+    assert retry.command[0] == "diagnose"
+
+    # Second failure at same SHA → fix round 1.
+    assert step(s, opts, counters=counters, verifier=v).command == ("fix", "w1")
+    assert counters.fix_rounds == 1
+
+    # Simulate the fix worker pushing a commit (new SHA).
+    v = FakeVerifier(head_sha="bbb")
+    # #3714 retry fires at the new SHA.
+    retry2 = step(s, opts, counters=counters, verifier=v)
+    assert retry2.command[0] == "diagnose"
+    # Second failure at new SHA → fix round 2.
+    assert step(s, opts, counters=counters, verifier=v).command == ("fix", "w1")
+    assert counters.fix_rounds == 2
+
+    # Third attempt at yet another SHA → ceiling reached.
+    v = FakeVerifier(head_sha="ccc")
+    exhausted = step(s, opts, counters=counters, verifier=v)
     assert exhausted.is_exit
     assert exhausted.exit_code == EXIT_TERMINAL_FAILURE
     assert "after 2 fix round(s)" in exhausted.message
@@ -3688,29 +3754,34 @@ def test_the_review_fix_arm_shares_one_fix_budget_with_the_test_arm():
     """Not a parallel counter (#1692): a failing test and a request-changes
     review are two shapes of one loop, so a drive that bounces between them
     spends ONE budget. Two rounds of mixed kinds exhaust --max-fix-rounds 2."""
-    counters = DriveCounters()
+    sha = "aaa"
+    v = FakeVerifier(head_sha=sha)
+    counters = DriveCounters(test_retry_sha=sha)  # #3714 retry already spent
     opts = DriveOptions(machine="precision", max_fix_rounds=2)
 
     first = step(
         done_work(work_test_state="failed", work_test_reason="3 failed"),
-        opts, counters=counters,
+        opts, counters=counters, verifier=v,
     )
     assert first.command == ("fix", "w1")  # test arm, round 1
 
-    second = step(requested_changes(), opts, counters=counters)
+    # Simulate the fix worker pushing (SHA advances).
+    v2 = FakeVerifier(head_sha="bbb")
+    second = step(requested_changes(), opts, counters=counters, verifier=v2)
     assert second.command == ("fix", "r1")  # review arm, round 2
     assert counters.fix_rounds == 2
 
     # A THIRD round of either kind is over budget.
-    exhausted = step(requested_changes(review_aid="r2"), opts, counters=counters)
+    exhausted = step(requested_changes(review_aid="r2"), opts, counters=counters, verifier=v2)
     assert exhausted.is_exit
     assert exhausted.exit_code == EXIT_TERMINAL_FAILURE
     assert "after 2 fix round(s)" in exhausted.message
     assert "NOT exhausted" in exhausted.message  # says WHICH cap was hit
 
+    # The test arm also stays exhausted (fix_rounds already at ceiling).
     still_exhausted = step(
         done_work(work_test_state="failed", work_test_reason="3 failed"),
-        opts, counters=counters,
+        opts, counters=counters, verifier=v2,
     )
     assert still_exhausted.is_exit
 

code_coordinator-0.5.646/code_coordinator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.646",
-  "distance": 0,
-  "node": "ge59cc3a4876a427faa94ffa1298b1a0bab4b5852",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-16"
-}