code-coordinator 0.5.565__tar.gz → 0.5.566__tar.gz

{code_coordinator-0.5.565 → code_coordinator-0.5.566}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.565",
+  "tag": "0.5.566",
   "distance": 0,
-  "node": "g17a32a973761388195b697736864929850be4d1f",
+  "node": "g17554137715ba9508260794b6ffb9ccdd0cd3906",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-02"

{code_coordinator-0.5.565 → code_coordinator-0.5.566}/coord/commands/drive_queue.py

@@ -67,8 +67,10 @@ from coord.drive_queue import (
     STATE_PARKED,
     STATE_RUNNING,
     STATE_WAITING,
+    STUCK_QUEUE_STATES,
     TERMINAL_QUEUE_STATES,
     BoardView,
+    ExistingPrMatch,
     IssueFacts,
     ProbeResult,
     QueueEntry,
@@ -79,11 +81,13 @@ from coord.drive_queue import (
     add_preflight_notice,
     apply_gate_status,
     build_board_view,
+    conventional_branch_patterns,
     detect_unreachable_waits,
     diagnose_blocked_after,
     effective_max_fix_rounds,
     entries_from_rows,
     entry_key,
+    existing_pr_relaunch_remedy,
     find_cycle,
     fired_holds,
     flag_shadows_config_warning,
@@ -464,6 +468,33 @@ def drive_queue_add(
             "(entries-only). Pass --scope fleet again if the fleet-wide stop was still needed."
         )
 
+    # #2377: refuse OUTRIGHT — never just advise — when an OPEN PR already
+    # exists on this entry's conventional branch name(s), but ONLY for the
+    # two shapes that can actually relaunch a drive over it: a true fresh
+    # insert (`previous is None` — including the `coord drive-queue remove
+    # <k> && coord drive-queue add <k>` remedy, which drops the row entirely
+    # before this `add` runs, so by then there is no `previous` left either)
+    # and a requeue-style `add` over an already-stuck row (`previous.state`
+    # in `STUCK_QUEUE_STATES` — the #2972 "bump --max-fix-rounds and re-add"
+    # pattern `_requeue_command` documents). `_enqueue_drive_queue_local`
+    # is a pure metadata upsert for every OTHER case — `waiting`/`running`
+    # entries that pushed their own (healthy, simply not-yet-green) PR on the
+    # expected path through Work -> Test -> Review -> Merge — and routine
+    # `--hold-after`/`--machine`/`--after` edits to those must keep working
+    # even though a matching PR already exists, since no relaunch of any
+    # 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.
+    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)
+        if existing_remedy is not None:
+            raise click.ClickException(
+                f"refusing to queue {entry_key(repo, issue)} — "
+                f"{existing_remedy['what_happens']} Run instead: "
+                f"{existing_remedy['command_or_action']}"
+            )
+
     # #2247: predicted file overlap ORDERS, never refuses. Anything that goes
     # wrong in here (unreadable body, unreachable board, a failed compare)
     # yields an empty prediction and this add behaves exactly as it did before
@@ -900,6 +931,73 @@ def _repo_coordinates(config_path: Path, repo: str) -> tuple[str, str] | None:
     return str(repo_cfg.github or ""), str(getattr(repo_cfg, "default_branch", "") or "main")
 
 
+def _existing_pr_match(
+    config_path: Path, repo: str, issue: int,
+) -> "ExistingPrMatch | None":
+    """#2377: resolve *repo*#*issue*'s conventional-branch PR, if any, to a
+    go/no-go CI verdict — the one place that owns the `gh pr list` + checks
+    read `coord.drive_queue.ExistingPrMatch` stays pure of.
+
+    Fail-open at every layer (unreadable config, no GitHub slug, `gh`
+    error, unreadable checks) — the same posture #2247's overlap prediction
+    takes: a false "nothing found" costs an operator a wasted relaunch, but
+    a false block on a healthy queue would be strictly worse (it IS the
+    queue). `coord.github_ops.find_open_pr_for_branch_patterns` and
+    `coord.ci_github.GitHubCi.list_checks_for_pr` already fail open on a
+    transient `gh` error on their own; this only adds the same posture
+    around the config/slug lookup wrapping them.
+
+    `all_green` here is a narrower "safe to merge instead of relaunching"
+    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.
+    """
+    coordinates = _repo_coordinates(config_path, repo)
+    if coordinates is None:
+        return None
+    repo_github, _base_branch = coordinates
+    if not repo_github:
+        return None
+    try:
+        from coord import github_ops  # noqa: PLC0415
+
+        pr = github_ops.find_open_pr_for_branch_patterns(
+            repo_github, conventional_branch_patterns(issue)
+        )
+    except Exception:  # noqa: BLE001 — fail-open, see docstring
+        pr = None
+    if not pr:
+        return None
+    number = pr.get("number")
+    if not isinstance(number, int):
+        return None
+    try:
+        from coord.ci_github import GitHubCi  # noqa: PLC0415
+        from coord.ci_store import failed_checks, in_flight_checks  # noqa: PLC0415
+
+        checks = GitHubCi().list_checks_for_pr(repo_github, number)
+    except Exception:  # noqa: BLE001 — fail-open: an unreadable check list
+        # is not evidence of green OR red — treat it the same as "no checks
+        # 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)
+    return ExistingPrMatch(
+        number=number,
+        branch=str(pr.get("headRefName") or ""),
+        url=str(pr.get("url") or ""),
+        all_green=all_green,
+    )
+
+
 def _predict_overlap(
     config_path: Path, repo: str, issue: int, existing_entries: list[QueueEntry],
 ) -> tuple[Prediction, str, str]:
@@ -6299,7 +6397,13 @@ def _requeue_command(entry: QueueEntry | None, key: str) -> str:
     )
 
 
