code-coordinator 0.5.163__tar.gz → 0.5.165__tar.gz

{code_coordinator-0.5.163 → code_coordinator-0.5.165}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.163",
+  "tag": "0.5.165",
   "distance": 0,
-  "node": "g6fa07c5850b078c8d3d43576ceee2b342698e255",
+  "node": "g5bd13e9adba9bf24c0bf6aedd8cb4bd19bb41bb1",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.163 → code_coordinator-0.5.165}/coord/drive.py

@@ -996,22 +996,35 @@ def _decide_acceptance_landing(
     something that will happen, and waiting for the fourth is the #1526
     defect: an unbounded wait for an event that cannot occur.
 
-    Three shapes get an immediate, actionable exit instead of a wait,
-    because for each of them the corrective action belongs to a loop that
-    will never run for this row:
+    Two shapes get an immediate, actionable exit instead of a wait, because
+    for each of them the corrective action belongs to a loop that will never
+    run for this row:
 
     * a FAILED slice test — the work row's equivalent dispatches
       ``coord fix``, but nothing dispatches one for a ``test-author`` row
       whose Test stage failed;
-    * a ``request-changes`` slice review — ``auto_loop`` accepts a
-      ``test-author`` fix (``FIX_DISPATCH_TYPES``), but the daemon drain
-      deliberately excludes fix dispatch (#476/#477, and #1692's own
-      analysis), so for the work row it is THIS driver that runs
-      ``coord fix``; there was no such arm for the slice;
     * ``--no-merge`` — the slice merge is a hard prerequisite for
       dispatching any work at all (#1138), so with merging switched off the
       run cannot progress, and saying so beats idling to the deadline.
 
+    A third shape — a ``request-changes`` slice review — used to be a fourth
+    immediate exit for the identical reason (``auto_loop`` accepts a
+    ``test-author`` fix via ``FIX_DISPATCH_TYPES``, but the daemon drain
+    deliberately excludes fix dispatch — #476/#477, and #1692's own
+    analysis — so for the work row it is THIS driver that runs
+    ``coord fix``, and there was no such arm for the slice). #2425: it no
+    longer is. Every retry of this lane re-dispatched a fresh author on the
+    SAME branch name instead of fixing the one review blocking it
+    (claude-coordinator#2286 — 11 re-authoring attempts over ~11h with the
+    review's findings never once addressed), because re-authoring was the
+    only path this lane had. Below, ``request-changes`` now gets the same
+    bounded ``coord fix <acceptance_review_aid>`` arm :func:`decide` already
+    runs for the work row's own review (the ``REVIEW: request-changes → fix
+    round`` arm), spending :attr:`DriveCounters.acceptance`'s OWN
+    ``fix_rounds`` — not the work row's — for the same #2079 reason the
+    slice's merge attempts get their own budget: a struggling slice review
+    must not silently leave the issue's real fix budget at zero.
+
     The merge itself reuses :func:`_decide_merge` verbatim against a shadow
     :class:`~coord.drive_state.IssueState` whose "work row" IS the slice —
     that is what carries #1891 (CI not reported → wait, don't retry), #1892
@@ -1049,15 +1062,81 @@ def _decide_acceptance_landing(
         )
 
     if state.acceptance_review_verdict == "request-changes":
-        return _die(
-            f"the JIT acceptance slice {aid} was reviewed REQUEST-CHANGES "
-            f"(review {state.acceptance_review_aid or 'unknown'}) — it will "
-            "never reach the merge queue until that is addressed, and no "
-            "loop dispatches the fix for a test-author row on its own.\n"
-            f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
-            f"   Fix it: coord fix {state.acceptance_review_aid or aid}\n"
-            "   or re-run coord drive with --no-acceptance to skip JIT "
-            "authoring."
+        # #2425: the slice's own twin of `decide()`'s `REVIEW: request-
+        # changes → fix round` arm — see the docstring above for why this
+        # used to be a bare `_die()`. `coord fix` already accepts a
+        # `type="test-author"` review id (#1622/#1692:
+        # `auto_loop.FIX_DISPATCH_TYPES` includes `SEALED_PATH_AUTHOR_TYPES`,
+        # which is where "test-author" lives), so this is the SAME command
+        # the work-row arm dispatches, not a second implementation of it.
+        slice_counters = counters.slice_budget()
+        if not state.auto_loop:
+            return _die(
+                "the JIT acceptance slice's review requested changes, but "
+                "pipeline.auto_loop is OFF — the review→fix path is "
+                "switched off in coordinator.yml, so no fix can be "
+                "dispatched.\n"
+                f"   Findings: coord log {state.acceptance_review_aid or aid}\n"
+                "   Continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid or aid}"
+            )
+        # Belt-and-braces, mirroring the work-row arm: `acceptance_review_
+        # verdict` and `acceptance_review_aid` are read off the SAME board
+        # row (drive_state.project), so a verdict without an id is
+        # impossible today. Refuse to guess rather than dispatch `coord fix`
+        # against the wrong assignment.
+        if not state.acceptance_review_aid:
+            return _die(
+                "the JIT acceptance slice's review verdict is "
+                "'request-changes' but no review assignment id is on the "
+                "board — refusing to guess which review to fix. Inspect: "
+                f"coord gates {state.repo} {state.issue}"
+            )
+        # Same de-duplication latch as `review_fix_dispatched_for` on the
+        # work row's own arm, just on the slice's own counters: `coord fix`
+        # returns as soon as the fix worker is dispatched, and the board
+        # this driver polls needs a beat to show the new row.
+        if slice_counters.review_fix_dispatched_for == state.acceptance_review_aid:
+            return _wait(
+                label=(
+                    "ACCEPTANCE: fix already dispatched for "
+                    f"{state.acceptance_review_aid} — waiting for the fix "
+                    "row to appear on the board"
+                )
+            )
+        if slice_counters.fix_rounds >= opts.max_fix_rounds:
+            return _die(
+                f"the JIT acceptance slice {aid} was reviewed REQUEST-"
+                f"CHANGES (review {state.acceptance_review_aid}) after "
+                f"{slice_counters.fix_rounds} fix round(s) this drive spent "
+                "landing the slice — stopping.\n"
+                f"   Findings: coord log {state.acceptance_review_aid}\n"
+                f"   Continue by hand: coord fix {state.acceptance_review_aid}\n"
+                "   or re-run coord drive with --no-acceptance to skip JIT "
+                "authoring."
+            )
+        slice_counters.fix_rounds += 1
+        slice_counters.review_fix_dispatched_for = state.acceptance_review_aid
+        return Action(
+            kind=RUN,
+            label=(
+                "ACCEPTANCE: review request-changes → fix round "
+                f"{slice_counters.fix_rounds}/{opts.max_fix_rounds} "
+                f"(coord fix {state.acceptance_review_aid})"
+            ),
+            command=("fix", state.acceptance_review_aid),
+            error_message=(
+                f"coord fix {state.acceptance_review_aid} failed to "
+                "dispatch a fix for the JIT acceptance slice's review.\n"
+                "   Its refusals are all guards doing their job: auto_loop "
+                "disabled, no structured\n"
+                "   findings, approve-with-nits (#476), max_review_"
+                "iterations, or the #522\n"
+                "   terminal-work guard — the message above names which.\n"
+                f"   Check: coord log {state.acceptance_review_aid}   /   "
+                "continue by hand: coord assign --interactive --fix-of "
+                f"{state.acceptance_review_aid}"
+            ),
         )
 
     if not opts.do_merge:

{code_coordinator-0.5.163 → code_coordinator-0.5.165}/coord/drive_queue.py

@@ -97,6 +97,7 @@ from coord.merge_queue import (
     is_ci_infra_reason,
     is_ci_pending_reason,
     is_ci_unreadable_reason,
+    is_stale_smoke_reason,
 )
 from coord.models import is_policy_refusal_reason
 
@@ -1810,6 +1811,57 @@ def _dispatch_produced_nothing(entry: QueueEntry, facts: IssueFacts) -> bool:
     return facts.last_dispatched_at < entry.launched_at
 
 
+def _is_merge_gate_block_reason(reason: str | None) -> bool:
+    """#2424: does *reason* already name a merge-gate block — a death whose
+    real cause is a LATER stage (merge), not a dispatch-layer failure?
+
+    `_dispatch_produced_nothing`'s own comparison (``facts.last_dispatched_at
+    < entry.launched_at``) goes stale specifically for a relaunch whose only
+    job is retrying the Merge stage: by design, that relaunch dispatches no
+    new assignment (there is nothing left to dispatch — Work/Test/Review
+    already completed), so the comparison reads exactly like a genuine
+    dispatch failure even though three real assignments did real work. This
+    is the textual escape hatch for that case: when *reason* itself already
+    names a merge-gate block, the generic "#2273 no assignment was ever
+    created" note must not be layered on top of it — see
+    claude-coordinator#2405 (stale smoke verdict) and coord-web#2 (red CI),
+    both live escalations where the dispatch-note actively misdirected an
+    operator toward `drive-queue remove && add` (a wasted Work/Test/Review
+    cycle) instead of the real one-line fix (`coord merge --revalidate`, or
+    fixing the failing CI check).
+
+    Four shapes, all written by `coord/drive.py`'s own merge-stage decision
+    functions — none of them a "no assignment created" signal:
+
+    * `_die`'s exhausted-merge-attempts wording ("merge attempted N times
+      without landing") — `coord assign` succeeded and Work/Test/Review all
+      completed; the LOOP inside a single drive session that kept retrying
+      `coord merge --only` simply ran out of its own attempt budget
+      (#1505/#2078).
+    * `is_stale_smoke_reason` — the #1479 staleness race: the merge base
+      moved out from under a still-valid smoke verdict.
+    * "checks failed" — `coord.merge_queue`'s own `checks_failed` prose
+      (``f"checks failed: {summary}"``): red CI on a PR that was dispatched,
+      built, and reviewed fine.
+    * `_escalate_merge`'s own gate-divergence/terminal-status wording
+      ("smoke_required —" / "review_required —" / "merge_status=...") — the
+      #1505/#1526 immediate-escalation path, which already recorded its own
+      accurate `coord escalate record` before this drive exited.
+    """
+    if not reason:
+        return False
+    lowered = reason.lower()
+    if "merge attempted" in lowered:
+        return True
+    if is_stale_smoke_reason(reason):
+        return True
+    if "checks failed" in lowered:
+        return True
+    if "smoke_required —" in lowered or "review_required —" in lowered:
+        return True
+    return "merge_status=" in lowered
+
+
 def _is_empty_branch_death_reason(reason: str | None) -> bool:
     """#2363: does *reason* name the "claimed success, wrote nothing"
     signature — an acceptance-author or plain work session that exited
@@ -1858,6 +1910,7 @@ def _retry_backoff_reason(
     now: float | None,
     attempts: int,
     retry_backoff_at: float | None,
+    own_reason: str | None = None,
 ) -> str:
     """#2273's launch-side guard: ``''`` unless *entry* is still inside its
     post-death backoff window.
@@ -1898,6 +1951,23 @@ def _retry_backoff_reason(
     ``retry_backoff_at is None`` (a pure-logic caller with no clock, or a row
     predating this column — both degrade to the pre-#2273 behaviour exactly,
     the same posture every other clock-gated check in this module takes).
+
+    *own_reason* (#2424 follow-up): the same text the launch-side dispatch
+    note is gated on (see the comment above `dispatch_only` in
+    `_reconcile_running`'s retry/exhausted branches). Passed through so the
+    widened `DISPATCH_FAILURE_MIN_BACKOFF_SECONDS` spacing below answers the
+    identical "was this actually a dispatch failure" question the launch-side
+    note already answers, rather than recomputing it from
+    `_dispatch_produced_nothing` alone — which, like the note before #2424,
+    cannot tell a genuine pre-`coord assign` crash from a merge-only relaunch
+    that dispatches no new assignment by design. Once `own_reason` already
+    names a merge-gate block (`_is_merge_gate_block_reason`), the 300s floor
+    would be pure mispacing: the rationale for widening it ("a transient
+    dispatch failure cannot spend the whole retry budget inside one tick
+    cadence") does not apply once the cause is known to be a merge-gate
+    block, not a dispatch failure. ``None`` (the default) degrades to the
+    pre-#2424-follow-up behaviour exactly, for callers that have not been
+    updated to pass it.
     """
     if now is None or attempts <= 0 or retry_backoff_at is None:
         return ""
@@ -1906,7 +1976,9 @@ def _retry_backoff_reason(
         return ""
     idx = min(attempts - 1, len(RETRY_BACKOFF_SECONDS) - 1)
     backoff = RETRY_BACKOFF_SECONDS[idx]
-    if _dispatch_produced_nothing(entry, facts):
+    if _dispatch_produced_nothing(entry, facts) and not _is_merge_gate_block_reason(
+        own_reason
+    ):
         backoff = max(backoff, DISPATCH_FAILURE_MIN_BACKOFF_SECONDS)
     if age >= backoff:
         return ""
@@ -2347,7 +2419,21 @@ def _reconcile_running(
     # — or the escalation this produces once the budget IS exhausted — sees
     # "no assignment was ever created" instead of a bare exit code that
     # could mean anything.
-    dispatch_only = _dispatch_produced_nothing(entry, facts)
+    #
+    # #2424: EXCEPT when `own_reason` already names a merge-gate block
+    # ("merge attempted N times without landing", a stale smoke verdict, red
+    # CI, ...) — a relaunch whose only job is retrying the Merge stage
+    # dispatches no new assignment BY DESIGN (Work/Test/Review already
+    # completed; there is nothing left to dispatch), so the comparison above
+    # reads exactly like a dispatch failure even though it plainly is not.
+    # The generic note is additive evidence for when nothing more specific is
+    # known; it must never be layered on top of a reason that already
+    # contradicts it — see `_is_merge_gate_block_reason` for the two live
+    # escalations (claude-coordinator#2405, coord-web#2) this false-positive
+    # actually produced.
+    dispatch_only = _dispatch_produced_nothing(
+        entry, facts
+    ) and not _is_merge_gate_block_reason(own_reason)
     dispatch_note = (
         " — no assignment was ever created for this run (#2273): likely an "
         "infrastructure/dispatch-layer failure, not a code defect"
@@ -3604,17 +3690,24 @@ def plan_tick(
         `effective_last_reason`) so both call sites below — the report-only
         dry-run pass and the persisted `last_reason` write — get the combined
         text for free, with no change needed at either site.
+
+        #2424 follow-up: that same `effective_last_reason` resolution is also
+        what `_retry_backoff_reason` needs to answer its own "was this
+        actually a dispatch failure" question — see its `own_reason`
+        parameter's docstring — so it is resolved once, here, and passed to
+        both.
         """
+        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         backoff = _retry_backoff_reason(
             candidate,
             board.facts(candidate.key),
             now,
             effective_attempts.get(candidate.key, candidate.attempts),
             retry_backoff_at_map.get(candidate.key, candidate.retry_backoff_at),
+            own_reason=previous,
         )
         if not backoff:
             return ""
-        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         return _augment_backoff_reason(previous, backoff)
 
     # #1972's projection of per-repo occupancy AS THE WALK SEES IT: the board

{code_coordinator-0.5.163 → code_coordinator-0.5.165}/tests/test_drive.py

@@ -1304,18 +1304,112 @@ def test_failed_slice_test_stops_with_the_fix_command():
     assert "coord fix ta1" in action.message
 
 
-def test_slice_review_request_changes_stops_with_the_fix_command():
+def test_slice_review_request_changes_dispatches_a_fix():
+    """#2425: the JIT lane's own twin of the work row's `REVIEW:
+    request-changes → fix round` arm — before this, a request-changes
+    verdict on the slice was a dead end nothing ever dispatched a fix for
+    (claude-coordinator#2286: 11 re-authoring retries over ~11h, never once
+    addressing the review)."""
+    counters = DriveCounters()
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == RUN
+    assert action.command == ("fix", "rv1")
+    assert "rv1" in action.label
+    assert not action.is_exit
+    # Spends the SLICE's own budget, not the work row's (#2079's rule,
+    # extended to fix rounds): landing the slice must not silently leave
+    # the issue's own fix budget at zero.
+    assert counters.fix_rounds == 0
+    assert counters.acceptance is not None
+    assert counters.acceptance.fix_rounds == 1
+    assert counters.acceptance.review_fix_dispatched_for == "rv1"
+
+
+def test_slice_review_fix_already_dispatched_waits_for_the_board():
+    """The de-dup latch: a second poll against the SAME review id must not
+    spawn a second fix worker on the same branch (#476/#477)."""
+    counters = DriveCounters()
+    counters.slice_budget().review_fix_dispatched_for = "rv1"
     action = landing_step(
         landing_state(
             acceptance_review_verdict="request-changes",
             acceptance_merge_status="",
+        ),
+        counters=counters,
+    )
+    assert action.kind == WAIT
+    assert "rv1" in action.label
+    assert counters.acceptance.fix_rounds == 0
+
+
+def test_slice_review_fix_rounds_are_bounded_then_die():
+    """Bounded the same way the work row's fix loop is — a slice review that
+    keeps coming back request-changes must eventually escalate, not spin."""
+    opts = DriveOptions(machine="precision", max_fix_rounds=2)
+    counters = DriveCounters()
+    for expected_round in (1, 2):
+        action = landing_step(
+            landing_state(
+                acceptance_review_verdict="request-changes",
+                acceptance_merge_status="",
+            ),
+            opts,
+            counters=counters,
         )
+        assert action.kind == RUN
+        assert action.command == ("fix", "rv1")
+        assert counters.acceptance.fix_rounds == expected_round
+        # Clear the latch between rounds the same way a changed review row
+        # would on the real board (a fresh review after the fix landed).
+        counters.acceptance.review_fix_dispatched_for = ""
+
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+        ),
+        opts,
+        counters=counters,
     )
     assert action.is_exit
     assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "2 fix round(s)" in action.message
     assert "coord fix rv1" in action.message
 
 
+def test_slice_review_request_changes_with_auto_loop_off_dies_without_dispatching():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            auto_loop=False,
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "auto_loop is OFF" in action.message
+    assert "coord assign --interactive --fix-of rv1" in action.message
+
+
+def test_slice_review_request_changes_with_no_review_id_refuses_to_guess():
+    action = landing_step(
+        landing_state(
+            acceptance_review_verdict="request-changes",
+            acceptance_merge_status="",
+            acceptance_review_aid="",
+        )
+    )
+    assert action.is_exit
+    assert action.exit_code == EXIT_TERMINAL_FAILURE
+    assert "refusing to guess" in action.message
+
+
 def test_no_merge_refuses_up_front_instead_of_idling_to_the_deadline():
     """`--no-merge` makes the run unable to progress at all (#1138 refuses
     the work dispatch until the slice lands) — say so immediately."""

{code_coordinator-0.5.163 → code_coordinator-0.5.165}/tests/test_drive_queue.py

@@ -1512,6 +1512,40 @@ def test_a_dispatch_failure_that_created_no_assignment_backs_off_longer():
     assert len(backoff) == 1 and backoff[0].backing_off is True
 
 
+def test_a_merge_gate_block_retry_does_not_get_the_widened_backoff():
+    """#2424 follow-up: identical setup to the test above (no board-visible
+    assignment for this launch — by itself indistinguishable from a genuine
+    dispatch failure) EXCEPT the entry's own `last_reason` already names a
+    merge-gate block. `_retry_backoff_reason` must not widen the spacing to
+    `DISPATCH_FAILURE_MIN_BACKOFF_SECONDS` (300s) on top of a reason that
+    already says the real cause is a merge-gate block, not a dispatch
+    failure — the same "one question, one answer" fix `_is_merge_gate_block_
+    reason` already applies to the escalation text, now also applied to the
+    retry-pacing decision that answers the same question independently."""
+    launched_at = NOW - DRIVE_STARTUP_GRACE_SECONDS - 400.0
+    entries = [
+        entry(
+            1650,
+            position=3,
+            state=STATE_WAITING,
+            attempts=1,
+            launched_at=launched_at,
+            # Same 90s elapsed as the widened-backoff test above: clears the
+            # plain RETRY_BACKOFF_SECONDS[0] (60s) but not the widened 300s
+            # floor.
+            retry_backoff_at=NOW - 90.0,
+            last_reason=(
+                "merge attempted 3 times without landing. (attempt 2/5) — "
+                "requeued at position 3"
+            ),
+        )
+    ]
+    facts = IssueFacts(known=True, issue_state="open")  # no assignment at all
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(entries, view, capacity=1, now=NOW)
+    assert plan.launch is not None and plan.launch.issue == 1650
+
+
 def test_a_dispatched_run_that_died_later_gets_the_plain_backoff_only():
     """The counterpart: a launch that DID dispatch (an assignment exists,
     created after `launched_at`) is NOT treated as a pure dispatch failure —
@@ -1555,6 +1589,149 @@ def test_exhausted_reason_names_a_dispatch_only_failure():
     assert "no assignment was ever created for this run" in plan.blocked[0].reason
 
 
+def test_exhausted_merge_gate_block_does_not_get_the_dispatch_note():
+    """#2424: claude-coordinator#2405 / coord-web#2 — a relaunch whose only
+    job is retrying the Merge stage dispatches no NEW assignment by design
+    (Work/Test/Review already completed), so `_dispatch_produced_nothing`'s
+    comparison reads exactly like a genuine dispatch failure. The own exit
+    reason already names the real cause (a merge-gate block); the #2273 note
+    must not be layered on top of it, or an operator reading the escalation
+    is misdirected toward `drive-queue remove && add` (a wasted Work/Test/
+    Review cycle) instead of `coord merge --revalidate`."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "attempted 3 times without landing.\n"
+        "   Last board state: status='CONFLICT' reason='smoke test verdict "
+        "is stale'"
+    )
+    # No assignment dispatched AFTER `launched_at` — exactly the shape a
+    # merge-only relaunch produces, and exactly what used to trip the #2273
+    # note despite three real assignments already having done real work.
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created" not in reason
+    assert "infrastructure/dispatch-layer failure" not in reason
+
+
+def test_exhausted_checks_failed_does_not_get_the_dispatch_note():
+    """Same #2424 fix, the red-CI shape (coord-web#2): `own_reason` names a
+    `checks_failed` merge-gate block, not a dispatch failure."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "attempted 3 times without landing.\n"
+        "   Last board state: status='CONFLICT' reason='checks failed: "
+        "checks'"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert "no assignment was ever created" not in reason
+
+
+def test_exhausted_immediate_escalation_merge_status_does_not_get_the_dispatch_note():
+    """#2424's fourth documented shape: `_escalate_merge`'s #1505
+    immediate-escalation path (`coord/drive.py:2809`), whose `Action.message`
+    is `f"merge escalated: {reason}\\n   gates: {gates_summary}\\n..."`
+    (`coord/drive.py:2836`) and whose `reason` for a terminal/unrecognized
+    merge status is `f"merge_status={status or '(empty)'} — no number of
+    retries..."`. `_drive_exit_summary` then wraps that whole message as
+    `f"drive exited for {ident} (exit_code={exit_code}): {reason}"`
+    (`coord/drive.py:3677`) before it is read back verbatim as `own_reason` —
+    so the real string never STARTS WITH "merge_status=", it merely CONTAINS
+    it (both in the `reason` line and again in `gates_summary`'s own
+    `merge_status=...` pair). A prior `.startswith("merge_status=")` check
+    left this one shape unmatched — dead code against real data — so a drive
+    that hit this exact path still got the false #2273 dispatch-note."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): merge "
+        "escalated: merge_status=CONFLICT — no number of retries changes "
+        "this; escalating on first encounter instead of burning the "
+        "merge-attempt budget (#1505)\n"
+        "   gates: merge_status=CONFLICT | merge_reason=(none) | "
+        "review_verdict=approved | test_state=passed | pr_url=(none)\n"
+        "   proposed: coord merge --plan --repo claude-coordinator   "
+        "# inspect the gates, then decide\n"
+        "   Recorded on the board — see: coord escalate list --repo "
+        "claude-coordinator"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created" not in reason
+    assert "infrastructure/dispatch-layer failure" not in reason
+
+
+def test_a_genuine_dispatch_failure_still_gets_the_note_alongside_own_reason():
+    """Regression guard for #2424's fix: an own_reason that does NOT name a
+    merge-gate block (a genuine pre-`coord assign` crash) must still get the
+    #2273 note — the fix narrows the false-positive, it does not remove the
+    signal entirely."""
+    entries = [
+        entry(
+            1650,
+            state=STATE_RUNNING,
+            attempts=DEFAULT_MAX_ATTEMPTS - 1,
+            launched_at=NOW - DRIVE_STARTUP_GRACE_SECONDS - 1,
+        )
+    ]
+    own_reason = (
+        "drive exited for claude-coordinator#1650 (exit_code=1): unhandled "
+        "exception in dispatch"
+    )
+    facts = IssueFacts(known=True, issue_state="open")
+    view = BoardView(issues={entry_key(REPO, 1650): facts})
+    plan = plan_tick(
+        entries, view, capacity=1, now=NOW,
+        exit_reasons={entry_key(REPO, 1650): own_reason},
+    )
+    assert plan.reconciles[0].outcome == "exhausted"
+    reason = plan.blocked[0].reason
+    assert own_reason in reason
+    assert "no assignment was ever created for this run" in reason
+
+
 def test_a_dead_drive_out_of_attempts_blocks_and_escalates():
     entries = [
         entry(1650, state=STATE_RUNNING, attempts=DEFAULT_MAX_ATTEMPTS - 1)