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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-coordinator
-Version: 0.5.114
+Version: 0.5.116
 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.116}/code_coordinator.egg-info/SOURCES.txt

@@ -673,6 +673,7 @@ tests/test_quiet_hours.py
 tests/test_quiet_hours_store_2146.py
 tests/test_reap_merged_sessions.py
 tests/test_reap_stale_interactive_tick.py
+tests/test_reconcile.py
 tests/test_reconcile_branch.py
 tests/test_reconcile_completions.py
 tests/test_reconcile_merges.py

{code_coordinator-0.5.114 → code_coordinator-0.5.116}/code_coordinator.egg-info/scm_file_list.json

@@ -704,6 +704,7 @@
     "tests/test_quiet_hours_store_2146.py",
     "tests/test_reap_merged_sessions.py",
     "tests/test_reap_stale_interactive_tick.py",
+    "tests/test_reconcile.py",
     "tests/test_reconcile_branch.py",
     "tests/test_reconcile_completions.py",
     "tests/test_reconcile_merges.py",

{code_coordinator-0.5.114 → code_coordinator-0.5.116}/code_coordinator.egg-info/scm_version.json

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

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

@@ -1797,9 +1797,12 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
     from coord.board_service import read_board, write_board
     from coord.models import WORK_LIKE_TYPES
     from coord.reconcile import (
+        RetryProviderMismatch,
         UnsupportedRetryType,
         _reassign,
+        _resolve_retry_provider,
         describe_no_candidate_machines,
+        describe_retry_provider_mismatch,
         describe_unsupported_retry_type,
     )
 
@@ -1873,18 +1876,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)
@@ -1903,14 +1923,59 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
         click.echo(f"error: {describe_unsupported_retry_type(exc)}", err=True)
         sys.exit(1)
 
-    # Determine escalated model for the retry.
+    # #2323: resolve (and #437 TOS-guard) the provider this retry would
+    # dispatch through BEFORE deciding anything about the model — printed
+    # up front so it's never left for the drive's own header to contradict
+    # four seconds later, and checked before the escalation message so a
+    # refusal is never preceded by a reassuring "escalating model" line for
+    # a retry that's about to be refused. `providers.labels` is consulted
+    # the same way a first work dispatch consults it (gated to
+    # `type="work"`, coord/dispatch.py:548); a genuine `harness:opencode`
+    # label match here means retry lands back on `opencode`, not the
+    # claude default that a label-blind resolution used to fall through to.
+    from coord.state import get_cached_issue_labels  # noqa: PLC0415
+
+    issue_labels = get_cached_issue_labels(
+        assignment.repo_name, assignment.issue_number,
+    )
+    try:
+        resolved_provider_name = _resolve_retry_provider(assignment, cfg, issue_labels)
+    except RetryProviderMismatch as exc:
+        click.echo(f"error: {describe_retry_provider_mismatch(exc)}", err=True)
+        sys.exit(1)
+    except ValueError as exc:
+        click.echo(f"error: {exc}", err=True)
+        sys.exit(1)
+    click.echo(f"  provider: {resolved_provider_name}")
+
+    # Determine escalated model for the retry. #2323: `cfg.models.
+    # next_model` walks the claude tier ladder — only meaningful when this
+    # retry actually resolves to a claude-family provider. The precheck
+    # above already guarantees `resolved_provider_name` matches the failed
+    # run's own provider (else it would have refused), so gating on the
+    # resolved provider's TYPE here is equivalent to gating on the failed
+    # run's, without a second lookup.
+    from coord.config import IMPLICIT_PROVIDER_TYPES  # noqa: PLC0415
+    from coord.providers import provider_type_for  # noqa: PLC0415
+
     original_model = assignment.model or cfg.models.default
-    escalated = cfg.models.next_model(original_model)
-    if escalated != original_model:
-        click.echo(f"  escalating model: {original_model} → {escalated}")
+    if provider_type_for(resolved_provider_name, cfg.providers) in IMPLICIT_PROVIDER_TYPES:
+        escalated = cfg.models.next_model(original_model)
+        if escalated != original_model:
+            click.echo(f"  escalating model: {original_model} → {escalated}")
+        retry_model = escalated
+    else:
+        # Not a claude-family provider — the escalation ladder doesn't
+        # apply; reuse the failed run's own model field exactly (`None`
+        # tells `_reassign` to reuse `assignment.model` verbatim, rather
+        # than stamping `original_model`'s `cfg.models.default` fallback
+        # onto a provider that fallback means nothing to).
+        retry_model = None
 
     try:
-        result = _reassign(assignment, board, cfg, model=escalated)
+        result = _reassign(
+            assignment, board, cfg, model=retry_model, issue_labels=issue_labels,
+        )
     except UnsupportedRetryType as exc:
         # Defense in depth — the precheck above already covers this, but
         # `_reassign` is shared with `auto_reassign` and must never silently
@@ -1918,12 +1983,19 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
         # precheck.
         click.echo(f"error: {describe_unsupported_retry_type(exc)}", err=True)
         sys.exit(1)
+    except RetryProviderMismatch as exc:
+        # Defense in depth — the precheck above already covers this, but
+        # `_reassign` is shared with `auto_reassign` and must never
+        # silently substitute the provider even if a future caller skips
+        # the precheck.
+        click.echo(f"error: {describe_retry_provider_mismatch(exc)}", err=True)
+        sys.exit(1)
     if result is None:
         # #1396: name the blocking machines and their apparent load instead
         # of a bare "no available machine" — the usual cause is a phantom
         # `running` row from a dead interactive session nothing reaped.
         click.echo(
-            f"error: {describe_no_candidate_machines(assignment, board, cfg)}",
+            f"error: {describe_no_candidate_machines(assignment, board, cfg, issue_labels)}",
             err=True,
         )
         sys.exit(1)
@@ -1943,7 +2015,7 @@ def retry(assignment_id: str, config_path: Path, acknowledge_cost: bool = False)
     click.echo(
         f"Retried: {result.machine_name} → {result.repo_name} "
         f"#{result.issue_number} (assignment {result.assignment_id}, "
-        f"type={result.type})"
+        f"type={result.type}, provider={resolved_provider_name})"
     )
     # #1101: surface the continued branch so it's obvious the retry picked
     # up existing work instead of forking a fresh branch off the default.

{code_coordinator-0.5.114 → code_coordinator-0.5.116}/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.116}/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: