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

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

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

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

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

{code_coordinator-0.5.569 → code_coordinator-0.5.571}/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.571}/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.571}/coord/win_native_driver.py

@@ -370,11 +370,18 @@ class WinCalls(Protocol):
     def launch_in_terminal(self, command: str, cwd: str, terminal_app: str) -> int: ...
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
-        """Poll for the launched process's real top-level window, returning
-        its handle once found. Raises :class:`WinNativeRuntimeError` if none
-        appears within *timeout_s* — this is the "launch" step's own
-        confirmation that the process didn't just start, but actually
-        produced a window (#2096)."""
+        """Poll for *pid*'s (or one of its descendant processes') real
+        top-level window, returning its handle once found. Raises
+        :class:`WinNativeRuntimeError` if none appears within *timeout_s* —
+        this is the "launch" step's own confirmation that the process
+        didn't just start, but actually produced a window (#2096).
+
+        *pid* is not always the real app's own pid: ``subprocess.Popen(...,
+        shell=True)`` on Windows spawns ``cmd.exe`` as the immediate child
+        and returns *its* pid, while the real app (e.g. ``vimcode.exe``) is
+        a grandchild with a different pid that ``cmd.exe`` itself never
+        owns a window for (#3542). Implementations must search *pid*'s
+        whole descendant-process tree, not just *pid* itself."""
         ...
 
     def move_window(self, hwnd: int, x: int, y: int, width: int, height: int) -> None: ...
@@ -857,12 +864,28 @@ class Win32Calls:
 
     def _logonui_running_in_session(self, session_id: int) -> bool:
         """``True`` iff ``LogonUI.exe`` (the Windows lock-screen host
-        process) is running in *session_id* — walked via a
-        ``CreateToolhelp32Snapshot`` process snapshot, the same mechanism
-        Task Manager itself uses, rather than anything that could be
-        confused by a differently-named process (the module docstring's
-        "kill only the PID this driver itself launched" safety note applies
-        equally here: this is read-only enumeration, never a kill)."""
+        process) is running in *session_id* — walked via
+        :meth:`_snapshot_processes`, the same mechanism Task Manager itself
+        uses, rather than anything that could be confused by a differently-
+        named process (the module docstring's "kill only the PID this
+        driver itself launched" safety note applies equally here: this is
+        read-only enumeration, never a kill)."""
+        ctypes = self._ctypes
+        for pid, _ppid, name in self._snapshot_processes():
+            if name.lower() == "logonui.exe":
+                proc_session = ctypes.wintypes.DWORD()
+                self._kernel32.ProcessIdToSessionId(pid, ctypes.byref(proc_session))
+                if proc_session.value == session_id:
+                    return True
+        return False
+
+    def _snapshot_processes(self) -> list[tuple[int, int, str]]:
+        """Every currently running process as ``(pid, parent_pid,
+        exe_name)``, via a single ``CreateToolhelp32Snapshot`` walk — the
+        same mechanism Task Manager itself uses. Read-only enumeration,
+        shared by :meth:`_logonui_running_in_session` (#3510) and
+        :meth:`_descendant_pids` (#3542); never used to kill (see the
+        module docstring's safety note)."""
         ctypes = self._ctypes
         kernel32 = self._kernel32
         TH32CS_SNAPPROCESS = 0x00000002
@@ -880,48 +903,81 @@ class Win32Calls:
 
         snapshot = kernel32.CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)
         if not snapshot or snapshot == -1:
-            return False
+            return []
+        out: list[tuple[int, int, str]] = []
         try:
             entry = PROCESSENTRY32()
             entry.dwSize = ctypes.sizeof(PROCESSENTRY32)
             if not kernel32.Process32First(snapshot, ctypes.byref(entry)):
-                return False
+                return []
             while True:
                 name = entry.szExeFile.decode("mbcs", errors="ignore")
-                if name.lower() == "logonui.exe":
-                    proc_session = ctypes.wintypes.DWORD()
-                    kernel32.ProcessIdToSessionId(
-                        entry.th32ProcessID, ctypes.byref(proc_session),
-                    )
-                    if proc_session.value == session_id:
-                        return True
+                out.append((entry.th32ProcessID, entry.th32ParentProcessID, name))
                 if not kernel32.Process32Next(snapshot, ctypes.byref(entry)):
-                    return False
+                    break
         finally:
             kernel32.CloseHandle(snapshot)
+        return out
+
+    def _descendant_pids(self, root_pid: int) -> set[int]:
+        """*root_pid* plus every process it transitively spawned (child,
+        grandchild, ...) — a fresh :meth:`_snapshot_processes` walk each
+        call, since the real app may not have started yet the first time
+        this is polled.
+
+        #3542: ``launch``/``launch_in_terminal`` don't always return the
+        real app's own pid — ``subprocess.Popen(..., shell=True)`` returns
+        ``cmd.exe``'s pid, with the real app (``vimcode.exe``) a grandchild
+        that ``cmd.exe`` itself never owns a window for. Searching the
+        whole descendant tree finds the real app's window regardless of
+        how many shell/console hosts sit between the returned pid and it.
+        """
+        children: dict[int, list[int]] = {}
+        for pid, ppid, _name in self._snapshot_processes():
+            children.setdefault(ppid, []).append(pid)
+        result = {root_pid}
+        frontier = [root_pid]
+        while frontier:
+            current = frontier.pop()
+            for child in children.get(current, ()):
+                if child not in result:
+                    result.add(child)
+                    frontier.append(child)
+        return result
 
     def find_top_window(self, pid: int, timeout_s: float) -> int:
         ctypes = self._ctypes
         deadline = time.monotonic() + timeout_s
         found: list[int] = []
-
-        @ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
+        candidate_pids: set[int] = {pid}
+        # `WINFUNCTYPE` (stdcall) only exists in ctypes on real Windows —
+        # real runs always go through it (Win32Calls.__init__ guards
+        # off-Windows construction), but falling back to `CFUNCTYPE` off-
+        # Windows is what lets this method's descendant-walk logic be
+        # exercised by a scripted fake on Linux/macOS too (#3542), the same
+        # "unit-testable on any platform" seam the module docstring
+        # describes for the rest of this class.
+        win_functype = getattr(ctypes, "WINFUNCTYPE", ctypes.CFUNCTYPE)
+
+        @win_functype(ctypes.c_bool, ctypes.c_void_p, ctypes.c_void_p)
         def _enum_proc(hwnd, _lparam):
             owner_pid = ctypes.wintypes.DWORD()
             self._user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner_pid))
-            if owner_pid.value == pid and self._user32.IsWindowVisible(hwnd):
+            if owner_pid.value in candidate_pids and self._user32.IsWindowVisible(hwnd):
                 found.append(hwnd)
                 return False
             return True
 
         while time.monotonic() < deadline:
+            candidate_pids = self._descendant_pids(pid)
             found.clear()
             self._user32.EnumWindows(_enum_proc, 0)
             if found:
                 return found[0]
             time.sleep(0.1)
         raise WinNativeRuntimeError(
-            f"no visible top-level window appeared for pid={pid} within {timeout_s}s"
+            f"no visible top-level window appeared for pid={pid} or any of "
+            f"its child processes within {timeout_s}s"
         )
 
     def is_window_alive(self, hwnd: int) -> bool:

{code_coordinator-0.5.569 → code_coordinator-0.5.571}/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.571}/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))