code-coordinator 0.5.76__tar.gz → 0.5.77__tar.gz

{code_coordinator-0.5.76 → code_coordinator-0.5.77}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.76",
+  "tag": "0.5.77",
   "distance": 0,
-  "node": "gdd3b9581f5fd9462b2fb9a85757ee783e3b09911",
+  "node": "gb940996c651692e5e0c90012a9046b2dfe09ec50",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.76 → code_coordinator-0.5.77}/coord/drive.py

@@ -289,6 +289,21 @@ class DriveCounters:
     # capture deserves its own full budget of cheap waits before the next
     # forced retry.
     gate_wait_rounds: int = 0
+    # #2229: the value `merge_attempts` held when the #1738 stale-smoke
+    # re-test last fired off a reason read out of `last_merge_diagnostic`
+    # rather than off the board (`-1` = never). A de-duplication latch in the
+    # same spirit as `review_fix_dispatched_for` above, for the same reason:
+    # `coord diagnose --stage test --reset` clears `test_state`, but the board
+    # this driver polls needs a beat to show it, and until it does the state
+    # is byte-for-byte identical to the one that triggered the re-test —
+    # except that, unlike a board `merge_reason`, the captured diagnostic is
+    # frozen and CANNOT change on its own. Without the latch a lagging board
+    # would burn the whole `max_fix_rounds` budget re-testing off one stale
+    # snapshot. Releases when `merge_attempts` advances, i.e. when a real
+    # `coord merge --only` attempt has re-captured the diagnostic — which is
+    # #2149's rule (act on the snapshot, then go re-validate it for real)
+    # expressed as a latch rather than a wait counter.
+    stale_smoke_diagnostic_attempt: int = -1
     # #2199: bounded retry for the trust gate's OWN dispatch — distinct from
     # `fix_rounds` (which bounds "the work needs another round" once a
     # verdict, passed or failed, actually landed on the board). This counts
@@ -2377,19 +2392,112 @@ def _merge_gate_kind(reason: str) -> str | None:
 _STALE_SMOKE_MARKERS = _mq_stale_smoke_markers
 _is_stale_smoke_reason = _mq_is_stale_smoke_reason
 
