code-coordinator 0.5.85__tar.gz → 0.5.86__tar.gz

{code_coordinator-0.5.85 → code_coordinator-0.5.86}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.85",
+  "tag": "0.5.86",
   "distance": 0,
-  "node": "g87a8be6dfe549ad5607352dbdda991a3ed87f1fd",
+  "node": "g38313e96b2a9fecca7cffcdcfc0c9f15b86ea28b",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-14"

{code_coordinator-0.5.85 → code_coordinator-0.5.86}/coord/commands/merge.py

@@ -317,6 +317,101 @@ def _dispatch_revalidation_conflicts(conflicted, config, *, dry_run: bool) -> No
     _dispatch_conflict_fixes(events, config, dry_run=False)
 
 
+def _sweep_sibling_conflicts(events, items, config, gh_ops, *, dry_run: bool) -> list:
+    """#2246: after a merge lands, ask GitHub which sibling PRs it just broke.
+
+    A merge into ``target_branch`` can invalidate every other open PR against
+    that same branch. GitHub computes exactly which ones, asynchronously and
+    for free, and until #2246 nothing asked at the moment it matters —
+    ``mergeable`` was consulted only at *merge* time, i.e. one drive attempt
+    too late. On 2026-08-14 that cost four terminal ``blocked`` entries across
+    two repos: quadraui #306/#309 presented as "smoke gate — test verdict
+    stale", claude-coordinator #2234 as "checks_failed … (unknown)" with
+    ``coord fix`` asserting "CI is RED" for a PR whose CI had never run at all
+    (GitHub builds ``pull_request`` workflows from ``refs/pull/N/merge``, which
+    cannot exist while the PR conflicts, so *zero* check-suites were queued and
+    the absence was read as failure — #2244). No surface said *conflict*.
+
+    Two things happen for each sibling GitHub now reports ``CONFLICTING``,
+    both inside :func:`coord.merge_queue.sweep_sibling_conflicts` and the
+    dispatch call below:
+
+    1. The entry is parked at ``CONFLICT`` with an error naming the merge that
+       broke it — so the next surface to read it says the true thing instead of
+       re-deriving whichever gate happened to be failing for an unrelated
+       reason, and ``coord drive``'s #1738 re-test arm stops answering a
+       conflict with a suite run.
+    2. It is handed to :func:`_dispatch_conflict_fixes` as an ordinary
+       ``conflict`` event — the SAME call the post-``process()`` path makes —
+       so #241's conflict-fix worker is dispatched with every guard intact:
+       :func:`coord.merge_queue.classify_conflict` must still read the error as
+       ``rebaseable``, the #241/#784 retry cap still flips a second failure to
+       ``HUMAN_REQUIRED``, and ``dispatch_conflict_fix``'s in-flight check
+       still refuses a duplicate. Routed through that function rather than
+       calling ``dispatch_conflict_fix`` directly for the reason #2231 gives:
+       a second dispatch site with its own copy of those guards is how they
+       drift apart. That dispatch call can advance ``ev.entry.state`` a
+       second time (e.g. to ``HUMAN_REQUIRED`` on a retry-cap hit) — this
+       function persists that too, scoped to just the swept entries, so a
+       sibling this caller doesn't hold in ``items`` (the ``--only`` path)
+       doesn't have its escalation silently dropped on the floor while the
+       audit log claims it happened (#2246 review).
+
+    Skipped entirely under ``--dry-run`` — ``process()`` emits ``merged``
+    events there too, but nothing actually landed, so no sibling's mergeability
+    can have changed and marking one would be a lie written to the queue.
+
+    Returns the conflict events so the caller can fold them into its summary;
+    never raises (the sweep itself fails open — see its docstring). The merge
+    that triggered this has already succeeded and must not be undone or
+    obscured by a failed read afterwards.
+    """
+    if dry_run:
+        return []
+    from coord import merge_queue as _mq  # noqa: PLC0415
+
+    try:
+        sweep_events = _mq.sweep_sibling_conflicts(events, items, gh_ops)
+    except Exception as e:  # noqa: BLE001 — never let the sweep undo a merge
+        click.echo(
+            f"  sibling-conflict sweep failed (merge itself is unaffected): {e!r}",
+            err=True,
+        )
+        return []
+    for ev in sweep_events:
+        e = ev.entry
+        click.echo(
+            f"  {e.repo_name} #{e.issue_number} ({e.branch}): {ev.kind} — "
+            f"{ev.message}"
+        )
+    _dispatch_conflict_fixes(sweep_events, config, dry_run=False)
+    # #2246 review: `_dispatch_conflict_fixes` can advance a swept sibling's
+    # state a second time in place — e.g. `entry.state = HUMAN_REQUIRED` when
+    # `has_prior_conflict_fix` finds this sibling already burned a
+    # conflict-fix attempt against an earlier conflict. `mq.sweep_sibling_
+    # conflicts` above already persisted its own CONFLICT write, but for a
+    # sibling this caller doesn't hold in `items` (the `--only` path, the
+    # exact one #2246 targets), nothing after that dispatch call ever writes
+    # the newer HUMAN_REQUIRED back — `merge()`'s own final save keys only on
+    # `only_entry`. Without this, the audit log records "manual resolution
+    # required" while the board/queue still say CONFLICT: the split-brain
+    # class this repo's CLAUDE.md calls out (#1832/#2085). Persist here,
+    # scoped to just the entries this sweep touched — never the full queue —
+    # so a fresh conflict elsewhere isn't clobbered.
+    if sweep_events:
+        try:
+            fresh = _mq.load_queue()
+            by_id = {ev.entry.assignment_id: ev.entry for ev in sweep_events}
+            _mq.save_queue([by_id.get(x.assignment_id, x) for x in fresh])
+        except Exception as e:  # noqa: BLE001 — fail open, per the sweep's own contract
+            click.echo(
+                "  sibling-conflict fix-dispatch state failed to persist "
+                f"(merge itself is unaffected): {e!r}",
+                err=True,
+            )
+    return sweep_events
+
+
 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``
@@ -1691,6 +1786,16 @@ def merge(
         # before the save below so a retry-cap/non-rebaseable HUMAN_REQUIRED
         # mutation on only_entry.state is persisted, not lost.
         _dispatch_conflict_fixes(events_only, cfg_only, dry_run=dry_run)
+        # #2246: `--only` merges one entry, but the branch it just moved is
+        # shared — every OTHER queued PR based on it may have become
+        # CONFLICTING a second ago. This is the drive-queue's path (`coord
+        # drive` and the TUI both merge via `--only`), so it is exactly where
+        # the 2026-08-14 collisions were minted. The sweep persists any
+        # sibling it parks itself: the save below deliberately writes back
+        # only `only_entry`.
+        _sweep_sibling_conflicts(
+            events_only, only_items, cfg_only, gh_ops, dry_run=dry_run,
+        )
         if not dry_run:
             # Save only the modified entry back; all other entries are untouched.
             all_items_only = mq.load_queue()
@@ -2003,6 +2108,13 @@ def merge(
     # review, so the --only path below can share it).
     _dispatch_conflict_fixes(events, cfg, dry_run=dry_run)
 
+    # #2246: whatever just landed may have invalidated its siblings — ask
+    # GitHub now, while the merge that caused it is still the obvious
+    # explanation, rather than letting the next drive attempt discover it as
+    # some unrelated gate failure. Entries it parks are in `items`, so the
+    # save below carries the mutation through naturally.
+    _sweep_sibling_conflicts(events, items, cfg, gh_ops, dry_run=dry_run)
+
     # Save state only when we actually moved
     if not dry_run:
         # Persist the updated entries by merging back over the on-disk queue.

{code_coordinator-0.5.85 → code_coordinator-0.5.86}/coord/merge_queue.py

@@ -3017,6 +3017,283 @@ def reconcile_conflict_entries(gh_ops: "GhOps") -> list["MergeEvent"]:
     return events
 
 
+# ── Post-merge sibling conflict sweep (#2246) ───────────────────────────────
+
+#: How many times the sweep re-asks GitHub for a sibling's mergeability while
+#: it still reads ``UNKNOWN``. GitHub computes ``mergeable`` asynchronously and
+#: a merge that JUST landed is precisely the moment it is least likely to have
+#: settled — treating the first ``None`` as "clean" is the bug (#2246), so the
+#: probe is retried a bounded number of times before giving up.
+SIBLING_SWEEP_ATTEMPTS = 3
+
+#: Seconds between sweep probe rounds. Total added wall-clock is at most
+#: ``(SIBLING_SWEEP_ATTEMPTS - 1) * SIBLING_SWEEP_INTERVAL`` regardless of how
+#: many siblings are in the queue — see :func:`sweep_sibling_conflicts`, which
+#: probes in ROUNDS (everyone, then only the still-unresolved) rather than
+#: exhausting the retry budget per entry.
+SIBLING_SWEEP_INTERVAL = 2.0
+
+
+def merged_bases(events: Iterable["MergeEvent"]) -> set[tuple[str, str]]:
+    """The ``(repo_github, target_branch)`` pairs a batch of events just moved.
+
+    Scoped deliberately to ``kind == "merged"``: a base branch only invalidates
+    siblings when something actually landed on it. Every other event kind
+    (``opened``, ``sized``, ``conflict``, gate blocks) leaves the base exactly
+    where it was and must not trigger a sweep.
+    """
+    return {
+        (ev.entry.repo_github, ev.entry.target_branch)
+        for ev in events
+        if ev.kind == "merged" and ev.entry.repo_github and ev.entry.target_branch
+    }
+
+
+def sibling_sweep_candidates(
+    events: Iterable["MergeEvent"], items: Iterable["QueuedMerge"],
+) -> list["QueuedMerge"]:
+    """The queue entries a just-landed merge could plausibly have broken.
+
+    An entry qualifies when **all** of the following hold:
+
+    * Its ``(repo_github, target_branch)`` is one the batch actually moved
+      (:func:`merged_bases`) — #2246's "scope to the merged repo, and only to
+      PRs whose base is the branch that just moved".
+    * It is not itself one of the entries that merged.
+    * It has an open PR (``pr_number``) — GitHub can only compute
+      mergeability for a PR, and an entry with no PR has nothing to mark.
+    * It is still ``PENDING``. This is the **transition** filter #2246 asks
+      for, expressed in the state the queue already keeps: ``CONFLICT`` is the
+      durable record of "we already know this one is conflicting", so an entry
+      parked there was somebody else's problem before this merge and is left
+      alone (it is #1477's :func:`reconcile_conflict_entries` that unparks it).
+      ``HUMAN_REQUIRED``/``MERGED``/``SKIPPED`` are equally not ours to touch.
+    * Its cached ``error`` does not already read as a conflict. Belt-and-braces
+      for the same rule: an entry can be ``PENDING`` while carrying a conflict
+      error from a prior attempt (a re-enqueue, a #1477 unpark that raced),
+      and re-dispatching a conflict-fix for it on every merge is exactly the
+      loop #2246 says not to build.
+
+    Note what is deliberately *not* required: that the sibling be blocked on
+    some particular gate. The whole point is that the gate it is blocked on
+    (stale smoke verdict, "checks_failed (unknown)") is the WRONG reason — the
+    real blocker is the conflict, and it is only visible if we look regardless.
+    """
+    moved = merged_bases(events)
+    if not moved:
+        return []
+    merged_ids = {
+        ev.entry.assignment_id for ev in events if ev.kind == "merged"
+    }
+    out: list[QueuedMerge] = []
+    for entry in items:
+        if entry.assignment_id in merged_ids:
+            continue
+        if (entry.repo_github, entry.target_branch) not in moved:
+            continue
+        if entry.state != PENDING or not entry.pr_number:
+            continue
+        if classify_conflict(entry.error) == "rebaseable":
+            continue
+        out.append(entry)
+    return out
+
+
+def sibling_conflict_error(
+    entry: "QueuedMerge", events: Iterable["MergeEvent"],
+) -> str:
+    """The ``entry.error`` text a swept sibling is parked with.
+
+    Two hard requirements, both load-bearing:
+
+    1. It must contain wording :func:`classify_conflict` reads as
+       ``"rebaseable"`` (here: ``merge conflict``), because the whole value of
+       the sweep is that ``coord merge``'s existing ``_dispatch_conflict_fixes``
+       step then routes it to the #241 worker with every guard intact — the
+       retry cap, the in-flight check, the HUMAN_REQUIRED escalation.
+    2. It must NOT contain any ``_HUMAN_SIGNALS`` wording ("review required",
+       "permission", "protected branch", …), which would classify it as a
+       branch-protection problem and escalate straight to a human.
+
+    Beyond that it names the merge that caused it, because "which PR broke me"
+    was the fact a human had to reconstruct by hand in both 2026-08-14
+    collisions.
+    """
+    culprits = sorted({
+        f"{ev.entry.repo_name}#{ev.entry.issue_number}"
+        + (f" (PR #{ev.entry.pr_number})" if ev.entry.pr_number else "")
+        for ev in events
+        if ev.kind == "merged"
+        and ev.entry.repo_github == entry.repo_github
+        and ev.entry.target_branch == entry.target_branch
+    })
+    blame = ", ".join(culprits) if culprits else "a sibling merge"
+    return (
+        f"merge conflict: GitHub reports PR #{entry.pr_number} ({entry.branch}) "
+        f"as CONFLICTING against {entry.target_branch} immediately after "
+        f"{blame} landed on it. The blocker is a content conflict — not a "
+        "stale test verdict and not a CI failure (a conflicting PR has no "
+        f"{entry.target_branch} merge ref, so GitHub queues no pull_request "
+        "check-suites for it at all). Rebase the branch onto "
+        f"{entry.target_branch} and resolve (#2246)."
+    )
+
+
+def sweep_sibling_conflicts(
+    events: list["MergeEvent"],
+    items: list["QueuedMerge"],
+    gh_ops: "GhOps",
+    *,
+    attempts: int = SIBLING_SWEEP_ATTEMPTS,
+    interval: float = SIBLING_SWEEP_INTERVAL,
+    sleep=None,
+    persist: bool = True,
+) -> list["MergeEvent"]:
+    """Ask GitHub which siblings *events*' merges just broke (#2246).
+
+    When a PR merges it can silently invalidate every other open PR against
+    the same base. GitHub computes that for us exactly and for free, and
+    before this nothing asked at the one moment it matters — ``mergeable`` was
+    only consulted at merge time, i.e. after the next drive attempt was
+    already spent. On 2026-08-14 that cost four terminal ``blocked`` entries
+    across two repos, presented as "smoke gate — test verdict stale" and
+    "checks_failed … (unknown)", neither of which said *conflict*.
+
+    Called immediately after :func:`process` with the events it returned and
+    the item list the caller is about to persist. For every sibling that now
+    reads ``CONFLICTING`` (see :func:`sibling_sweep_candidates` for who
+    qualifies), the entry is moved to ``CONFLICT`` with a
+    :func:`sibling_conflict_error` explaining what happened, and a
+    ``conflict`` :class:`MergeEvent` is returned. The caller echoes those
+    events and hands them to its usual conflict-fix dispatch step — the sweep
+    itself never dispatches, so #241's retry cap and in-flight guards keep
+    living in exactly one place.
+
+    **UNKNOWN is not clean.** GitHub recomputes mergeability asynchronously,
+    and the instant after a merge is when it is most likely to still be
+    computing — the first read came back ``UNKNOWN`` repeatedly in the
+    2026-08-14 session. Probing is therefore retried up to *attempts* times,
+    in ROUNDS: every unresolved sibling is probed, then only the ones still
+    unresolved are probed again after *interval* seconds. Total added
+    wall-clock is bounded by ``(attempts - 1) * interval`` no matter how many
+    siblings there are, rather than growing per entry.
+
+    **Fails open, always.** A ``gh`` error, a ``gh_ops`` with no
+    ``check_pr_mergeable`` (the duck-typed stubs in older tests), an
+    unreadable queue — every one of them yields "no sweep", never an
+    exception. The merge that triggered this already succeeded; a read failure
+    afterwards must not undo or obscure it.
+
+    Cost is one API call per candidate sibling per merge — single digits on
+    this fleet — and zero when nothing merged, which is the overwhelmingly
+    common tick.
+
+    Persistence: mutations are written straight back to the queue (``persist``
+    is only turned off by tests). Entries the caller already holds in *items*
+    are mutated **in place**, so the caller's own subsequent
+    ``save_queue(merge_over_disk)`` step re-writes the same values rather than
+    clobbering them — the same convention
+    ``coord.commands.merge._dispatch_conflict_fixes`` relies on. Siblings the
+    caller does *not* hold (the ``--only`` path, where ``items`` is a single
+    entry) are persisted by this function's own write, which reloads the
+    queue fresh and overrides **only** the entries this call itself moved to
+    ``CONFLICT`` (one per event in the return value) — never the full *rows*
+    snapshot this function built before its retry-sleep loop, which can be
+    stale by the time we get here and would otherwise clobber any concurrent
+    writer's changes to unrelated rows.
+    """
+    if not any(ev.kind == "merged" for ev in events):
+        return []
+    probe = getattr(gh_ops, "check_pr_mergeable", None)
+    if probe is None:
+        return []
+
+    try:
+        disk = load_queue()
+    except Exception:  # noqa: BLE001 — a queue read error must not undo a merge
+        _log.warning("sibling sweep: could not read the merge queue", exc_info=True)
+        return []
+
+    # Prefer the caller's live objects for any row it already holds: mutating
+    # a second copy loaded here would be silently reverted by the caller's own
+    # save-over-disk step a few lines later.
+    pool = {x.assignment_id: x for x in items}
+    rows = [pool.get(x.assignment_id, x) for x in disk]
+    known = {x.assignment_id for x in rows}
+    rows.extend(x for x in items if x.assignment_id not in known)
+
+    candidates = sibling_sweep_candidates(events, rows)
+    if not candidates:
+        return []
+
+    _sleep = sleep if sleep is not None else time.sleep
+    verdicts: dict[str, bool] = {}
+    unresolved = list(candidates)
+    for attempt in range(max(1, attempts)):
+        if not unresolved:
+            break
+        if attempt:
+            # Only ever paid when GitHub is genuinely still computing.
+            _sleep(interval)
+        still: list[QueuedMerge] = []
+        for entry in unresolved:
+            try:
+                verdict = probe(entry.repo_github, entry.pr_number)
+            except Exception:  # noqa: BLE001 — fail open, per entry
+                verdict = None
+            if verdict is None:
+                still.append(entry)
+            else:
+                verdicts[entry.assignment_id] = bool(verdict)
+        unresolved = still
+
+    for entry in unresolved:
+        # Never resolved inside the budget. Deliberately NOT marked: an
+        # inconclusive read is not evidence of a conflict, and #1477's
+        # reconcile pass plus the next ordinary merge attempt will both look
+        # again. Logged so a systematically-slow repo is attributable.
+        _log.info(
+            "sibling sweep: %s#%s (PR #%s) still UNKNOWN after %d attempt(s)"
+            " — left PENDING",
+            entry.repo_name, entry.issue_number, entry.pr_number, max(1, attempts),
+        )
+
+    out: list[MergeEvent] = []
+    for entry in candidates:
+        if verdicts.get(entry.assignment_id) is not False:
+            continue
+        entry.error = sibling_conflict_error(entry, events)
+        entry.state = CONFLICT
+        out.append(MergeEvent(
+            entry, "conflict",
+            f"became CONFLICTING when a sibling merged into "
+            f"{entry.target_branch} — parked as a conflict, not a gate "
+            "failure (#2246)",
+        ))
+
+    if out and persist:
+        try:
+            fresh = load_queue()
+            # Scope the override to the entries THIS call actually mutated
+            # (one per `out` event) — never the full `rows` snapshot. `rows`
+            # was built before the retry-sleep loop above (up to
+            # ``(attempts - 1) * interval``, longer under real GitHub
+            # latency), so by the time we get here it can be stale for every
+            # entry in the queue, not just the swept candidates. Building
+            # `by_id` from it and replacing the whole table would silently
+            # revert any concurrent writer's changes to unrelated rows made
+            # during that wait — exactly the convention this function's
+            # docstring promises to follow (mutate in place, override only
+            # what changed, default everything else to the fresh read).
+            by_id = {ev.entry.assignment_id: ev.entry for ev in out}
+            save_queue([by_id.get(x.assignment_id, x) for x in fresh])
+        except Exception:  # noqa: BLE001 — fail open
+            _log.warning(
+                "sibling sweep: could not persist conflict markers", exc_info=True,
+            )
+    return out
+
+
 def resolve_entry_key(items: list["QueuedMerge"], key: str) -> "QueuedMerge | None":
     """Resolve *key* to a queue entry by whatever identifier the read path
     printed — ``assignment_id``, the durable ``repo#issue`` form, a bare

{code_coordinator-0.5.85 → code_coordinator-0.5.86}/coord/serve_app.py

@@ -1247,6 +1247,24 @@ def _auto_drain_tick(config: Config) -> "list":
             skip_smoke=False,
         )
 
+        # #2246: anything that just landed may have made a SIBLING PR
+        # CONFLICTING — GitHub knows exactly which, and auto-drain (unlike a
+        # human running `coord merge`) has no other moment to ask. Held inside
+        # the same lock as everything above: it is another full load->mutate->
+        # save of the queue table and would race a concurrent `/merge`
+        # otherwise. Best-effort — a sweep failure must not undo or obscure
+        # the merge that triggered it, nor disable the persist step below.
+        #
+        # Marks only. Auto-drain has never dispatched a conflict-fix (that
+        # lives in the `coord merge` CLI's `_dispatch_conflict_fixes`), and
+        # #2246's floor is that the entry report *conflict* as its blocking
+        # reason instead of whichever gate happened to be red — which is
+        # exactly what parking it at CONFLICT with an explanatory error does.
+        try:
+            events.extend(mq.sweep_sibling_conflicts(events, ready_items, github_ops))
+        except Exception:  # noqa: BLE001
+            log.warning("auto-drain: sibling-conflict sweep failed", exc_info=True)
+
         # Persist: merge the mutated rows back over the on-disk queue (same
         # pattern as ``coord merge`` in cli.py to avoid clobbering unrelated rows).
         fresh = mq.load_queue()

{code_coordinator-0.5.85 → code_coordinator-0.5.86}/docs/OPERATING_GOTCHAS.md

@@ -964,3 +964,73 @@ If the conflict-fix worker itself fails, the #241/#784 retry cap still flips
 the entry to `HUMAN_REQUIRED` on the second attempt — rule #10's escape hatch
 applies from there. Nothing here loosens that: this only removes the case
 where **no** mechanism ran at all.
+
+## 19. A merge silently breaks its siblings, and until #2246 nothing asked GitHub which ones
+
+Rule #18 is about **gate ordering** — a conflict reported as a stale verdict
+because the smoke gate short-circuits first. This one is about **when we
+look**. Both present as "the surface says something that isn't the blocker",
+and they were filed the same day for a reason.
+
+When a PR merges, every other open PR against that same base can become
+unmergeable. GitHub computes exactly which ones, asynchronously and for free,
+and `GhOps.check_pr_mergeable` has always been able to read it — but it was
+consulted only at *merge* time, i.e. one drive attempt after the moment that
+mattered. The merge that invalidated the sibling is the event; nothing was
+listening to it.
+
+Measured on 2026-08-14, two independent collisions, both through the drive
+queue:
+
+| collision | trigger | how it presented | cost |
+|---|---|---|---|
+| quadraui #306, #309 | #307/#308 merged first; all four append to `quadraui/tests/tui_example_driver.rs` | `smoke gate — test verdict stale` | both terminal `blocked`, 2 attempts each, 3 wasted `--revalidate` suite runs, 2 `coord fix` dispatches |
+| claude-coordinator #2234 | #2230 merged; both touch `coord/drive_queue.py` | `checks_failed … (unknown)`, and `coord fix` reported *"CI is RED"* | terminal `blocked`, 2 attempts, a wasted empty commit, one `coord fix` dispatch |
+
+In neither case did any surface say *conflict* until a human went looking. In
+the second, **CI had never run at all**: GitHub builds `pull_request`
+workflows from the merge ref (`refs/pull/N/merge`), which cannot exist while
+the PR conflicts, so zero check-suites were queued and the absence was misread
+as failure (that misreading is #2244's arm of the same day).
+
+### What runs now
+
+Immediately after any merge lands, `merge_queue.sweep_sibling_conflicts` asks
+GitHub about the other queued PRs **in that repo, on the branch that just
+moved**. A sibling GitHub now reports `CONFLICTING` is parked at `CONFLICT`
+with an error naming the merge that broke it, and handed to the same
+`_dispatch_conflict_fixes` call a failed merge attempt makes — so #241's
+`conflict-fix` worker is dispatched with the retry cap, the in-flight guard,
+and the `HUMAN_REQUIRED` escalation all intact.
+
+Wired into `coord merge` (both the whole-queue path and `--only`, which is how
+`coord drive` and the TUI merge) and into the daemon's auto-drain tick. Never
+under `--dry-run`: nothing landed, so no sibling's mergeability can have
+changed and marking one would write a lie into the queue.
+
+### Four things to know when reading it
+
+- **`mergeable` is not instant.** GitHub recomputes it asynchronously and the
+  instant after a merge is when it is least likely to have settled — `UNKNOWN`
+  came back repeatedly on 2026-08-14. The probe retries (`SIBLING_SWEEP_ATTEMPTS`,
+  default 3) in **rounds**: everyone, then only the still-unresolved, so total
+  added wall-clock is bounded by the attempt budget however long the queue is.
+  A sibling still `UNKNOWN` when the budget runs out is left `PENDING` — an
+  inconclusive read is not evidence of a conflict.
+- **Only transitions.** An entry already at `CONFLICT` is never probed. That
+  state is the queue's own record of "we already know", so a PR that was
+  conflicting before the merge is somebody else's problem — #1477's
+  `reconcile_conflict_entries` is what unparks it when the fix lands. Without
+  that rule, every merge in the repo would re-dispatch a conflict-fix for it,
+  forever.
+- **Cost is one API call per queued sibling per merge**, not per tick. On this
+  fleet that is single digits, and it is exactly zero on the overwhelmingly
+  common tick where nothing merged.
+- **It fails open.** A `gh` error, an unreadable queue, a `gh_ops` without the
+  probe — every one yields "no sweep", never an exception. The merge that
+  triggered it has already succeeded and must not be undone or obscured by a
+  read that failed afterwards.
+
+Related: **#1894** — an unavailable CI must not consume retry budget, and a
+structurally-impossible CI (a conflicting PR has no merge ref, so no
+check-suite) is the same class.