code-coordinator 0.5.258__tar.gz → 0.5.260__tar.gz

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.258
+Version: 0.5.260
 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.260/code_coordinator.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.260",
+  "distance": 0,
+  "node": "g573c17e8ef6c8019f91d8f409127e24e5e3224fd",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-08-28"
+}

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/coord/notify.py

@@ -3660,6 +3660,28 @@ def post_orphaned_review_findings(
     return posted_ids
 
 
+def _dispatch_board_pending_pr_opens(config: Config) -> None:
+    """Load the board, open PRs for any work-leg completions still missing
+    one, and save (#2844).
+
+    Runs BEFORE smoke/review dispatch so the ``pull_request`` CI run starts
+    the instant a work leg pushes its branch, overlapping the ~20-minute
+    smoke leg and the review leg instead of being serialised after both.
+    `dispatch_pending_pr_opens` (:mod:`coord.review`) is itself idempotent —
+    it always finds-or-creates via GitHub — so calling it every pass, even
+    after `dispatch_review` already opened the PR, only ever finds the
+    existing one. Mirrors :func:`_dispatch_board_pending_smoke` exactly, and
+    is safe to call even when the board file doesn't exist.
+    """
+    from coord.board_service import read_board, write_board
+    from coord.review import dispatch_pending_pr_opens
+
+    board = read_board()
+    opened = dispatch_pending_pr_opens(board, config)
+    if opened:
+        write_board(board)
+
+
 def _dispatch_board_pending_smoke(config: Config) -> None:
     """Load the board, dispatch any pending Test-stage smoke, and save.
 
@@ -4223,6 +4245,15 @@ def _run_drain_locked(config: Config) -> DrainResult:
     except Exception:  # noqa: BLE001
         log.exception("notify drain: stuck test_state sweep failed")
 
+    # Step 2.5 (#2844): open PRs for work-leg completions still missing one —
+    # BEFORE the Test-stage dispatch below, so the pull_request CI run starts
+    # overlapping smoke instead of waiting for review dispatch to open the
+    # PR ~20 minutes later.
+    try:
+        _dispatch_board_pending_pr_opens(config)
+    except Exception:  # noqa: BLE001
+        log.exception("notify drain: PR-open dispatch failed")
+
     # Step 3: dispatch pending Test-stage smoke (#1426).  Runs BEFORE review
     # dispatch to mirror the pipeline's Work -> Test -> Review order.
     try:
@@ -4524,6 +4555,13 @@ def run(
     # dispatch — skipped while `_roll_pending` is true, same posture the
     # drive-queue tick takes under a pending roll.
     if not _roll_pending:
+        # #2844: open PRs for work-leg completions still missing one, before
+        # smoke/review dispatch — see _dispatch_board_pending_pr_opens.
+        try:
+            _dispatch_board_pending_pr_opens(config)
+        except Exception:  # noqa: BLE001
+            pass
+
         try:
             _dispatch_board_pending_smoke(config)
         except Exception:  # noqa: BLE001

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/coord/reconcile.py

@@ -2226,6 +2226,17 @@ def reconcile(board: Board, config: Config) -> list[str]:
                 _escalate_spend_ceiling_best_effort(a, entry)
         changed.append(a.assignment_id)
 
+    # Open PRs for completed work-like assignments still missing one (#2844).
+    # Runs BEFORE smoke/review dispatch below so the pull_request CI run
+    # starts overlapping the smoke leg instead of waiting for review dispatch
+    # to open the PR itself once smoke finishes. Idempotent — see
+    # dispatch_pending_pr_opens's docstring.
+    from coord.review import dispatch_pending_pr_opens
+
+    for opened in dispatch_pending_pr_opens(board, config):
+        if opened.assignment_id is not None:
+            changed.append(opened.assignment_id)
+
     # Dispatch pending reviews for all completed work assignments.
     # We iterate board.completed (not just newly-done) so that a failed
     # dispatch on a previous reconcile pass is retried here automatically.

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/coord/review.py

@@ -14,6 +14,10 @@ Public entry points:
 - `dispatch_review(...)`        — full path: find/open PR, pick reviewer,
   build briefing, send to agent server, add a review `Assignment` to the
   board. Called from reconcile when a work assignment transitions to done.
+- `dispatch_pending_pr_opens(...)` — #2844: open a PR the instant a work leg
+  pushes its branch, rather than waiting for `dispatch_review` to do it once
+  the Test/smoke leg finishes — lets the `pull_request` CI run overlap smoke
+  and review instead of being serialised after both.
 
 Why a separate module: the work-dispatch path (`coord/dispatch.py`) is shaped
 around `Proposal` objects from the brain. Reviews are triggered by completion
@@ -1869,6 +1873,177 @@ def _find_or_open_pr(
         return None
 
 
+def _resolve_pr_base_branch(
+    completed: Assignment,
+    repo,
+    *,
+    milestone_fetcher=None,
+) -> str:
+    """Resolve the PR base branch for `completed` (#1077's develop_branch /
+    milestone routing).
+
+    Shared by :func:`dispatch_review` and :func:`dispatch_pending_pr_opens`
+    (#2844) so an early PR-open and the later review dispatch always agree
+    on the base — opening against the wrong base would surface as a PR that
+    `find_pr_for_branch` still finds, but whose diff nobody intended.
+    """
+    base_branch = repo.default_branch
+    if getattr(repo, "develop_branch", None):
+        from coord.branch_model import resolve_base_branch  # noqa: PLC0415
+
+        fetch_milestone = milestone_fetcher or _fetch_issue_milestone_number
+        milestone_number = fetch_milestone(repo.github, completed.issue_number)
+        base_branch = resolve_base_branch(repo, milestone_number)
+    return base_branch
+
+
+def open_pr_for_completed_work(
+    completed: Assignment,
+    config: Config,
+    *,
+    pr_lookup=_find_or_open_pr,
+    milestone_fetcher=None,
+    commits_ahead_checker=None,
+) -> dict | None:
+    """Open (or find) the PR for `completed` as soon as its branch is pushed
+    (#2844), instead of waiting until review dispatch — which itself waits
+    for the Test/smoke leg to finish, ~20 minutes later.
+
+    Opening this early is what lets GitHub's ``pull_request`` CI run overlap
+    the smoke leg and the review leg instead of being serialised after both
+    — the ~25-minute median dead time #2844 measured across 8 issues.
+
+    Returns the ``{number, url, existed}`` dict `pr_lookup` (default
+    :func:`_find_or_open_pr`) returns, or ``None`` when a PR should not be
+    opened yet: no repo config, no branch, the branch has 0 commits ahead of
+    its base (#1534's zero-commit gate, applied here too so an empty branch
+    never gets a PR), or `pr_lookup` itself fails.
+
+    Stores the resulting URL on ``completed.pr_url`` as a side effect, purely
+    so a caller scanning the board can skip a row without a fresh GitHub
+    round-trip (see :func:`dispatch_pending_pr_opens`). This is advisory
+    only: `dispatch_review`'s own `pr_lookup` call and the merge phase's
+    `create_pr` both re-resolve the PR from GitHub
+    (``github_ops.find_pr_for_branch``) rather than trusting a cached field,
+    so a stale or missing ``pr_url`` here can never cause a duplicate PR —
+    it can only cost one redundant lookup.
+    """
+    repo = config.repo(completed.repo_name)
+    if repo is None or not completed.branch:
+        return None
+
+    base_branch = _resolve_pr_base_branch(
+        completed, repo, milestone_fetcher=milestone_fetcher
+    )
+
+    # #1534: same zero-commit gate `dispatch_review` applies — never open a
+    # PR for a branch that (as far as GitHub can confirm) carries no commits
+    # over its base. Fail-open: `commits_ahead_checker` returns `None` (never
+    # a bare 0) on any lookup failure, so a transient `gh` blip can't block a
+    # legitimate early PR-open.
+    _ahead_check = commits_ahead_checker or github_ops.branch_commits_ahead
+    _ahead = _ahead_check(repo.github, base_branch, completed.branch)
+    if _ahead == 0:
+        return None
+
+    try:
+        pr = pr_lookup(
+            repo.github,
+            branch=completed.branch,
+            default_branch=base_branch,
+            issue_number=completed.issue_number,
+            issue_title=completed.issue_title,
+            assignment_type=completed.type,
+        )
+    except Exception:  # noqa: BLE001 — best-effort; dispatch_review retries later
+        log.warning(
+            "[pr-open] %s: pr_lookup raised opening/finding a PR for branch "
+            "%r — will retry from dispatch_review or the next pass",
+            completed.assignment_id, completed.branch, exc_info=True,
+        )
+        return None
+
+    if pr:
+        completed.pr_url = pr.get("url")
+    return pr
+
+
+def dispatch_pending_pr_opens(
+    board: Board,
+    config: Config,
+    *,
+    pr_lookup=_find_or_open_pr,
+    milestone_fetcher=None,
+    commits_ahead_checker=None,
+) -> list[Assignment]:
+    """Bulk PR-open pass (#2844) — open a PR the instant a work leg pushes a
+    branch, rather than waiting for review dispatch to do it after the
+    Test/smoke leg finishes.
+
+    Scans `board.completed` for work-like rows that are ``status="done"``
+    (a work leg that never reaches "done" never appears here, so a failed
+    work leg can never leave an orphan PR open — #2844's "failed work legs"
+    requirement), carry a branch, and have no `pr_url` recorded yet. Both
+    `reconcile()` and `coord notify` are expected to route through here every
+    pass — the same bulk-choke-point shape as
+    :func:`coord.smoke.dispatch_pending_smoke` and
+    :func:`dispatch_pending_reviews` — so a row missed on an earlier pass (no
+    repo config yet, a transient `gh` failure) is retried automatically.
+
+    Gated on ``reviews.enabled``/``reviews.auto_dispatch``: this path exists
+    solely to feed `dispatch_review`'s own PR lookup earlier, so when reviews
+    are off there is no reason to open a PR ahead of anything.
+
+    Idempotent by construction: `pr_lookup` (`_find_or_open_pr`) always
+    checks `find_pr_for_branch` before creating, and both `dispatch_review`
+    and the merge phase's `create_pr` do the same — so calling this every
+    tick, including after review dispatch already opened the PR itself, only
+    ever finds the existing one.
+
+    Returns the `completed` `Assignment`s a PR was opened/found for this
+    pass. The caller is responsible for persisting the board (only `pr_url`
+    is mutated on `board`-owned rows).
+    """
+    if not (config.reviews.enabled and config.reviews.auto_dispatch):
+        return []
+
+    opened: list[Assignment] = []
+    for completed in board.completed:
+        if completed.type not in WORK_LIKE_TYPES:
+            continue
+        if completed.status != "done":
+            continue
+        if not completed.branch:
+            continue
+        if completed.pr_url:
+            continue
+        repo = config.repo(completed.repo_name)
+        if repo is None:
+            continue
+        # #522-style chokepoint: never open a PR for work GitHub already
+        # considers finished (issue closed / a PR already merged) — mirrors
+        # dispatch_review's own terminal check so a stray late pass can't
+        # reopen a PR against dead work.
+        if github_ops.work_is_terminal(
+            repo.github,
+            completed.issue_number,
+            completed.branch,
+            trust_issue_closed=trust_issue_closed_for(completed.type),
+        ):
+            continue
+        pr = open_pr_for_completed_work(
+            completed,
+            config,
+            pr_lookup=pr_lookup,
+            milestone_fetcher=milestone_fetcher,
+            commits_ahead_checker=commits_ahead_checker,
+        )
+        if pr:
+            opened.append(completed)
+
+    return opened
+
+
 def _fetch_agent_advertised_repos(
     host: str,
     port: int = AGENT_PORT,
@@ -2101,13 +2276,9 @@ def dispatch_review(
     # `branch` payload field below, so they never disagree. The milestone
     # lookup itself is skipped entirely (no `gh` call) when the repo hasn't
     # opted in — a non-opted-in repo pays zero extra cost.
-    base_branch = repo.default_branch
-    if getattr(repo, "develop_branch", None):
-        from coord.branch_model import resolve_base_branch  # noqa: PLC0415
-
-        fetch_milestone = milestone_fetcher or _fetch_issue_milestone_number
-        milestone_number = fetch_milestone(repo.github, completed.issue_number)
-        base_branch = resolve_base_branch(repo, milestone_number)
+    base_branch = _resolve_pr_base_branch(
+        completed, repo, milestone_fetcher=milestone_fetcher
+    )
 
     # #1534: ZERO-COMMIT GATE.  Refuse to spend a metered review on a branch
     # that carries no commits over its base — there is literally nothing to

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/coord/test_orchestrator.py

@@ -293,9 +293,12 @@ def local_machine(config: Config) -> Machine | None:
     don't have to re-derive the match. Returns ``None`` when this host isn't
     a recognized machine in ``coordinator.yml``.
     """
-    local_hostname = socket.gethostname().split(".")[0]
+    local_hostname = socket.gethostname().split(".")[0].lower()
     for machine in config.machines:
-        if machine.name == local_hostname or machine.host.split(".")[0] == local_hostname:
+        if (
+            machine.name.lower() == local_hostname
+            or machine.host.split(".")[0].lower() == local_hostname
+        ):
             return machine
     return None
 

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/tests/test_review.py

@@ -2920,6 +2920,216 @@ def test_dispatch_review_passes_assignment_type_to_pr_lookup(
     assert captured.get("assignment_type") == "mock-author"
 
 
+# ── open_pr_for_completed_work / dispatch_pending_pr_opens (#2844) ──────────
+#
+# #2844: the PR used to open at review-dispatch time — after the ~20-minute
+# smoke leg finished — serialising CI onto the end of the pipeline instead of
+# overlapping it. These cover the new early-open path that fires the moment
+# a work leg pushes its branch.
+
+
+def test_open_pr_for_completed_work_opens_immediately_after_work_done(
+    two_machine_config: Config,
+) -> None:
+    """A `status="done"` work row with a branch gets its PR opened right
+    away — not gated on any test/review state — and the URL is cached on
+    the assignment."""
+    from coord.review import open_pr_for_completed_work
+
+    completed = _completed_assignment()
+    calls: list[dict] = []
+
+    def _pr_lookup(repo_github, **kw):
+        calls.append(kw)
+        return {"number": 7, "url": "https://github.com/acme/api/pull/7", "existed": False}
+
+    pr = open_pr_for_completed_work(
+        completed, two_machine_config,
+        pr_lookup=_pr_lookup,
+        commits_ahead_checker=lambda repo, base, branch: 3,
+    )
+
+    assert pr == {"number": 7, "url": "https://github.com/acme/api/pull/7", "existed": False}
+    assert completed.pr_url == "https://github.com/acme/api/pull/7"
+    assert len(calls) == 1
+    assert calls[0]["branch"] == "issue-1-fix"
+    assert calls[0]["assignment_type"] == "work"
+
+
+def test_open_pr_for_completed_work_skips_zero_commit_branch(
+    two_machine_config: Config,
+) -> None:
+    """#1534's zero-commit gate applies to the early open too — an empty
+    branch must never get a PR, early or late."""
+    from coord.review import open_pr_for_completed_work
+
+    completed = _completed_assignment()
+    calls: list[dict] = []
+
+    def _pr_lookup(repo_github, **kw):
+        calls.append(kw)
+        return {"number": 7, "url": "u", "existed": False}
+
+    pr = open_pr_for_completed_work(
+        completed, two_machine_config,
+        pr_lookup=_pr_lookup,
+        commits_ahead_checker=lambda repo, base, branch: 0,
+    )
+
+    assert pr is None
+    assert completed.pr_url is None
+    assert calls == []
+
+
+def test_dispatch_pending_pr_opens_opens_for_done_work_with_branch(
+    two_machine_config: Config,
+) -> None:
+    """The bulk pass finds every eligible done/work-like/branched row and
+    opens (or finds) a PR for each, recording pr_url on the row."""
+    from coord.review import dispatch_pending_pr_opens
+
+    completed = _completed_assignment()
+    board = Board(completed=[completed])
+
+    def _pr_lookup(repo_github, **kw):
+        return {"number": 9, "url": "https://github.com/acme/api/pull/9", "existed": False}
+
+    opened = dispatch_pending_pr_opens(
+        board, two_machine_config,
+        pr_lookup=_pr_lookup,
+        commits_ahead_checker=lambda repo, base, branch: 1,
+    )
+
+    assert opened == [completed]
+    assert completed.pr_url == "https://github.com/acme/api/pull/9"
+
+
+def test_dispatch_pending_pr_opens_skips_rows_that_already_have_a_pr(
+    two_machine_config: Config,
+) -> None:
+    """A row that already carries pr_url is skipped — no redundant lookup."""
+    from coord.review import dispatch_pending_pr_opens
+
+    completed = replace(_completed_assignment(), pr_url="https://github.com/acme/api/pull/1")
+    board = Board(completed=[completed])
+    calls = {"n": 0}
+
+    def _pr_lookup(repo_github, **kw):
+        calls["n"] += 1
+        return {"number": 1, "url": "u", "existed": True}
+
+    opened = dispatch_pending_pr_opens(board, two_machine_config, pr_lookup=_pr_lookup)
+
+    assert opened == []
+    assert calls["n"] == 0
+
+
+def test_dispatch_pending_pr_opens_skips_failed_and_non_done_rows(
+    two_machine_config: Config,
+) -> None:
+    """A failed work leg must never get an early-opened orphan PR (#2844's
+    'failed work legs' requirement) — only status='done' rows qualify."""
+    from coord.review import dispatch_pending_pr_opens
+
+    failed = replace(_completed_assignment(), status="failed")
+    running_like = replace(_completed_assignment(), status="running")
+    no_branch = replace(_completed_assignment(), branch=None)
+    board = Board(completed=[failed, running_like, no_branch])
+    calls = {"n": 0}
+
+    def _pr_lookup(repo_github, **kw):
+        calls["n"] += 1
+        return {"number": 1, "url": "u", "existed": True}
+
+    opened = dispatch_pending_pr_opens(board, two_machine_config, pr_lookup=_pr_lookup)
+
+    assert opened == []
+    assert calls["n"] == 0
+
+
+def test_dispatch_pending_pr_opens_skips_terminal_rows(
+    two_machine_config: Config, monkeypatch,
+) -> None:
+    """#522-style chokepoint: never open a PR for work GitHub already
+    considers finished (issue closed / PR merged)."""
+    from coord.review import dispatch_pending_pr_opens
+
+    monkeypatch.setattr("coord.github_ops.work_is_terminal", lambda *a, **k: True)
+    completed = _completed_assignment()
+    board = Board(completed=[completed])
+    calls = {"n": 0}
+
+    def _pr_lookup(repo_github, **kw):
+        calls["n"] += 1
+        return {"number": 1, "url": "u", "existed": True}
+
+    opened = dispatch_pending_pr_opens(board, two_machine_config, pr_lookup=_pr_lookup)
+
+    assert opened == []
+    assert calls["n"] == 0
+
+
+def test_dispatch_pending_pr_opens_off_when_reviews_disabled(repo: Repo) -> None:
+    """Gated on reviews.enabled/auto_dispatch — this path exists purely to
+    feed dispatch_review's own PR lookup earlier, so it's a no-op when
+    reviews are off entirely."""
+    from coord.review import dispatch_pending_pr_opens
+
+    cfg = Config(
+        repos=[repo],
+        machines=[],
+        reviews=ReviewsConfig(enabled=False, auto_dispatch=False),
+    )
+    completed = _completed_assignment()
+    board = Board(completed=[completed])
+    calls = {"n": 0}
+
+    def _pr_lookup(repo_github, **kw):
+        calls["n"] += 1
+        return {"number": 1, "url": "u", "existed": True}
+
+    opened = dispatch_pending_pr_opens(board, cfg, pr_lookup=_pr_lookup)
+
+    assert opened == []
+    assert calls["n"] == 0
+
+
+def test_dispatch_pending_pr_opens_is_idempotent_with_dispatch_review(
+    two_machine_config: Config,
+) -> None:
+    """Opening early and then reaching dispatch_review later must not create
+    a second PR — both look the branch up fresh and get the same one back."""
+    from coord.review import dispatch_pending_pr_opens
+
+    completed = replace(_completed_assignment(), review_state="pending")
+    board = Board(completed=[completed])
+    create_calls = {"n": 0}
+
+    def _find_or_create(repo_github, **kw):
+        # Simulate GitHub: first call creates, every later call finds it.
+        create_calls["n"] += 1
+        existed = create_calls["n"] > 1
+        return {"number": 123, "url": "https://github.com/acme/api/pull/123", "existed": existed}
+
+    opened = dispatch_pending_pr_opens(
+        board, two_machine_config, pr_lookup=_find_or_create,
+    )
+    assert opened == [completed]
+    assert create_calls["n"] == 1
+
+    result = dispatch_review(
+        completed, board, two_machine_config,
+        http_client=_FakeHTTPClient({"id": "review-id-late"}),
+        pr_lookup=_find_or_create,
+        claude_md_reader=lambda p: None,
+        issue_body_fetcher=lambda repo, num: "",
+        remote_branch_checker=lambda repo, branch: True,
+    )
+
+    assert result is not None
+    assert create_calls["n"] == 2, "dispatch_review must reuse the same PR, not create a new one"
+
+
 # ── Reviewer system prompt ──────────────────────────────────────────────────
 
 

{code_coordinator-0.5.258 → code_coordinator-0.5.260}/tests/test_test_orchestrator.py

@@ -635,6 +635,29 @@ class TestLocalMachine:
         monkeypatch.setattr("socket.gethostname", lambda: "nowhere")
         assert local_machine(self._config()) is None
 
+    def test_matches_by_machine_name_case_insensitively(self, monkeypatch) -> None:
+        # #2860: OS hostnames commonly carry capitals (e.g. an Ubuntu install
+        # named "john-HP-EliteBook-830-G7-Notebook-PC") while coordinator.yml
+        # conventionally lowercases `name`/`host` -- the match must not care.
+        monkeypatch.setattr("socket.gethostname", lambda: "LAPTOP")
+        cfg = self._config()
+        machine = local_machine(cfg)
+        assert machine is not None
+        assert machine.name == "laptop"
+
+    def test_matches_by_host_prefix_case_insensitively_with_fqdn(self, monkeypatch) -> None:
+        monkeypatch.setattr("socket.gethostname", lambda: "SERVER.Tail.TS.Net")
+        cfg = self._config()
+        machine = local_machine(cfg)
+        assert machine is not None
+        assert machine.name == "server"
+
+    def test_unlisted_hostname_still_returns_none(self, monkeypatch) -> None:
+        # A genuinely unrecognized hostname must keep failing closed even
+        # after casefolding both sides.
+        monkeypatch.setattr("socket.gethostname", lambda: "SOME-OTHER-BOX")
+        assert local_machine(self._config()) is None
+
     def test_find_local_repo_path_still_prefers_matching_machine(self, monkeypatch) -> None:
         # Regression: local_machine() extraction must not change
         # find_local_repo_path's existing preference behavior.

code_coordinator-0.5.258/code_coordinator.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.5.258",
-  "distance": 0,
-  "node": "gef4810f9d5759ef0c6af207cb768d16498aae9f4",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-27"
-}