+# #2229: `coord merge --only` prints a gate line per REFUSED gate, and the
+# same run prints a "waived by this run" variant of that line for a gate the
+# invocation's own `--skip-review`/`--skip-smoke` disarmed
+# (`coord.commands.merge`, the `_status` ternary). A waived gate did not
+# refuse anything, so its line must never be read back as a refusal.
+_GATE_WAIVED_MARKER = "waived by this run"
+
+
+def _extract_gate_refusal_reason(diagnostic: str | None) -> str:
+    """The first smoke/review gate refusal named anywhere in a captured
+    `coord merge --only` *diagnostic*, or ``""`` (#2229).
+
+    Unlike :func:`_extract_gate_block_reason` — which matches only
+    `_explain_missing_only_entry`'s "enqueue blocked by <gate>" wording, i.e.
+    the NOT-YET-ENQUEUED shape — this reads the refusal out of a run where
+    the entry *did* resolve. `coord merge --only` echoes one
+    ``  gate <name>: <reason> — will block this merge`` line per failing gate
+    before `process()` runs, and `process()`'s own events (``smoke_required
+    — …``) name it again; both are ordinary lines carrying the same gate
+    vocabulary :func:`_merge_gate_kind` already classifies, so this scans
+    lines rather than pinning one exact format that would silently stop
+    matching the day either message is reworded.
+
+    quadraui#309: that text is the ONLY place the refusal existed. The board
+    plan reported ``READY`` with an empty reason (``merge_queue.plan()``'s
+    `_entry_gate_status` degrades to a no-op without live SHA data — the
+    #1640 door, the #1566 "plan says ready, ``--only`` refuses" split), so
+    `_merge_gate_divergence` saw nothing to classify and the drive spent
+    three blind retries and died — printing this very text in its own death
+    message.
+    """
+    for line in (diagnostic or "").splitlines():
+        if _GATE_WAIVED_MARKER in line.lower():
+            continue
+        if _merge_gate_kind(line) is not None:
+            return line.strip()
+    return ""
+
+
+def _effective_merge_gate_reason(
+    state: IssueState, counters: DriveCounters
+) -> tuple[str, bool]:
+    """The reason to classify the merge gate from, and whether it came from
+    the captured diagnostic rather than the board (#2229).
+
+    Prefers `state.merge_reason` — live, re-read on every poll. Falls back to
+    `counters.last_merge_diagnostic` only when the board reason names no gate
+    this module knows an action for, because that is exactly the quadraui#309
+    shape: the board is silent while this driver's OWN last `coord merge
+    --only` attempt already captured the refusal verbatim.
+
+    The fallback is a LAST resort, taken only when the board offers no
+    competing live signal — a snapshot must never outrank something being
+    re-read every poll. Three cases keep the board's own reading:
+
+    - ``merge_status == ""`` — "no queue entry at all" is #2078's shape, with
+      its own `_extract_gate_block_reason` bounded-wait arm in
+      :func:`_decide_merge`. #2229 is about the case #2078 skips wholesale:
+      an entry that IS enqueued (READY, PENDING, …) whose refusal only a
+      live attempt ever saw.
+    - ``merge_status == "CONFLICT"`` — a live merge-mechanics block with its
+      own resolution path (#1474/#241's conflict-fix dispatch, reached
+      through the bounded retry below). A re-test does not rebase a branch,
+      and diverting to one is the same stall this issue is about, inverted.
+    - a CI reason (#1891/#1892) — `merge_reason` already carries a live,
+      recognised signal whose only resolution is more real time. Those two
+      bare waits sit right after the divergence check and must keep winning.
+
+    The bool is the caller's warning label: a diagnostic-derived reason is a
+    SNAPSHOT of the last real attempt, refreshed by nothing but another
+    attempt (#2149's lesson — coord-portal#50 waited 2h33m on a cached
+    "review required" that had already cleared). It is strictly fresher than
+    an empty board reason, but it must not be re-acted on indefinitely; see
+    `DriveCounters.stale_smoke_diagnostic_attempt`.
+    """
+    if _merge_gate_kind(state.merge_reason) is not None:
+        return state.merge_reason, False
+    if state.merge_status == "" or state.merge_status.upper() == "CONFLICT":
+        return state.merge_reason, False
+    if is_ci_pending_reason(state.merge_reason) or is_ci_infra_reason(
+        state.merge_reason
+    ):
+        return state.merge_reason, False
+    fallback = _extract_gate_refusal_reason(counters.last_merge_diagnostic)
+    if fallback:
+        return fallback, True
+    return state.merge_reason, False
 
-def _merge_gate_divergence(state: IssueState) -> str | None:
+
+def _merge_gate_divergence(state: IssueState, reason: str | None = None) -> str | None:
     """``"smoke"``/``"review"`` when *state* shows the #1526 divergence,
     else ``None``.
 
-    The divergence: `state.merge_reason` names a smoke/review block while
-    this SAME state's `work_test_state`/`review_verdict` says the opposite.
-    That contradiction can only come from `coord merge` checking something
-    this driver's view does not (freshness against the CURRENT branch/base,
-    not just the terminal verdict) — never from a retry, since neither
-    input changes by running `coord merge` again unchanged.
+    The divergence: the merge gate's *reason* names a smoke/review block
+    while this SAME state's `work_test_state`/`review_verdict` says the
+    opposite. That contradiction can only come from `coord merge` checking
+    something this driver's view does not (freshness against the CURRENT
+    branch/base, not just the terminal verdict) — never from a retry, since
+    neither input changes by running `coord merge` again unchanged.
+
+    *reason* (#2229) defaults to `state.merge_reason`, the board's own text.
+    :func:`_decide_merge` passes :func:`_effective_merge_gate_reason`'s
+    result instead so a refusal that exists ONLY in the last captured
+    `coord merge --only` diagnostic still classifies.
     """
-    kind = _merge_gate_kind(state.merge_reason)
+    kind = _merge_gate_kind(state.merge_reason if reason is None else reason)
     if kind == "smoke" and state.work_test_state in ("passed", "skipped"):
         return "smoke"
     if kind == "review" and state.review_verdict == "approve":
