code-coordinator 0.5.541__tar.gz → 0.5.542__tar.gz

{code_coordinator-0.5.541 → code_coordinator-0.5.542}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.541",
+  "tag": "0.5.542",
   "distance": 0,
-  "node": "g86827ed61aa79dc5a11cdfbac183ed00d6439c84",
+  "node": "gdf0736aada6feb22b04725dbc54d5aec689a1da6",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-30"

{code_coordinator-0.5.541 → code_coordinator-0.5.542}/coord/notify.py

@@ -1175,6 +1175,44 @@ def _fix_round_ceiling_blocked_for_work(work: "Assignment") -> bool:
     return is_fix_round_ceiling_blocked(dq_entry.state, dq_entry.last_reason)
 
 
+def _drive_terminally_exited_for_work(work: "Assignment") -> bool:
+    """#3308: true when *work*'s (repo, issue) has a drive-queue row that has
+    already exited for good — :data:`coord.drive_queue.STUCK_QUEUE_STATES`
+    (``blocked``/``failed``), the same "is this row stuck" question
+    :func:`coord.drive_queue.add_preflight_notice` and :mod:`coord.reports`
+    already ask rather than re-deriving it (#2096's "one question, one
+    answer").
+
+    ``blocked`` covers every terminal cause ``_reconcile_running`` can write
+    for a drive-queue row: the permanent give-ups already marked with a
+    :data:`coord.drive_queue._PERMANENT_BLOCK_MARKERS` token
+    (``refused``/``dead_end``/the #2972 fix-round ceiling) AND the plain
+    ``N/N attempts — giving up`` ``exhausted`` outcome that carries no
+    marker at all — vimcode#883, this issue's own reference case, exhausted
+    a ``checks_stale`` merge block that way. All of them share the same
+    consequence for THIS caller: nothing is going to relaunch the row on
+    its own. #2230's blocked-resume sweep only resumes a `blocked` entry on
+    POSITIVE evidence its own merge gate now reads clear, and a
+    ``merge_conflict_unresolved`` CONFLICT can never supply that evidence —
+    so distinguishing which specific `blocked` reason this is would add
+    complexity with no different answer for this call site.
+
+    Same "no row for this (repo, issue) reads as nothing to act on" default
+    as :func:`_fix_round_ceiling_blocked_for_work` above — an issue can be
+    driven with no ``coord drive-queue add`` at all, and a live/waiting row
+    (still owned by a real or soon-to-relaunch drive) correctly reads
+    ``False`` here too.
+    """
+    from coord.drive_queue import QueueEntry, STUCK_QUEUE_STATES  # noqa: PLC0415
+    from coord.state import get_drive_queue_entry  # noqa: PLC0415
+
+    row = get_drive_queue_entry(work.repo_name, work.issue_number)
+    if row is None:
+        return False
+    dq_entry = QueueEntry.from_row(row)
+    return dq_entry.state in STUCK_QUEUE_STATES
+
+
 def _conflict_confined_to_sealed_paths(
     entry: "QueuedMerge", config: Config,
 ) -> list[str] | None:
@@ -1238,7 +1276,17 @@ def dispatch_stalled_pipeline_action(
     ``mock-author``), which dispatches regardless of the flag: no loop owns
     that row (#2302), so the flag would only leave it stalled forever with
     no alternative dispatcher to race. ``work`` rows under the same reasons
-    keep the opt-in gate — ``coord drive`` owns those.
+    keep the opt-in gate — ``coord drive`` owns those — UNLESS (#3308) the
+    reason is ``merge_conflict_unresolved`` AND the owning drive-queue row
+    has already exited for good (:func:`_drive_terminally_exited_for_work`
+    — budget-exhausted or dead-end): the "``coord drive`` owns those"
+    premise is false the instant the drive itself has terminally stopped,
+    and #2230's own blocked-resume sweep cannot recover a genuine conflict
+    either, so this is the identical "no loop owns this row, no alternative
+    dispatcher to race" shape #2302/#2537 already carved out — just for a
+    ``work`` row whose drive has exited rather than a row type ``coord
+    drive`` never ran at all.
+
     Mutates *board* in place exactly like
     the auto-loop / review-dispatch helpers it delegates to — the caller is
     responsible for persisting it.
@@ -1331,13 +1379,32 @@ def dispatch_stalled_pipeline_action(
     # (observed live: coord-portal#132). So this reason joins the bypass for
     # these row types too — every other reason, and `work` rows under either
     # reason, keep the opt-in gate unchanged.
+    #
+    # #3308: a `merge_conflict_unresolved` stall whose OWNING drive-queue row
+    # has already exited for good (vimcode#883: `checks_stale` exhausted its
+    # attempt budget, then a #2246 sibling sweep reclassified the parked
+    # merge-queue entry as a rebaseable CONFLICT) is the SAME "no loop owns
+    # this row" shape as the #2302/#2537 carve-outs above — just reached from
+    # a `work` row whose drive genuinely ran, rather than a row type `coord
+    # drive` never touches. The "`coord drive` owns those" premise the `work`
+    # opt-in gate otherwise relies on is false once that drive has terminally
+    # exited: there is no live session left to race, and #2230's own
+    # blocked-resume sweep only resumes on evidence the merge gate reads
+    # clear, which a genuine conflict can never supply. See
+    # `_drive_terminally_exited_for_work`'s docstring for the full case list.
     from coord.models import SEALED_PATH_AUTHOR_TYPES  # noqa: PLC0415
 
     sealed_author_stall = (
         detection.reason in ("review_request_changes_no_fix", "merge_conflict_unresolved")
         and work.type in SEALED_PATH_AUTHOR_TYPES
     )
-    if not config.pipeline.auto_dispatch_stalled and not sealed_author_stall:
+    drive_exhausted_conflict = (
+        detection.reason == "merge_conflict_unresolved"
+        and _drive_terminally_exited_for_work(work)
+    )
+    if not config.pipeline.auto_dispatch_stalled and not (
+        sealed_author_stall or drive_exhausted_conflict
+    ):
         return StalledDispatchAction(
             kind="disabled", detail="pipeline.auto_dispatch_stalled is False",
         )

{code_coordinator-0.5.541 → code_coordinator-0.5.542}/tests/test_stalled_pipeline.py

@@ -2383,6 +2383,148 @@ class TestDispatchSealedAuthorBypassesFlagCoversMergeConflict:
         stub.assert_not_called()
 
 
+class TestDispatchDriveExhaustedConflictBypassesFlag:
+    """#3308: a `merge_conflict_unresolved` stall on a plain `work` row whose
+    OWNING drive-queue row has already exited for good (blocked/failed) must
+    dispatch regardless of `auto_dispatch_stalled` — the "`coord drive` owns
+    that row" premise the flag otherwise relies on is false once the drive
+    itself has terminally stopped, and #2230's own blocked-resume sweep can
+    never clear a genuine conflict either. Reference case: vimcode#883
+    exhausted its attempt budget on a `checks_stale` merge block (a PLAIN
+    `exhausted` give-up, no `_PERMANENT_BLOCK_MARKERS` token at all), then a
+    #2246 sibling sweep reclassified its parked merge-queue entry as a
+    rebaseable CONFLICT."""
+
+    def test_work_conflict_stall_dispatches_when_drive_exhausted_with_flag_off(
+        self, config: Config, monkeypatch
+    ) -> None:
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _work("work-1", test_state="passed", issue_number=883),
+            _review("work-1", aid="review-1", review_verdict="approve"),
+        )
+        queued = [QueuedMerge(
+            assignment_id="work-1", repo_name="vimcode", repo_github="acme/vimcode",
+            branch="issue-883-fix", target_branch="develop", issue_number=883,
+            issue_title="t", state=CONFLICT,
+            # #2246's own wording for a sibling-triggered park —
+            # `classify_conflict` reads "could not be rebased" as
+            # rebaseable, exactly the shape that sweep relies on.
+            error=(
+                "could not be rebased onto develop — became CONFLICTING "
+                "when a sibling merged into develop (#2246)"
+            ),
+        )]
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=queued
+        )[0]
+        assert detection.reason == "merge_conflict_unresolved"
+        assert work.type == "work"
+
+        monkeypatch.setattr("coord.merge_queue.load_queue", lambda: queued)
+        monkeypatch.setattr(
+            state_mod,
+            "get_drive_queue_entry",
+            lambda repo_name, issue_number: {
+                "repo_name": repo_name,
+                "issue_number": issue_number,
+                "state": "blocked",
+                "last_reason": (
+                    "merge : BLOCKED (checks_stale) (2/2 attempts) — "
+                    "giving up"
+                ),
+            },
+        )
+        fix_assignment = Assignment(
+            machine_name="mac-mini", repo_name="vimcode", issue_number=883,
+            issue_title="[conflict-fix] t", assignment_id="cf-883", status="pending",
+            type="conflict-fix",
+        )
+        stub = MagicMock(return_value=fix_assignment)
+        monkeypatch.setattr("coord.conflict_fix.dispatch_conflict_fix", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "conflict_fix_dispatched"
+        stub.assert_called_once()
+
+    def test_work_conflict_stall_stays_disabled_when_drive_still_waiting(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """A drive-queue row that is merely `waiting` (still scheduled to
+        relaunch) has NOT terminally exited — the flag must still gate the
+        dispatch, unlike the `blocked` case above."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _work("work-1", test_state="passed"),
+            _review("work-1", aid="review-1", review_verdict="approve"),
+        )
+        queued = [QueuedMerge(
+            assignment_id="work-1", repo_name="vimcode", repo_github="acme/vimcode",
+            branch="issue-883-fix", target_branch="develop", issue_number=883,
+            issue_title="t", state=CONFLICT,
+            error="could not be rebased onto develop",
+        )]
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=queued
+        )[0]
+        assert detection.reason == "merge_conflict_unresolved"
+
+        monkeypatch.setattr("coord.merge_queue.load_queue", lambda: queued)
+        monkeypatch.setattr(
+            state_mod,
+            "get_drive_queue_entry",
+            lambda repo_name, issue_number: {
+                "repo_name": repo_name,
+                "issue_number": issue_number,
+                "state": "waiting",
+                "last_reason": "requeued at position 1",
+            },
+        )
+        stub = MagicMock()
+        monkeypatch.setattr("coord.conflict_fix.dispatch_conflict_fix", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "disabled"
+        stub.assert_not_called()
+
+    def test_drive_exhausted_bypass_scoped_to_merge_conflict_unresolved_only(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """The #3308 bypass must not widen to OTHER stalled-pipeline
+        reasons on a `work` row just because its drive-queue row happens to
+        be `blocked` — only `merge_conflict_unresolved` is in scope."""
+        assert config.pipeline.auto_dispatch_stalled is False
+        board = _board(
+            _work("work-1", test_state="passed"),
+            _review("work-1", aid="review-1", review_verdict="request-changes"),
+        )
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=[]
+        )[0]
+        assert detection.reason == "review_request_changes_no_fix"
+        assert work.type == "work"
+
+        monkeypatch.setattr(
+            state_mod,
+            "get_drive_queue_entry",
+            lambda repo_name, issue_number: {
+                "repo_name": repo_name,
+                "issue_number": issue_number,
+                "state": "blocked",
+                "last_reason": "2/2 attempts — giving up",
+            },
+        )
+        stub = MagicMock()
+        monkeypatch.setattr("coord.auto_loop.process_review_completion", stub)
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "disabled"
+        stub.assert_not_called()
+
+
 class TestLiveSessionGuard:
     def test_dispatch_skipped_when_live_session_active(
         self, config: Config, monkeypatch