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

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

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

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

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

{code_coordinator-0.5.76 → code_coordinator-0.5.78}/coord/commands/merge.py

@@ -76,6 +76,7 @@ def _apply_revalidation(items, board, config, gh_ops, *, dry_run: bool):
 
     recorded_any = False
     total_runs = 0
+    conflicted: list = []
     groups = _rv.group_candidates(candidates)
     for (repo_name, target_branch), group in groups:
         click.echo(
@@ -85,6 +86,7 @@ def _apply_revalidation(items, board, config, gh_ops, *, dry_run: bool):
         batch = _rv.revalidate_group(group, config, echo=click.echo)
         total_runs += batch.suite_runs
         recorded_any = recorded_any or bool(batch.recorded)
+        conflicted.extend(batch.conflicted)
         if not batch.composite.ok:
             # The composite's own failure report — stderr, as before.
             for line in _rv.format_failure(batch.composite):
@@ -100,6 +102,13 @@ def _apply_revalidation(items, board, config, gh_ops, *, dry_run: bool):
             f"{len(candidates)} entry(ies)"
         )
 
+    # #2231: the composed run just PROVED these branches don't merge. That is
+    # not a staleness problem and re-testing can never resolve it — hand it to
+    # the mechanism built for it instead of formatting a diagnosis nobody acts
+    # on.
+    if conflicted:
+        _dispatch_revalidation_conflicts(conflicted, config, dry_run=dry_run)
+
     if not recorded_any:
         return board
 
@@ -249,6 +258,65 @@ def _reload_board_after_wait(board, *, dry_run: bool):
     return refreshed if refreshed is not None else _Board(active=[], completed=[])
 
 