@@ -2398,7 +2506,11 @@ def _merge_gate_divergence(state: IssueState) -> str | None:
 
 
 def _escalate_merge(
-    state: IssueState, status: str, *, gate_kind: str | None = None
+    state: IssueState,
+    status: str,
+    *,
+    gate_kind: str | None = None,
+    gate_reason: str | None = None,
 ) -> Action:
     """Build the EXIT action for a merge status retrying cannot fix (#1505).
 
@@ -2422,6 +2534,16 @@ def _escalate_merge(
     (re-confirm the test verdict, or a scoped/full re-review) rather than the
     generic "inspect the plan" fallback below.
 
+    *gate_reason* (#2229) is the text that gate_kind was classified from,
+    when it is NOT `state.merge_reason` — i.e. when the board carried no
+    reason and :func:`_effective_merge_gate_reason` recovered the refusal
+    from the last captured `coord merge --only` diagnostic instead. The
+    escalation narrative quotes it, because ``reports ''`` is exactly the
+    unactionable escalation quadraui#309 would otherwise have produced. The
+    recorded ``--gate merge_reason=…`` pair still reports the BOARD's own
+    (empty) value — the gates block is a snapshot of board state, and
+    overwriting it here would hide the very divergence being escalated.
+
     Otherwise, the proposed command mirrors the #1477 resolution this issue
     was opened over: when a PR is known, ``gh pr merge --rebase`` + ``coord
     reconcile-merges`` is the sanctioned escape hatch (also documented in
@@ -2468,9 +2590,10 @@ def _escalate_merge(
             if gate_kind == "smoke"
             else f"review_verdict={state.review_verdict!r}"
         )
+        reported = state.merge_reason if gate_reason is None else gate_reason
         reason = (
             f"{gate_kind}_required — coord merge's own gate reports "
-            f"{state.merge_reason!r}, but this driver's OWN view already "
+            f"{reported!r}, but this driver's OWN view already "
             f"shows {driver_view} — the two cannot converge by retrying the "
             "identical `coord merge` command (#1526); a human must "
             "reconcile them"
@@ -2562,8 +2685,30 @@ def _decide_merge(
     readings; retrying the identical ``coord merge`` command changes neither
     side of the disagreement.
     """
-    divergence = _merge_gate_divergence(state)
-    if divergence == "smoke" and _is_stale_smoke_reason(state.merge_reason):
+    # #2229: classify from the board's `merge_reason` when it names a gate,
+    # and otherwise from this driver's OWN last `coord merge --only` output.
+    # quadraui#309 sat blocked for 11h on a merge that landed first try by
+    # hand because the board reason was empty (#1566/#1640) while the
+    # captured diagnostic said, in as many words, "smoke test verdict is
+    # stale" — the exact string the #1738 auto-repair arm below keys on. It
+    # was used for one thing: being printed into the give-up message.
+    gate_reason, gate_reason_from_diagnostic = _effective_merge_gate_reason(
+        state, counters
+    )
+    divergence = _merge_gate_divergence(state, reason=gate_reason)
+    if (
+        gate_reason_from_diagnostic
+        and divergence == "smoke"
+        and _is_stale_smoke_reason(gate_reason)
+        and counters.stale_smoke_diagnostic_attempt == counters.merge_attempts
+    ):
+        # A re-test already fired off THIS snapshot and no real attempt has
+        # re-captured it since, so re-firing would spend a second fix round
+        # on evidence that literally cannot have changed. Drop to the bounded
+        # retry below instead: that attempt refreshes the diagnostic, which
+        # either lands the merge or re-arms this arm against fresh evidence.
+        divergence = None
+    if divergence == "smoke" and _is_stale_smoke_reason(gate_reason):
         # #1738: a STALE (not missing) smoke verdict has a safe, bounded
         # self-service fix this driver can take without a human — re-run the
         # Test stage against the current base via the same non-destructive