-def _blocked_escalation_command(entry: QueueEntry | None, key: str, reason: str) -> str:
+def _blocked_escalation_command(
+    entry: QueueEntry | None,
+    key: str,
+    reason: str,
+    *,
+    config_path: Path | None = None,
+) -> str:
     """The command a `blocked`/`oscillating` escalation should propose
     (#3016) — `_requeue_command` ONLY for a genuinely never-dispatched entry;
     a gate-specific remedy (or the safe read-only inspect fallback) whenever
@@ -6315,11 +6419,33 @@ def _blocked_escalation_command(entry: QueueEntry | None, key: str, reason: str)
     one place that maps a merge-gate reason to its safe one-line fix (or, if
     none is known blind, the inspect command); this only decides WHICH of
     the two families applies.
+
+    #2377: even when nothing names a merge-gate block, "nothing left to
+    lose" from a blind requeue is only true when nothing ELSE has since
+    fixed this entry by hand — the claude-coordinator#2283 incident: a
+    manual `coord acceptance author` run outside the drive loop had already
+    produced a green, ready-to-merge PR for this exact entry while it sat
+    `blocked` on the empty-branch-death signature. So before falling back to
+    `_requeue_command`, check GitHub for an OPEN PR on this entry's
+    conventional branch name(s) and propose THAT remedy instead — merge it
+    when every check is green, inspect it otherwise — never the requeue.
+    *config_path* is optional (defaults to no check, i.e. today's unchanged
+    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.
     """
     if is_merge_gate_block_reason(reason):
         parsed = parse_key(key)
         if parsed is not None:
             return merge_gate_remedy_command(reason, parsed[0], parsed[1])
+    if config_path is not None:
+        parsed = parse_key(key)
+        if parsed is not None:
+            repo, issue = parsed
+            match = _existing_pr_match(config_path, repo, issue)
+            remedy = existing_pr_relaunch_remedy(repo, issue, match)
+            if remedy is not None:
+                return remedy["command_or_action"]
     return _requeue_command(entry, key)
 
 
@@ -7121,7 +7247,9 @@ def drive_queue_tick(
                     f"{entry.position if entry else '?'} | after="
                     f"{','.join(entry.after) if entry and entry.after else '(none)'}"
                 ),
-                command=_blocked_escalation_command(entry, item.key, item.reason),
+                command=_blocked_escalation_command(
+                    entry, item.key, item.reason, config_path=config_path,
+                ),
             )
 
         # #2230: an entry #2230's sweep would have resumed, but has already
@@ -7148,7 +7276,9 @@ def drive_queue_tick(
                     f"/{MAX_BLOCKED_RESUMES} | position="
                     f"{entry.position if entry else '?'}"
                 ),
-                command=_blocked_escalation_command(entry, item.key, item.reason),
+                command=_blocked_escalation_command(
+                    entry, item.key, item.reason, config_path=config_path,
+                ),
             )
 
         # #2806: a `blocked` entry #2230's sweep targeted this tick, but whose