+def _dispatch_revalidation_conflicts(conflicted, config, *, dry_run: bool) -> None:
+    """#2231: turn ``--revalidate``'s conflict verdict into a #241 dispatch.
+
+    *conflicted* is :attr:`coord.revalidate.BatchRevalidationResult.conflicted`
+    — the candidates whose revalidation run died composing the branch onto its
+    current base. ``--revalidate`` already did the expensive, authoritative
+    part: it fetched, built a worktree at the live base, ran ``git merge`` and
+    watched it fail. That is strictly better evidence than the failed ``gh pr
+    merge`` that normally arms this path, and it was being spent on an
+    operator-facing paragraph and then discarded (quadraui #306/#309 sat 11h
+    each behind a "test verdict stale" gate whose real blocker was a content
+    conflict; a human eventually typed ``coord fix --force`` by hand, which is
+    #241's own job description).
+
+    Two things happen per entry, in this order:
+
+    1. The entry is moved to ``CONFLICT`` with an ``entry.error`` that names
+       the conflict (:func:`coord.revalidate.compose_conflict_error`). This is
+       the reporting half: the gate reason stops reading (only) "stale
+       verdict", so ``coord drive``'s #1738 arm no longer sees a shape it
+       would answer with a re-test, and ``merge_queue.process()`` — which acts
+       only on ``PENDING`` — leaves the entry alone this pass instead of
+       re-deriving the same smoke block. The caller persists the mutation with
+       the rest of the queue; nothing is written here.
+    2. The entry is handed to :func:`_dispatch_conflict_fixes` as a synthetic
+       ``conflict`` event, which is the SAME call the whole-queue and
+       ``--only`` paths make after a live merge attempt. Every guard it owns
+       still applies unchanged: :func:`coord.merge_queue.classify_conflict`
+       must read the error as ``rebaseable``, the #241/#784 retry cap still
+       flips a second failure to ``HUMAN_REQUIRED``, and
+       ``dispatch_conflict_fix``'s own in-flight check still refuses a
+       duplicate. Deliberately routed through that function rather than
+       calling ``dispatch_conflict_fix`` directly — a second dispatch site
+       with its own copy of those guards is how they drift apart.
+
+    Under ``--dry-run`` nothing is mutated and nothing is dispatched (the
+    revalidation itself never ran either — see :func:`_apply_revalidation`).
+    """
+    if dry_run or not conflicted:
+        return
+
+    from coord.merge_queue import CONFLICT, MergeEvent  # noqa: PLC0415
+    from coord.revalidate import compose_conflict_error  # noqa: PLC0415
+
+    events = []
+    for candidate, _result in conflicted:
+        entry = candidate.entry
+        entry.error = compose_conflict_error(entry)
+        entry.state = CONFLICT
+        click.echo(
+            f"  --revalidate: {entry.repo_name} #{entry.issue_number}: "
+            "the blocker is a CONFLICT, not a stale verdict — the branch does "
+            "not compose onto its base. Routing to the conflict-fix path "
+            "(#241) instead of re-testing (#2231)."
+        )
+        events.append(MergeEvent(entry, "conflict", entry.error))
+    _dispatch_conflict_fixes(events, config, dry_run=False)
+
+
 def _dispatch_conflict_fixes(events, config, *, dry_run: bool) -> None:
     """#241: classify any conflict events and dispatch a conflict-fix worker
     for the eligible ones.  Mutates each conflict event's ``ev.entry.state``

{code_coordinator-0.5.76 → code_coordinator-0.5.78}/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.78}/coord/merge_queue.py

@@ -1906,6 +1906,67 @@ def evaluate_smoke_verdict(
     )
 
 
+def stale_smoke_conflict_reason(entry, smoke, gh_ops) -> str | None:
+    """#2231: the conflict hiding behind a stale-verdict smoke block, if any.
+
+    Gate evaluation is ordered (review → smoke → CI → …) and every gate
+    short-circuits, so an entry whose branch does not merge AT ALL never gets
+    that far: it reports "test verdict stale", which invites exactly the one
+    remedy that cannot work. Worse, the two mechanisms that could fix it are
+    both downstream of a step that never runs — #1738's auto-repair answers a
+    stale verdict (there wasn't one) and #241's conflict-fix is dispatched off
+    a failed *merge attempt* (the smoke gate returned before one happened).
+    quadraui #306/#309 spent 11h there apiece.
+
+    So: when the smoke gate is about to block on a **stale** verdict
+    specifically, ask GitHub whether the PR merges at all. A confirmed
+    ``mergeable: false`` means the stale verdict is not the blocker, and this
+    returns a reason naming the conflict — the caller turns that into a
+    ``conflict`` event, which is what arms :func:`classify_conflict` and #241.
+
+    Returns ``None`` — leaving today's stale-verdict block exactly as it was —
+    whenever the answer isn't a definite yes:
+
+    * the verdict is MISSING rather than stale (the #1640 lost-write shape,
+      deliberately out of scope here as in :func:`revalidation_candidates`);
+    * there is no PR yet, so there is nothing to ask about;
+    * ``gh_ops`` has no ``check_pr_mergeable`` — the same duck-typed probe the
+      #1877 CI-absent branch uses, and for the same reason: this function also
+      runs against a :class:`~coord.gate_snapshot.GateSnapshot` on the
+      ``/board`` read path (#1336 Invariant 1, no third-party I/O), which
+      doesn't implement it;
+    * the probe returns ``None`` (GitHub still computing mergeability) or
+      raises. An inconclusive read must never be upgraded to "conflict": that
+      would replace a recoverable staleness block with one that dispatches a
+      rebase worker at a branch which merges fine.
+
+    The wording is load-bearing in both directions — see
+    :func:`coord.revalidate.compose_conflict_error`, whose docstring explains
+    the same constraint for the local-compose variant of this fact.
+    """
+    if smoke is None or smoke.ok or smoke.kind != SMOKE_STALE:
+        return None
+    pr_number = getattr(entry, "pr_number", None)
+    if not pr_number:
+        return None
+    probe = getattr(gh_ops, "check_pr_mergeable", None)
+    if probe is None:
+        return None
+    try:
+        conflicted = probe(entry.repo_github, pr_number) is False
+    except Exception:  # noqa: BLE001 — inconclusive, never a block upgrade
+        return None
+    if not conflicted:
+        return None
+    return (
+        f"merge conflict: PR #{pr_number} does not merge into "
+        f"{entry.target_branch} — GitHub reports it as not mergeable. Its "
+        "test verdict is out of date against the current base too, but that "
+        "is downstream: no re-test can clear a branch that will not merge "
+        "(#2231)"
+    )
+
+
 @dataclass(frozen=True)
 class RevalidationCandidate:
     """One queue entry that ``coord merge --revalidate`` may re-test (#1769).
@@ -3184,6 +3245,19 @@ def _entry_gate_status(
             # write instead of re-verifying against the moved base.
             smoke = evaluate_smoke_verdict(entry, board, gh_ops)
             if not smoke.ok:
+                # #2231: name the conflict when there is one — the plan view
+                # is where an operator (and `coord drive`, via the board's
+                # `merge_reason`) reads WHY an entry is stuck, and "test
+                # verdict stale" on a branch that doesn't compose sends both
+                # of them at a remedy that cannot work. Costs one `gh` call,
+                # only for an entry already blocked on a STALE verdict, and
+                # only where a live probe exists (never on the `/board` read
+                # path — see `stale_smoke_conflict_reason`).
+                conflict_reason = stale_smoke_conflict_reason(
+                    entry, smoke, gh_ops,
+                )
+                if conflict_reason is not None:
+                    return PLAN_BLOCKED, conflict_reason
                 return PLAN_BLOCKED, smoke.short_reason
     if ci_store is not None and ci_store.is_available and entry.pr_number:
         checks = ci_store.list_checks_for_pr(entry.repo_github, entry.pr_number)
@@ -4279,6 +4353,23 @@ def process(
                         else evaluate_smoke_verdict(entry, board, gh_ops)
                     )
                     if _smoke is None or not _smoke.ok:
+                        # #2231: mirror the live path (line ~4689) — before
+                        # previewing a block on a stale verdict, check whether
+                        # the branch is actually conflicted. A dry run that
+                        # skips this reports the misleading "test verdict
+                        # stale" headline for an entry a real run (or
+                        # `--plan`) would already report/dispatch as
+                        # `conflict`, which is precisely the split-brain this
+                        # issue exists to fix.
+                        _conflict_msg = stale_smoke_conflict_reason(
+                            entry, _smoke, gh_ops,
+                        )
+                        if _conflict_msg is not None:
+                            events.append(MergeEvent(
+                                entry, "conflict",
+                                f"(dry run) {_conflict_msg}",
+                            ))
+                            continue
                         _why = (
                             "board unavailable to confirm smoke verdict"
                             if _smoke is None
@@ -4606,6 +4697,22 @@ def process(
                     None if board is None else evaluate_smoke_verdict(entry, board, gh_ops)
                 )
                 if smoke is None or not smoke.ok:
+                    # #2231: before parking this entry behind a gate whose
+                    # stated cause invites a re-test, check whether the branch
+                    # merges at all. A confirmed conflict is the real blocker
+                    # and a re-test can never clear it — emit the `conflict`
+                    # event so `_dispatch_conflict_fixes` arms #241's rebase
+                    # worker, exactly as a failed merge attempt would have.
+                    conflict_msg = stale_smoke_conflict_reason(
+                        entry, smoke, gh_ops,
+                    )
+                    if conflict_msg is not None:
+                        entry.state = CONFLICT
+                        entry.error = conflict_msg
+                        events.append(
+                            MergeEvent(entry, "conflict", conflict_msg)
+                        )
+                        continue
                     msg = (
                         "smoke test required but board unavailable to confirm verdict"
                         if smoke is None

{code_coordinator-0.5.76 → code_coordinator-0.5.78}/coord/revalidate.py

@@ -379,6 +379,15 @@ class BatchRevalidationResult:
     A red composite fills ``per_entry`` with one solo result per candidate.
     ``recorded`` then holds only the survivors' assignment ids, and
     ``culprits`` names the branches whose own run failed.
+
+    ``conflicted`` (#2231) is the subset of the culprits whose run died at
+    :data:`KIND_COMPOSE` — the branch does not merge onto its current base at
+    all. That is categorically different from every other culprit: no verdict
+    is wrong, no suite is red, and no amount of re-testing can change it. It
+    carries the *candidate* (not just its label) precisely so a caller can act
+    on it — see :func:`coord.commands.merge._dispatch_revalidation_conflicts`,
+    which turns it into #241's ``conflict-fix`` dispatch. Before #2231 this
+    diagnosis was formatted for a human and then dropped on the floor.
     """
 
     composite: RevalidationResult
@@ -386,6 +395,9 @@ class BatchRevalidationResult:
     recorded: list[str] = field(default_factory=list)
     culprits: list[str] = field(default_factory=list)
     suite_runs: int = 0
+    conflicted: list[tuple[RevalidationCandidate, RevalidationResult]] = field(
+        default_factory=list,
+    )
 
     @property
     def ok(self) -> bool:
@@ -1000,6 +1012,16 @@ def revalidate_group(
     )
 
     if composite.ok or len(candidates) == 1 or not composite.narrowable:
+        # #2231: a single-candidate composite IS that candidate's own run, so
+        # a COMPOSE failure here names it as surely as a solo run would. The
+        # N>1 case is attributed in the per-entry loop below instead — the
+        # composite stops at the FIRST branch that won't merge, which says
+        # nothing about the ones after it.
+        if (
+            len(candidates) == 1
+            and composite.kind == KIND_COMPOSE
+        ):
+            batch.conflicted.append((candidates[0], composite))
         return batch
 
     echo(
@@ -1027,6 +1049,12 @@ def revalidate_group(
         else:
             batch.culprits.append(label)
             echo(f"  --revalidate: {label} FAILS alone — {solo.reason}")
+            if solo.kind == KIND_COMPOSE:
+                # #2231: not a verdict problem at all — this branch cannot
+                # merge. Recorded structurally so the caller can dispatch
+                # #241's conflict-fix instead of leaving the entry parked
+                # behind a stale-verdict gate it can never clear.
+                batch.conflicted.append((c, solo))
 
     if not batch.culprits:
         # Every branch is green by itself, yet together they are not. That is a
@@ -1046,6 +1074,36 @@ def revalidate_group(
     return batch
 
 
+def compose_conflict_error(entry) -> str:
+    """The ``entry.error`` text for a branch that will not compose (#2231).
+
+    Deliberately worded to be classified correctly by the two consumers that
+    read merge prose rather than structured state:
+
+    * :func:`coord.merge_queue.classify_conflict` must return ``"rebaseable"``
+      — it is what decides whether ``coord merge`` dispatches #241's
+      conflict-fix worker — so the text carries the ``merge conflict`` signal
+      that function already keys on.
+    * :func:`coord.merge_queue.is_stale_smoke_reason` (and ``coord drive``'s
+      ``_SMOKE_GATE_MARKERS``) must NOT match, or the driver would read this
+      as the #1738 stale-verdict shape and spend a fix round re-testing a
+      branch that cannot merge — the exact loop #2231 reports. So the stale
+      verdict is *described* here in wording that matches none of
+      :data:`coord.merge_queue.STALE_SMOKE_MARKERS` (this module must not
+      carry a copy of those strings either — see
+      ``TestSingleStaleDetector``). ``tests/test_revalidate.py`` asserts both
+      classifications directly, since the wording is load-bearing rather than
+      cosmetic.
+    """
+    return (
+        f"merge conflict: branch {entry.branch!r} does not compose onto "
+        f"origin/{entry.target_branch} — `git merge` reported a content "
+        "conflict when --revalidate composed it against the current base, so "
+        "no test verdict (fresh or otherwise) can clear this entry until the "
+        "branch is rebased (#2231)"
+    )
+
+
 def format_batch(batch: BatchRevalidationResult) -> list[str]:
     """Operator-facing OUTCOME lines for one group's revalidation (#1715).
 
@@ -1201,6 +1259,7 @@ __all__ = [
     "BatchRevalidationResult",
     "RevalidationResult",
     "client_timeout_seconds",
+    "compose_conflict_error",
     "describe_batches",
     "describe_candidates",
     "format_batch",

{code_coordinator-0.5.76 → code_coordinator-0.5.78}/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.