code-coordinator 0.5.186__tar.gz → 0.5.187__tar.gz

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.186",
+  "tag": "0.5.187",
   "distance": 0,
-  "node": "g91a8fc0c07fd891a6a9c258c7f30aba6e090c865",
+  "node": "gc74dfc5a8d399b33526076eaec24aed5d5ad1ce3",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-20"

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/coord/commands/merge.py

@@ -456,7 +456,9 @@ def _dispatch_conflict_fixes(events, config, *, dry_run: bool) -> None:
             # failed for this entry in this session, don't loop — mark
             # HUMAN_REQUIRED so the user takes over.  A successful
             # prior fix does not trigger this guard (#784).
-            if has_prior_conflict_fix(fix_board, ev.entry.assignment_id):
+            if has_prior_conflict_fix(
+                fix_board, ev.entry.assignment_id, current_error=ev.entry.error,
+            ):
                 ev.entry.state = HUMAN_REQUIRED
                 click.echo(
                     f"  {ev.entry.repo_name} #{ev.entry.issue_number}: "

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/coord/conflict_fix.py

@@ -367,7 +367,32 @@ def _has_active_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
     )
 
 
-def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
+def _dispatched_error(assignment: Assignment) -> str | None:
+    """The merge-failure text *assignment*'s briefing was built from.
+
+    ``build_conflict_fix_briefing``/``build_semantic_conflict_briefing``
+    both embed the triggering ``QueuedMerge.error`` verbatim (as a
+    ``"Reason: …"``/``"Last merge error: …"`` line) — that's the only durable
+    record of what the merge looked like *at dispatch time*, since
+    ``on_conflict_fix_done`` clears ``entry.error`` back to ``None`` on
+    success before the merge is retried. Returns ``None`` when the briefing
+    doesn't carry either marker (e.g. a hand-built test ``Assignment``).
+    """
+    briefing = assignment.briefing or ""
+    for line in briefing.splitlines():
+        if line.startswith("Reason: "):
+            return line[len("Reason: "):]
+        if line.startswith("Last merge error: "):
+            return line[len("Last merge error: "):]
+    return None
+
+
+def has_prior_conflict_fix(
+    board: Board,
+    merge_entry_id: str | None,
+    *,
+    current_error: str | None = None,
+) -> bool:
     """True when a second conflict-fix dispatch for *merge_entry_id* is blocked.
 
     Blocks when a conflict-fix is **active** (running/pending — don't spawn a
@@ -379,6 +404,18 @@ def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
     followed by a new conflict if other PRs merged in the meantime; that is a
     fresh situation and warrants a fresh fix attempt.  Only actual failures
     consume the one-per-entry cap.
+
+    #2475: that "successful" carve-out assumed a ``done`` conflict-fix always
+    resolved *something*. It doesn't when the merge was never blocked by a
+    content conflict in the first place (e.g. a permanently-unmergeable
+    branch-protection state) — the worker finds nothing to rebase, exits
+    ``done``, and the merge queue retries into the *identical* failure
+    forever (#2009's 38-turn thrash). When *current_error* is given and a
+    prior ``done`` conflict-fix's dispatch-time error
+    (:func:`_dispatched_error`) matches it exactly, that's the same blocker
+    recurring unchanged — not a fresh conflict — so it now consumes the cap
+    too. Callers that don't pass *current_error* keep the pre-#2475 behaviour
+    (``done`` never blocks) since they have no error text to compare.
     """
     if merge_entry_id is None:
         return False
@@ -393,9 +430,16 @@ def has_prior_conflict_fix(board: Board, merge_entry_id: str | None) -> bool:
         # Genuine failure — retry cap consumed, surface to human.
         if a.status in ("failed", "advisory"):
             return True
-        # "done" = successful rebase → cap not consumed; a re-conflict is new.
-        # "cancelled" falls through here too — a cancelled attempt did no work,
-        # so it is treated the same as "done": re-dispatch is allowed.
+        if a.status == "done":
+            if current_error is not None and _dispatched_error(a) == current_error:
+                # Same failure text recurring after a "successful" fix means
+                # nothing was actually fixed — treat like a genuine failure.
+                return True
+            # Otherwise: successful rebase, different (or unknown) situation
+            # now → cap not consumed; a re-conflict is new.
+        # "cancelled" falls through here too — a cancelled attempt did no
+        # work, so it is treated the same as an unrelated "done": re-dispatch
+        # is allowed.
     return False
 
 