@@ -7310,7 +7440,14 @@ def drive_queue_tick(
                 target.issue,
                 reason=reason,
                 gates=f"queue_state=blocked | attempts={attempts}",
-                command=_requeue_command(target, target.key),
+                # #2377: route through the same existing-PR check as the
+                # `plan.blocked`/`oscillating` escalations above — a launch
+                # subprocess failing to even start says nothing about
+                # whether a PR from an earlier attempt (or a manual
+                # recovery) already landed the fix.
+                command=_blocked_escalation_command(
+                    target, target.key, reason, config_path=config_path,
+                ),
             )
             # #2235 Phase 0: a launch that never reached tmux is #2235's own
             # `stick-demo#1` row. It blocks OUTSIDE the plan (the subprocess

{code_coordinator-0.5.565 → code_coordinator-0.5.566}/coord/drive_queue.py

@@ -4274,6 +4274,96 @@ def is_dispatch_failure_reason(reason: str | None) -> bool:
     return _is_dispatch_failure_reason(reason)
 
 
+# ── don't relaunch over an already-fixed PR (#2377) ─────────────────────────
+#
+# The live incident: claude-coordinator#2283's drive-queue entry was `blocked`
+# on exactly the #2363 empty-branch-death signature, and the decisions
+# report's recommended remedy was a blind `coord drive-queue remove 2283 &&
+# coord drive-queue add 2283` — blind to the fact that PR #2353 already
+# carried the correctly re-authored work, merged into no branch yet but every
+# CI check green. Relaunching would have, at best, wasted work re-authoring
+# what already existed, at worst clobbered it mid-flight. See the two
+# chokepoints both `coord drive-queue add` and the tick's escalation writer
+# (`coord.commands.drive_queue._blocked_escalation_command`) funnel through.
+
+
+def conventional_branch_patterns(issue: int) -> list[str]:
+    """The ``fnmatch`` glob(s) for *issue*'s conventional branch name(s)
+    (#2377) — the two shapes this repo's own dispatch convention and
+    `docs/ORACLE_LOOP.md` name, and deliberately ONLY these two (#2377 scopes
+    a third naming scheme to "add one when one is actually observed to need
+    it", not guessed ahead of time):
+
+    * ``issue-<n>-*`` — a plain ``type=work`` dispatch's branch. Globbed
+      because the suffix is a free-text, worker/dispatch-chosen slug (e.g.
+      this very issue's own branch, ``issue-2377-drive-queue-reliability-
+      a-blocked-entry``) that a caller checking a drive-queue row has no way
+      to predict ahead of time.
+    * ``test-author-ms-*-slice-<n>`` — an oracle-loop JIT acceptance-author
+      slice (`coord/test_author.py`'s ``target_branch``). Globbed on the
+      milestone number for the same reason: a blocked/failed QUEUE entry
+      does not reliably carry which epic/milestone its issue belongs to
+      without a live GitHub read of its own.
+    """
+    return [f"issue-{issue}-*", f"test-author-ms-*-slice-{issue}"]
+
+
+@dataclass(frozen=True)
+class ExistingPrMatch:
+    """An OPEN PR found on one of *issue*'s conventional branch names
+    (#2377), already resolved to a go/no-go CI verdict by the caller that
+    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.
+    """
+
+    number: int
+    branch: str
+    url: str
+    all_green: bool
+
+
+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.
+    """
+    if match is None:
+        return None
+    key = entry_key(repo, issue)
+    if match.all_green:
+        return {
+            "label": "Merge existing PR",
+            "command_or_action": f"coord merge --only {key}",
+            "what_happens": (
+                f"PR #{match.number} ({match.branch}) already carries this "
+                "work with every check green — merge it instead of "
+                "relaunching a fresh drive over it."
+            ),
+        }
+    return {
+        "label": "Inspect existing PR",
+        "command_or_action": merge_plan_inspect_command(repo),
+        "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."
+        ),
+    }
+
+
 # ── `add`-time preflight (#2339) ─────────────────────────────────────────────
 
 #: Board statuses a queue attempt can never move on its own — every launch

{code_coordinator-0.5.565 → code_coordinator-0.5.566}/coord/github_ops.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import base64
+import fnmatch
 import json
 import re
 import socket
@@ -2345,6 +2346,58 @@ def find_pr_for_branch(repo: str, branch: str) -> dict | None:
     return items[0] if items else None
 
 
+def find_open_pr_for_branch_patterns(repo: str, patterns: Sequence[str]) -> dict | None:
+    """Return the first OPEN, non-draft PR on *repo* whose head branch
+    matches one of *patterns* (``fnmatch`` globs), or ``None`` when none
+    match or ``gh`` fails (#2377).
+
+    Unlike :func:`find_pr_for_branch` (an exact ``gh pr list --head
+    <branch>`` match), the caller here does not know the exact branch name
+    ahead of time — only its conventional SHAPE (see
+    `coord.drive_queue.conventional_branch_patterns`), since a worker's real
+    branch carries a free-text descriptive suffix a caller cannot predict.
+    This lists every OPEN PR once and matches client-side instead.
+
+    Draft PRs are skipped: a draft matching the conventional branch pattern
+    with green checks is not a valid "don't relaunch, merge this instead"
+    answer, since `coord merge --only <n>` cannot merge a draft — surfacing
+    one here would just trade a safe relaunch refusal for a dead-end one.
+
+    Capped at 200 open PRs with no further paging — a repo with more than
+    200 concurrently open PRs would silently read a true match past the
+    limit as "not found" (the same fail-open posture as everything else
+    here: a missed match costs a wasted relaunch, not a wrong block).
+
+    Fail-open like every other read in this module: a transient ``gh``
+    error returns ``None`` — "no match found" — the same answer a caller
+    gets when no PR actually exists. Both degrade to the caller's existing
+    "nothing found, proceed" default, which is the deliberately safe
+    posture here: a false negative (missed an existing PR) costs an
+    operator a wasted relaunch; a false block on a healthy queue would be
+    strictly worse.
+    """
+    try:
+        raw = _gh(
+            "pr", "list", "--repo", repo, "--state", "open",
+            "--json", "number,headRefName,url,isDraft", "--limit", "200",
+            caller="github_ops.find_open_pr_for_branch_patterns",
+        )
+    except RuntimeError:
+        return None
+    prs = _json_loads_or(raw, default=[])
+    if not isinstance(prs, list):
+        return None
+    for pr in prs:
+        if not isinstance(pr, dict):
+            continue
+        if pr.get("isDraft"):
+            continue
+        branch = str(pr.get("headRefName") or "")
+        if branch and any(fnmatch.fnmatch(branch, pattern) for pattern in patterns):
+            return pr
+    return None
+
+
 def get_pr_state_for_branch(repo: str, branch: str) -> str | None:
     """Return the current lifecycle state (``OPEN``/``MERGED``/``CLOSED``) of
     the PR whose head is *branch*, or ``None`` when no such PR exists (or

{code_coordinator-0.5.565 → code_coordinator-0.5.566}/tests/conftest.py

@@ -515,6 +515,36 @@ def _no_live_tmux_driver_probe(monkeypatch):
     monkeypatch.setattr("coord.drive.tmux_session_alive", lambda *a, **k: False)
 
 
+@pytest.fixture(autouse=True)
+def _no_existing_pr_match(monkeypatch):
+    """#2377: default ``coord.commands.drive_queue._existing_pr_match`` to
+    "no PR found" instead of shelling out to a real ``gh pr list``.
+
+    ``coord drive-queue add`` (and the tick's blocked/oscillating escalation
+    writer) now checks GitHub for an OPEN PR on the entry's conventional
+    branch name before proposing a relaunch. Left unmocked, a test whose
+    fixture ALSO replaces ``coord.commands.drive_queue.subprocess.run`` (the
+    ``launches`` fixture in ``tests/test_cli_drive_queue.py`` and its
+    siblings — one process-wide symbol, so it sees every subprocess call the
+    module makes, not just a drive launch) would route this new `gh pr list`
+    call through the real ``coord.github_ops._gh`` (per ``_no_live_gh``
+    above: once a test mocks the subprocess boundary, the real `_gh` body
+    runs against THAT mock) and the resulting ``["gh", "pr", "list", ...]``
+    argv would land in the SAME captured-launches list those tests assert is
+    `coord drive --tmux` argv only — the exact #2839 hazard
+    ``_default_pipeline_labels`` (see ``tests/test_cli_drive_queue.py``)
+    already guards for `apply_issue_labels`'s own `gh issue` calls.
+
+    A test that wants to exercise the real check monkeypatches this back
+    explicitly — its own ``monkeypatch.setattr`` call runs after this
+    fixture's, so it wins — exactly as the #2377 tests in
+    ``tests/test_cli_drive_queue.py`` do.
+    """
+    monkeypatch.setattr(
+        "coord.commands.drive_queue._existing_pr_match", lambda *a, **k: None
+    )
+
+
 @pytest.fixture(autouse=True)
 def _interactive_stdin_is_tty(monkeypatch):
     """#2086: ``coord assign --interactive`` now refuses up front when