code-coordinator 0.5.521__tar.gz → 0.5.522__tar.gz

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.521",
+  "tag": "0.5.522",
   "distance": 0,
-  "node": "g1d59afeac7d0d003c9bbecd7b2711c6ebe8adaf8",
+  "node": "g3d51cf0a782a606306c6175a5b2271d2d93ea2d4",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-27"

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/coord/commands/drive_queue.py

@@ -35,7 +35,7 @@ import socket
 import subprocess
 import time
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Mapping, Sequence
+from typing import TYPE_CHECKING, Any, Iterable, Mapping, Sequence
 
 import click
 
@@ -88,6 +88,7 @@ from coord.drive_queue import (
     fired_holds,
     flag_shadows_config_warning,
     is_dispatch_failure_reason,
+    is_fix_round_ceiling_blocked,
     is_merge_gate_block_reason,
     is_permanent_block_reason,
     is_pre_dispatch_block_reason,
@@ -1386,10 +1387,10 @@ _BLOCKED_AFTER_NOTE = (
 # ships doesn't have to go read the issue to learn their remove+add might be
 # about to race an automatic resume.
 _BLOCKED_GATE_NOTE = (
-    "note: a re-evaluable blocked cause (i.e. not a #1844/#2019 permanent "
-    "refusal) IS re-checked against the merge gate automatically (#2230) — "
-    "see `resumes=` above if this row has already self-resumed and "
-    "re-blocked"
+    "note: a re-evaluable blocked cause (i.e. not a #1844/#2019/#2972 "
+    "permanent refusal) IS re-checked against the merge gate automatically "
+    "(#2230) — see `resumes=` above if this row has already self-resumed "
+    "and re-blocked"
 )
 
 # #2589: `_BLOCKED_GATE_NOTE` above is flatly wrong for a row whose cause is
@@ -5576,6 +5577,34 @@ def _record_checks_stale_escalation(entry: "QueuedMerge", *, reason: str) -> Non
         click.echo(f"  (could not record the checks_stale escalation: {exc})")
 
 
+def _fix_round_ceiling_blocked_keys(
+    queue_entries: Iterable[QueueEntry],
+) -> set[tuple[str, int]]:
+    """#3454: ``(repo, issue)`` keys whose drive-queue row has already given
+    up on the #2972 fix-round ceiling — a block means stop: nothing this
+    module auto-dispatches should fire again for one of these until an
+    operator runs ``coord drive-queue remove`` + ``add``.
+
+    Delegates the actual predicate to :func:`coord.drive_queue.
+    is_fix_round_ceiling_blocked` — the #3454 review's "one question, one
+    answer" fix: ``coord.notify``'s stalled-pipeline sweep (a second,
+    independent ``dispatch_conflict_fix`` caller) asks this SAME function
+    per-row rather than re-deriving the ``state == blocked AND
+    is_fix_round_ceiling_reason`` check here a second time.
+
+    Pure, over an already-fetched entry list, so
+    ``_run_auto_revalidate_checks_stale``'s use of it (skip a
+    stale-rebase conflict-fix candidate whose OWN entry gave up this way) is
+    testable without mocking the live board/ci_store/conflict_fix stack that
+    function otherwise needs.
+    """
+    return {
+        (e.repo, e.issue)
+        for e in queue_entries
+        if is_fix_round_ceiling_blocked(e.state, e.last_reason)
+    }
+
+
 def _run_auto_revalidate_checks_stale(config_path: Path | None) -> None:
     """#2535: unattended remedy for merge-queue entries blocked SOLELY on
     stale CI checks against an already-approved review — closing the gap
@@ -5720,6 +5749,7 @@ def _run_auto_revalidate_checks_stale(config_path: Path | None) -> None:
         from coord.state import (  # noqa: PLC0415
             dismiss_drive_escalation,
             list_drive_escalations,
+            list_drive_queue,
             load_board as _load_board,
         )
 
@@ -5743,6 +5773,33 @@ def _run_auto_revalidate_checks_stale(config_path: Path | None) -> None:
             return
         items = _mq.load_queue()
         candidates = _mq.ci_revalidation_candidates(items, board, cfg, ci_store, _gh_ops)
+        # #3454: an entry whose drive-queue row already gave up on the #2972
+        # fix-round ceiling is PARKED — a block means stop, not "the driver
+        # stopped but the pipeline is still live" (quadraui#1077: a
+        # stale-rebase conflict-fix from THIS mechanism fired 6h07m after the
+        # ceiling block, one of the paid legs the block's own "giving up"
+        # wording told the operator would not happen). Filtered out of
+        # `candidates` itself, not just the dispatch loop below, so the
+        # escalation-cleanup pass right above also treats a newly-parked
+        # entry as no-longer-live and dismisses any open `checks_stale`
+        # escalation for it — the ceiling block's own reason is the one
+        # surface an operator needs, not a second "needs a human" this
+        # mechanism would otherwise keep alive for a row that already has
+        # one. `is_fix_round_ceiling_blocked` (not the broader
+        # `is_permanent_block_reason`) so a #1844/#2019 permanent block —
+        # neither of which this mechanism has ever been asked to change —
+        # keeps its pre-#3454 behaviour exactly. `coord.notify`'s stalled-
+        # pipeline sweep — the THIRD, independent `dispatch_conflict_fix`
+        # caller the #3454 review found unfiltered — now calls this exact
+        # same predicate per-row rather than a separately-derived check.
+        ceiling_blocked_keys = _fix_round_ceiling_blocked_keys(
+            entries_from_rows(list_drive_queue())
+        )
+        candidates = [
+            c
+            for c in candidates
+            if (c.repo_name, c.issue_number) not in ceiling_blocked_keys
+        ]
     except Exception:  # noqa: BLE001 — best-effort, see docstring
         return
 

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/coord/drive_queue.py

@@ -160,9 +160,10 @@ def dispatch_type_for_labels(issue_labels: Iterable[str] | None) -> str:
 #
 # #2230 qualifies "terminal" for `blocked` specifically: it still means "no
 # `coord drive` launches from this row again on its own" and "stays in the
-# table for history" for a PERMANENT cause (#1844/#2019) or one the sweep has
-# no evidence about. It no longer means "nothing ever writes to this row
-# again" — a `blocked` entry whose cause was a re-evaluable gate reading may
+# table for history" for a PERMANENT cause (#1844/#2019/#2972 — see
+# `_PERMANENT_BLOCK_MARKERS`) or one the sweep has no evidence about. It no
+# longer means "nothing ever writes to this row again" — a `blocked` entry
+# whose cause was a re-evaluable gate reading may
 # be moved straight back to `waiting` by `plan_tick`'s own reconcile pass,
 # with no operator action, the moment that reading clears. See
 # `is_permanent_block_reason` and `_reconcile_blocked` below for exactly
@@ -282,7 +283,74 @@ PARK_STALE_SECONDS = 45 * 60.0
 # clear (see `_reconcile_blocked` and the `live_blocked_gate` parameter of
 # `plan_tick`). No evidence either way leaves the entry exactly as untouched
 # as it was before this feature existed.
-_PERMANENT_BLOCK_MARKERS: tuple[str, ...] = ("(#1844)", "(#2019)")
+#
+# #3454: `(#2972)` joined this tuple after quadraui#1077 (2026-09-27) showed
+# the gap a THIRD marker was needed for — a #2972 fix-round-ceiling give-up
+# is not like #309's ordinary `exhausted`: relaunching cannot produce more
+# budget no matter how the merge gate reads, so treating it as merely
+# "unlucky, re-check later" let #2230's own sweep silently resume it back to
+# `waiting` (attempts reset to 0!) the moment the gate cleared — handing the
+# exact fresh budget the ceiling exists to deny, from inside the mechanism
+# built to respect it. Marking it permanent here closes that specific hole:
+# `_reconcile_blocked` returns `None` for it unconditionally, same as
+# #1844/#2019, and only an operator's `coord drive-queue remove` + `add`
+# (a fresh row) ever gives this entry another attempt. This
+# does NOT stop the row from being noticed if the issue lands anyway
+# out-of-band — `plan_tick`'s own step-1b `facts.landed` check (#2055/#3368)
+# runs unconditionally for every `blocked` entry regardless of this marker,
+# exactly as it always has; what stops is only the AUTOMATIC relaunch/
+# merge-only paths #2230 gates. See :func:`is_fix_round_ceiling_reason` for
+# the narrower predicate `coord.commands.drive_queue` uses to also stop its
+# OWN independent auto-dispatch (the stale-rebase conflict-fix revalidation)
+# from re-firing against a row that has already given up this way.
+_PERMANENT_BLOCK_MARKERS: tuple[str, ...] = ("(#1844)", "(#2019)", "(#2972)")
+
+
+def is_fix_round_ceiling_reason(reason: str | None) -> bool:
+    """#3454: does *reason* name the #2972 fix-round-ceiling give-up — the
+    ``_reconcile_running`` "giving up rather than relaunching with a fresh
+    budget" branch, below?
+
+    Marker-based, same convention as :func:`is_permanent_block_reason` (whose
+    ``_PERMANENT_BLOCK_MARKERS`` this reuses the same ``(#2972)`` text for):
+    the branch that writes this reason stamps the marker unconditionally, so
+    a substring check is exact, not a heuristic guess. A dedicated predicate
+    rather than reusing ``is_permanent_block_reason`` directly because a
+    caller outside this module (``coord.commands.drive_queue``'s stale-rebase
+    auto-revalidation, #3454) wants to ask SPECIFICALLY "did this entry give
+    up on the fix-round ceiling", not the broader "is this blocked for any
+    permanent reason" — conflating the two would silently widen that other
+    caller's behaviour to #1844/#2019 rows too, which nothing in #3454 asked
+    for and nothing has verified is safe.
+    """
+    if not reason:
+        return False
+    return "(#2972)" in reason
+
+
+def is_fix_round_ceiling_blocked(state: str | None, last_reason: str | None) -> bool:
+    """#3454 review: the ONE predicate every auto-dispatcher must consult
+    before firing against a (repo, issue) — "has this row's drive-queue
+    entry already given up on the #2972 fix-round ceiling".
+
+    The review that opened this function found TWO independent
+    ``dispatch_conflict_fix`` callers deciding this question with different
+    logic: ``coord.commands.drive_queue``'s stale-rebase auto-revalidation
+    checked it, ``coord.notify``'s stalled-pipeline sweep (a third,
+    pre-existing caller of the same worker) did not — so a
+    ``(#2972)``-blocked entry could still receive a brand-new conflict-fix
+    leg via the second path, entirely unaffected by the first fix. Both now
+    call this one function instead of each re-deriving "blocked AND
+    :func:`is_fix_round_ceiling_reason`" — the "one question, one answer"
+    rule this module already applies elsewhere (#2096/#2085).
+
+    ``state`` must be the LIVE state (:data:`STATE_BLOCKED`, not merely "the
+    reason string looks like a ceiling give-up") — a row that has since been
+    removed/re-added by an operator (the documented remedy) has a fresh
+    ``last_reason`` from a NEW life, but a stale caller that only checked the
+    reason string could still misfire against the archived one.
+    """
+    return state == STATE_BLOCKED and is_fix_round_ceiling_reason(last_reason)
 
 
 def is_permanent_block_reason(text: str | None) -> bool:
@@ -5112,13 +5180,25 @@ def _reconcile_running(
     # ran.
     budget = total_fix_round_budget(entry, fix_round_config_default)
     if remaining_fix_rounds(entry, facts, fix_round_config_default) <= 0:
+        # #3454: this block now DOES mean "stop" — see
+        # `_PERMANENT_BLOCK_MARKERS`'s `(#2972)` entry and
+        # `is_fix_round_ceiling_reason` above for the mechanics. Say so
+        # explicitly rather than leaving an operator to infer it: quadraui#1077
+        # showed a bare "giving up" read as "nothing more will happen or be
+        # spent" while the fleet kept dispatching paid legs against the same
+        # branch for hours.
         reason = (
             f"fix-round ceiling reached across relaunches (#2972): "
             f"{facts.work_leg_count} work leg(s) already run against a "
             f"budget of {budget} (1 work dispatch + "
             f"{effective_max_fix_rounds(entry, fix_round_config_default)} fix "
             f"round(s)) — giving up rather than relaunching with a fresh "
-            f"budget{dispatch_note}"
+            f"budget{dispatch_note}. Stopped (#3454): no further relaunch, "
+            f"gate-clear resume, or auto-dispatched stale-rebase conflict-fix "
+            f"(from any of this fleet's independent dispatchers) will fire "
+            f"for this entry — `coord drive-queue remove {entry.repo} "
+            f"{entry.issue}` + `add` (a fresh row) is the only way to give "
+            f"it another attempt."
         )
         return (
             Reconcile(entry.key, "exhausted", reason, occupies=False),

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/coord/notify.py

@@ -1069,6 +1069,14 @@ class StalledDispatchAction:
       (#602).
     - ``"skipped_human_required"``  — the conflict-fix retry cap was already
       hit; surfacing to a human, not auto-retrying.
+    - ``"skipped_fix_round_ceiling_blocked"`` (#3454) — ``merge_conflict_
+      unresolved`` or ``merge_gate_checks_stale`` on a (repo, issue) whose
+      drive-queue row already gave up on the #2972 fix-round ceiling (see
+      :func:`coord.drive_queue.is_fix_round_ceiling_blocked`) — a block
+      means stop, so this sweep leaves it parked exactly like ``coord.
+      commands.drive_queue``'s stale-rebase auto-revalidation already does,
+      rather than handing it a third independent path to a fresh
+      conflict-fix leg (quadraui#1077).
     - ``"skipped_sealed_conflict"`` (#2537, narrowed by #2555) —
       ``merge_conflict_unresolved`` on a
       :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row whose conflict was
@@ -1138,6 +1146,35 @@ def _stalled_row_has_live_session(board: "Board", work: "Assignment") -> bool:
     return False
 
 
+def _fix_round_ceiling_blocked_for_work(work: "Assignment") -> bool:
+    """#3454 review: true when *work*'s (repo, issue) has a drive-queue row
+    that has already given up on the #2972 fix-round ceiling.
+
+    This module's ``merge_conflict_unresolved`` and ``merge_gate_checks_
+    stale`` arms are a THIRD, independent caller of :func:`coord.
+    conflict_fix.dispatch_conflict_fix` — the review found them unfiltered
+    while ``coord.commands.drive_queue``'s stale-rebase auto-revalidation
+    (the second caller) already skipped a ceiling-blocked candidate,
+    letting quadraui#1077's "giving up" block get a brand-new conflict-fix
+    leg anyway via THIS path 6h07m later. Both callers now ask the exact
+    same question — :func:`coord.drive_queue.is_fix_round_ceiling_blocked`
+    — rather than each re-deriving it (#2096's "one question, one answer").
+
+    A drive-queue row is optional infrastructure (an issue can be worked
+    with no ``coord drive-queue add`` at all), so "no row for this (repo,
+    issue)" reads as "nothing to block on" — ``False`` — same as it always
+    implicitly has for every OTHER stalled-pipeline reason.
+    """
+    from coord.drive_queue import QueueEntry, is_fix_round_ceiling_blocked  # 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 is_fix_round_ceiling_blocked(dq_entry.state, dq_entry.last_reason)
+
+
 def _conflict_confined_to_sealed_paths(
     entry: "QueuedMerge", config: Config,
 ) -> list[str] | None:
@@ -1230,7 +1267,11 @@ def dispatch_stalled_pipeline_action(
       the same bulk gate-checked enqueue the daemon passive tick already
       runs on every interval.
     - ``merge_conflict_unresolved`` → :func:`coord.conflict_fix.dispatch_conflict_fix`,
-      the #1474 ``_dispatch_conflict_fixes`` path — UNLESS (#2537) *work* is a
+      the #1474 ``_dispatch_conflict_fixes`` path — UNLESS (#3454) the
+      (repo, issue)'s drive-queue row already gave up on the #2972
+      fix-round ceiling (:func:`_fix_round_ceiling_blocked_for_work`),
+      which returns ``"skipped_fix_round_ceiling_blocked"`` instead, or
+      (#2537) *work* is a
       :data:`coord.models.SEALED_PATH_AUTHOR_TYPES` row AND the conflict can
       be confirmed (via :func:`_conflict_confined_to_sealed_paths`, a
       compare-API-only check) to be confined to the repo's sealed
@@ -1257,7 +1298,9 @@ def dispatch_stalled_pipeline_action(
       ``merge_conflict_unresolved`` dispatches, briefed for a PURE,
       content-preserving rebase (no conflict expected) rather than the
       ordinary conflict-resolution briefing. Guarded by the same
-      :func:`coord.conflict_fix.has_prior_conflict_fix` retry cap.
+      :func:`coord.conflict_fix.has_prior_conflict_fix` retry cap, and
+      (#3454) the same fix-round-ceiling park as ``merge_conflict_
+      unresolved`` above.
 
     Never re-entrant across ticks: the caller only reaches this after
     :func:`detect_stalled_pipeline` has already filtered out any row whose
@@ -1598,6 +1641,18 @@ def dispatch_stalled_pipeline_action(
             return StalledDispatchAction(
                 kind="no_action", detail="merge queue entry no longer found",
             )
+        # #3454: a #2972 fix-round-ceiling give-up parks the row — no further
+        # auto-dispatched conflict-fix for it from ANY caller, this sweep
+        # included. See `_fix_round_ceiling_blocked_for_work`'s docstring.
+        if _fix_round_ceiling_blocked_for_work(work):
+            return StalledDispatchAction(
+                kind="skipped_fix_round_ceiling_blocked",
+                detail=(
+                    "drive-queue row already gave up on the #2972 fix-round "
+                    "ceiling (#3454) — parked; needs `coord drive-queue "
+                    "remove` + `add`, not another auto-dispatched conflict-fix"
+                ),
+            )
         if has_prior_conflict_fix(
             board, entry.assignment_id, current_error=entry.error,
         ):
@@ -1697,6 +1752,18 @@ def dispatch_stalled_pipeline_action(
             return StalledDispatchAction(
                 kind="no_action", detail="merge queue entry no longer found",
             )
+        # #3454: same park as the `merge_conflict_unresolved` arm above — a
+        # #2972 fix-round-ceiling give-up means stop, including the stale-
+        # rebase conflict-fix this arm dispatches.
+        if _fix_round_ceiling_blocked_for_work(work):
+            return StalledDispatchAction(
+                kind="skipped_fix_round_ceiling_blocked",
+                detail=(
+                    "drive-queue row already gave up on the #2972 fix-round "
+                    "ceiling (#3454) — parked; needs `coord drive-queue "
+                    "remove` + `add`, not another auto-dispatched conflict-fix"
+                ),
+            )
         if has_prior_conflict_fix(
             board, entry.assignment_id, current_error=entry.error,
         ):

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/tests/test_drive_queue.py

@@ -4355,6 +4355,78 @@ def test_a_dead_end_blocked_entry_is_never_resumed():
     assert plan.launch is None
 
 
+def test_a_fix_round_ceiling_blocked_entry_is_never_resumed():
+    """#3454: same posture as the #1844/#2019 permanent blocks above — a
+    #2972 fix-round-ceiling give-up must not auto-resume just because the
+    merge gate reads clear again. Before this fix, `_reconcile_blocked`
+    treated this reason as an ordinary re-checkable `exhausted` (#309's
+    shape) and would have relaunched with `attempts` reset to 0 — handing
+    the entry a fresh work-leg budget the ceiling exists to deny, exactly
+    the quadraui#625 silent-reset bug #2972 itself closed for the ordinary
+    retry path. Contrast with
+    test_a_blocked_entry_whose_live_gate_reads_clear_resumes_with_attempts_reset,
+    where an entry blocked for an ordinary reason DOES resume on identical
+    gate evidence."""
+    entries = [
+        _blocked_entry(
+            1077,
+            position=1,
+            last_reason=(
+                "fix-round ceiling reached across relaunches (#2972): 3 "
+                "work leg(s) already run against a budget of 3 (1 work "
+                "dispatch + 2 fix round(s)) — giving up rather than "
+                "relaunching with a fresh budget. Stopped (#3454): no "
+                "further relaunch, gate-clear resume, or auto-dispatched "
+                "stale-rebase conflict-fix (from any of this fleet's "
+                "independent dispatchers) will fire for this entry — "
+                "`coord drive-queue remove claude-coordinator 1077` + "
+                "`add` (a fresh row) is the only way to give it another "
+                "attempt."
+            ),
+        )
+    ]
+    key = entry_key(REPO, 1077)
+    plan = plan_tick(
+        entries,
+        board(),
+        capacity=1,
+        live_blocked_gate={key: False},  # gate reads clear
+        merge_only_ready={key: True},  # even Merge-only-ready must not fire
+    )
+    assert plan.reconciles == ()
+    assert plan.blocked == ()
+    assert plan.merge_only == ()
+    assert plan.launch is None
+
+
+def test_fix_round_ceiling_blocked_keys_finds_only_2972_blocked_rows():
+    """#3454: `coord.commands.drive_queue._fix_round_ceiling_blocked_keys` —
+    the filter `_run_auto_revalidate_checks_stale` uses so it never
+    re-dispatches a stale-rebase conflict-fix for an entry that already gave
+    up on the ceiling (quadraui#1077: this mechanism fired one 6h07m after
+    the block). A `waiting`/`running` row and a `blocked` row for an
+    UNRELATED (#1844) reason must both be left out — only a genuinely
+    #2972-blocked row counts."""
+    from coord.commands.drive_queue import _fix_round_ceiling_blocked_keys
+
+    ceiling_reason = (
+        "fix-round ceiling reached across relaunches (#2972): 3 work "
+        "leg(s) already run against a budget of 3 — giving up"
+    )
+    entries = [
+        entry(1077, state=STATE_BLOCKED, last_reason=ceiling_reason),
+        entry(
+            70,
+            state=STATE_BLOCKED,
+            last_reason=(
+                "... (#1844); blocking without spending an attempt"
+            ),
+        ),
+        entry(309, state=STATE_WAITING, last_reason=""),
+    ]
+    assert _fix_round_ceiling_blocked_keys(entries) == {(REPO, 1077)}
+
+
 def test_a_blocked_entry_that_has_hit_the_resume_ceiling_stays_blocked_and_says_so():
     """#2230's churn bound: an entry already resumed MAX_BLOCKED_RESUMES times
     must not oscillate forever — it stays `blocked`, but `last_reason` is
@@ -5194,11 +5266,17 @@ def test_a_parked_entry_with_review_still_pending_falls_through_to_the_ordinary_
     assert plan.launch is not None and plan.launch.issue == 2350
 
 
-def test_is_permanent_block_reason_recognises_both_markers_and_nothing_else():
+def test_is_permanent_block_reason_recognises_all_three_markers_and_nothing_else():
     from coord.drive_queue import is_permanent_block_reason
 
     assert is_permanent_block_reason("... (#1844); blocking without spending an attempt")
     assert is_permanent_block_reason("... (#2019); blocking without spending an attempt")
+    # #3454: the #2972 fix-round ceiling joined the permanent set — see
+    # test_a_fix_round_ceiling_block_never_auto_resumes below for why.
+    assert is_permanent_block_reason(
+        "fix-round ceiling reached across relaunches (#2972): 3 work leg(s) "
+        "already run against a budget of 3 — giving up"
+    )
     assert not is_permanent_block_reason(
         "drive session died without landing the work 2/2 times — giving up"
     )
@@ -5206,6 +5284,47 @@ def test_is_permanent_block_reason_recognises_both_markers_and_nothing_else():
     assert not is_permanent_block_reason(None)
 
 
+def test_is_fix_round_ceiling_reason_matches_only_the_2972_marker():
+    """#3454: the narrower predicate `coord.commands.drive_queue` uses to
+    also stop its OWN independent stale-rebase auto-dispatch — must not
+    fire for the OTHER two permanent-block markers, or that other call site
+    would silently widen to #1844/#2019 rows too."""
+    from coord.drive_queue import is_fix_round_ceiling_reason
+
+    assert is_fix_round_ceiling_reason(
+        "fix-round ceiling reached across relaunches (#2972): giving up"
+    )
+    assert not is_fix_round_ceiling_reason(
+        "... (#1844); blocking without spending an attempt"
+    )
+    assert not is_fix_round_ceiling_reason(
+        "... (#2019); blocking without spending an attempt"
+    )
+    assert not is_fix_round_ceiling_reason(
+        "drive session died without landing the work 2/2 times — giving up"
+    )
+    assert not is_fix_round_ceiling_reason("")
+    assert not is_fix_round_ceiling_reason(None)
+
+
+def test_is_fix_round_ceiling_blocked_requires_both_state_and_reason():
+    """#3454 review: `is_fix_round_ceiling_blocked` is the ONE predicate
+    `coord.commands.drive_queue` (via `_fix_round_ceiling_blocked_keys`) AND
+    `coord.notify` (via `_fix_round_ceiling_blocked_for_work`) now both
+    call — must require the LIVE `blocked` state, not just a reason string
+    that merely mentions #2972 (e.g. a stale/archived one from a row an
+    operator already removed and re-added)."""
+    from coord.drive_queue import STATE_BLOCKED, STATE_WAITING, is_fix_round_ceiling_blocked
+
+    ceiling_reason = "fix-round ceiling reached across relaunches (#2972): giving up"
+    assert is_fix_round_ceiling_blocked(STATE_BLOCKED, ceiling_reason)
+    assert not is_fix_round_ceiling_blocked(STATE_WAITING, ceiling_reason)
+    assert not is_fix_round_ceiling_blocked(
+        STATE_BLOCKED, "... (#1844); blocking without spending an attempt"
+    )
+    assert not is_fix_round_ceiling_blocked(STATE_BLOCKED, None)
+
+
 def test_a_genuinely_dead_drive_without_ci_pending_still_retries_normally():
     """No regression: without `merge_ci_pending`, a dead drive takes the
     EXACT pre-#1891 path — this is byte-for-byte

{code_coordinator-0.5.521 → code_coordinator-0.5.522}/tests/test_stalled_pipeline.py

@@ -1595,6 +1595,138 @@ class TestDispatchPerReason:
         _, call_kwargs = stub.call_args
         assert call_kwargs["stale_rebase"] is True
 
+    def test_merge_conflict_unresolved_skips_a_fix_round_ceiling_blocked_row(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """#3454 review: `coord.notify` is a THIRD, independent
+        `dispatch_conflict_fix` caller the review found unfiltered — a
+        (repo, issue) whose drive-queue row already gave up on the #2972
+        fix-round ceiling must not get a brand-new conflict-fix leg from
+        THIS sweep either, exactly like `coord.commands.drive_queue`'s
+        stale-rebase auto-revalidation already refuses it."""
+        config.pipeline.auto_dispatch_stalled = True
+        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-602-fix", target_branch="main", issue_number=602,
+            issue_title="t", state=CONFLICT, error="could not be rebased onto main",
+        )]
+        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": "blocked",
+                "last_reason": (
+                    "fix-round ceiling reached across relaunches (#2972): "
+                    "3 work leg(s) already run against a budget of 3 — "
+                    "giving up rather than relaunching with a fresh budget"
+                ),
+            },
+        )
+        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 == "skipped_fix_round_ceiling_blocked"
+        assert "#2972" in action.detail
+        stub.assert_not_called()
+
+    def test_merge_gate_checks_stale_skips_a_fix_round_ceiling_blocked_row(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """Same #3454 gate on the `merge_gate_checks_stale` arm — the
+        review named both `coord.notify` call sites."""
+        config.pipeline.auto_dispatch_stalled = True
+        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-951-fix", target_branch="develop", issue_number=951,
+            issue_title="t", state=PENDING,
+            error=f"{CI_STALE_PREFIX} checks predate the current base",
+        )]
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=queued
+        )[0]
+        assert detection.reason == "merge_gate_checks_stale"
+
+        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": (
+                    "fix-round ceiling reached across relaunches (#2972): "
+                    "3 work leg(s) already run against a budget of 3 — "
+                    "giving up rather than relaunching with a fresh budget"
+                ),
+            },
+        )
+        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 == "skipped_fix_round_ceiling_blocked"
+        assert "#2972" in action.detail
+        stub.assert_not_called()
+
+    def test_merge_conflict_unresolved_still_dispatches_when_no_drive_queue_row(
+        self, config: Config, monkeypatch
+    ) -> None:
+        """No drive-queue row at all for this (repo, issue) (an issue can be
+        worked with no `coord drive-queue add`) must read as "nothing to
+        block on", same as before #3454 — not silently swallow every
+        conflict-fix dispatch that has no queue entry."""
+        config.pipeline.auto_dispatch_stalled = True
+        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-602-fix", target_branch="main", issue_number=602,
+            issue_title="t", state=CONFLICT, error="could not be rebased onto main",
+        )]
+        detection, work = notify_mod.detect_stalled_pipeline(
+            config, board=board, merge_queue_items=queued
+        )[0]
+        assert detection.reason == "merge_conflict_unresolved"
+
+        fix_assignment = Assignment(
+            machine_name="mac-mini", repo_name="vimcode", issue_number=602,
+            issue_title="[conflict-fix] t", assignment_id="cf-1", status="pending",
+            type="conflict-fix",
+        )
+        stub = MagicMock(return_value=fix_assignment)
+        monkeypatch.setattr("coord.conflict_fix.dispatch_conflict_fix", stub)
+        monkeypatch.setattr("coord.merge_queue.load_queue", lambda: queued)
+        monkeypatch.setattr(
+            state_mod, "get_drive_queue_entry", lambda repo_name, issue_number: None,
+        )
+
+        action = notify_mod.dispatch_stalled_pipeline_action(detection, work, board, config)
+
+        assert action.kind == "conflict_fix_dispatched"
+        stub.assert_called_once()
+
     def test_conflict_fix_decline_reports_the_real_reason(
         self, config: Config, monkeypatch
     ) -> None: