code-coordinator 0.5.518__tar.gz → 0.5.520__tar.gz

{code_coordinator-0.5.518 → code_coordinator-0.5.520}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.518",
+  "tag": "0.5.520",
   "distance": 0,
-  "node": "gdba4bd13008ab845617ff22df60d1009a4ce15b9",
+  "node": "g2ea6b6f3078698338dac5da492049a1c5a760d8e",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-26"

{code_coordinator-0.5.518 → code_coordinator-0.5.520}/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.518 → code_coordinator-0.5.520}/coord/gates.py

@@ -42,6 +42,7 @@ duck-typed shape they expect.
 from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 from coord.confirm_test import (
@@ -60,6 +61,21 @@ if TYPE_CHECKING:  # avoid import cycles / heavy imports at module load
 # "smoke_required" finds both a live merge attempt AND a `coord gates` read.
 REVIEW_REQUIRED = "review_required"
 SMOKE_REQUIRED = "smoke_required"
+# #3445: distinct from the two tokens above — a latched HUMAN_REQUIRED
+# merge-queue entry (an automated conflict-fix that already gave up, #1291)
+# is not "review/smoke unmet", it is "the merge itself already failed and
+# needs a human (or `--override-human-required`)". Clearing review or smoke
+# cannot unstick it, so it outranks both as the merge gate's headline reason
+# — see `_merge_queue_state_decision` and its call site in
+# `build_gate_report`.
+HUMAN_REQUIRED_BLOCKED = "human_required"
+# #3445 review: SKIPPED is `_merge_queue_state_decision`'s own comment's
+# other "parked, needs-attention" state alongside HUMAN_REQUIRED (and
+# `coord/drive.py`'s `_RETRYABLE_MERGE_STATUSES` docstring independently
+# documents it as equally terminal, unlike CONFLICT, which self-heals via
+# `dispatch_conflict_fix` and is deliberately NOT in this override) — so it
+# gets the same headline-outranking treatment, not just HUMAN_REQUIRED.
+SKIPPED_BLOCKED = "skipped"
 
 
 @dataclass
@@ -451,6 +467,124 @@ def _exempt_dependency_notes_for_winner(
         return []
 
 
+def _iso(ts: float | None) -> str | None:
+    if not ts:
+        return None
+    return datetime.fromtimestamp(float(ts), tz=timezone.utc).strftime("%Y-%m-%d %H:%M:%SZ")
+
+
+def _merge_queue_state_decision(
+    repo_name: str, issue_number: int, fallback_assignment_id: str | None,
+) -> GateDecision | None:
+    """The REAL, persisted ``merge_queue`` row's state for
+    ``(repo_name, issue_number)``, or ``None`` when no such row exists
+    (#3445).
+
+    This is deliberately a *second* read, distinct from the synthetic
+    ``QueuedMerge`` :func:`build_gate_report` builds via
+    ``mq.live_gate_entry`` to feed the review/test/registry gate checks:
+    that object is constructed fresh on every call and never persisted, so
+    it always carries the dataclass default ``state=PENDING`` — it was
+    never going to surface a *latched* CONFLICT/HUMAN_REQUIRED/SKIPPED.
+    Before this, ``coord gates`` had no read of the real merge-queue table
+    at all, so an issue whose entry had already given up (an automated
+    conflict-fix exhausting its one retry, #1291, or a stale-rebase worker
+    refusing to push a non-content-preserving rebase) reported
+    ``merge : BLOCKED — smoke_required`` — true in isolation, but not the
+    reason nothing is moving: clearing the smoke gate cannot unstick a
+    HUMAN_REQUIRED entry, only a human (or ``coord merge --only <aid>
+    --override-human-required``) can.
+
+    Matched on ``(repo_name, issue_number)`` — the same two facts
+    :func:`coord.drive_state._merge_entry` matches the raw ``merge_queue``
+    row against for exactly the same reason (a fix-chain may have re-keyed
+    the entry's ``assignment_id`` to a newer work row) — with
+    *fallback_assignment_id* (the winning work row `build_gate_report`
+    already selected) preferred when more than one row matches.
+
+    Fail-open like every other best-effort DB read in this module
+    (``_backfill_is_interactive``, ``_apply_gate_decision``): an
+    unreachable DB degrades to "no merge-queue line" rather than failing
+    the whole ``coord gates`` read.
+    """
+    try:
+        from coord import merge_queue as mq  # noqa: PLC0415
+
+        entries = mq.load_queue()
+    except Exception:  # noqa: BLE001 — advisory only, see docstring
+        return None
+
+    matches = [
+        e for e in entries
+        if e.repo_name == repo_name and e.issue_number == issue_number
+    ]
+    if not matches:
+        return None
+    if fallback_assignment_id:
+        by_aid = [e for e in matches if e.assignment_id == fallback_assignment_id]
+        if by_aid:
+            matches = by_aid
+    # First match in list order — not the most recent — mirroring
+    # `coord.drive_state._merge_entry` (the docstring's own cited
+    # precedent for matching on this same `(repo_name, issue_number)` pair):
+    # when more than one row matches and none matches *fallback_assignment_id*
+    # (e.g. a retarget/new branch for the same issue left an old row behind),
+    # `coord gates` must agree with the other `merge_queue` consumers
+    # (`coord drive-queue block-log`, `coord status`, `_decide_merge`) on
+    # which row is "the" entry, or the same issue reads differently on
+    # different surfaces (#3445 review).
+    entry = matches[0]
+
+    state = (entry.state or "").upper()
+    # PENDING/MERGING/MERGED (and any future non-terminal state) read as
+    # "nothing to escalate here" — the raw state name is still shown, but
+    # unadorned. CONFLICT/HUMAN_REQUIRED/SKIPPED are the parked, needs-
+    # attention states. Delegated to `mq._state_to_plan_status` — the
+    # CANONICAL classifier for this exact question (`PENDING`->READY,
+    # `MERGING`->MERGING, `MERGED`->MERGED, anything else, including any
+    # future/unknown state -> NEEDS_ATTENTION) — rather than a second,
+    # hand-maintained tuple of "which states need attention" that could
+    # silently drift from it (#2096, #3445 review). That classifier fails
+    # CLOSED on an unrecognized state; re-deriving the tri-state locally
+    # would fail open instead, exactly the "gate must be able to fail"
+    # pattern this repo's review checklist calls out.
+    ok = mq._state_to_plan_status(entry.state or "") != mq.PLAN_NEEDS_ATTENTION
+
+    reason: str | None = None
+    if state == "HUMAN_REQUIRED":
+        aid = entry.assignment_id or fallback_assignment_id or "<assignment-id>"
+        detail_lines = [entry.error or "no reason recorded"]
+        latched = _iso(entry.last_attempt)
+        if latched:
+            detail_lines.append(
+                f"as of last merge-queue write {latched} — this timestamp "
+                "does not advance while the entry is parked, so treat it as "
+                "a LOWER BOUND on when it latched, not necessarily still "
+                "current (#3445)"
+            )
+        else:
+            detail_lines.append(
+                "latched time unknown — no merge-queue attempt timestamp "
+                "recorded on this entry"
+            )
+        detail_lines.append(
+            f"override: coord merge --only {aid} --override-human-required "
+            "'<reason>'"
+        )
+        reason = "\n".join(detail_lines)
+    elif not ok:
+        reason = entry.error or None
+
+    return GateDecision(
+        gate="merge_queue",
+        required=False,
+        ok=ok,
+        reason=reason,
+        state=state or None,
+        assignment_id=entry.assignment_id or None,
+    )
+
+
 def _apply_gate_decision(repo_name: str, issue_number: int) -> GateDecision | None:
     """The ``"apply"`` :class:`GateDecision` for *(repo_name, issue_number)*,
     or ``None`` when there is no ``--hold-after`` deploy-gate entry for it in
@@ -741,8 +875,42 @@ def build_gate_report(
         registry_decisions[gate_name] = decision
         report.decisions.append(decision)
 
+    # #3445: the REAL, persisted merge-queue row — distinct from the
+    # synthetic `entry` above, which always reads state=PENDING (see
+    # `_merge_queue_state_decision`'s docstring). Read AFTER the registry
+    # gates so it can be reported alongside them, but consulted FIRST below
+    # when deciding the merge gate's headline reason: a latched
+    # HUMAN_REQUIRED (or SKIPPED, #3445 review) entry is the actual reason
+    # nothing is moving, and no amount of review/smoke/registry-gate
+    # clearing can unstick it. CONFLICT is deliberately NOT in this set — it
+    # self-heals via `dispatch_conflict_fix` (#1474), so it does not outrank
+    # the normal review/smoke headline.
+    mq_state_decision = _merge_queue_state_decision(
+        repo_name, issue_number, winner.assignment_id,
+    )
+    if mq_state_decision is not None:
+        report.decisions.append(mq_state_decision)
+
     merge_blocked_gate: str | None = None
-    if review_required and not review_ok:
+    if mq_state_decision is not None and mq_state_decision.state in (
+        "HUMAN_REQUIRED", "SKIPPED",
+    ):
+        # #3445 review: the full detail (reason, latched-time caveat,
+        # override command) is already rendered on the "merge-queue" line
+        # `format_gate_report` prints alongside this one — keep the
+        # presentation cross-reference ("see the merge-queue line above...")
+        # OUT of this data field, since `merge.reason` is also consumed
+        # verbatim by non-CLI-rendering readers with no such line above it
+        # (`coord.queue_diagnose`'s `_gates()` probe). This field stays a
+        # short, state-only headline; `format_gate_report` adds the
+        # cross-reference itself, only where the referent actually exists.
+        token = (
+            HUMAN_REQUIRED_BLOCKED
+            if mq_state_decision.state == "HUMAN_REQUIRED"
+            else SKIPPED_BLOCKED
+        )
+        merge_blocked_gate = f"{token} — {mq_state_decision.state}"
+    elif review_required and not review_ok:
         merge_blocked_gate = REVIEW_REQUIRED
     elif smoke_required and not test_ok:
         merge_blocked_gate = SMOKE_REQUIRED
@@ -912,6 +1080,29 @@ def format_gate_report(report: GateReport) -> str:
                 lines.append(f"           {test.reason}")
             else:
                 lines.append(f"  test   : BLOCKED — {test.reason}")
+        # #3445: the REAL, persisted merge-queue row's state — distinct from
+        # the review/test/merge decisions above, which are all evaluated
+        # against a synthetic, never-persisted entry (see
+        # `_merge_queue_state_decision`'s docstring). Only printed when a
+        # row actually exists for this (repo, issue) — the common case for
+        # an issue that never reached the merge queue at all is silence,
+        # same convention as the "apply" line below. A HUMAN_REQUIRED row
+        # gets its full multi-line detail (reason, latched-time caveat,
+        # override command); every other state is a single unadorned line.
+        merge_queue_decision = by_gate.get("merge_queue")
+        if merge_queue_decision is not None:
+            state_label = merge_queue_decision.state or "UNKNOWN"
+            detail_lines = (
+                merge_queue_decision.reason.split("\n")
+                if merge_queue_decision.reason
+                else []
+            )
+            if not detail_lines:
+                lines.append(f"  merge-queue : {state_label}")
+            else:
+                lines.append(f"  merge-queue : {state_label} — {detail_lines[0]}")
+                for extra in detail_lines[1:]:
+                    lines.append(f"                {extra}")
         # #3273 (S-5 of #3261): any other registry-backed gate (today just
         # "uat") renders generically here, in `report.decisions`' own
         # insertion order — a gate GATE_REGISTRY grows in the future needs no
@@ -919,7 +1110,7 @@ def format_gate_report(report: GateReport) -> str:
         # skipped/inapplicable one (UAT not configured, or an exempt issue)
         # gets an explicit reason instead of being silently omitted like it
         # was before #3273.
-        _KNOWN_GATE_LINES = ("review", "test", "merge", "apply")
+        _KNOWN_GATE_LINES = ("review", "test", "merge_queue", "merge", "apply")
         for decision in report.decisions:
             if decision.gate in _KNOWN_GATE_LINES:
                 continue
@@ -938,9 +1129,27 @@ def format_gate_report(report: GateReport) -> str:
                 lines.append(f"  {label} : BLOCKED — {decision.reason}")
         merge = by_gate.get("merge")
         if merge is not None:
-            lines.append(
-                "  merge  : READY" if merge.ok else f"  merge  : BLOCKED — {merge.reason}"
-            )
+            if merge.ok:
+                lines.append("  merge  : READY")
+            else:
+                lines.append(f"  merge  : BLOCKED — {merge.reason}")
+                # #3445 review: the cross-reference belongs only in THIS
+                # rendering, right after the "merge-queue" line it actually
+                # points at — not baked into `merge.reason` itself, which
+                # `coord.queue_diagnose`'s `_gates()` probe also surfaces
+                # verbatim with no such line above it.
+                if (
+                    merge_queue_decision is not None
+                    and merge_queue_decision.state in ("HUMAN_REQUIRED", "SKIPPED")
+                ):
+                    lines.append(
+                        "           (see the merge-queue line above for detail"
+                        + (
+                            " — the latched time and the override command)"
+                            if merge_queue_decision.state == "HUMAN_REQUIRED"
+                            else ")"
+                        )
+                    )
         # #3236: only printed when a --hold-after deploy gate actually
         # exists for this (repo, issue) — see `_apply_gate_decision`.
         apply_ = by_gate.get("apply")

{code_coordinator-0.5.518 → code_coordinator-0.5.520}/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.518 → code_coordinator-0.5.520}/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