@@ -463,7 +507,10 @@ def dispatch_conflict_fix(
     the caller marks the entry ``HUMAN_REQUIRED``.  A ``done`` (successful)
     conflict-fix does *not* block a new dispatch — a successful rebase can be
     followed by a fresh conflict if other PRs merged in the meantime, and that
-    warrants a new attempt rather than an immediate human escalation (#784).
+    warrants a new attempt rather than an immediate human escalation (#784) —
+    UNLESS (#2475) *entry.error* is identical to the error the prior ``done``
+    attempt was dispatched for, which means the merge failed the same way
+    again with nothing actually fixed; see :func:`has_prior_conflict_fix`.
 
     ``semantic=True`` (#1291) dispatches the escalated second attempt: a
     different, less prescriptive briefing (see
@@ -481,7 +528,9 @@ def dispatch_conflict_fix(
             return None
         if _has_active_conflict_fix(board, entry.assignment_id):
             return None
-    elif has_prior_conflict_fix(board, entry.assignment_id):
+    elif has_prior_conflict_fix(
+        board, entry.assignment_id, current_error=entry.error,
+    ):
         return None
 
     repo = config.repo(entry.repo_name)

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/coord/merge_queue.py

@@ -93,6 +93,18 @@ _HUMAN_SIGNALS = (
     "permission",
     "protected branch",
     "branch protection",
+    # #2475: GitHub's wording when a required status check can never report
+    # — e.g. its source CI job was deleted from the workflow while the
+    # check was still required in branch protection. This is a *permanent*
+    # block; no rebase or content change fixes it. The full message is
+    # something like "Pull request X is not mergeable: the base branch
+    # policy prohibits the merge.", which also contains "not mergeable" —
+    # a _REBASEABLE_SIGNALS entry — so without this specific phrase here,
+    # classify_conflict fell through past _HUMAN_SIGNALS (no match) to
+    # _REBASEABLE_SIGNALS's generic "not mergeable" match and misclassified
+    # the failure as "rebaseable", dispatching a conflict-fix worker that
+    # could never succeed (#2009's 38-turn thrash).
+    "policy prohibits the merge",
 )
 
 

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/coord/notify.py

@@ -884,7 +884,11 @@ def detect_stalled_pipeline(
             elif (
                 matching_entry.state == CONFLICT
                 and classify_conflict(matching_entry.error) == "rebaseable"
-                and not has_prior_conflict_fix(board, matching_entry.assignment_id)
+                and not has_prior_conflict_fix(
+                    board,
+                    matching_entry.assignment_id,
+                    current_error=matching_entry.error,
+                )
             ):
                 # #1478: a rebaseable CONFLICT with no active/failed
                 # conflict-fix attempt — the #1474 classify-and-dispatch step
@@ -1412,7 +1416,9 @@ def dispatch_stalled_pipeline_action(
             return StalledDispatchAction(
                 kind="no_action", detail="merge queue entry no longer found",
             )
-        if has_prior_conflict_fix(board, entry.assignment_id):
+        if has_prior_conflict_fix(
+            board, entry.assignment_id, current_error=entry.error,
+        ):
             return StalledDispatchAction(
                 kind="skipped_human_required",
                 detail="conflict-fix already active or its retry cap was already hit",

{code_coordinator-0.5.186 → code_coordinator-0.5.187}/tests/test_conflict_fix.py

@@ -111,6 +111,21 @@ class TestClassifyConflict:
     def test_human(self, msg: str) -> None:
         assert classify_conflict(msg) == "human"
 
+    def test_branch_policy_block_is_human_not_rebaseable(self) -> None:
+        """#2475: GitHub's wording when a required status check can never
+        report (its source CI job was deleted while still required) also
+        contains "not mergeable" — a _REBASEABLE_SIGNALS entry — so without
+        a specific _HUMAN_SIGNALS match this fell through and was
+        misclassified "rebaseable", dispatching a conflict-fix worker that
+        could never succeed (#2009's 38-turn thrash: 38 dispatches over ~7
+        hours before a human intervened).
+        """
+        msg = (
+            "Pull request #2471 is not mergeable: the base branch policy "
+            "prohibits the merge."
+        )
+        assert classify_conflict(msg) == "human"
+
     def test_unknown(self) -> None:
         assert classify_conflict("some other error") == "unknown"
         assert classify_conflict("") == "unknown"
@@ -445,6 +460,38 @@ class TestDispatch:
         )
         assert len(client.calls) == 1, "HTTP should have been called"
 
+    def test_retry_cap_blocks_when_done_fix_precedes_identical_error(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        """#2475: a `done` conflict-fix that is immediately followed by the
+        SAME merge failure text must consume the retry cap — the worker
+        found nothing to rebase (no real content conflict), so a second
+        dispatch would just repeat the same no-op forever (#2009's 38-turn
+        thrash)."""
+        board = Board()
+        first_client = _FakeHTTPClient({"id": "prev-fix"})
+        first = dispatch_conflict_fix(
+            _entry(), board, two_machine_config,
+            http_client=first_client, prefer_machine="laptop",
+        )
+        assert first is not None
+        # Simulate the worker finishing successfully and the merge queue
+        # retrying — same entry, same error (nothing was actually fixed).
+        board.active.remove(first)
+        first.status = "done"
+        board.completed.append(first)
+
+        second_client = _FakeHTTPClient({"id": "would-not-fire"})
+        result = dispatch_conflict_fix(
+            _entry(), board, two_machine_config,
+            http_client=second_client, prefer_machine="laptop",
+        )
+        assert result is None
+        assert second_client.calls == [], (
+            "HTTP should not be called when the identical failure recurs "
+            "after a done conflict-fix"
+        )
+
 
 class TestHasPriorConflictFix:
     """Cover the retry-cap predicate directly so the cli.py guard is exercised."""
@@ -487,6 +534,53 @@ class TestHasPriorConflictFix:
         ))
         assert has_prior_conflict_fix(board, "abc123") is False
 
+    def test_false_when_successful_fix_precedes_a_different_error(self) -> None:
+        """#2475: passing `current_error` doesn't change the #784 outcome
+        when the new failure is genuinely different — only an IDENTICAL
+        recurrence should consume the cap."""
+        from coord.conflict_fix import has_prior_conflict_fix
+        board = Board()
+        board.completed.append(Assignment(
+            machine_name="m", repo_name="api", issue_number=1, issue_title="x",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            status="done",
+            briefing="# Conflict fix\nReason: Merge conflict in foo.py\n",
+        ))
+        assert has_prior_conflict_fix(
+            board, "abc123", current_error="Merge conflict in bar.py",
+        ) is False
+
+    def test_true_when_successful_fix_precedes_the_identical_error(self) -> None:
+        """#2475: a `done` conflict-fix whose worker found nothing to
+        rebase (because the real blocker was never a content conflict —
+        e.g. a permanent branch-policy block, #2009) is followed by the
+        merge queue retrying into the SAME failure text. That is not a
+        fresh conflict (#784's carve-out), so it now consumes the retry cap
+        just like a genuine failure would — otherwise the queue loops
+        forever dispatching conflict-fix workers that can never help.
+        """
+        from coord.conflict_fix import has_prior_conflict_fix
+        board = Board()
+        board.completed.append(Assignment(
+            machine_name="m", repo_name="api", issue_number=1, issue_title="x",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            status="done",
+            briefing=(
+                "# Conflict fix: acme/api branch `issue-1-fix`\n\n"
+                "The merge of `issue-1-fix` → `main` failed.\n"
+                "Reason: Pull request #2471 is not mergeable: the base "
+                "branch policy prohibits the merge.\n"
+            ),
+        ))
+        assert has_prior_conflict_fix(
+            board,
+            "abc123",
+            current_error=(
+                "Pull request #2471 is not mergeable: the base branch "
+                "policy prohibits the merge."
+            ),
+        ) is True
+
     def test_ignores_non_conflict_fix_types(self) -> None:
         from coord.conflict_fix import has_prior_conflict_fix
         board = Board()