code-coordinator 0.5.164__tar.gz → 0.5.167__tar.gz

{code_coordinator-0.5.164 → code_coordinator-0.5.167}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.164",
+  "tag": "0.5.167",
   "distance": 0,
-  "node": "gacacc73c143b2a972a04f33649be185678913aa4",
+  "node": "g9016461101b4920502a7937e28cfdc70410ffc2f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-08-19"

{code_coordinator-0.5.164 → code_coordinator-0.5.167}/coord/drive.py

@@ -890,7 +890,20 @@ def _decide_acceptance_author(
         # pass-through.
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
-        if not branch or not verifier.branch_has_commits(probe):
+        commits = verifier.branch_has_commits(probe) if branch else False
+        if commits is None:
+            # #2426: `None` means the check could not be completed (e.g. a
+            # transient `git fetch` failure) — NOT evidence the branch is
+            # empty. Wait for the next poll to retry rather than
+            # misdiagnosing a verification failure as the terminal
+            # zero-commit dead end below.
+            return _wait(
+                label=(
+                    f"ACCEPTANCE: JIT slice {aid} branch {branch!r} — could "
+                    "not verify commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
             # #2061: a commit-less ADVISORY row IS what an earlier-landed
             # slice's stale/retried author row looks like — check the
             # manifest before declaring failure.
@@ -936,7 +949,20 @@ def _decide_acceptance_author(
         # `advisory` branch's probe exactly.
         branch = state.acceptance_author_branch
         probe = replace(state, work_branch=branch) if branch else state
-        if not branch or not verifier.branch_has_commits(probe):
+        commits = verifier.branch_has_commits(probe) if branch else False
+        if commits is None:
+            # #2426: same distinction as the ADVISORY branch above — a
+            # verification failure is not proof of an empty branch. This is
+            # exactly the claude-coordinator#2286 incident: a real pushed
+            # commit sat on the remote while a transient `git fetch` failure
+            # made this arm declare the branch commit-less and terminal.
+            return _wait(
+                label=(
+                    f"ACCEPTANCE: JIT slice {aid} branch {branch!r} — could "
+                    "not verify commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
             # #2061 (coord-portal#13): a re-dispatched author that lands in
             # a world where the slice is ALREADY on the default branch
             # correctly does nothing — DONE with zero commits — and that is
@@ -1221,7 +1247,7 @@ def _acceptance_message(message: str, state: IssueState) -> str:
 class MergeVerifier(Protocol):
     """The git/GitHub questions the state machine cannot answer itself."""
 
-    def branch_has_commits(self, state: IssueState) -> bool: ...
+    def branch_has_commits(self, state: IssueState) -> bool | None: ...
 
     def verify_merged(self, state: IssueState) -> bool: ...
 
@@ -1254,9 +1280,23 @@ class GitMergeVerifier:
             check=False,
         )
 
-    def branch_has_commits(self, state: IssueState) -> bool:
-        """True when *branch* exists on the remote and carries a commit the
-        default branch does not.
+    def branch_has_commits(self, state: IssueState) -> bool | None:
+        """``True``/``False`` when *branch* was actually checked against the
+        default branch; ``None`` when the check could not be completed.
+
+        ``False`` means VERIFIED empty: the fetches and the ``rev-list``
+        count all succeeded, and the count was exactly 0. ``None`` means no
+        such evidence exists — a transient ``git fetch`` failure (network
+        blip, GitHub hiccup, SSH auth glitch — see ``is_ci_unreadable_reason``
+        for the CI-side equivalent of this exact distinction), a missing
+        local checkout, or an unparsable ``rev-list`` count. Before #2426
+        every one of those collapsed into ``False``, indistinguishable from a
+        genuinely empty branch — and callers treated ``False`` as proof of a
+        TERMINAL dead end, misdiagnosing a fetch hiccup as "nothing was ever
+        authored" (claude-coordinator#2286: a real, pushed commit sat on the
+        remote while `coord drive` declared the branch commit-less and burned
+        11 retry cycles re-authoring from scratch). ``None`` must never be
+        treated as "no commits" — callers wait and let the next poll retry.
 
         Used to tell a REAL zero-commit advisory apart from the #1357 false
         positive, where the agent downgrades a good DONE over an artifact glob
@@ -1267,19 +1307,19 @@ class GitMergeVerifier:
             return False
         base = self._base(state)
         if base is None:
-            return False
+            return None
         target = state.repo_default_branch or "main"
         if self._git(base, "fetch", "--quiet", "origin", target).returncode != 0:
-            return False
+            return None
         if self._git(base, "fetch", "--quiet", "origin", branch).returncode != 0:
-            return False
+            return None
         proc = self._git(base, "rev-list", "--count", f"origin/{target}..FETCH_HEAD")
         if proc.returncode != 0:
-            return False
+            return None
         try:
             return int((proc.stdout or "0").strip() or 0) > 0
         except ValueError:
-            return False
+            return None
 
     def verify_merged(self, state: IssueState) -> bool:
         """Confirm the branch actually landed on the target.
@@ -1699,16 +1739,22 @@ def decide(
         pass
     elif state.work_status == "advisory":
         advisory = _decide_advisory(state, opts, counters, machine, verifier)
-        # #2416: `_decide_advisory` now returns a RUN action (a bounded
-        # `coord retry` dispatch) for the zero-commit case, not only an EXIT
-        # — `is_exit` alone would let a RUN action fall through to the
+        # #2416: `_decide_advisory` returns a RUN action (a bounded `coord
+        # retry` dispatch) for the zero-commit case, not only an EXIT —
+        # `is_exit` alone would let a RUN action fall through to the
         # Test/Review/Merge logic below as though the row were validated
-        # work. Only its "proceeding under --accept-advisory" branch returns
-        # WAIT (with warnings to fold in); every other branch (EXIT or RUN)
-        # is this poll's whole answer.
-        if advisory.kind != WAIT:
+        # work. #2426: it returns an explicit WAIT for the "could not verify
+        # — fetch failed" case, which must ALSO be this poll's whole answer,
+        # not folded into the fall-through below (that fall-through means
+        # "commits confirmed present, proceed as normal work", which a
+        # verification failure has not established either way). Only `None`
+        # — "proceeding under --accept-advisory", commits confirmed present
+        # — falls through, carrying its warning.
+        if advisory is not None:
             return advisory
-        warnings = advisory.warnings
+        warnings = (
+            "ADVISORY with commits present — proceeding per --accept-advisory (#1357)",
+        )
     elif state.work_status == "refused_policy":
         # #2234: the worker exited cleanly, pushed 0 commits, and its own
         # final message cited a standing repo-rule prohibition (`coord.agent.
@@ -1762,18 +1808,25 @@ def decide(
     # applies when there is nothing to test, review, or merge. A labelled
     # issue whose worker DID push commits (the label describes the common
     # case, not a hard rule) falls through unchanged — `branch_has_commits`
-    # is False only for the genuine 0-commit shape.
-    if (
-        state.work_status == "done"
-        and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels
-        and (not state.work_branch or not verifier.branch_has_commits(state))
-    ):
-        return _succeed(
-            f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
-            f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
-            "worker's final message is the deliverable and was posted to "
-            "the issue automatically — nothing to test, review, or merge."
-        )
+    # is False only for the genuine 0-commit shape; `None` (#2426 — the
+    # check could not be completed, e.g. a `git fetch` failure) is neither
+    # "done" nor "push commits", so it waits below instead of guessing.
+    if state.work_status == "done" and DELIVERABLE_ANALYSIS_LABEL in state.issue_labels:
+        commits = verifier.branch_has_commits(state) if state.work_branch else False
+        if commits is None:
+            return _wait(
+                label=(
+                    f"ANALYSIS: {state.work_aid} — could not verify branch "
+                    "commits (git fetch failed), retrying"
+                )
+            )
+        if not commits:
+            return _succeed(
+                f"✓ ANALYSIS DELIVERABLE — {state.work_aid} completed with 0 "
+                f"commits (issue labelled `{DELIVERABLE_ANALYSIS_LABEL}`); the "
+                "worker's final message is the deliverable and was posted to "
+                "the issue automatically — nothing to test, review, or merge."
+            )
 
     # A 'done' row with no branch never pushed anything either.
     if not state.work_branch:
@@ -1930,7 +1983,7 @@ def _decide_advisory(
     counters: DriveCounters,
     machine: str,
     verifier: MergeVerifier,
-) -> Action:
+) -> Action | None:
     """The #448 downgrade: the agent flagged a zero-commit / stash-miss exit.
 
     #1357 makes this a FALSE POSITIVE for every Python-only headless assignment
@@ -1952,8 +2005,30 @@ def _decide_advisory(
     advisory_retries`) before finally giving up, so a row whose correct
     resolution really is "dispatch something else" still reaches a terminal
     `_die()` naming `coord retry` for a human — never an unbounded loop.
+
+    Returns ``None`` only for the "commits confirmed present, proceed under
+    --accept-advisory" case — the caller (`decide`) reads ``None`` as "fall
+    through to the normal Test/Review/Merge machinery", the same "nothing to
+    report, proceed" convention `_decide_test`/`_decide_review`/
+    `_decide_acceptance_gate` already use. Every other outcome, including the
+    #2426 "could not verify" case below, returns a real ``Action`` that IS
+    this poll's whole answer.
     """
-    if not state.work_branch or not verifier.branch_has_commits(state):
+    branch = state.work_branch
+    commits = verifier.branch_has_commits(state) if branch else False
+    if commits is None:
+        # #2426: `git fetch` failing does not mean the branch is empty — it
+        # means nothing was learned. Wait for the next poll to retry the
+        # check itself; do NOT spend an `advisory_retries` budget attempt (or
+        # worse, `_die()`) on a verification failure that says nothing about
+        # what the branch actually contains.
+        return _wait(
+            label=(
+                f"WORK: {state.work_aid} ADVISORY — could not verify branch "
+                "commits (git fetch failed), retrying"
+            )
+        )
+    if not commits:
         budget = opts.max_work_retries
         if counters.advisory_retries >= budget:
             return _die(
@@ -1992,12 +2067,9 @@ def _decide_advisory(
             "   Proceed anyway with --accept-advisory (and fix #1357 to stop "
             "needing it)."
         )
-    return Action(
-        kind=WAIT,
-        warnings=(
-            "ADVISORY with commits present — proceeding per --accept-advisory (#1357)",
-        ),
-    )
+    # Commits confirmed present, --accept-advisory set: fall through to the
+    # normal Test/Review/Merge machinery (the caller attaches the warning).
+    return None
 
 
 def _decide_acceptance_gate(

{code_coordinator-0.5.164 → code_coordinator-0.5.167}/coord/drive_queue.py

@@ -97,6 +97,7 @@ from coord.merge_queue import (
     is_ci_infra_reason,
     is_ci_pending_reason,
     is_ci_unreadable_reason,
+    is_stale_smoke_reason,
 )
 from coord.models import is_policy_refusal_reason
 
@@ -1810,6 +1811,57 @@ def _dispatch_produced_nothing(entry: QueueEntry, facts: IssueFacts) -> bool:
     return facts.last_dispatched_at < entry.launched_at
 
 
+def _is_merge_gate_block_reason(reason: str | None) -> bool:
+    """#2424: does *reason* already name a merge-gate block — a death whose
+    real cause is a LATER stage (merge), not a dispatch-layer failure?
+
+    `_dispatch_produced_nothing`'s own comparison (``facts.last_dispatched_at
+    < entry.launched_at``) goes stale specifically for a relaunch whose only
+    job is retrying the Merge stage: by design, that relaunch dispatches no
+    new assignment (there is nothing left to dispatch — Work/Test/Review
+    already completed), so the comparison reads exactly like a genuine
+    dispatch failure even though three real assignments did real work. This
+    is the textual escape hatch for that case: when *reason* itself already
+    names a merge-gate block, the generic "#2273 no assignment was ever
+    created" note must not be layered on top of it — see
+    claude-coordinator#2405 (stale smoke verdict) and coord-web#2 (red CI),
+    both live escalations where the dispatch-note actively misdirected an
+    operator toward `drive-queue remove && add` (a wasted Work/Test/Review
+    cycle) instead of the real one-line fix (`coord merge --revalidate`, or
+    fixing the failing CI check).
+
+    Four shapes, all written by `coord/drive.py`'s own merge-stage decision
+    functions — none of them a "no assignment created" signal:
+
+    * `_die`'s exhausted-merge-attempts wording ("merge attempted N times
+      without landing") — `coord assign` succeeded and Work/Test/Review all
+      completed; the LOOP inside a single drive session that kept retrying
+      `coord merge --only` simply ran out of its own attempt budget
+      (#1505/#2078).
+    * `is_stale_smoke_reason` — the #1479 staleness race: the merge base
+      moved out from under a still-valid smoke verdict.
+    * "checks failed" — `coord.merge_queue`'s own `checks_failed` prose
+      (``f"checks failed: {summary}"``): red CI on a PR that was dispatched,
+      built, and reviewed fine.
+    * `_escalate_merge`'s own gate-divergence/terminal-status wording
+      ("smoke_required —" / "review_required —" / "merge_status=...") — the
+      #1505/#1526 immediate-escalation path, which already recorded its own
+      accurate `coord escalate record` before this drive exited.
+    """
+    if not reason:
+        return False
+    lowered = reason.lower()
+    if "merge attempted" in lowered:
+        return True
+    if is_stale_smoke_reason(reason):
+        return True
+    if "checks failed" in lowered:
+        return True
+    if "smoke_required —" in lowered or "review_required —" in lowered:
+        return True
+    return "merge_status=" in lowered
+
+
 def _is_empty_branch_death_reason(reason: str | None) -> bool:
     """#2363: does *reason* name the "claimed success, wrote nothing"
     signature — an acceptance-author or plain work session that exited
@@ -1858,6 +1910,7 @@ def _retry_backoff_reason(
     now: float | None,
     attempts: int,
     retry_backoff_at: float | None,
+    own_reason: str | None = None,
 ) -> str:
     """#2273's launch-side guard: ``''`` unless *entry* is still inside its
     post-death backoff window.
@@ -1898,6 +1951,23 @@ def _retry_backoff_reason(
     ``retry_backoff_at is None`` (a pure-logic caller with no clock, or a row
     predating this column — both degrade to the pre-#2273 behaviour exactly,
     the same posture every other clock-gated check in this module takes).
+
+    *own_reason* (#2424 follow-up): the same text the launch-side dispatch
+    note is gated on (see the comment above `dispatch_only` in
+    `_reconcile_running`'s retry/exhausted branches). Passed through so the
+    widened `DISPATCH_FAILURE_MIN_BACKOFF_SECONDS` spacing below answers the
+    identical "was this actually a dispatch failure" question the launch-side
+    note already answers, rather than recomputing it from
+    `_dispatch_produced_nothing` alone — which, like the note before #2424,
+    cannot tell a genuine pre-`coord assign` crash from a merge-only relaunch
+    that dispatches no new assignment by design. Once `own_reason` already
+    names a merge-gate block (`_is_merge_gate_block_reason`), the 300s floor
+    would be pure mispacing: the rationale for widening it ("a transient
+    dispatch failure cannot spend the whole retry budget inside one tick
+    cadence") does not apply once the cause is known to be a merge-gate
+    block, not a dispatch failure. ``None`` (the default) degrades to the
+    pre-#2424-follow-up behaviour exactly, for callers that have not been
+    updated to pass it.
     """
     if now is None or attempts <= 0 or retry_backoff_at is None:
         return ""
@@ -1906,7 +1976,9 @@ def _retry_backoff_reason(
         return ""
     idx = min(attempts - 1, len(RETRY_BACKOFF_SECONDS) - 1)
     backoff = RETRY_BACKOFF_SECONDS[idx]
-    if _dispatch_produced_nothing(entry, facts):
+    if _dispatch_produced_nothing(entry, facts) and not _is_merge_gate_block_reason(
+        own_reason
+    ):
         backoff = max(backoff, DISPATCH_FAILURE_MIN_BACKOFF_SECONDS)
     if age >= backoff:
         return ""
@@ -2347,7 +2419,21 @@ def _reconcile_running(
     # — or the escalation this produces once the budget IS exhausted — sees
     # "no assignment was ever created" instead of a bare exit code that
     # could mean anything.
-    dispatch_only = _dispatch_produced_nothing(entry, facts)
+    #
+    # #2424: EXCEPT when `own_reason` already names a merge-gate block
+    # ("merge attempted N times without landing", a stale smoke verdict, red
+    # CI, ...) — a relaunch whose only job is retrying the Merge stage
+    # dispatches no new assignment BY DESIGN (Work/Test/Review already
+    # completed; there is nothing left to dispatch), so the comparison above
+    # reads exactly like a dispatch failure even though it plainly is not.
+    # The generic note is additive evidence for when nothing more specific is
+    # known; it must never be layered on top of a reason that already
+    # contradicts it — see `_is_merge_gate_block_reason` for the two live
+    # escalations (claude-coordinator#2405, coord-web#2) this false-positive
+    # actually produced.
+    dispatch_only = _dispatch_produced_nothing(
+        entry, facts
+    ) and not _is_merge_gate_block_reason(own_reason)
     dispatch_note = (
         " — no assignment was ever created for this run (#2273): likely an "
         "infrastructure/dispatch-layer failure, not a code defect"
@@ -3604,17 +3690,24 @@ def plan_tick(
         `effective_last_reason`) so both call sites below — the report-only
         dry-run pass and the persisted `last_reason` write — get the combined
         text for free, with no change needed at either site.
+
+        #2424 follow-up: that same `effective_last_reason` resolution is also
+        what `_retry_backoff_reason` needs to answer its own "was this
+        actually a dispatch failure" question — see its `own_reason`
+        parameter's docstring — so it is resolved once, here, and passed to
+        both.
         """
+        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         backoff = _retry_backoff_reason(
             candidate,
             board.facts(candidate.key),
             now,
             effective_attempts.get(candidate.key, candidate.attempts),
             retry_backoff_at_map.get(candidate.key, candidate.retry_backoff_at),
+            own_reason=previous,
         )
         if not backoff:
             return ""
-        previous = effective_last_reason.get(candidate.key, candidate.last_reason)
         return _augment_backoff_reason(previous, backoff)
 
     # #1972's projection of per-repo occupancy AS THE WALK SEES IT: the board

{code_coordinator-0.5.164 → code_coordinator-0.5.167}/tests/test_drive.py

@@ -87,7 +87,7 @@ class FakeVerifier:
     def __init__(
         self,
         *,
-        has_commits: bool = True,
+        has_commits: bool | None = True,
         merged: bool = True,
         head_sha: str | None = "deadbeef" * 5,
     ) -> None:
@@ -98,7 +98,7 @@ class FakeVerifier:
         self.merged_calls = 0
         self.head_sha_calls = 0
 
-    def branch_has_commits(self, s: IssueState) -> bool:
+    def branch_has_commits(self, s: IssueState) -> bool | None:
         self.commits_calls += 1
         return self._has_commits
 
@@ -1019,6 +1019,29 @@ def test_oracle_active_advisory_with_no_commits_is_not_terminal_when_the_slice_a
     )
 
 
+def test_oracle_active_advisory_with_unverifiable_branch_waits():
+    """#2426: `branch_has_commits` returning `None` (e.g. a `git fetch`
+    failure) must NOT be treated as "no commits" — that misdiagnoses a
+    transient verification failure as the terminal "nothing was authored"
+    dead end (claude-coordinator#2286: a real, pushed commit sat on the
+    remote while this exact path declared the branch commit-less). It must
+    wait and let the next poll retry the check instead."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=None)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="advisory",
+            acceptance_author_branch="test-author-ms-65-slice-2286",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert "no commits" not in (action.message or "")
+
+
 def test_oracle_active_advisory_with_commits_requires_accept_advisory():
     """The #1357 false-positive shape — real commits, downgraded to
     advisory anyway — must not be treated as "still landing"; it needs the
@@ -1148,6 +1171,29 @@ def test_oracle_active_done_with_no_branch_is_terminal():
     assert "no commits" in action.message
 
 
+def test_oracle_active_done_with_unverifiable_branch_waits():
+    """#2426: the exact incident this issue documents — a terminal
+    `test-author` DONE row whose branch really did carry a commit
+    (claude-coordinator#2286's `test-author-ms-65-slice-2286`, commit
+    `250b4df8`), observed through a `git fetch` failure. Must wait and
+    retry, not declare DONE terminal-with-no-commits and burn a re-author
+    cycle."""
+    oracle = OracleDecision(True, "ORACLE DRIVE", tracking_issue=1120)
+    verifier = FakeVerifier(has_commits=None)
+    action = step(
+        oracle_state(
+            acceptance_author_aid="ta1",
+            acceptance_author_status="done",
+            acceptance_author_branch="test-author-ms-65-slice-2286",
+        ),
+        oracle=oracle,
+        verifier=verifier,
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert "no commits" not in (action.message or "")
+
+
 def test_oracle_active_done_with_commits_lands_the_slice():
     """#2079: a DONE slice whose branch carries commits is MERGED by this
     driver, not waited on.
@@ -1752,6 +1798,23 @@ def test_advisory_with_no_commits_retries_via_coord_retry_then_stops_at_the_cap(
     assert verifier.commits_calls == 2
 
 
+def test_advisory_with_unverifiable_branch_waits_without_spending_a_retry():
+    """#2426: a `git fetch` failure while checking the branch is not proof
+    it's empty. Must wait for the next poll rather than either spending an
+    `advisory_retries` budget attempt or (once the budget is spent) dying
+    with the terminal "no commits" message on evidence that never
+    materialized."""
+    verifier = FakeVerifier(has_commits=None)
+    counters = DriveCounters()
+    opts = DriveOptions(machine="precision", max_work_retries=1)
+    s = state(work_aid="w1", work_status="advisory", work_branch="b")
+
+    action = step(s, opts, verifier=verifier, counters=counters)
+    assert action.kind == WAIT
+    assert not action.is_exit
+    assert counters.advisory_retries == 0
+
+
 def test_advisory_with_no_commits_retry_is_unaffected_by_accept_advisory():
     """#1606: `--accept-advisory` exists to unblock the #1357 false-positive
     (real commits, downgraded status) — it must NOT adopt a genuine
@@ -1850,6 +1913,23 @@ def test_analysis_deliverable_done_with_no_commits_succeeds():
     assert "deliverable:analysis" in action.message
 
 
+def test_analysis_deliverable_done_with_unverifiable_branch_waits():
+    """#2426: a `git fetch` failure while checking an analysis-labelled
+    branch is neither "0-commit success" nor "commits pushed, fall
+    through" — it's no evidence at all. Must wait for the next poll."""
+    action = step(
+        state(
+            work_aid="w1",
+            work_status="done",
+            work_branch="issue-2132-diagnose",
+            issue_labels=("deliverable:analysis",),
+        ),
+        verifier=FakeVerifier(has_commits=None),
+    )
+    assert action.kind == WAIT
+    assert not action.is_exit
+
+
 def test_analysis_deliverable_done_with_no_branch_at_all_succeeds():
     """Same as above when the reap never captured a branch name at all
     (e.g. the worktree was already gone) — `not state.work_branch` alone
@@ -4290,20 +4370,60 @@ def test_branch_has_commits_is_false_for_zero(recorded_git, tmp_path):
     assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is False
 
 
-def test_branch_has_commits_is_false_when_the_remote_branch_is_missing(
+def test_branch_has_commits_is_none_when_rev_list_fails(recorded_git, tmp_path):
+    """#2426: both fetches succeeded but `rev-list` itself failed — still no
+    completed count, so still `None`, not `False`."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("rev-list",)] = (128, "")
+    s = state(work_branch="b")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_rev_list_output_is_unparsable(
     recorded_git, tmp_path
 ):
+    """#2426: a malformed count is the same "learned nothing" shape as a
+    failed command — `None`, not `False`."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("rev-list",)] = (0, "not-a-number\n")
+    s = state(work_branch="b")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_a_fetch_fails(recorded_git, tmp_path):
+    """#2426: a `git fetch` failure (returncode 128 here covers both "branch
+    genuinely doesn't exist on the remote" and "transient network/auth
+    blip" — the two are indistinguishable from the exit code alone) must NOT
+    collapse into `False`. `False` is reserved for a check that actually
+    completed and counted zero commits; a failed fetch produced no such
+    count, so it is `None` — "couldn't verify" — not "verified empty"."""
     _calls, scripted = recorded_git
     (tmp_path / ".git").mkdir()
     scripted[("fetch", "b")] = (128, "")
     s = state(work_branch="b")
-    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is False
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
+
+
+def test_branch_has_commits_is_none_when_the_target_fetch_fails(
+    recorded_git, tmp_path
+):
+    """Same #2426 distinction, for the OTHER fetch (`origin/<target>`)."""
+    _calls, scripted = recorded_git
+    (tmp_path / ".git").mkdir()
+    scripted[("fetch", "main")] = (128, "")
+    s = state(work_branch="b", repo_default_branch="main")
+    assert GitMergeVerifier(repo_path=str(tmp_path)).branch_has_commits(s) is None
 
 
 def test_the_verifiers_are_inert_without_a_local_checkout(tmp_path):
+    """#2426: no local checkout means no evidence either way — `None`, not
+    `False`. `verify_merged` is untouched by #2426 (GitHub is its primary
+    source of truth, not this local checkout) and keeps its `False`."""
     verifier = GitMergeVerifier(repo_path=str(tmp_path / "nope"))
     s = state(work_branch="b", repo_github="")
-    assert verifier.branch_has_commits(s) is False
+    assert verifier.branch_has_commits(s) is None
     assert verifier.verify_merged(s) is False