code-coordinator 0.5.218__tar.gz → 0.5.219__tar.gz

{code_coordinator-0.5.218 → code_coordinator-0.5.219}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.218",
+  "tag": "0.5.219",
   "distance": 0,
-  "node": "ge3d2e92010c272a4de2492c97e24a763480894bd",
+  "node": "g570324652ea19cd658d0b5503959bae5bc90a452",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-22"

{code_coordinator-0.5.218 → code_coordinator-0.5.219}/coord/commands/merge.py

@@ -1933,6 +1933,35 @@ def merge(
                 "— nothing to do"
             )
             sys.exit(0)
+        # #2558: a CONFLICT entry used to dead-end right here — the generic
+        # "not PENDING) — cannot merge" refusal below applies equally to
+        # HUMAN_REQUIRED/DROPPED, but CONFLICT is different from those: it is
+        # the state #241's conflict-fix exists to clear, and nothing else
+        # ever gives it a second look (`merge_queue.process()` only acts on
+        # PENDING; the reconcile pass above only unparks an entry GitHub
+        # already reports mergeable again). Give it the SAME
+        # classify-and-dispatch chance the whole-queue path gets for a fresh
+        # conflict, then still fall through to the generic refusal below —
+        # dispatching a fix does not put the branch on the target branch
+        # THIS pass, so the postcondition genuinely isn't met yet.
+        if only_entry.state == CONFLICT:
+            _verb = "(dry run) would retry" if dry_run else "retrying"
+            click.echo(
+                f"  {only_entry.repo_name} #{only_entry.issue_number} "
+                f"({only_entry.branch}): still CONFLICT — {_verb} #241 "
+                "conflict-fix dispatch instead of refusing outright (#2558)"
+            )
+            _dispatch_conflict_fixes(
+                [mq.MergeEvent(only_entry, "conflict", only_entry.error)],
+                cfg_only, dry_run=dry_run,
+            )
+            if not dry_run:
+                all_items_only = mq.load_queue()
+                by_id_only = {only_entry.assignment_id: only_entry}
+                merged_only = [
+                    by_id_only.get(x.assignment_id, x) for x in all_items_only
+                ]
+                mq.save_queue(merged_only)
         if only_entry.state != PENDING:
             click.echo(
                 f"merge-queue: entry {only_assignment!r} is in state "
@@ -2292,7 +2321,44 @@ def merge(
         presorted = True
 
     pending = [x for x in items if x.state == PENDING]
+
+    # #2558: a CONFLICT row is a dead end everywhere else in this command.
+    # #241's conflict-fix is normally dispatched off a FRESH transition into
+    # CONFLICT — process() below, the sibling sweep, --revalidate — because
+    # all three build their dispatch event from the transition itself. An
+    # entry that transitioned on some EARLIER tick and is still sitting
+    # there (no machine was free at the time, the fix is still running, or
+    # dispatch was simply declined) never reappears in a fresh `events`
+    # list, so nothing ever asks again — see the #2558 issue's coord-portal
+    # #131 repro, wedged this way with zero conflict-fix assignments ever
+    # dispatched. Give every standing CONFLICT row a fresh chance on EVERY
+    # invocation, before the terminal-state early-return below — a queue
+    # that is 100% terminal (#131's exact shape) is exactly the case that
+    # return skips.
+    standing_conflicts = [x for x in items if x.state == CONFLICT]
+    if standing_conflicts:
+        _verb = "(dry run) would retry" if dry_run else "retrying"
+        for x in standing_conflicts:
+            click.echo(
+                f"  {x.repo_name} #{x.issue_number} ({x.branch}): still "
+                f"CONFLICT — {_verb} #241 conflict-fix dispatch (#2558)"
+            )
+        _dispatch_conflict_fixes(
+            [mq.MergeEvent(x, "conflict", x.error) for x in standing_conflicts],
+            cfg, dry_run=dry_run,
+        )
+
     if not pending:
+        if not dry_run and standing_conflicts:
+            # process() never runs this pass (nothing is PENDING), so its
+            # own save-queue step below is unreached — persist whatever the
+            # redispatch above mutated (e.g. a retry-cap escalation to
+            # HUMAN_REQUIRED) before returning, same convention as the
+            # --only path above.
+            all_items = mq.load_queue()
+            by_id = {x.assignment_id: x for x in items}
+            merged = [by_id.get(x.assignment_id, x) for x in all_items]
+            mq.save_queue(merged)
         # Still surface terminal states so the user knows what happened.
         for x in items:
             click.echo(f"  [{x.state}] {x.repo_name} #{x.issue_number} ({x.branch})")

{code_coordinator-0.5.218 → code_coordinator-0.5.219}/tests/test_cli_merge.py

@@ -563,6 +563,56 @@ class TestMergeConflictReconciliation:
         states = {e.assignment_id: e.state for e in mq.load_queue()}
         assert states["c2"] == mq.CONFLICT
 
+    def test_terminal_queue_still_redispatches_a_standing_conflict(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        """#2558: a queue where EVERY entry is terminal (one MERGED, one
+        genuinely-still-conflicting CONFLICT — coord-portal#131's exact
+        shape) used to hit `if not pending: return` before ever reaching
+        the #241 classify-and-dispatch step, so a standing CONFLICT row got
+        zero chances at a conflict-fix dispatch, forever. The dispatch
+        attempt must happen BEFORE that early return, not only when other
+        PENDING work happens to be in the same batch.
+        """
+        from coord.models import Board
+        from coord.state import save_board
+        save_board(Board())
+        conflict_entry = mq.QueuedMerge(
+            assignment_id="c4", repo_name="api", repo_github="acme/api",
+            branch="worker/c4", target_branch="main", issue_number=4,
+            issue_title="t", state=mq.CONFLICT, pr_number=903,
+            error="merge conflict: GitHub reports PR #903 as CONFLICTING",
+        )
+        merged_entry = mq.QueuedMerge(
+            assignment_id="m4", repo_name="api", repo_github="acme/api",
+            branch="worker/m4", target_branch="main", issue_number=5,
+            issue_title="t", state=mq.MERGED,
+        )
+        _seed_queue([conflict_entry, merged_entry])
+
+        fake_fix = MagicMock()
+        fake_fix.machine_name = "laptop"
+
+        with patch("coord.github_ops.check_pr_mergeable", return_value=False), \
+             patch("coord.github_ops.merge_pr") as merge_fn, \
+             patch(
+                 "coord.conflict_fix.dispatch_conflict_fix",
+                 return_value=fake_fix,
+             ) as dcf:
+            result = CliRunner().invoke(
+                main, ["merge", "--config", str(config_file)]
+            )
+
+        assert result.exit_code == 0, result.output
+        merge_fn.assert_not_called()
+        assert dcf.called, "expected a #241 dispatch attempt for the standing conflict"
+        assert "conflict-fix dispatched to laptop" in result.output
+        assert "[conflict]" in result.output or "[merged]" in result.output
+
+        states = {e.assignment_id: e.state for e in mq.load_queue()}
+        assert states["c4"] == mq.CONFLICT
+        assert states["m4"] == mq.MERGED
+
     def test_dry_run_reflects_cleared_conflict_not_stale_verdict(
         self, config_file: Path, coord_dir: Path
     ) -> None:
@@ -784,6 +834,52 @@ class TestMergeOnly:
         states = {x.assignment_id: x.state for x in mq.load_queue()}
         assert states["cf1"] == mq.CONFLICT
 
+    def test_only_redispatches_a_standing_conflict(
+        self, config_file: Path, coord_dir: Path
+    ) -> None:
+        """#2558: an entry that was ALREADY sitting at CONFLICT before this
+        invocation (not one that just transitioned during it, the case
+        `test_only_dispatches_conflict_fix_on_a_fresh_conflict` covers) used
+        to hit the generic "not PENDING) — cannot merge" refusal and nothing
+        else — no reconsideration, ever, since `merge_queue.process()` only
+        acts on PENDING entries. `--only` must give it the SAME
+        classify-and-dispatch chance the whole-queue path gets, then still
+        refuse to merge it this pass (the branch isn't on the target branch
+        yet).
+        """
+        from coord.models import Board
+        from coord.state import save_board
+        save_board(Board())
+        entry = mq.QueuedMerge(
+            assignment_id="sc1", repo_name="api", repo_github="acme/api",
+            branch="worker/sc1", target_branch="main", issue_number=1,
+            issue_title="t", state=mq.CONFLICT, pr_number=910,
+            error="merge conflict: GitHub reports PR #910 as CONFLICTING",
+        )
+        _seed_queue([entry])
+
+        fake_fix = MagicMock()
+        fake_fix.machine_name = "laptop"
+
+        with patch("coord.github_ops.check_pr_mergeable", return_value=False), \
+             patch(
+                 "coord.conflict_fix.dispatch_conflict_fix",
+                 return_value=fake_fix,
+             ) as dcf:
+            result = CliRunner().invoke(
+                main, ["merge", "--config", str(config_file), "--only", "sc1"]
+            )
+
+        # Still refuses to merge THIS pass — dispatching a fix doesn't land
+        # the branch on the target branch immediately.
+        assert result.exit_code == 1
+        assert "is in state 'conflict' (not PENDING) — cannot merge" in result.output
+        assert dcf.called, "expected a fresh #241 dispatch attempt for a standing conflict"
+        assert "conflict-fix dispatched to laptop" in result.output
+
+        states = {x.assignment_id: x.state for x in mq.load_queue()}
+        assert states["sc1"] == mq.CONFLICT
+
     def test_only_errors_when_entry_not_pending(
         self, config_file: Path, coord_dir: Path
     ) -> None: