code-coordinator 0.5.517__tar.gz → 0.5.519__tar.gz

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.519",
+  "distance": 0,
+  "node": "gdec8a9dd7ece07ccb502104f68acf67eeaff322a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-26"
+}

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/coord/conflict_fix.py

@@ -928,6 +928,7 @@ def has_prior_conflict_fix(
     merge_entry_id: str | None,
     *,
     current_error: str | None = None,
+    ignore_stale_rebase_attempts: bool = False,
 ) -> bool:
     """True when a second conflict-fix dispatch for *merge_entry_id* is blocked.
 
@@ -952,6 +953,21 @@ def has_prior_conflict_fix(
     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.
+
+    *ignore_stale_rebase_attempts* (#3444): a stale-rebase dispatch
+    (``dispatch_conflict_fix(..., stale_rebase=True)``, title prefixed
+    :data:`STALE_REBASE_FIX_TITLE_PREFIX`) never even attempts a mechanical
+    resolution — it is authorized ONLY for a pure, content-preserving
+    rebase, and its own briefing embeds the SAME ``entry.error`` as its
+    "Reason:" line. Without this flag, its refusal (agent-reported ``done``,
+    downgraded to a give-up by the ``stale-rebase-mismatch`` marker — see
+    :func:`detect_stale_rebase_mismatch`) would trip the #2475
+    identical-error check above and block the ordinary conflict-fix #3444
+    escalates to right after, even though the ordinary path hasn't been
+    tried yet. Set by the one caller doing that escalation
+    (:func:`coord.reconcile._try_ordinary_escalation_after_stale_mismatch`)
+    to skip every stale-rebase-titled row entirely — active or not — so
+    ONLY prior *ordinary* conflict-fix attempts count against the cap.
     """
     if merge_entry_id is None:
         return False
@@ -960,6 +976,10 @@ def has_prior_conflict_fix(
             continue
         if a.review_of_assignment_id != merge_entry_id:
             continue
+        if ignore_stale_rebase_attempts and (a.issue_title or "").startswith(
+            STALE_REBASE_FIX_TITLE_PREFIX,
+        ):
+            continue
         # Active attempt in flight — prevent duplicate dispatch.
         if a.status in ("running", "pending"):
             return True
@@ -1254,6 +1274,7 @@ def dispatch_conflict_fix(
     model: str | None = None,
     stuck_summary: str | None = None,
     stale_rebase: bool = False,
+    after_stale_rebase_mismatch: bool = False,
     status_fetcher: Callable[..., StatusResult] | None = None,
     machine_pick_out: "list[ConflictFixMachinePick] | None" = None,
 ) -> Assignment | None:
@@ -1357,6 +1378,23 @@ def dispatch_conflict_fix(
     (non-``semantic``) path below — a staleness-only block that recurs
     against the same error after a prior conflict-fix attempt escalates to
     a human exactly like a recurring mechanical conflict would.
+
+    ``after_stale_rebase_mismatch=True`` (#3444) dispatches the ORDINARY
+    conflict-fix path (same briefing/system-prompt/title as the plain
+    ``else`` branch below — this is not a distinct dispatch kind, just a
+    retry-cap carve-out) right after a stale-rebase worker's
+    ``stale-rebase-mismatch`` refusal: that verdict means the *just-stale*
+    premise was wrong — the rebase hit a genuine content conflict, so this
+    is an ordinary conflict that deserves the ordinary mechanical attempt,
+    not an immediate HUMAN_REQUIRED. Passes
+    ``ignore_stale_rebase_attempts=True`` to :func:`has_prior_conflict_fix`
+    so the just-failed stale-rebase attempt — which never even tried a
+    mechanical resolution — doesn't itself consume this cap; only a prior
+    *ordinary* conflict-fix attempt does, capping this escalation at one
+    per entry same as everything else here. #3349's safety property is
+    unaffected: the stale-rebase worker itself still never resolves
+    anything — only this ordinary worker (or its own semantic-escalation
+    tier) may.
     """
     if semantic:
         if has_prior_semantic_escalation(board, entry.assignment_id):
@@ -1365,6 +1403,7 @@ def dispatch_conflict_fix(
             return None
     elif has_prior_conflict_fix(
         board, entry.assignment_id, current_error=entry.error,
+        ignore_stale_rebase_attempts=after_stale_rebase_mismatch,
     ):
         return None
 
@@ -1576,6 +1615,11 @@ def dispatch_conflict_fix(
             # rebase dispatch from an ordinary conflict-fix without
             # re-deriving it from the assignment title prefix.
             "stale_rebase": stale_rebase,
+            # #3444: distinguishes an ordinary conflict-fix dispatched
+            # normally from one escalated right after a stale-rebase
+            # worker's mismatch refusal — same title/briefing either way,
+            # so this is the only durable trace of which path led here.
+            "after_stale_rebase_mismatch": after_stale_rebase_mismatch,
         },
     )
 

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/coord/merge_queue.py

@@ -3169,6 +3169,19 @@ def evaluate_smoke_verdict(
     #821/#1475's existing convention), so rows/entries predating this
     feature behave exactly as before.
 
+    #3443: "the merge base moved" is not, by itself, "a rebase happened" —
+    the smoke runner tests the branch checked out as-is, never a merge with
+    the base, so a base that merely advanced underneath an UNREBASED branch
+    changed nothing the suite could see. Before consulting the #1738/#1778/
+    #1847 file-compare escape hatches below, a confirmed-unchanged branch
+    head (``test_head_sha == current_branch_sha``) spares the base move
+    outright — cheaper than any file compare, and exactly the signal that a
+    rebase (which always changes the branch's head SHA) did *not* happen.
+    Without it, `dispatch_pending_smoke` (#3309) re-tested an identical,
+    un-rebased branch head on every single commit landing on an active
+    target branch, converging on nothing but flakiness (vimcode#523/#526,
+    2026-09-24/25: ~20 re-runs of an unchanged branch head in a few hours).
+
     #1732: ``skipped`` is deliberately excluded from all of the above. It is
     not a measurement of code at a SHA the way ``passed`` is — it is a
     structural claim about the diff itself ("contract/fixture-only, nothing
@@ -3385,6 +3398,7 @@ def evaluate_smoke_verdict(
 
         base_move_spare_reason: str | None = None
         test_base_sha = getattr(a, "test_base_sha", None)
+        test_head_sha = getattr(a, "test_head_sha", None)
         if test_state == "passed":
             # Merge base moved: the tested combination (this branch + that
             # base) no longer exists, even if the branch's own diff is
@@ -3425,32 +3439,78 @@ def evaluate_smoke_verdict(
                     )
                 continue
 
-            # #1738/#1778/#1847: the base moved, but a moved SHA doesn't
-            # necessarily mean a content change that could affect a test
-            # result. `_base_move_spared` tries, in order: is the base move
-            # itself provably inert content (docs/scripts/issue-template
-            # only, #1738); failing that, is *this branch*'s entire diff (as
-            # actually tested, test_base_sha..test_head_sha) provably inert
-            # (#1778); failing that, do the two diffs simply touch disjoint
-            # files (#1847) — a substantive base move and a substantive
-            # branch that have nothing to do with each other. Any one being
-            # true means the tested combination is still covered — fall
-            # through to the branch-content check below instead of staling
-            # here. If the branch has since gained real content, that check
-            # still catches it independently via the patch-id compare
-            # (#1847 doesn't short-circuit it).
+            # #3443: before even asking whether the base move is content-
+            # relevant, ask the cheaper, load-bearing question first — did
+            # THIS branch actually move? The smoke runner checks the branch
+            # out as-is; it does not merge or rebase onto the base before
+            # testing (see the module-level #1479 note above), so a moved
+            # target tip only invalidates a `passed` verdict when the
+            # branch itself picked up new commits since the test ran (a
+            # rebase). A branch head confirmed identical to what was tested
+            # means its merge-base with the target cannot have changed
+            # either — the target only grows forward; it never rewrites the
+            # history the branch forked from — so re-dispatching a
+            # byte-identical branch head every time the target advances
+            # (#3309 looping against develop, vimcode#523/#526) is pure
+            # spend, not a re-test of anything new. Probed here, ahead of
+            # the base-move check, so a confirmed-unchanged branch spares it
+            # before `_base_move_spared`'s file-compare hatches even run;
+            # those stay as the fallback for what this can't confirm (probe
+            # unavailable) or the case where the branch genuinely moved.
+            if (
+                test_head_sha is not None
+                and current_branch_sha is None
+                and not branch_sha_attempted
+                and gh_ops is not None
+                and repo_github
+                and entry_branch
+            ):
+                current_branch_sha, branch_sha_probe_failed, branch_sha_probe_error = (
+                    _gh_get_branch_sha(gh_ops, repo_github, entry_branch)
+                )
+                branch_sha_attempted = True
+
             if (
                 test_base_sha is not None
                 and current_base_sha is not None
                 and test_base_sha != current_base_sha
             ):
-                spared, base_move_spare_reason = _base_move_spared(
-                    gh_ops,
-                    repo_github,
-                    test_base_sha,
-                    current_base_sha,
-                    getattr(a, "test_head_sha", None),
-                )
+                if (
+                    test_head_sha is not None
+                    and current_branch_sha is not None
+                    and test_head_sha == current_branch_sha
+                ):
+                    spared, base_move_spare_reason = (
+                        True,
+                        "branch head unchanged since test — no rebase, "
+                        "base move alone does not stale (#3443)",
+                    )
+                else:
+                    # #1738/#1778/#1847: the base moved AND the branch head
+                    # also moved (or couldn't be confirmed unchanged), but a
+                    # moved base SHA still doesn't necessarily mean a content
+                    # change that could affect a test result.
+                    # `_base_move_spared` tries, in order: is the base move
+                    # itself provably inert content (docs/scripts/issue-
+                    # template only, #1738); failing that, is *this
+                    # branch*'s entire diff (as actually tested,
+                    # test_base_sha..test_head_sha) provably inert (#1778);
+                    # failing that, do the two diffs simply touch disjoint
+                    # files (#1847) — a substantive base move and a
+                    # substantive branch that have nothing to do with each
+                    # other. Any one being true means the tested combination
+                    # is still covered — fall through to the branch-content
+                    # check below instead of staling here. If the branch has
+                    # since gained real content, that check still catches it
+                    # independently via the patch-id compare (#1847 doesn't
+                    # short-circuit it).
+                    spared, base_move_spare_reason = _base_move_spared(
+                        gh_ops,
+                        repo_github,
+                        test_base_sha,
+                        current_base_sha,
+                        test_head_sha,
+                    )
                 if not spared:
                     # stale: re-verify against the new base
                     if stale is None:
@@ -3467,7 +3527,11 @@ def evaluate_smoke_verdict(
         # Branch content changed since the test ran. Same SHA-then-patch-id
         # fallback as has_approved_review: a content-identical rebase (SHA
         # moved, patch-id didn't) does not invalidate the verdict.
-        test_head_sha = getattr(a, "test_head_sha", None)
+        # `test_head_sha` was already read above (#3443's branch-probe
+        # reordering); the probe below is a no-op here whenever the
+        # `passed` branch already ran it (`branch_sha_attempted` guards it),
+        # and is the FIRST attempt for a `skipped`/`baseline_red` row, which
+        # never enters that block.
         if (
             test_head_sha is not None
             and current_branch_sha is None

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/coord/notify.py

@@ -3809,9 +3809,14 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                 except Exception:  # noqa: BLE001
                     board, config = None, None
             elif stale_rebase_mismatch:
-                # No board/config needed here — a stale-rebase mismatch has
-                # no tier-2 escalation path, it goes straight to
-                # HUMAN_REQUIRED inside `on_conflict_fix_done`.
+                # #3444: board/config ARE needed here now — a stale-rebase
+                # mismatch escalates to the ORDINARY conflict-fix path
+                # (`_try_ordinary_escalation_after_stale_mismatch`) inside
+                # `on_conflict_fix_done`, not straight to HUMAN_REQUIRED.
+                # Without them that escalation call returns `None`
+                # immediately and this — the operationally dominant path,
+                # per the comment above — would reproduce #3444's exact bug
+                # on every stale-rebase-mismatch it sees.
                 progress = entry.get("progress") or {}
                 stuck_summary = progress.get("stuck")
                 if not stuck_summary and log_path:
@@ -3820,6 +3825,13 @@ def post_transition(transition: Transition, record: dict, entry: dict) -> None:
                         stuck_summary = parse_progress(log_path).stuck
                     except Exception:  # noqa: BLE001
                         stuck_summary = None
+                try:
+                    from coord.board_service import read_board  # noqa: PLC0415
+                    from coord.config import load as _load_config  # noqa: PLC0415
+                    board = read_board()
+                    config = _load_config()
+                except Exception:  # noqa: BLE001
+                    board, config = None, None
 
             on_conflict_fix_done(
                 parent_assignment_id=parent_id,

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/coord/reconcile.py

@@ -2978,6 +2978,67 @@ def _try_semantic_escalation(
         return None
 
 
+def _try_ordinary_escalation_after_stale_mismatch(
+    entry: mq.QueuedMerge,
+    *,
+    board: Board | None,
+    config: Config | None,
+    machine_name: str,
+    stuck_summary: str | None,
+) -> "Assignment | None":
+    """Dispatch the ordinary conflict-fix path after a stale-rebase
+    worker's ``stale-rebase-mismatch`` refusal (#3444).
+
+    A ``stale-rebase-mismatch`` verdict means the ``checks_stale`` premise
+    that triggered the stale-rebase dispatch was wrong — the rebase hit a
+    genuine content conflict, not just a moved base. That makes this an
+    ORDINARY conflict, so it deserves the ordinary #241 conflict-fix
+    worker's mechanical/additive attempt (and its own
+    ``SEMANTIC_STUCK_MARKER`` → escalation-or-HUMAN_REQUIRED handling on a
+    second failure) before anything goes to a human — not an immediate
+    HUMAN_REQUIRED, which is what happened before this fix.
+
+    Returns the dispatched Assignment, or ``None`` when the plumbing isn't
+    available or dispatch declined for any of the ordinary reasons (no
+    capable machine, already active, retry cap already consumed by a prior
+    *ordinary* attempt, …) — every ``None`` case falls through to the
+    caller's pre-#3444 HUMAN_REQUIRED behaviour.
+
+    Deliberately does NOT gate on a config flag the way
+    :func:`_try_semantic_escalation` gates on
+    ``pipeline.escalate_semantic_conflicts`` — unlike a semantic escalation
+    to a stronger model, this is just the ordinary conflict-fix path that
+    every other conflict already gets; there is no reason to withhold it
+    here specifically.
+    """
+    if board is None or config is None:
+        return None
+
+    from coord.conflict_fix import dispatch_conflict_fix  # noqa: PLC0415
+    from coord.network import fetch_status  # noqa: PLC0415
+
+    try:
+        return dispatch_conflict_fix(
+            entry,
+            board,
+            config,
+            prefer_machine=machine_name or None,
+            after_stale_rebase_mismatch=True,
+            stuck_summary=stuck_summary,
+            # #3353: same liveness-aware selection every other call site
+            # here uses — a dead machine with zero active assignments must
+            # not be picked first just because it looks idle on the board.
+            status_fetcher=fetch_status,
+        )
+    except Exception as exc:  # noqa: BLE001 — never break reconcile on this
+        import logging  # noqa: PLC0415
+        logging.warning(
+            "stale-rebase-mismatch → ordinary conflict-fix escalation "
+            "dispatch failed: %s", exc,
+        )
+        return None
+
+
 def on_conflict_fix_done(
     *,
     parent_assignment_id: str,
@@ -2998,16 +3059,21 @@ def on_conflict_fix_done(
     can surface "manual resolution required", and a comment is posted on
     the underlying issue so the user is notified outside the TUI too.
 
-    *stale_rebase_mismatch* (#3349 review): when ``True``, a stale-rebase
-    worker (dispatched for ``merge_gate_checks_stale``, not an ordinary
-    conflict) correctly refused to push per its own briefing's "When NOT to
-    guess" section — its rebase either hit a real conflict marker or
-    produced a different patch-id than the pre-rebase branch, so it is not
-    a pure content-preserving rebase. This is NOT a SEMANTIC give-up (no
-    tier-2 escalation applies — there is nothing to retry with a stronger
-    model; the base and this branch genuinely overlap) and lands directly
-    on HUMAN_REQUIRED with that reason recorded, mirroring the *semantic*
-    handling below but skipping its escalation path entirely.
+    *stale_rebase_mismatch* (#3349 review, escalation added #3444): when
+    ``True``, a stale-rebase worker (dispatched for
+    ``merge_gate_checks_stale``, not an ordinary conflict) correctly
+    refused to push per its own briefing's "When NOT to guess" section —
+    its rebase either hit a real conflict marker or produced a different
+    patch-id than the pre-rebase branch, so it is not a pure
+    content-preserving rebase. That means the *just-stale* premise behind
+    the stale-rebase dispatch was wrong — this is an ORDINARY conflict, so
+    it gets the ordinary #241 conflict-fix worker's mechanical/additive
+    attempt (:func:`_try_ordinary_escalation_after_stale_mismatch`) before
+    anything reaches a human, exactly like any other conflict. Only when
+    THAT dispatch itself declines (no capable machine, already active,
+    retry cap consumed, …) does the entry land on HUMAN_REQUIRED — #3349's
+    safety property (the stale-rebase worker itself never resolves
+    anything) is unaffected either way.
 
     #2566: when *semantic* is ``True`` and the tier-2 escalation didn't
     fire specifically because ``pipeline.escalate_semantic_conflicts`` is
@@ -3058,24 +3124,54 @@ def on_conflict_fix_done(
                 )
                 failed_entry = entry
             elif stale_rebase_mismatch:
-                # #3349 review: a stale-rebase worker's refusal is a
-                # correct, deliberate stop — not a give-up to retry with a
-                # stronger model — so it goes straight to HUMAN_REQUIRED
-                # with the mismatch reason recorded, skipping the SEMANTIC
-                # tier-2 escalation path entirely.
-                entry.state = mq.HUMAN_REQUIRED
+                # #3444: a stale-rebase worker's refusal means the
+                # "just-stale" premise was wrong — this is a genuine
+                # content conflict, i.e. an ORDINARY conflict, so it gets
+                # the ordinary #241 conflict-fix worker's mechanical
+                # attempt before anything reaches a human (previously this
+                # skipped straight to HUMAN_REQUIRED — #3444's bug).
                 detail = stuck_summary or (
                     "rebase was not content-preserving (a conflict marker "
                     "appeared, or the resulting patch-id differed from the "
                     "pre-rebase branch's)"
                 )
-                entry.error = (
-                    f"{existing_error}; stale-rebase worker refused to "
-                    f"push: {detail}. This is a genuine content conflict "
-                    "against the new base, not a pure rebase — manual "
-                    "resolution required."
+                fix = _try_ordinary_escalation_after_stale_mismatch(
+                    entry,
+                    board=board,
+                    config=config,
+                    machine_name=machine_name,
+                    stuck_summary=stuck_summary,
                 )
-                failed_entry = entry
+                if fix is not None:
+                    # Stay in CONFLICT, not HUMAN_REQUIRED — the ordinary
+                    # conflict-fix worker is now in flight. If it also
+                    # fails (or itself judges the conflict SEMANTIC), this
+                    # hook runs again with `stale_rebase_mismatch=False`
+                    # and the ordinary/semantic-escalation-or-HUMAN_REQUIRED
+                    # logic below applies exactly as it does for any other
+                    # conflict.
+                    entry.state = mq.CONFLICT
+                    entry.error = (
+                        f"{existing_error}; stale-rebase worker refused to "
+                        f"push: {detail}. Not a stale-base mismatch after "
+                        "all — this is a genuine content conflict, "
+                        f"escalated to an ordinary conflict-fix (assignment "
+                        f"{fix.assignment_id}) on {fix.machine_name}."
+                    )
+                else:
+                    # The ordinary escalation itself declined (no capable
+                    # machine, already active, retry cap already consumed
+                    # by a prior ordinary attempt, …) — fall through to
+                    # HUMAN_REQUIRED exactly like the pre-#3444 behaviour.
+                    entry.state = mq.HUMAN_REQUIRED
+                    entry.error = (
+                        f"{existing_error}; stale-rebase worker refused to "
+                        f"push: {detail}. This is a genuine content conflict "
+                        "against the new base, not a pure rebase, and the "
+                        "ordinary conflict-fix escalation could not be "
+                        "dispatched either — manual resolution required."
+                    )
+                    failed_entry = entry
             else:
                 # #1291: a SEMANTIC give-up gets ONE escalated attempt from a
                 # stronger model before the entry is parked.  Everything

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/tests/test_cli_merge.py

@@ -2887,9 +2887,12 @@ class TestGateBlockedRowEntersQueueBlocked:
         assert mq.load_queue() == []
 
         def fake_get_branch_sha(repo, branch):
-            # The base moved since the verdict was recorded; the branch
-            # itself did not.
-            return "newbase111" if branch == "main" else "branchsha000"
+            # The base moved since the verdict was recorded, AND the branch
+            # itself was rebased (its head moved too) — #3443: a base move
+            # alone, with the branch head confirmed unchanged, no longer
+            # stales the verdict, so this needs both to still exercise a
+            # genuine STALE for the #1926 fallback-agreement check below.
+            return "newbase111" if branch == "main" else "branchsha111"
 
         with patch(
             "coord.github_ops.get_branch_sha", side_effect=fake_get_branch_sha

{code_coordinator-0.5.517 → code_coordinator-0.5.519}/tests/test_conflict_fix.py

@@ -1160,6 +1160,153 @@ class TestDispatch:
         assert client.calls == []
 
 
+class TestAfterStaleRebaseMismatchEscalation:
+    """#3444: a `stale-rebase-mismatch` verdict must escalate to the
+    ORDINARY conflict-fix path — `dispatch_conflict_fix(...,
+    after_stale_rebase_mismatch=True)` — not straight to HUMAN_REQUIRED.
+    That flag changes nothing about the dispatched briefing/title (same as
+    the plain `else` branch) — it only carves the just-failed stale-rebase
+    attempt out of the retry cap, since that attempt never even tried a
+    mechanical resolution.
+    """
+
+    def test_sends_the_ordinary_briefing_and_title(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        client = _FakeHTTPClient({"id": "fix-id-ordinary-after-mismatch"})
+        entry = _entry(error=f"{CI_STALE_PREFIX} checks predate the current base")
+        result = dispatch_conflict_fix(
+            entry, Board(), two_machine_config,
+            http_client=client, prefer_machine="laptop",
+            after_stale_rebase_mismatch=True,
+        )
+        assert result is not None
+        assert not result.issue_title.startswith(STALE_REBASE_FIX_TITLE_PREFIX)
+        assert result.issue_title.startswith("[conflict-fix]")
+        _, payload = client.calls[0]
+        assert payload["system_prompt"] == CONFLICT_FIX_SYSTEM_PROMPT
+
+    def test_a_failed_stale_rebase_attempt_does_not_consume_the_cap(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        """The just-finished stale-rebase attempt is recorded on the board
+        as a `[stale-rebase]`-titled conflict-fix row whose dispatch-time
+        `Reason:` line is the SAME `entry.error` this escalation call
+        carries (both dispatches read straight off `entry.error`) — without
+        `ignore_stale_rebase_attempts`, the #2475 identical-error check
+        would misread that as a recurring, already-failed mechanical
+        attempt and block this escalation before it ever tries."""
+        board = Board()
+        error = f"{CI_STALE_PREFIX} checks predate the current base"
+        board.completed.append(Assignment(
+            machine_name="laptop", repo_name="api", issue_number=1,
+            issue_title=f"{STALE_REBASE_FIX_TITLE_PREFIX} Fix the thing",
+            assignment_id="stale-fix-1", status="done",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            briefing=f"# Stale-CI rebase\nReason: {error}\n",
+        ))
+        entry = _entry(error=error)
+        client = _FakeHTTPClient({"id": "fix-id-escalated"})
+        result = dispatch_conflict_fix(
+            entry, board, two_machine_config,
+            http_client=client, prefer_machine="laptop",
+            after_stale_rebase_mismatch=True,
+        )
+        assert result is not None
+        assert len(client.calls) == 1
+
+    def test_a_prior_ordinary_conflict_fix_failure_still_blocks(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        """The carve-out is narrow: only stale-rebase-titled rows are
+        ignored. A genuinely failed ORDINARY conflict-fix attempt for the
+        same entry still consumes the cap exactly like any other retry."""
+        board = Board()
+        board.completed.append(Assignment(
+            machine_name="laptop", repo_name="api", issue_number=1,
+            issue_title="[conflict-fix] Fix the thing",
+            assignment_id="ordinary-fix-1", status="failed",
+            type="conflict-fix", review_of_assignment_id="abc123",
+        ))
+        entry = _entry()
+        client = _FakeHTTPClient({"id": "would-not-fire"})
+        result = dispatch_conflict_fix(
+            entry, board, two_machine_config,
+            http_client=client, prefer_machine="laptop",
+            after_stale_rebase_mismatch=True,
+        )
+        assert result is None
+        assert client.calls == []
+
+    def test_no_double_dispatch_while_a_conflict_fix_is_already_active(
+        self, two_machine_config: Config, coord_db,
+    ) -> None:
+        """Acceptance: no double-dispatch while one is active, regardless
+        of which flavor is running."""
+        board = Board()
+        board.active.append(Assignment(
+            machine_name="laptop", repo_name="api", issue_number=1,
+            issue_title="[conflict-fix] Fix the thing",
+            assignment_id="running-fix-1", status="running",
+            type="conflict-fix", review_of_assignment_id="abc123",
+        ))
+        entry = _entry()
+        client = _FakeHTTPClient({"id": "would-not-fire"})
+        result = dispatch_conflict_fix(
+            entry, board, two_machine_config,
+            http_client=client, prefer_machine="laptop",
+            after_stale_rebase_mismatch=True,
+        )
+        assert result is None
+        assert client.calls == []
+
+
+class TestHasPriorConflictFixIgnoresStaleRebaseAttempts:
+    """Direct coverage of `has_prior_conflict_fix`'s
+    `ignore_stale_rebase_attempts` carve-out (#3444)."""
+
+    def test_failed_stale_rebase_row_ignored_when_flag_set(self) -> None:
+        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=f"{STALE_REBASE_FIX_TITLE_PREFIX} x",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            status="failed",
+        ))
+        assert has_prior_conflict_fix(
+            board, "abc123", ignore_stale_rebase_attempts=True,
+        ) is False
+
+    def test_failed_stale_rebase_row_still_counts_by_default(self) -> None:
+        """Every OTHER caller (default `ignore_stale_rebase_attempts=False`)
+        is byte-for-byte unaffected."""
+        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=f"{STALE_REBASE_FIX_TITLE_PREFIX} x",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            status="failed",
+        ))
+        assert has_prior_conflict_fix(board, "abc123") is True
+
+    def test_failed_ordinary_row_still_counts_even_with_flag_set(self) -> None:
+        """The carve-out is narrow: it names the stale-rebase title prefix
+        specifically, not "any prior conflict-fix"."""
+        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="[conflict-fix] x",
+            type="conflict-fix", review_of_assignment_id="abc123",
+            status="failed",
+        ))
+        assert has_prior_conflict_fix(
+            board, "abc123", ignore_stale_rebase_attempts=True,
+        ) is True
+
+
 class TestSemanticEscalationDisabled:
     """#2566: the predicate that lets HUMAN_REQUIRED messaging say *why*
     the tier-2 semantic escalation didn't run, rather than reading as