code-coordinator 0.5.163__tar.gz → 0.5.164__tar.gz

{code_coordinator-0.5.163 → code_coordinator-0.5.164}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.163",
+  "tag": "0.5.164",
   "distance": 0,
-  "node": "g6fa07c5850b078c8d3d43576ceee2b342698e255",
+  "node": "gacacc73c143b2a972a04f33649be185678913aa4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.163 → code_coordinator-0.5.164}/coord/drive.py

@@ -996,22 +996,35 @@ def _decide_acceptance_landing(
     something that will happen, and waiting for the fourth is the #1526
     defect: an unbounded wait for an event that cannot occur.
 
-    Three shapes get an immediate, actionable exit instead of a wait,
-    because for each of them the corrective action belongs to a loop that
-    will never run for this row:
+    Two shapes get an immediate, actionable exit instead of a wait, because
+    for each of them the corrective action belongs to a loop that will never
+    run for this row:
 
     * a FAILED slice test — the work row's equivalent dispatches
       ``coord fix``, but nothing dispatches one for a ``test-author`` row
       whose Test stage failed;
-    * a ``request-changes`` slice review — ``auto_loop`` accepts a
-      ``test-author`` fix (``FIX_DISPATCH_TYPES``), but the daemon drain
-      deliberately excludes fix dispatch (#476/#477, and #1692's own
-      analysis), so for the work row it is THIS driver that runs
-      ``coord fix``; there was no such arm for the slice;
     * ``--no-merge`` — the slice merge is a hard prerequisite for
       dispatching any work at all (#1138), so with merging switched off the
       run cannot progress, and saying so beats idling to the deadline.
 
+    A third shape — a ``request-changes`` slice review — used to be a fourth
+    immediate exit for the identical reason (``auto_loop`` accepts a
+    ``test-author`` fix via ``FIX_DISPATCH_TYPES``, but the daemon drain
+    deliberately excludes fix dispatch — #476/#477, and #1692's own
+    analysis — so for the work row it is THIS driver that runs
+    ``coord fix``, and there was no such arm for the slice). #2425: it no
+    longer is. Every retry of this lane re-dispatched a fresh author on the
+    SAME branch name instead of fixing the one review blocking it
+    (claude-coordinator#2286 — 11 re-authoring attempts over ~11h with the
+    review's findings never once addressed), because re-authoring was the
+    only path this lane had. Below, ``request-changes`` now gets the same
+    bounded ``coord fix <acceptance_review_aid>`` arm :func:`decide` already
+    runs for the work row's own review (the ``REVIEW: request-changes → fix
+    round`` arm), spending :attr:`DriveCounters.acceptance`'s OWN
+    ``fix_rounds`` — not the work row's — for the same #2079 reason the
+    slice's merge attempts get their own budget: a struggling slice review
+    must not silently leave the issue's real fix budget at zero.
+
     The merge itself reuses :func:`_decide_merge` verbatim against a shadow
     :class:`~coord.drive_state.IssueState` whose "work row" IS the slice —
     that is what carries #1891 (CI not reported → wait, don't retry), #1892
@@ -1049,15 +1062,81 @@ def _decide_acceptance_landing(
         )
 
     if state.acceptance_review_verdict == "request-changes":
-        return _die(
-            f"the JIT acceptance slice {aid} was reviewed REQUEST-CHANGES "
-            f"(review {state.acceptance_review_aid or 'unknown'}) — it will "
-            "never reach the merge queue until that is addressed, and no "
-            "loop dispatches the fix for a test-author row on its own.\n"
-            f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
-            f"   Fix it: coord fix {state.acceptance_review_aid or aid}\n"
-            "   or re-run coord drive with --no-acceptance to skip JIT "
-            "authoring."
+        # #2425: the slice's own twin of `decide()`'s `REVIEW: request-
+        # changes → fix round` arm — see the docstring above for why this
+        # used to be a bare `_die()`. `coord fix` already accepts a
+        # `type="test-author"` review id (#1622/#1692:
+        # `auto_loop.FIX_DISPATCH_TYPES` includes `SEALED_PATH_AUTHOR_TYPES`,
+        # which is where "test-author" lives), so this is the SAME command
+        # the work-row arm dispatches, not a second implementation of it.
+        slice_counters = counters.slice_budget()
+        if not state.auto_loop:
+            return _die(
+                "the JIT acceptance slice's review requested changes, but "
+                "pipeline.auto_loop is OFF — the review→fix path is "
+                "switched off in coordinator.yml, so no fix can be "
+                "dispatched.\n"
+                f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
+                "   Continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid or aid}"
+            )
+        # Belt-and-braces, mirroring the work-row arm: `acceptance_review_
+        # verdict` and `acceptance_review_aid` are read off the SAME board
+        # row (drive_state.project), so a verdict without an id is
+        # impossible today. Refuse to guess rather than dispatch `coord fix`
+        # against the wrong assignment.
+        if not state.acceptance_review_aid:
+            return _die(
+                "the JIT acceptance slice's review verdict is "
+                "'request-changes' but no review assignment id is on the "
+                "board — refusing to guess which review to fix. Inspect: "
+                f"coord gates {state.repo} {state.issue}"
+            )
+        # Same de-duplication latch as `review_fix_dispatched_for` on the
+        # work row's own arm, just on the slice's own counters: `coord fix`
+        # returns as soon as the fix worker is dispatched, and the board
+        # this driver polls needs a beat to show the new row.
+        if slice_counters.review_fix_dispatched_for == state.acceptance_review_aid:
+            return _wait(
+                label=(
+                    "ACCEPTANCE: fix already dispatched for "
+                    f"{state.acceptance_review_aid} — waiting for the fix "
+                    "row to appear on the board"
+                )
+            )
+        if slice_counters.fix_rounds >= opts.max_fix_rounds:
+            return _die(
+                f"the JIT acceptance slice {aid} was reviewed REQUEST-"
+                f"CHANGES (review {state.acceptance_review_aid}) after "
+                f"{slice_counters.fix_rounds} fix round(s) this drive spent "
+                "landing the slice — stopping.\n"
+                f"   Findings: coord log {state.acceptance_review_aid}\n"
+                f"   Continue by hand: coord fix {state.acceptance_review_aid}\n"
+                "   or re-run coord drive with --no-acceptance to skip JIT "
+                "authoring."
+            )
+        slice_counters.fix_rounds += 1
+        slice_counters.review_fix_dispatched_for = state.acceptance_review_aid
+        return Action(
+            kind=RUN,
+            label=(
+                "ACCEPTANCE: review request-changes → fix round "
+                f"{slice_counters.fix_rounds}/{opts.max_fix_rounds} "
+                f"(coord fix {state.acceptance_review_aid})"
+            ),
+            command=("fix", state.acceptance_review_aid),
+            error_message=(
+                f"coord fix {state.acceptance_review_aid} failed to "
+                "dispatch a fix for the JIT acceptance slice's review.\n"
+                "   Its refusals are all guards doing their job: auto_loop "
+                "disabled, no structured\n"
+                "   findings, approve-with-nits (#476), max_review_"
+                "iterations, or the #522\n"
+                "   terminal-work guard — the message above names which.\n"
+                f"   Check: coord log {state.acceptance_review_aid}   /   "
+                "continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid}"
+            ),
         )
 
     if not opts.do_merge:

{code_coordinator-0.5.163 → code_coordinator-0.5.164}/tests/test_drive.py

@@ -1304,18 +1304,112 @@ def test_failed_slice_test_stops_with_the_fix_command():
     assert "coord fix ta1" in action.message
 
 
-def test_slice_review_request_changes_stops_with_the_fix_command():
+def test_slice_review_request_changes_dispatches_a_fix():
+    """#2425: the JIT lane's own twin of the work row's `REVIEW:
+    request-changes → fix round` arm — before this, a request-changes
+    verdict on the slice was a dead end nothing ever dispatched a fix for
+    (claude-coordinator#2286: 11 re-authoring retries over ~11h, never once
+    addressing the review)."""
+    counters = DriveCounters()
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == ("fix", "rv1")
+    assert "rv1" in action.label
+    assert not action.is_exit
+    # Spends the SLICE's own budget, not the work row's (#2079's rule,
+    # extended to fix rounds): landing the slice must not silently leave
+    # the issue's own fix budget at zero.
+    assert counters.fix_rounds == 0
+    assert counters.acceptance is not None
+    assert counters.acceptance.fix_rounds == 1
+    assert counters.acceptance.review_fix_dispatched_for == "rv1"
+
+
+def test_slice_review_fix_already_dispatched_waits_for_the_board():
+    """The de-dup latch: a second poll against the SAME review id must not
+    spawn a second fix worker on the same branch (#476/#477)."""
+    counters = DriveCounters()
+    counters.slice_budget().review_fix_dispatched_for = "rv1"
     action = landing_step(
         landing_state(
             acceptance_review_verdict="request-changes",
             acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == WAIT
+    assert "rv1" in action.label
+    assert counters.acceptance.fix_rounds == 0
+
+
+def test_slice_review_fix_rounds_are_bounded_then_die():
+    """Bounded the same way the work row's fix loop is — a slice review that
+    keeps coming back request-changes must eventually escalate, not spin."""
+    opts = DriveOptions(machine="precision", max_fix_rounds=2)
+    counters = DriveCounters()
+    for expected_round in (1, 2):
+        action = landing_step(
+            landing_state(
+                acceptance_review_verdict="request-changes",
+                acceptance_merge_status="",
+            ),
+            opts,
+            counters=counters,
         )
+        assert action.kind == RUN
+        assert action.command == ("fix", "rv1")
+        assert counters.acceptance.fix_rounds == expected_round
+        # Clear the latch between rounds the same way a changed review row
+        # would on the real board (a fresh review after the fix landed).
+        counters.acceptance.review_fix_dispatched_for = ""
+
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        opts,
+        counters=counters,
     )
     assert action.is_exit
     assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "2 fix round(s)" in action.message
     assert "coord fix rv1" in action.message
 
 
+def test_slice_review_request_changes_with_auto_loop_off_dies_without_dispatching():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            auto_loop=False,
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "auto_loop is OFF" in action.message
+    assert "coord assign --interactive --fix-of rv1" in action.message
+
+
+def test_slice_review_request_changes_with_no_review_id_refuses_to_guess():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            acceptance_review_aid="",
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "refusing to guess" in action.message
+
+
 def test_no_merge_refuses_up_front_instead_of_idling_to_the_deadline():
     """`--no-merge` makes the run unable to progress at all (#1138 refuses
     the work dispatch until the slice lands) — say so immediately."""