code-coordinator 0.5.114__tar.gz → 0.5.115__tar.gz

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.114",
+  "tag": "0.5.115",
   "distance": 0,
-  "node": "g3415bd29a5ed645fb1b607710d503c75830b4bfc",
+  "node": "g28e36b1a94feb56072af2832c5a0025e5b6ffa90",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-16"

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/coord/commands/dispatch.py

@@ -1873,18 +1873,35 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
         # an independent inline copy of the same "branch empty → 0, repo
         # missing → None, else ask GitHub" logic.
         ahead = github_ops.branch_commits_ahead_for_assignment(assignment, cfg)
-        if ahead != 0:
-            detail = (
-                "its commit count could not be confirmed (gh lookup failed)"
-                if ahead is None
-                else f"{ahead} commit(s) present on its branch"
+        if ahead is None:
+            # #2324: a genuine lookup failure (network error, auth, rate
+            # limit, repo missing) is NOT evidence that commits exist — it's
+            # just an unanswered question. Don't assert the #1357
+            # false-positive shape or point at `--accept-advisory`, which
+            # assumes real commits are sitting on the branch; nothing here
+            # established that. Say the lookup failed and name what to
+            # check instead. (A confirmed 404 on the head branch is handled
+            # above this `is None` check — `branch_commits_ahead_for_assignment`
+            # reads that as 0, not None.)
+            click.echo(
+                f"error: assignment {assignment_id} is 'advisory', and its "
+                "commit count could not be confirmed (gh lookup failed) — "
+                "coord retry only re-dispatches a GENUINE zero-commit "
+                "advisory, and a failed lookup isn't confirmation either "
+                "way. Check `gh api` access and the recorded branch/repo, "
+                "then retry; or inspect by hand: coord log "
+                f"{assignment_id}.",
+                err=True,
             )
+            sys.exit(1)
+        if ahead != 0:
             click.echo(
-                f"error: assignment {assignment_id} is 'advisory', and {detail} "
-                "— coord retry only re-dispatches a GENUINE zero-commit "
-                "advisory. This looks like the #1357 false-positive "
-                "signature instead; use `coord drive --accept-advisory` to "
-                "proceed with the existing commits, or inspect by hand.",
+                f"error: assignment {assignment_id} is 'advisory', and "
+                f"{ahead} commit(s) are present on its branch — coord retry "
+                "only re-dispatches a GENUINE zero-commit advisory. This is "
+                "the #1357 false-positive signature instead; use `coord "
+                "drive --accept-advisory` to proceed with the existing "
+                "commits, or inspect by hand.",
                 err=True,
             )
             sys.exit(1)

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/coord/diagnose.py

@@ -1069,6 +1069,12 @@ def _work_advisory_commits_ahead(assignment: "Assignment", config: "Config") ->
     zero-commit gate uses) rather than a local git checkout — `coord
     diagnose` runs on the daemon host, which has no guarantee of a local
     clone of every worker's branch.