@@ -2575,8 +2720,17 @@ def _decide_merge(
         # going stale (e.g. a base that keeps moving under it) still
         # converges to an escalation instead of spinning forever.
         if counters.fix_rounds >= opts.max_fix_rounds:
-            return _escalate_merge(state, state.merge_status, gate_kind=divergence)
+            return _escalate_merge(
+                state,
+                state.merge_status,
+                gate_kind=divergence,
+                gate_reason=gate_reason,
+            )
         counters.fix_rounds += 1
+        if gate_reason_from_diagnostic:
+            # #2229: arm the latch above — one re-test per captured
+            # diagnostic, then a real attempt has to re-validate it.
+            counters.stale_smoke_diagnostic_attempt = counters.merge_attempts
         return Action(
             kind=RUN,
             label=(
@@ -2597,7 +2751,9 @@ def _decide_merge(
             ),
         )
     if divergence is not None:
-        return _escalate_merge(state, state.merge_status, gate_kind=divergence)
+        return _escalate_merge(
+            state, state.merge_status, gate_kind=divergence, gate_reason=gate_reason
+        )
 
     # #1891: a CI verdict that has not arrived is not a CI verdict of "no" —
     # checked BEFORE the `status` switch below (and regardless of what

{code_coordinator-0.5.76 → code_coordinator-0.5.77}/docs/DRIVE_QUEUE.md

@@ -34,6 +34,19 @@ Three arms have since landed against it:
 * **#1738** — `coord drive` re-dispatches the Test stage once, automatically,
   on a STALE (not missing) verdict. Only fires while a **live drive** is
   watching the issue. Measured 2026-08-03: reached 1 of 4 real stalls.
+  **#2229** widened what it can see: the arm used to classify the gate from
+  the board's `merge_reason` alone, which `merge_queue.plan()` leaves *empty*
+  whenever its render-time freshness check has no live SHA data (the #1640
+  door / the #1566 "plan says READY, `--only` refuses" split) — so on an
+  already-enqueued entry the arm could not arm at all, and the drive spent
+  three blind retries and died *printing the refusal it had captured*
+  (quadraui#309: 11h blocked on a merge that then landed first try by hand).
+  It now falls back to the last `coord merge --only` diagnostic the drive
+  itself captured. Still only the STALE arm self-repairs — a *missing*
+  verdict is the #1640 lost-write shape and escalates to a human unchanged —
+  and, because that diagnostic is a snapshot rather than live state (#2149),
+  each capture buys at most one re-test before a real attempt has to
+  re-validate it.
 * **#1769** — `coord merge --revalidate` re-tests a stale-but-`passed` entry
   against the current base from the *merge* lane, which is where a branch with
   no live drive actually sits.

{code_coordinator-0.5.76 → code_coordinator-0.5.77}/tests/test_drive.py

@@ -3413,6 +3413,277 @@ def test_is_stale_smoke_reason_distinguishes_stale_from_missing():
     assert not _is_stale_smoke_reason(None)
 
 
+# ═══════════════════════════════════════════════════════════════════════════
+# #2229: the driver captured the exact merge refusal, printed it into its own
+# death message, and never classified it.
+#
+# quadraui#309 sat blocked for 11h on a merge that landed first try by hand.
+# `merge_queue.plan()` reported READY with NO reason (`_entry_gate_status`
+# re-derives freshness at board-build time and degrades to a no-op without
+# live SHA data — the #1640 door / #1566 "plan says ready, --only refuses"
+# split), so `_merge_gate_divergence` had nothing to classify. Meanwhile every
+# `coord merge --only` attempt captured "smoke test verdict is stale" into
+# `counters.last_merge_diagnostic` — the exact string the #1738 auto-repair
+# arm keys on — and used it for nothing but the give-up message.
+#
+# #2078's diagnostic fallback did not cover this: it lives inside the
+# `status == ""` arm (#309's entry WAS enqueued) and matches only the
+# not-yet-enqueued `enqueue blocked by <gate>` wording.
+# ═══════════════════════════════════════════════════════════════════════════
+
+
+def _stale_smoke_diagnostic() -> str:
+    """The quadraui#309 diagnostic, verbatim in shape: `coord merge --only`'s
+    own pre-`process()` gate line plus the `smoke_required` event."""
+    return (
+        "  gate smoke: test verdict stale (recorded against base f6216e4, "
+        "base now c50e30c) — will block this merge\n"
+        "  quadraui #309 (issue-309-drive-queue-bot): smoke_required — smoke "
+        "test verdict is stale: recorded against base f6216e4, base is now "
+        "c50e30c — re-verify against the current base, then `coord test "
+        "41ae4f893239 --passed`"
+    )
+
+
+def _missing_smoke_diagnostic() -> str:
+    return (
+        "  gate smoke: smoke test required but no verdict recorded — will "
+        "block this merge"
+    )
+
+
+def test_stale_smoke_only_in_the_captured_diagnostic_takes_the_retest_arm():
+    """THE #2229 regression test. Board: `merge_status='READY'`,
+    `merge_reason=''` — nothing to classify. Diagnostic: this driver's own
+    last `coord merge --only`, saying the smoke verdict is stale. The #1738
+    re-test must arm off that, instead of the three blind retries that ended
+    in `exit_code=1` and an 11h stall."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == (
+        "diagnose", REPO, str(ISSUE), "--stage", "test", "--reset",
+    )
+    assert counters.fix_rounds == 1
+    assert counters.merge_attempts == 0  # no blind retry spent
+
+
+def test_missing_verdict_in_the_captured_diagnostic_escalates_and_never_repairs():
+    """`_STALE_SMOKE_MARKERS` stays a STRICT subset of `_SMOKE_GATE_MARKERS`
+    on the diagnostic path too: a MISSING verdict is the #1640 lost-write
+    shape, which a re-test cannot safely paper over. It escalates to a human
+    on first encounter, exactly as it does off a board reason."""
+    counters = DriveCounters(last_merge_diagnostic=_missing_smoke_diagnostic())
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""),
+        counters=counters,
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_ESCALATED
+    assert counters.fix_rounds == 0
+    assert "smoke" in action.message.lower()
+
+
+def test_diagnostic_derived_escalation_quotes_the_recovered_reason():
+    """An escalation that says `reports ''` is unactionable — the whole #2229
+    complaint. The recovered gate text has to reach the recorded reason."""
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""),
+        counters=DriveCounters(last_merge_diagnostic=_missing_smoke_diagnostic()),
+    )
+    assert action.is_exit
+    assert "smoke test required but no verdict recorded" in " ".join(action.command)
+
+
+def test_diagnostic_derived_retest_fires_once_per_captured_snapshot():
+    """#2149's lesson as a latch: the diagnostic is a SNAPSHOT that nothing
+    but a real attempt refreshes. `coord diagnose --stage test --reset` clears
+    `test_state`, but the board needs a beat to show it — until then the state
+    is byte-for-byte identical. One re-test per snapshot, then a REAL attempt
+    has to re-validate; otherwise a lagging board burns the whole
+    `max_fix_rounds` budget off one frozen line."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    opts = DriveOptions(machine="precision", max_fix_rounds=3)
+    s = approved_work(merge_status="READY", merge_reason="")
+
+    first = step(s, opts, counters=counters)
+    assert first.command[0] == "diagnose"
+    assert counters.fix_rounds == 1
+
+    # Same frozen diagnostic, same board — must NOT spend a second fix round.
+    second = step(s, opts, counters=counters)
+    assert second.kind == RUN
+    assert second.command == ("merge", "--only", "w1", "--method", "rebase")
+    assert counters.fix_rounds == 1
+    assert counters.merge_attempts == 1
+
+
+def test_diagnostic_derived_retest_is_bounded_by_max_fix_rounds():
+    """The re-test arm shares the same `fix_rounds` budget when it arms off
+    the diagnostic — a board that never catches up must converge on an
+    escalation, never spin to the deadline."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    opts = DriveOptions(machine="precision", max_fix_rounds=2, max_merge_attempts=99)
+    s = approved_work(merge_status="READY", merge_reason="")
+
+    actions = []
+    for _ in range(12):
+        action = step(s, opts, counters=counters)
+        actions.append(action)
+        if action.is_exit:
+            break
+
+    assert actions[-1].is_exit
+    assert actions[-1].exit_code == EXIT_ESCALATED
+    assert counters.fix_rounds == 2
+    retests = [a for a in actions if a.command and a.command[0] == "diagnose"]
+    assert len(retests) == 2
+
+
+def test_a_board_reason_still_wins_over_the_captured_diagnostic():
+    """The fallback is a fallback: `merge_reason` is live and re-read every
+    poll, the diagnostic is only as fresh as the last attempt. When the board
+    names a gate, that is what gets classified."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    action = step(
+        approved_work(
+            merge_status="READY",
+            merge_reason="review required but not approved",
+        ),
+        counters=counters,
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_ESCALATED
+    assert "review-reaffirm w1" in " ".join(action.command)
+    assert counters.fix_rounds == 0
+
+
+def test_an_enqueued_status_with_no_gate_in_the_diagnostic_still_retries_blind():
+    """The companion case: an enqueued entry whose captured diagnostic names
+    no gate at all has nothing to classify — the bounded `--only` retry is
+    still the right move, unchanged."""
+    counters = DriveCounters(
+        last_merge_diagnostic="merge-queue: 1 entry processed; 0 merged"
+    )
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == ("merge", "--only", "w1", "--method", "rebase")
+    assert counters.merge_attempts == 1
+
+
+def test_the_first_merge_poll_never_classifies_off_an_empty_diagnostic():
+    """Before any attempt has run there is no diagnostic, so #2229 can never
+    escalate (or re-test) a merge this drive has not even tried once."""
+    counters = DriveCounters()
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""), counters=counters
+    )
+    assert action.kind == RUN
+    assert action.command[0] == "merge"
+
+
+def test_the_empty_status_enqueue_blocked_path_is_unchanged_by_2229():
+    """`status == ""` is #2078's shape and keeps #2078's bounded-wait arm:
+    "no queue entry at all" is a different fact from "enqueued and refused",
+    and the cheap wait is what lets a not-yet-enqueued row self-heal without
+    spending a re-test on it."""
+    counters = DriveCounters()
+    opts = DriveOptions(machine="precision", max_merge_attempts=3)
+    counters.last_merge_diagnostic = (
+        "merge-queue: no entry found for 'w1', but 1 done work row(s) on the "
+        "board match it:\n"
+        "  claude-coordinator #1392 (assignment w1, branch fix-1392) — "
+        "enqueue blocked by smoke gate — test verdict stale (recorded "
+        "against base 5f34a46, base now ff1bd1f) (waive with --skip-smoke)"
+    )
+    action = step(approved_work(merge_status=""), opts, counters=counters)
+    assert action.kind == WAIT
+    assert "not yet enqueued" in action.label
+    assert counters.fix_rounds == 0
+    assert counters.gate_wait_rounds == 1
+
+
+def test_a_live_ci_wait_still_wins_over_a_captured_gate_line():
+    """#1891/#1892's bare waits sit right after the divergence check and must
+    keep winning: `merge_reason` carries a live, recognised signal whose only
+    resolution is more real time. A snapshot from an older attempt must not
+    divert the drive into a re-test while CI is still reporting."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    action = step(
+        approved_work(
+            merge_status="READY",
+            merge_reason="CI running: build, windows",
+        ),
+        counters=counters,
+    )
+    assert action.kind == WAIT
+    assert counters.fix_rounds == 0
+    assert counters.merge_attempts == 0
+
+
+def test_a_conflict_status_still_reaches_its_own_conflict_fix_dispatch():
+    """CONFLICT is a live merge-mechanics block with its own resolution path
+    (#1474/#241, reached through the bounded `--only` retry). A re-test does
+    not rebase a branch — diverting to one is this issue's stall, inverted."""
+    counters = DriveCounters(last_merge_diagnostic=_stale_smoke_diagnostic())
+    action = step(
+        approved_work(merge_status="CONFLICT", merge_reason=""),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == ("merge", "--only", "w1", "--method", "rebase")
+    assert counters.fix_rounds == 0
+
+
+def test_extract_gate_refusal_reason_reads_either_wording():
+    from coord.drive import _extract_gate_refusal_reason
+
+    assert "test verdict stale" in _extract_gate_refusal_reason(
+        _stale_smoke_diagnostic()
+    )
+    assert _extract_gate_refusal_reason(
+        "  gate review: review required but not approved — will block this merge"
+    ) == "gate review: review required but not approved — will block this merge"
+    # No gate named — nothing to classify.
+    assert _extract_gate_refusal_reason("merge-queue: 1 merged") == ""
+    assert _extract_gate_refusal_reason("") == ""
+    assert _extract_gate_refusal_reason(None) == ""
+
+
+def test_extract_gate_refusal_reason_ignores_a_gate_this_run_waived():
+    """`coord merge --only --skip-smoke` prints the SAME gate line with
+    "waived by this run" instead of "will block this merge". A waived gate
+    refused nothing and must never be read back as a refusal."""
+    from coord.drive import _extract_gate_refusal_reason
+
+    waived = (
+        "  gate smoke: test verdict stale (base moved) — waived by this run\n"
+        "  --skip-smoke: interactive smoke-test gate bypassed (#465)"
+    )
+    assert _extract_gate_refusal_reason(waived) == ""
+
+
+def test_a_waived_gate_in_the_diagnostic_leaves_the_merge_retryable():
+    """End to end: the waiver guard above must not turn a merge that this run
+    explicitly un-gated into an escalation or a re-test."""
+    counters = DriveCounters(
+        last_merge_diagnostic=(
+            "  gate smoke: test verdict stale (base moved) — waived by this run"
+        )
+    )
+    action = step(
+        approved_work(merge_status="READY", merge_reason=""), counters=counters
+    )
+    assert action.kind == RUN
+    assert action.command[0] == "merge"
+
+
 # ── terminal: merged, verified ───────────────────────────────────────────────