code-coordinator 0.5.569__tar.gz → 0.5.570__tar.gz

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.569",
+  "tag": "0.5.570",
   "distance": 0,
-  "node": "g5c759420fc3645ac55648f65ba5bfddf7ceae8f2",
+  "node": "g29bd794d5c1bbedb62f22cdd0bef36e1a1cddd33",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-03"

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/coord/commands/drive_queue.py

@@ -485,6 +485,7 @@ def drive_queue_add(
     # kind is happening on that path. Merging (or fixing forward) a
     # discovered PR is deliberately left to the operator — see
     # `existing_pr_relaunch_remedy`'s own docstring.
+    existing_pr_resume_note = ""
     if previous is None or previous.state in STUCK_QUEUE_STATES:
         existing_match = _existing_pr_match(config_path, repo, issue)
         existing_remedy = existing_pr_relaunch_remedy(repo, issue, existing_match)
@@ -494,6 +495,24 @@ def drive_queue_add(
                 f"{existing_remedy['what_happens']} Run instead: "
                 f"{existing_remedy['command_or_action']}"
             )
+        # #3539: `existing_remedy is None` with a real *existing_match* is
+        # ambiguous on its own — "no PR found, start fresh" and "PR found,
+        # green, but still missing a gate — resume on it" both return
+        # `None` from `existing_pr_relaunch_remedy` (see its docstring).
+        # Say which one happened: silently queuing a resume with no echo
+        # at all would read identically to a fresh `add` and hide the exact
+        # trap #3539 reports (an operator with no way to tell this add is
+        # about to drive the SAME branch, not a new one).
+        if existing_match is not None and existing_match.missing_gates:
+            gates_list = " and ".join(existing_match.missing_gates)
+            existing_pr_resume_note = (
+                f"\nresuming on existing PR #{existing_match.number} "
+                f"({existing_match.branch}) — CI is green but {gates_list} "
+                f"{'gate is' if len(existing_match.missing_gates) == 1 else 'gates are'} "
+                "not yet recorded; this add will dispatch only the missing "
+                f"stage(s) on that branch, never a new Work leg (coord "
+                f"gates {repo} {issue} shows the live detail)."
+            )
 
     # #2247: predicted file overlap ORDERS, never refuses. Anything that goes
     # wrong in here (unreadable body, unreachable board, a failed compare)
@@ -645,6 +664,7 @@ def drive_queue_add(
     click.echo(
         f"queued {entry_key(repo, issue)}{pinned}{suffix}{gate}{fix_rounds_note}"
         f"{no_acceptance_note}{scope_downgrade_warning}{overlap_note}"
+        f"{existing_pr_resume_note}"
     )
 
     # #2339: say out loud when this add cannot possibly accomplish anything —
@@ -951,15 +971,32 @@ def _existing_pr_match(
     answer than `coord.merge_queue.plan()`'s own `PLAN_READY` verdict — it
     reads raw `failed_checks`/`in_flight_checks` only and does not account
     for `merge_queue._ci_checks_are_stale` (a green check that silently
-    outlived a base move), review state, or any other merge gate. The
-    issue's own design accepted either condition ("all green OR `coord merge
-    --plan` reads READY"), and `coord merge --only` re-runs its own full gate
-    check before actually merging either way, so the worst case from the gap
-    is a confusing round trip (recommended here, still BLOCKED there), never
-    an incorrect merge. Wiring the fuller verdict in would need this call
-    site to assemble `plan()`'s board/GhOps/smoke-verdict inputs for a
-    single PR lookup — a bigger, riskier change than this fix-round's scope;
-    left as a known gap rather than attempted half-wired.
+    outlived a base move). The issue's own design accepted either condition
+    ("all green OR `coord merge --plan` reads READY"), and `coord merge
+    --only` re-runs its own full gate check before actually merging either
+    way, so the worst case from the gap is a confusing round trip
+    (recommended here, still BLOCKED there), never an incorrect merge.
+    Wiring the fuller verdict in would need this call site to assemble
+    `plan()`'s board/GhOps/smoke-verdict inputs for a single PR lookup — a
+    bigger, riskier change than this fix-round's scope; left as a known gap
+    rather than attempted half-wired.
+
+    `missing_gates` (#3539), unlike `all_green`, DOES reuse the real gate
+    decision — `coord.gates.build_gate_report`, the exact function `coord
+    gates` prints and that wraps `coord.merge_queue`'s own
+    `requires_review`/`scan_approved_reviews`/`requires_smoke`/
+    `evaluate_smoke_verdict` — rather than a second guess, closing the
+    quadraui#1109 gap: a PR can be all-green on CI while `coord gates`
+    still reports `review`/`test` BLOCKED, and the #2377 guard's old
+    "merge it" advice for an all-green PR was then impossible (`coord merge
+    --only` itself refused with `enqueue blocked by review gate`). Only
+    computed when `all_green` — a red PR's gate state is moot, the caller
+    refuses on CI alone either way. Fails open toward "missing" (NEVER
+    toward "satisfied"): an unreadable board/config, or a PR whose work
+    chain `build_gate_report` can't resolve a decision for, reports every
+    gate as still missing rather than claiming a merge is ready when a live
+    `coord merge --only` might still refuse it (#2096: unconfirmed success
+    is a defect).
     """
     coordinates = _repo_coordinates(config_path, repo)
     if coordinates is None:
@@ -990,14 +1027,64 @@ def _existing_pr_match(
         # reported", which `all_green` below already reads as not-green.
         checks = []
     all_green = bool(checks) and not failed_checks(checks) and not in_flight_checks(checks)
+    missing_gates = _missing_required_gates(config_path, repo, issue) if all_green else ()
     return ExistingPrMatch(
         number=number,
         branch=str(pr.get("headRefName") or ""),
         url=str(pr.get("url") or ""),
         all_green=all_green,
+        missing_gates=missing_gates,
     )
 
 
+def _missing_required_gates(config_path: Path, repo: str, issue: int) -> tuple[str, ...]:
+    """#3539: which of ``("review", "test")`` are still required-but-not-ok
+    for *repo*#*issue*, per `coord.gates.build_gate_report` — the SAME
+    review/test decision `coord gates` prints and `coord merge` itself
+    gates on (#2096: one question, one answer; never a second, driftable
+    guess at "is this PR actually ready").
+
+    Fails open toward "missing", never toward "satisfied": any read failure
+    (unreadable config, no board, an exception inside `build_gate_report`
+    itself) or a report with no resolved decisions at all (no work-like
+    assignment `build_gate_report` could select a winner from) reports
+    BOTH gates missing. A false "missing" here costs one operator-visible
+    resume note on an add that may turn out to be a no-op once the real
+    gates are read live again a moment later; a false "satisfied" would
+    reproduce the exact #3539 incident — advising ``coord merge --only``
+    over a PR a live merge attempt still refuses.
+
+    The board comes from ``coord.board_service.read_board()``, NOT
+    ``coord.state.build_board()`` (#615/#906): `coord drive-queue add` has
+    no whole-command daemon reroute, so a thin client reading the local DB
+    here would see an empty board, resolve no decisions, and fail open to
+    "both gates missing" on every add — technically safe, uselessly noisy.
+    `read_board()` is the one place the local-vs-daemon decision is made
+    (GET /board on a thin client, the local DB otherwise), which is also
+    why no entry is needed in `tests/test_thin_client_board_audit.py`'s
+    ``COMMANDS_ALLOWLIST``: there is no direct local-board call site to
+    allowlist.
+    """
+    try:
+        from coord import github_ops  # noqa: PLC0415
+        from coord.board_service import read_board  # noqa: PLC0415
+        from coord.commands._common import _load_config  # noqa: PLC0415
+        from coord.gates import build_gate_report  # noqa: PLC0415
+
+        cfg = _load_config(config_path)
+        board = read_board()
+        report = build_gate_report(board, cfg, repo, issue, gh_ops=github_ops)
+    except (Exception, SystemExit):  # noqa: BLE001 — fail-open to "missing"
+        return ("review", "test")
+    by_gate = {d.gate: d for d in report.decisions}
+    missing = []
+    for gate in ("review", "test"):
+        decision = by_gate.get(gate)
+        if decision is None or (decision.required and not decision.ok):
+            missing.append(gate)
+    return tuple(missing)
+
+
 def _predict_overlap(
     config_path: Path, repo: str, issue: int, existing_entries: list[QueueEntry],
 ) -> tuple[Prediction, str, str]:
@@ -6433,6 +6520,17 @@ def _blocked_escalation_command(
     behaviour) purely so every OTHER existing caller/test of this function
     that has no config to hand keeps working unchanged; the real `tick`
     call sites below always pass their own.
+
+    #3539: `existing_pr_relaunch_remedy` returning ``None`` is no longer
+    proof that *match* itself is ``None`` — a green PR with Test and/or
+    Review never recorded ALSO returns ``None`` (see that function's own
+    docstring), on purpose, so a plain `add` can resume on it. That case
+    still HAS a PR and HAS been dispatched, so it must not fall through to
+    `_requeue_command`'s blind ``remove && add`` either — remove would
+    discard a completed, green work cycle for no reason. Propose the plain
+    `add` (no `remove` first) instead; `_requeue_command` stays reserved for
+    the one case its own docstring names: *match* itself is ``None``,
+    i.e. nothing was ever dispatched for this row at all.
     """
     if is_merge_gate_block_reason(reason):
         parsed = parse_key(key)
@@ -6446,6 +6544,10 @@ def _blocked_escalation_command(
             remedy = existing_pr_relaunch_remedy(repo, issue, match)
             if remedy is not None:
                 return remedy["command_or_action"]
+            if match is not None:
+                # #3539: green PR, gate(s) not yet recorded — resume via a
+                # plain `add`, never the blind `remove && add` requeue below.
+                return f"coord drive-queue add {repo} {issue}"
     return _requeue_command(entry, key)
 
 

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/coord/drive_queue.py

@@ -4315,51 +4315,84 @@ class ExistingPrMatch:
     built it — :func:`coord.commands.drive_queue._existing_pr_match`, the
     one place that owns the `gh pr list` + checks read this module stays
     pure of.
+
+    *missing_gates* (#3539) is the subset of ``("review", "test")`` that
+    `coord.gates.build_gate_report` — the SAME read `coord gates`/`coord
+    merge` themselves use, never a second guess (#2096: one question, one
+    answer) — reports as still required-but-not-ok for this PR's work
+    chain. Empty by default so every pre-#3539 construction of this
+    dataclass (every existing test that only ever set *all_green*) keeps
+    reading as "fully gated" — i.e. byte-identical old behaviour — without
+    being touched.
     """
 
     number: int
     branch: str
     url: str
     all_green: bool
+    missing_gates: tuple[str, ...] = ()
 
 
 def existing_pr_relaunch_remedy(
     repo: str, issue: int, match: "ExistingPrMatch | None"
 ) -> dict[str, str] | None:
-    """#2377: the option (and `drive-queue add` refusal message) *match*
-    recommends INSTEAD OF a blind ``remove && add`` relaunch — or ``None``
-    when *match* is ``None`` (today's only behaviour unchanged: no PR on the
-    conventional branch name(s), start fresh).
-
-    Two shapes, both refusing the relaunch — a red/stale-checks PR is NOT a
-    green light to requeue either: something else may already be mid-fixing
-    that branch, and a fresh drive launched on top of it is exactly the "at
-    best wasted work, at worst clobbering it mid-flight" risk #2377 opens
-    with. Merging a discovered PR is deliberately NOT done here — surfacing
-    it (or refusing the relaunch) is enough; merging stays a `coord merge`
-    decision.
+    """#2377/#3539: the option (and `drive-queue add` refusal message)
+    *match* recommends INSTEAD OF a blind ``remove && add`` relaunch — or
+    ``None`` when *match* is ``None`` (no PR on the conventional branch
+    name(s), start fresh) OR when *match* is green but still carries
+    unrecorded gates (#3539 — see below): both ``None`` shapes mean "let
+    this `add` proceed", not "nothing was found".
+
+    Three shapes:
+
+    * **red / stale checks** — refuse; something else may already be
+      mid-fixing that branch, and a fresh drive launched on top of it is
+      exactly the "at best wasted work, at worst clobbering it mid-flight"
+      risk #2377 opens with.
+    * **green, but Test and/or Review never recorded** (#3539 — the
+      quadraui#1109/PR#1253 incident: CI all green, yet `coord gates`
+      showed both `review` and `test` BLOCKED, and the ``merge it instead``
+      advice below was impossible — `coord merge --only` itself refused
+      with ``enqueue blocked by review gate``). Refusing here would strand
+      the entry with no way to ever collect the missing verdicts. Returning
+      ``None`` lets the `add` proceed and the queue's own drive resume on
+      the EXISTING branch — `decide()` only ever dispatches a fresh Work
+      leg when ``state.work_aid`` is unset (see `coord/drive.py`), which it
+      is not here, so this can only ever run the missing stage(s) (Test
+      dispatch, Review dispatch) forward to merge, never restart Work.
+    * **green and every gate already satisfied** — truly done: refuse and
+      point at ``coord merge --only`` instead of relaunching a fresh drive
+      over it. Merging is deliberately NOT done here — surfacing it (or
+      refusing the relaunch) is enough; merging stays a `coord merge`
+      decision.
     """
     if match is None:
         return None
     key = entry_key(repo, issue)
-    if match.all_green:
+    if not match.all_green:
         return {
-            "label": "Merge existing PR",
-            "command_or_action": f"coord merge --only {key}",
+            "label": "Inspect existing PR",
+            "command_or_action": merge_plan_inspect_command(repo),
             "what_happens": (
-                f"PR #{match.number} ({match.branch}) already carries this "
-                "work with every check green — merge it instead of "
+                f"PR #{match.number} ({match.branch}) already exists for "
+                "this entry, but its checks are not all green — fix it "
+                "forward (or confirm by hand it is truly dead) before "
                 "relaunching a fresh drive over it."
             ),
         }
+    if match.missing_gates:
+        # #3539: deliberately no refusal dict — see the docstring's second
+        # shape. Returning `None` here is the whole fix: it lets `add`
+        # proceed instead of stranding the entry on an impossible "merge
+        # it" when `coord merge --only` would itself refuse.
+        return None
     return {
-        "label": "Inspect existing PR",
-        "command_or_action": merge_plan_inspect_command(repo),
+        "label": "Merge existing PR",
+        "command_or_action": f"coord merge --only {key}",
         "what_happens": (
-            f"PR #{match.number} ({match.branch}) already exists for this "
-            "entry, but its checks are not all green — fix it forward (or "
-            "confirm by hand it is truly dead) before relaunching a fresh "
-            "drive over it."
+            f"PR #{match.number} ({match.branch}) already carries this "
+            "work with every check green — merge it instead of "
+            "relaunching a fresh drive over it."
         ),
     }
 

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/tests/test_cli_drive_queue.py

@@ -921,6 +921,76 @@ def test_add_still_refuses_a_requeue_over_an_already_blocked_entry_with_a_green_
     assert f"coord merge --only {REPO}#1753" in result.output
 
 
+def test_add_accepts_a_requeue_over_a_blocked_entry_with_a_green_pr_missing_gates(
+    cli, seed, monkeypatch
+):
+    """#3539's actual end-to-end fix, driven through the real CLI: the exact
+    shape `test_add_still_refuses_a_requeue_over_an_already_blocked_entry_
+    with_a_green_pr` above pins as a REFUSAL (a `blocked` entry with a green
+    matching PR) must now instead be ACCEPTED when that PR's Test and/or
+    Review were never recorded — the quadraui#1109/PR#1253 incident: CI
+    green, `coord gates` showing both BLOCKED, and the old 'merge it
+    instead' advice impossible (`coord merge --only` itself refused). The
+    `add` must succeed and print the new resume note naming the PR and the
+    still-missing gate(s), never the #2377 refusal exception."""
+    from coord.drive_queue import ExistingPrMatch
+
+    seed(issues={1753: "open"})
+    cli("add", REPO, "1753")
+    state._update_drive_queue_entry_local(REPO, 1753, state=STATE_BLOCKED)
+
+    monkeypatch.setattr(
+        "coord.commands.drive_queue._existing_pr_match",
+        lambda config_path, repo, issue: ExistingPrMatch(
+            number=4242,
+            branch="issue-1753-some-fix",
+            url="https://github.com/example/claude-coordinator/pull/4242",
+            all_green=True,
+            missing_gates=("review", "test"),
+        ),
+    )
+
+    result = cli("add", REPO, "1753", "--max-fix-rounds", "3")
+
+    assert result.exit_code == 0, result.output
+    assert "4242" in result.output
+    assert "resuming on existing PR #4242" in result.output
+    assert "review and test" in result.output
+    assert "gates are not yet recorded" in result.output
+    assert f"coord gates {REPO} 1753" in result.output
+    # Accepted, not refused — never the #2377 merge-it exception text.
+    assert f"coord merge --only {REPO}#1753" not in result.output
+    assert queued(1753) is not None
+
+
+def test_add_resume_note_names_a_single_missing_gate_in_the_singular(
+    cli, seed, monkeypatch
+):
+    """Same accept path, but only ONE gate missing — the note's wording must
+    track the singular/plural split (`existing_pr_resume_note`'s own
+    ``'gate is' if len(...) == 1 else 'gates are'`` branch)."""
+    from coord.drive_queue import ExistingPrMatch
+
+    seed(issues={1753: "open"})
+
+    monkeypatch.setattr(
+        "coord.commands.drive_queue._existing_pr_match",
+        lambda config_path, repo, issue: ExistingPrMatch(
+            number=4242,
+            branch="issue-1753-some-fix",
+            url="https://github.com/example/claude-coordinator/pull/4242",
+            all_green=True,
+            missing_gates=("test",),
+        ),
+    )
+
+    result = cli("add", REPO, "1753")
+
+    assert result.exit_code == 0, result.output
+    assert "resuming on existing PR #4242" in result.output
+    assert "test gate is not yet recorded" in result.output
+
+
 def test_blocked_escalation_command_proposes_merge_over_requeue_when_pr_is_green(
     monkeypatch, config_file,
 ):
@@ -986,6 +1056,43 @@ def test_blocked_escalation_command_still_requeues_when_no_pr_matches(
     )
 
 
+def test_blocked_escalation_command_proposes_a_plain_add_when_pr_is_green_but_ungated(
+    monkeypatch, config_file,
+):
+    """#3539's non-blocking follow-up: a green PR whose gates were never
+    recorded makes `existing_pr_relaunch_remedy` return `None` for a REASON
+    other than 'no PR matched' (see that function's own docstring). This
+    call site must not conflate the two `None` shapes and fall through to
+    `_requeue_command`'s blind `remove && add` — that would discard a
+    completed, green work cycle for nothing. It must propose a plain `add`
+    (no `remove` first) instead, same as the #3539 `drive-queue add` fix
+    itself resumes on."""
+    from coord.commands.drive_queue import _blocked_escalation_command
+    from coord.drive_queue import ExistingPrMatch, entry_key
+
+    monkeypatch.setattr(
+        "coord.commands.drive_queue._existing_pr_match",
+        lambda config_path, repo, issue: ExistingPrMatch(
+            number=1253,
+            branch="issue-1109-fix",
+            url="https://github.com/example/quadraui/pull/1253",
+            all_green=True,
+            missing_gates=("review", "test"),
+        ),
+    )
+    reason = (
+        "work adv-1 exited ADVISORY with no commits on its branch "
+        "(3/3 attempts) — nothing was pushed, so there is nothing to test, "
+        "review, or merge, and retrying has not produced a different outcome."
+    )
+    key = entry_key(OTHER_REPO, 1109)
+
+    command = _blocked_escalation_command(None, key, reason, config_path=config_file)
+
+    assert command == f"coord drive-queue add {OTHER_REPO} 1109"
+    assert "remove" not in command
+
+
 def test_a_declared_file_is_checked_against_a_live_branchs_real_diff(
     cli, declare, seed, branch_diff,
 ):

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/tests/test_drive.py

@@ -2977,6 +2977,22 @@ def test_no_test_verdict_yet_waits_for_coord_to_dispatch_the_stage():
     assert action.command == ()
 
 
+def test_resuming_on_an_existing_pr_with_no_test_or_review_recorded_never_redispatches_work():
+    """#3539: the exact quadraui#1109/PR#1253 shape, pinned at `decide()`
+    itself — a `coord drive-queue add` the #2377/#3539 guard now ACCEPTS
+    (CI green, but neither Test nor Review ever recorded) resumes by
+    launching `coord drive` on this same (repo, issue) again. The guard's
+    whole premise that this can only ever run the missing stage(s) forward,
+    never restart Work, rests on `decide()` branching on `state.work_aid`
+    alone (see its own `if not state.work_aid:` dispatch-work arm) — this
+    pins that: a `work_aid`-bearing, branch-bearing, `done` state with BOTH
+    gates unrecorded must wait for the Test stage, never re-dispatch Work."""
+    action = step(done_work(work_test_state=""))
+    assert action.kind == WAIT
+    assert action.command == ()
+    assert not action.label.startswith("WORK:")
+
+
 def test_skip_test_records_the_verdict_through_the_test_cli():
     """The CLI, never record_test_verdict() — see #1384."""
     action = step(done_work(), DriveOptions(machine="precision", skip_test=True))

{code_coordinator-0.5.569 → code_coordinator-0.5.570}/tests/test_drive_queue.py

@@ -15,6 +15,8 @@ most attention here are the ones that caused real incidents:
 
 from __future__ import annotations
 
+from pathlib import Path
+
 import pytest
 
 from coord.drive_queue import (
@@ -7514,6 +7516,185 @@ def test_existing_pr_relaunch_remedy_refuses_the_relaunch_even_when_red():
     assert remedy["command_or_action"] == merge_plan_inspect_command(REPO)
 
 
+# ── #3539: green PR, but Test and/or Review never recorded ─────────────────
+#
+# The live incident: quadraui#1109 (PR #1253) had its Test stage dead-end on
+# an unrelated capability-probe failure, a `coord fix` worker then repaired
+# the PR's only red CI job, and once every check went green the #2377 guard
+# refused the re-add with "merge it instead" — but `coord gates` showed BOTH
+# `review` and `test` BLOCKED, and `coord merge --only` itself refused with
+# "enqueue blocked by review gate". The guard must tell these two "green"
+# shapes apart.
+
+
+def test_existing_pr_relaunch_remedy_recommends_merging_a_fully_gated_green_pr():
+    """Unchanged #2377 behaviour, now spelled out explicitly for the shape
+    `missing_gates` is empty on: every required gate already satisfied —
+    still refuse, still "merge it"."""
+    match = ExistingPrMatch(
+        number=1253, branch="issue-1109-fix",
+        url="https://github.com/example/quadraui/pull/1253",
+        all_green=True,
+        missing_gates=(),
+    )
+    remedy = existing_pr_relaunch_remedy("quadraui", 1109, match)
+    assert remedy is not None
+    assert remedy["command_or_action"] == "coord merge --only quadraui#1109"
+    assert "1253" in remedy["what_happens"]
+
+
+def test_existing_pr_relaunch_remedy_accepts_a_green_pr_missing_both_gates():
+    """#3539's actual fix: CI green, but review AND test were never
+    recorded — `None` (accept the `add`, resume on the existing branch),
+    never the impossible "merge it" advice."""
+    match = ExistingPrMatch(
+        number=1253, branch="issue-1109-fix",
+        url="https://github.com/example/quadraui/pull/1253",
+        all_green=True,
+        missing_gates=("review", "test"),
+    )
+    assert existing_pr_relaunch_remedy("quadraui", 1109, match) is None
+
+
+def test_existing_pr_relaunch_remedy_accepts_a_green_pr_missing_one_gate():
+    """Same fix, the partial shape — only ONE gate missing (e.g. review
+    approved, test never dispatched) is still "accept", not "merge it"."""
+    match = ExistingPrMatch(
+        number=1253, branch="issue-1109-fix",
+        url="https://github.com/example/quadraui/pull/1253",
+        all_green=True,
+        missing_gates=("test",),
+    )
+    assert existing_pr_relaunch_remedy("quadraui", 1109, match) is None
+
+
+def test_existing_pr_relaunch_remedy_still_refuses_fix_forward_when_red_with_missing_gates():
+    """A red PR is refused on CI alone, same as before #3539 — missing
+    gates are moot (and, realistically, implied) when checks are not even
+    green yet. `missing_gates` is populated here to prove the red-check
+    branch is checked FIRST and never looks at it."""
+    match = ExistingPrMatch(
+        number=1253, branch="issue-1109-fix",
+        url="https://github.com/example/quadraui/pull/1253",
+        all_green=False,
+        missing_gates=("review", "test"),
+    )
+    remedy = existing_pr_relaunch_remedy("quadraui", 1109, match)
+    assert remedy is not None
+    assert "coord merge --only" not in remedy["command_or_action"]
+    assert remedy["command_or_action"] == merge_plan_inspect_command("quadraui")
+
+
+# ── #3539: `_missing_required_gates` — the live read `_existing_pr_match`
+# feeds `missing_gates` from, pinned directly since it is the one place
+# that reuses `coord.gates.build_gate_report` (#2096: one question, one
+# answer) rather than a second, driftable guess at gate state. ───────────
+
+
+def test_missing_required_gates_reports_only_the_unsatisfied_gate(monkeypatch):
+    from coord.commands.drive_queue import _missing_required_gates
+    from coord.gates import GateDecision, GateReport
+
+    report = GateReport(repo_name="quadraui", issue_number=1109)
+    report.decisions = [
+        GateDecision(gate="review", required=True, ok=False, reason="review required but not approved"),
+        GateDecision(gate="test", required=True, ok=True),
+    ]
+    monkeypatch.setattr("coord.gates.build_gate_report", lambda *a, **k: report)
+    monkeypatch.setattr("coord.commands._common._load_config", lambda *a, **k: object())
+    monkeypatch.setattr("coord.board_service.read_board", lambda *a, **k: object())
+
+    assert _missing_required_gates(Path("/dev/null"), "quadraui", 1109) == ("review",)
+
+
+def test_missing_required_gates_empty_when_both_satisfied(monkeypatch):
+    from coord.commands.drive_queue import _missing_required_gates
+    from coord.gates import GateDecision, GateReport
+
+    report = GateReport(repo_name="quadraui", issue_number=1109)
+    report.decisions = [
+        GateDecision(gate="review", required=True, ok=True),
+        GateDecision(gate="test", required=False, ok=True),
+    ]
+    monkeypatch.setattr("coord.gates.build_gate_report", lambda *a, **k: report)
+    monkeypatch.setattr("coord.commands._common._load_config", lambda *a, **k: object())
+    monkeypatch.setattr("coord.board_service.read_board", lambda *a, **k: object())
+
+    assert _missing_required_gates(Path("/dev/null"), "quadraui", 1109) == ()
+
+
+def test_missing_required_gates_fails_open_to_missing_on_a_read_error(monkeypatch):
+    """#2096: a read that cannot confirm the gate is satisfied must never
+    report it as satisfied — an exception anywhere in the live read (here:
+    `build_gate_report` itself blowing up) reports BOTH gates missing, the
+    safe default, never `()`."""
+    from coord.commands.drive_queue import _missing_required_gates
+
+    def _boom(*a, **k):
+        raise RuntimeError("gh unreachable")
+
+    monkeypatch.setattr("coord.gates.build_gate_report", _boom)
+    monkeypatch.setattr("coord.commands._common._load_config", lambda *a, **k: object())
+    monkeypatch.setattr("coord.board_service.read_board", lambda *a, **k: object())
+
+    assert _missing_required_gates(Path("/dev/null"), "quadraui", 1109) == ("review", "test")
+
+
+def test_missing_required_gates_fails_open_when_no_decision_could_be_resolved(monkeypatch):
+    """A report with no resolved decisions at all (e.g. no work-like
+    assignment `build_gate_report` could select a winner from) is "unknown",
+    never "satisfied" — same fail-open default as a hard read error."""
+    from coord.commands.drive_queue import _missing_required_gates
+    from coord.gates import GateReport
+
+    report = GateReport(repo_name="quadraui", issue_number=1109)
+    report.notes = ["no assignments found on the board for quadraui#1109"]
+    monkeypatch.setattr("coord.gates.build_gate_report", lambda *a, **k: report)
+    monkeypatch.setattr("coord.commands._common._load_config", lambda *a, **k: object())
+    monkeypatch.setattr("coord.board_service.read_board", lambda *a, **k: object())
+
+    assert _missing_required_gates(Path("/dev/null"), "quadraui", 1109) == ("review", "test")
+
+
+def test_missing_required_gates_reads_the_board_through_the_daemon_aware_seam(monkeypatch):
+    """#615/#906: `coord drive-queue add` has no whole-command daemon
+    reroute, so this gate read must go through
+    `coord.board_service.read_board()` (GET /board on a thin client) and
+    never `coord.state.build_board()` directly — a thin client reading the
+    local DB would see an empty board and fail open to "both gates missing"
+    on every add. Pinned by making the local read EXPLODE: a regression back
+    to `build_board()` is swallowed by the fail-open `except` and shows up
+    here as ("review", "test") instead of the real ().
+    """
+    from coord.commands.drive_queue import _missing_required_gates
+    from coord.gates import GateDecision, GateReport
+
+    sentinel_board = object()
+    seen: list[object] = []
+
+    report = GateReport(repo_name="quadraui", issue_number=1109)
+    report.decisions = [
+        GateDecision(gate="review", required=True, ok=True),
+        GateDecision(gate="test", required=True, ok=True),
+    ]
+
+    def _build_gate_report(board, *a, **k):
+        seen.append(board)
+        return report
+
+    def _local_board_is_forbidden(*a, **k):
+        raise AssertionError("read the local board instead of board_service.read_board()")
+
+    monkeypatch.setattr("coord.gates.build_gate_report", _build_gate_report)
+    monkeypatch.setattr("coord.commands._common._load_config", lambda *a, **k: object())
+    monkeypatch.setattr("coord.board_service.read_board", lambda *a, **k: sentinel_board)
+    monkeypatch.setattr("coord.state.build_board", _local_board_is_forbidden)
+    monkeypatch.setattr("coord.state.load_board", _local_board_is_forbidden)
+
+    assert _missing_required_gates(Path("/dev/null"), "quadraui", 1109) == ()
+    assert seen == [sentinel_board]
+
+
 class TestDriveQueueListReadDistinguishesFailureFromEmpty:
     """#2992: `coord drive-queue list` must not report a daemon it could
     not read as "the queue is empty" — those are two different facts and