+
+    #2324: ``None`` here means the lookup genuinely couldn't be confirmed
+    (network/auth/rate-limit/repo-missing) — a head branch GitHub positively
+    404s, with the base branch still resolving, comes back as ``0`` instead
+    (see :func:`coord.github_ops.branch_commits_ahead`), since a deleted
+    branch is proof nothing was pushed, not an unknown.
     """
     from coord import github_ops  # noqa: PLC0415
 

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/coord/github_ops.py

@@ -1775,6 +1775,58 @@ def get_compare_files(repo: str, base: str, head: str) -> list[str] | None:
     return [line for line in (ln.strip() for ln in raw.splitlines()) if line]
 
 
+def _gh_ref_confirmed_missing(exc: Exception) -> bool:
+    """True when *exc* (raised by ``_gh`` for a ``gh api`` ref/compare call)
+    is GitHub positively saying "no such ref" — a 404 — as opposed to an
+    auth, rate-limit, network, or other transient failure that merely looks
+    like one from the caller's point of view.
+
+    #2324: deliberately narrower than the "http 4" match
+    :func:`branch_exists_on_remote` uses (which folds 401/403/429 in with
+    404, and fails open elsewhere for that function's own reasons). This is
+    the one call site where conflating "confirmed gone" with "auth/rate-limit
+    blip" would make `coord retry`'s zero-commit gate treat a locked-out
+    ``gh`` as proof a branch was deleted and race ahead re-dispatching real,
+    unconfirmed work — so it checks :func:`_is_transient_error`'s keywords
+    first and only then looks for an explicit "404"/"not found" signal.
+    """
+    if _is_transient_error(exc):
+        return False
+    msg = str(exc).lower()
+    return "404" in msg or "not found" in msg
+
+
+def _head_branch_confirmed_deleted(repo: str, base: str, branch: str) -> bool:
+    """True when *branch* 404s on *repo* while *base* still resolves.
+
+    #2324: :func:`branch_commits_ahead`'s three-dot compare call 404s
+    identically whether it's the head branch that's gone, the base branch,
+    or something else entirely obscures both — the compare error text alone
+    can't tell them apart. This asks each ref directly (the same
+    ``git/refs/heads`` lookup :func:`branch_exists_on_remote` uses) so a
+    branch that was genuinely deleted — the normal cleanup after a
+    zero-commit worker exit — reads as "confirmed gone" instead of being
+    lumped in with an unrelated failure and reported as unknown.
+
+    Only returns True on the one shape that's actually conclusive: the head
+    ref 404s (via :func:`_gh_ref_confirmed_missing`) *and* the base ref
+    still resolves. Any other combination — head resolves fine, head lookup
+    itself fails inconclusively, or base can't be confirmed either — returns
+    False so the caller keeps its existing fail-closed ``None``.
+    """
+    try:
+        _gh("api", f"repos/{repo}/git/refs/heads/{branch}")
+        return False  # head resolves fine; compare failed for some other reason
+    except RuntimeError as exc:
+        if not _gh_ref_confirmed_missing(exc):
+            return False  # inconclusive — do not guess
+    try:
+        _gh("api", f"repos/{repo}/git/refs/heads/{base}")
+    except RuntimeError:
+        return False  # base itself unconfirmable — don't trust the read
+    return True  # head confirmed gone, base confirmed present
+
+
 def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
     """Commits *branch* is ahead of *base* on the remote, or ``None``.
 
@@ -1790,6 +1842,16 @@ def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
     real reviews.  This is the opposite polarity from
     :func:`branch_is_fully_merged`, which returns a plain ``False`` on error
     because *its* fail-safe direction is "keep the PR open".
+
+    #2324 exception: when the compare call fails, a *confirmed* 404 on the
+    head branch while the base branch still resolves
+    (:func:`_head_branch_confirmed_deleted`) returns ``0``, not ``None`` — a
+    head ref that GitHub positively says doesn't exist is the strongest
+    possible evidence nothing was ever pushed to it (a branch carrying
+    commits would still be there). Every other failure shape — the compare
+    call fails for a reason that isn't a confirmed head-branch 404, or the
+    follow-up ref checks themselves are inconclusive — keeps the existing
+    fail-closed ``None``.
     """
     if not branch or not base:
         return None
@@ -1799,6 +1861,8 @@ def branch_commits_ahead(repo: str, base: str, branch: str) -> int | None:
         raw = _gh("api", f"repos/{repo}/compare/{base}...{branch}")
         cmp = json.loads(raw)
     except Exception:  # noqa: BLE001 — unknown, not zero
+        if _head_branch_confirmed_deleted(repo, base, branch):
+            return 0
         return None
     if not isinstance(cmp, dict):
         return None
@@ -1832,7 +1896,11 @@ def branch_commits_ahead_for_assignment(assignment: Any, config: Any) -> int | N
     that ``config`` doesn't know about returns ``None`` ("cannot confirm"),
     never a bare 0, matching :func:`branch_commits_ahead`'s own fail-closed
     polarity: an unconfirmable commit count must never be silently read as
-    "empty branch, safe to touch".
+    "empty branch, safe to touch" — *except* the one case
+    :func:`branch_commits_ahead` itself carves out (#2324): a recorded
+    branch whose head ref GitHub positively 404s, with the base branch still
+    resolving, comes back as 0 rather than ``None`` — a deleted branch
+    proves nothing was pushed at least as conclusively as a blank one does.
     """
     branch = (getattr(assignment, "branch", None) or "").strip()
     if not branch:

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/tests/test_diagnose.py

@@ -1651,6 +1651,43 @@ def test_zero_commit_advisory_is_not_reported_healthy(monkeypatch, config) -> No
     assert res.recovered is False
 
 
+def test_zero_commit_advisory_with_deleted_branch_is_not_reported_healthy(
+    monkeypatch, config
+) -> None:
+    """#2324: space-invaders#1's exact shape — a genuine zero-commit
+    advisory whose branch has already been deleted. Unlike the other tests
+    in this section, `_work_advisory_commits_ahead` is deliberately NOT
+    stubbed here — this exercises the real call into
+    `github_ops.branch_commits_ahead_for_assignment`, mocking only `gh`
+    itself, to prove the full chain (not just the diagnose-side branching)
+    reads a confirmed-404 head branch as 0, not None. Before #2324 this
+    reported "could not be confirmed" and steered toward `coord drive
+    --accept-advisory`, which assumes commits exist."""
+    _stub(monkeypatch, session="dead")
+
+    def _gh_dispatch(*args, **kwargs):
+        path = args[1] if len(args) > 1 else ""
+        if path == "repos/acme/api/compare/main...issue-42-deleted":
+            raise RuntimeError("gh: Not Found (HTTP 404)")
+        if path == "repos/acme/api/git/refs/heads/issue-42-deleted":
+            raise RuntimeError("gh: Not Found (HTTP 404)")
+        if path == "repos/acme/api/git/refs/heads/main":
+            return "{}"
+        raise AssertionError(f"unexpected _gh call: {args!r}")
+
+    monkeypatch.setattr("coord.github_ops._gh", _gh_dispatch)
+
+    a = _assign(aid="w-advisory-deleted", status="advisory", branch="issue-42-deleted")
+    board = Board(completed=[a])
+    res = diagnose.diagnose_stage(board, config, "api", 42, "work")
+
+    assert not any("looks healthy" in f for f in res.findings), res.findings
+    assert not any("could not be confirmed" in f for f in res.findings), res.findings
+    assert any("0 commits" in f for f in res.findings), res.findings
+    assert any("coord retry w-advisory-deleted" in f for f in res.findings), res.findings
+    assert res.recovered is False
+
+
 def test_zero_commit_advisory_on_a_plan_row_is_not_reported_healthy(
     monkeypatch, config
 ) -> None:

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/tests/test_github_ops.py

@@ -1277,6 +1277,167 @@ class TestComputePatchId:
             assert github_ops.compute_patch_id(_unified_diff("hello")) is None
 
 
+def _gh_ref_dispatch(repo: str, base: str, branch: str, *, head_error=None, base_error=None):
+    """Build a ``_gh`` ``side_effect`` for :func:`branch_commits_ahead`'s
+    #2324 fallback path: the initial ``compare`` call always fails (the
+    caller supplies that via a separate ``side_effect``/``compare_error``),
+    and this answers the two follow-up ``git/refs/heads/<ref>`` lookups —
+    raising *head_error*/*base_error* when given, succeeding otherwise.
+    """
+    head_path = f"repos/{repo}/git/refs/heads/{branch}"
+    base_path = f"repos/{repo}/git/refs/heads/{base}"
+
+    def _dispatch(*args, **kwargs):
+        path = args[1] if len(args) > 1 else ""
+        if path == head_path:
+            if head_error is not None:
+                raise head_error
+            return "{}"
+        if path == base_path:
+            if base_error is not None:
+                raise base_error
+            return "{}"
+        raise AssertionError(f"unexpected _gh call: {args!r}")
+
+    return _dispatch
+
+
+class TestGhRefConfirmedMissing:
+    """#2324: distinguishes a confirmed 404 (GitHub positively saying a ref
+    doesn't exist) from an auth/rate-limit/network failure that merely
+    looks like one — the exact conflation that made a deleted branch read
+    as "unconfirmed" instead of "confirmed empty"."""
+
+    def test_true_on_explicit_404(self) -> None:
+        assert github_ops._gh_ref_confirmed_missing(
+            RuntimeError("gh api branches: 404 not found")
+        ) is True
+
+    def test_true_on_not_found_message(self) -> None:
+        assert github_ops._gh_ref_confirmed_missing(
+            RuntimeError("gh: Not Found (HTTP 404)")
+        ) is True
+
+    def test_false_on_auth_failure(self) -> None:
+        assert github_ops._gh_ref_confirmed_missing(
+            RuntimeError("gh: HTTP 403: Bad credentials")
+        ) is False
+
+    def test_false_on_rate_limit(self) -> None:
+        assert github_ops._gh_ref_confirmed_missing(
+            RuntimeError("gh: API rate limit exceeded")
+        ) is False
+
+    def test_false_on_network_timeout(self) -> None:
+        assert github_ops._gh_ref_confirmed_missing(
+            RuntimeError("gh: connection timed out")
+        ) is False
+
+
+class TestBranchCommitsAhead:
+    """#2324: a compare-API failure that turns out to be a *confirmed* 404 on
+    the head branch — with the base branch still resolving — must read as 0
+    commits ahead, not None. A deleted branch is the strongest possible
+    evidence nothing was pushed; treating it as "unconfirmed" steered `coord
+    retry` toward refusing a genuine zero-commit advisory."""
+
+    def test_head_confirmed_deleted_base_resolves_is_zero(self) -> None:
+        repo, base, branch = "acme/api", "main", "issue-1-x"
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == f"repos/{repo}/compare/{base}...{branch}":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            return _gh_ref_dispatch(
+                repo, base, branch,
+                head_error=RuntimeError("gh: Not Found (HTTP 404)"),
+            )(*args, **kwargs)
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            assert github_ops.branch_commits_ahead(repo, base, branch) == 0
+
+    def test_head_resolves_fine_compare_failure_is_none(self) -> None:
+        """The compare call fails for some reason other than the head branch
+        being gone (e.g. a transient blip) — the head ref lookup itself
+        succeeds, so there is nothing to trust. Must stay None."""
+        repo, base, branch = "acme/api", "main", "issue-1-x"
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == f"repos/{repo}/compare/{base}...{branch}":
+                raise RuntimeError("gh: connection timed out")
+            return _gh_ref_dispatch(repo, base, branch)(*args, **kwargs)
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            assert github_ops.branch_commits_ahead(repo, base, branch) is None
+
+    def test_head_lookup_inconclusive_is_none(self) -> None:
+        """Compare fails, and the head-ref lookup fails too but for a
+        non-404 (auth/network) reason -- not a confirmed deletion, so this
+        must not be guessed as zero."""
+        repo, base, branch = "acme/api", "main", "issue-1-x"
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == f"repos/{repo}/compare/{base}...{branch}":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            return _gh_ref_dispatch(
+                repo, base, branch,
+                head_error=RuntimeError("gh: HTTP 403: Bad credentials"),
+            )(*args, **kwargs)
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            assert github_ops.branch_commits_ahead(repo, base, branch) is None
+
+    def test_head_deleted_but_base_unconfirmable_is_none(self) -> None:
+        """Head 404s, but the base ref itself can't be confirmed (e.g. the
+        whole repo is having an outage) — not the conclusive "head gone,
+        base fine" shape, so this must stay None rather than guess."""
+        repo, base, branch = "acme/api", "main", "issue-1-x"
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == f"repos/{repo}/compare/{base}...{branch}":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            return _gh_ref_dispatch(
+                repo, base, branch,
+                head_error=RuntimeError("gh: Not Found (HTTP 404)"),
+                base_error=RuntimeError("gh: connection timed out"),
+            )(*args, **kwargs)
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            assert github_ops.branch_commits_ahead(repo, base, branch) is None
+
+    def test_head_deleted_base_also_deleted_is_none(self) -> None:
+        """Both refs 404 -- e.g. the whole repo was renamed/deleted -- so
+        there is no confirmed base to compare against. Must not read as
+        zero."""
+        repo, base, branch = "acme/api", "main", "issue-1-x"
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == f"repos/{repo}/compare/{base}...{branch}":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            return _gh_ref_dispatch(
+                repo, base, branch,
+                head_error=RuntimeError("gh: Not Found (HTTP 404)"),
+                base_error=RuntimeError("gh: Not Found (HTTP 404)"),
+            )(*args, **kwargs)
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            assert github_ops.branch_commits_ahead(repo, base, branch) is None
+
+    def test_successful_compare_unaffected(self) -> None:
+        """The happy path (compare succeeds) never touches the new fallback
+        -- unchanged from before #2324."""
+        with patch(
+            "coord.github_ops._gh",
+            return_value=json.dumps({"ahead_by": 3}),
+        ) as gh:
+            assert github_ops.branch_commits_ahead("acme/api", "main", "issue-1-x") == 3
+        gh.assert_called_once()
+
+
 class TestBranchCommitsAheadForAssignment:
     """#1606: the one shared implementation of "branch empty -> 0, repo
     missing -> None, else ask GitHub" — `coord retry`'s advisory gate
@@ -1345,6 +1506,32 @@ class TestBranchCommitsAheadForAssignment:
             result = github_ops.branch_commits_ahead_for_assignment(assignment, config)
         assert result is None
 
+    def test_deleted_head_branch_with_resolving_base_is_zero(self) -> None:
+        """#2324: `coord retry` on space-invaders#1's exact shape — a
+        zero-commit advisory whose branch was already deleted. The compare
+        call 404s because the head branch is gone; the base branch
+        (default_branch) still resolves. That must read as a genuine
+        zero-commit advisory (0), not "could not be confirmed" (None) —
+        the None reading is what steered the operator toward the wrong
+        remedy (`coord drive --accept-advisory`, which assumes commits
+        exist)."""
+        assignment = self._Assignment(branch="issue-1-fix")
+        config = self._Config(self._RepoCfg("acme/api", default_branch="main"))
+
+        def _dispatch(*args, **kwargs):
+            path = args[1] if len(args) > 1 else ""
+            if path == "repos/acme/api/compare/main...issue-1-fix":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            if path == "repos/acme/api/git/refs/heads/issue-1-fix":
+                raise RuntimeError("gh: Not Found (HTTP 404)")
+            if path == "repos/acme/api/git/refs/heads/main":
+                return "{}"
+            raise AssertionError(f"unexpected _gh call: {args!r}")
+
+        with patch("coord.github_ops._gh", side_effect=_dispatch):
+            result = github_ops.branch_commits_ahead_for_assignment(assignment, config)
+        assert result == 0
+
 
 class TestGetBranchPatchId:
     """#1475: fetches the three-dot compare diff (no PR required, mirroring

{code_coordinator-0.5.114 → code_coordinator-0.5.115}/tests/test_retry_advisory_1606.py

@@ -121,6 +121,15 @@ class TestRetryAcceptsZeroCommitAdvisory:
         out = output_and_stderr(result)
         assert result.exit_code == 1
         assert "could not be confirmed" in out
+        # #2324: a genuine lookup failure is not confirmation that commits
+        # exist. The message must not assert the #1357 false-positive shape
+        # or steer the operator at a remedy (--accept-advisory) that assumes
+        # real commits are sitting on the branch — nothing here established
+        # that. It should instead say what to check.
+        assert "#1357" not in out
+        assert "--accept-advisory" not in out
+        assert "existing commits" not in out
+        assert "coord log 0256c844edfb" in out
 
     def test_done_status_is_still_refused(self, valid_config_path: Path) -> None:
         """Control: only `failed` and `advisory` are retryable — every other