code-coordinator 0.5.490__tar.gz → 0.5.492__tar.gz

{code_coordinator-0.5.490 → code_coordinator-0.5.492}/PKG-INFO

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

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

@@ -1,7 +1,7 @@
 {
-  "tag": "0.5.490",
+  "tag": "0.5.492",
   "distance": 0,
-  "node": "gfb5dc047d0e9acfa22f379bebb343d14c749080c",
+  "node": "gf825ecb0009197eb0b97ba8d836676c545ec6a00",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-18"

{code_coordinator-0.5.490 → code_coordinator-0.5.492}/coord/commands/test_gate.py

@@ -565,6 +565,45 @@ def test(assignment_id: str, config_path: Path, verdict: str | None, reason: str
         elif verdict == "running":
             click.echo("  (transient — record --passed/--fail/--skipped when the run concludes)")
 
+        # #3386 (item 3 of #3378): tell the human RIGHT HERE how close (or
+        # past) this repo is to the consecutive baseline-red merge-block
+        # limit — `record_test_verdict` above just incremented it if this
+        # was a `baseline_red`-confirmed skip
+        # (`coord.confirm_test.test_confirmation_for_skip_reason`). Silence
+        # here is exactly how #3378's bypass ran unnoticed for 33 days: the
+        # command that records the bypass is the one place a human is
+        # already looking.
+        if test_confirmation == "baseline_red":
+            from coord.state import (
+                BASELINE_RED_STREAK_LIMIT,
+                baseline_red_merge_blocked,
+                baseline_red_streak,
+            )
+
+            # #3386 review: `baseline_red_merge_blocked` is the ONE predicate
+            # both the real merge refusal (`coord.merge_queue.
+            # evaluate_smoke_verdict`) and any repo-level alert surface must
+            # call — never a second, independently-derived comparison
+            # against `BASELINE_RED_STREAK_LIMIT` (#2096). This echo used to
+            # re-derive `streak >= BASELINE_RED_STREAK_LIMIT` itself; now it
+            # asks the same function the merge gate asks, so the two can
+            # never silently disagree.
+            streak = baseline_red_streak(assignment.repo_name)
+            if baseline_red_merge_blocked(assignment.repo_name):
+                click.echo(
+                    f"  WARNING: {assignment.repo_name} has now recorded {streak} "
+                    f"consecutive baseline-red (#2170) classifications — "
+                    f"`coord merge` will refuse EVERY branch on this repo until "
+                    f"the merge base itself is fixed (#3386)."
+                )
+            else:
+                click.echo(
+                    f"  note: {assignment.repo_name}'s consecutive baseline-red "
+                    f"streak is now {streak}/{BASELINE_RED_STREAK_LIMIT} — "
+                    f"merges for this repo stop at {BASELINE_RED_STREAK_LIMIT} "
+                    f"in a row with no genuine pass in between (#3386)."
+                )
+
         # #271 part 1: restore the local checkout to `default_branch` after a
         # pass/skip verdict (legacy safety — #561 means a Build no longer moves
         # the base, so this is a no-op on fresh checkouts), and #561: remove the

{code_coordinator-0.5.490 → code_coordinator-0.5.492}/coord/diagnose.py

@@ -735,6 +735,22 @@ def diagnose_stage(
     latest = _latest(assignments)
 
     if latest is None:
+        # #3383: a `review_claims` row held for a work assignment with ZERO
+        # review/test-author/mock-author rows (never dispatched, or all
+        # deleted) is unreachable from `_recover_review` below — that
+        # function only ever runs once `latest` above is non-None. Before
+        # this, `--stage review` hit this exact branch and reported the
+        # stage healthy while `dispatch_review` was permanently wedged
+        # behind the leaked claim (#3206's failure one state earlier — see
+        # `_leaked_review_claim_without_row`'s docstring). Checked BEFORE
+        # the "no review assignment" finding below, on claim state rather
+        # than on row existence, exactly as #3206 already does once a row
+        # exists.
+        if stage == "review" and _leaked_review_claim_without_row(
+            board, repo_name, issue_number, res, reset=reset, dry_run=dry_run,
+        ):
+            _cleanup_issue(board, config, repo_name, issue_number, res, dry_run=dry_run, reset=reset)
+            return res
         res.findings.append(f"no {stage} assignment on the board for #{issue_number}")
         res.recovered = True  # nothing wedged
         # Still run the issue-wide cleanup below.
@@ -818,6 +834,154 @@ def diagnose_stage(
     return res
 
 
+# #3383: a claim taken by `claim_review_dispatch` shortly before its caller
+# inserts the review row it's claiming for looks, from a single read,
+# identical to a genuinely leaked claim — the same false-positive window
+# `_recover_review` below already documents for the terminal-row case
+# (#3206). Below this age the claim is reported but NOT offered for release;
+# above it, treated as leaked.
+#
+# NOT short on purpose — `dispatch_review` (coord/review.py) claims at
+# `claim_review_dispatch` (~line 3070) and does NOT insert the review's
+# `assignments` row until `record_dispatched_assignment` (~line 3763); its
+# own `except Exception` handler at ~line 3815 calls the ~500 lines between
+# those two points "pr_lookup, briefing assembly, JSON handling of
+# agent_response, ...". That gap includes several sequential GitHub API
+# calls (`work_is_terminal`, `branch_commits_ahead`, `pr_lookup`,
+# `branch_exists_on_remote`, `pr_diff`, `get_compare_files`,
+# `get_compare_diff`, `get_pr_commit_messages`, an issue-body fetch) and then
+# a candidate loop that POSTs to each reviewer machine's `/assign` with
+# `timeout=ASSIGN_POST_TIMEOUT_SECS` (`coord/dispatch.py` — 60.0s),
+# falling through to the next candidate on rejection/timeout/unreachability.
+# A single slow/unreachable first-choice reviewer machine alone can burn the
+# full 60s before a second candidate is even tried, and there is no hard cap
+# on candidate count — so this has to clear that whole chain, not one
+# network round trip. Picked as a small multiple of minutes so it
+# comfortably outlasts a worst-case multi-candidate dispatch plus GitHub API
+# latency, while still being short enough that a *genuinely* leaked claim
+# doesn't sit unrecoverable for long once someone runs `--reset`.
+_REVIEW_CLAIM_LEAK_GRACE_SECS = 600.0
+
+
+def _leaked_review_claim_without_row(
+    board: "Board",
+    repo_name: str,
+    issue_number: int,
+    res: DiagnoseResult,
+    *,
+    reset: bool,
+    dry_run: bool,
+) -> bool:
+    """#3383: detect (and, under ``--reset``, release) a leaked
+    ``review_claims`` row for a work assignment that has NO review /
+    test-author / mock-author row at all — the one shape `_recover_review`
+    can never see, because `diagnose_stage` only calls it once
+    `stage_assignments(..., "review")` finds a row. A claim can be (and, per
+    the issue that reported this, was) taken and never released when the
+    work assignment it's keyed on was dispatched to review, that review
+    never got as far as inserting its own `assignments` row (or its row was
+    later deleted, e.g. by an earlier `--reset`), and the claim outlived it.
+    Every future `dispatch_review` for that work assignment then denies
+    forever with the misleading #3113 "lost the atomic dispatch-claim race"
+    reason — while `coord diagnose --stage review` (which hit the
+    `latest is None` "no review assignment" branch before this function
+    existed) reported the stage healthy.
+
+    Checked against the WORK assignment's id — `claim_review_dispatch` is
+    keyed on the id of the assignment BEING reviewed, never on a review
+    row's own id (see `_recover_review`'s `work_assignment_id` resolution).
+
+    Returns ``True`` when a claim was found (whether or not it could be
+    released yet — see the grace-period case) and this function has already
+    appended the appropriate finding(s); ``False`` when there is nothing to
+    report, in which case the caller's own "no review assignment" message
+    is the correct (healthy) diagnosis.
+    """
+    from coord.state import (  # noqa: PLC0415
+        has_review_claim,
+        release_review_dispatch_claim,
+        review_claim_age_secs,
+    )
+
+    # Narrowing, acknowledged: this only checks the NEWEST `work`-type row
+    # for the issue, whereas `claim_review_dispatch` is keyed on whatever
+    # work-assignment id `dispatch_review` was actually called with. If the
+    # issue ever accumulates more than one `work` row (e.g. a rework/retry
+    # dispatched after the original work assignment that leaked the claim),
+    # a claim held on the *older* id is invisible here because this checks
+    # only the *newest* one. `_recover_review` avoids this by reading the
+    # exact id off the review row's own `review_of_assignment_id` FK — there
+    # is no review row here to read that FK from, so this has to guess.
+    # Probably rare, and the issue's own "worth also considering" `coord
+    # doctor` suggestion is the more complete fix; left as a known gap
+    # rather than iterating over every `work` row here.
+    work_rows = stage_assignments(board, repo_name, issue_number, "work")
+    work_latest = _latest(work_rows)
+    if work_latest is None or not work_latest.assignment_id:
+        return False
+    work_assignment_id = work_latest.assignment_id
+    if not has_review_claim(work_assignment_id):
+        return False
+
+    age = review_claim_age_secs(work_assignment_id)
+    if age is not None and age < _REVIEW_CLAIM_LEAK_GRACE_SECS:
+        # Too fresh to distinguish from an in-flight `dispatch_review` call
+        # that has taken the claim but not yet inserted its review row —
+        # report it, but don't offer to release something that might still
+        # be a live, wanted dispatch.
+        res.findings.append(
+            f"work assignment {work_assignment_id} holds a review-dispatch "
+            f"claim taken {age:.1f}s ago with no review row yet — likely an "
+            "in-flight dispatch_review, not a leak; re-run diagnose again "
+            "shortly if this persists"
+        )
+        res.recovered = True
+        return True
+
+    res.findings.append(
+        f"no review assignment exists for #{issue_number}, but work "
+        f"assignment {work_assignment_id} still holds a review-dispatch "
+        "claim (leaked review_claims row, #3383 — the #3206 class one state "
+        "earlier) — every future dispatch_review for this work assignment "
+        "will deny with the misleading #3113 'lost the atomic dispatch-claim "
+        "race' reason until it is released. Re-run with --reset to release it."
+    )
+    res.recovered = False
+    res.needs_reset = True
+
+    if reset:
+        if dry_run:
+            res.findings.append(
+                "(dry-run) would release the leaked review-dispatch claim"
+            )
+            return True
+        release_review_dispatch_claim(work_assignment_id)
+        if has_review_claim(work_assignment_id):
+            res.findings.append(
+                f"release requested for {work_assignment_id}'s "
+                "review-dispatch claim, but it is still present on re-read "
+                "— the release did NOT persist"
+            )
+        else:
+            res.actions_taken.append(
+                "released leaked review-dispatch claim for work assignment "
+                f"{work_assignment_id} — dispatch_review is now re-dispatchable"
+            )
+            res.reset_performed = True
+            res.recovered = True
+            res.branch_preserved = True
+            # Matches `_do_reset`'s (#3206) convention: a successful release
+            # must clear the `needs_reset=True` set a few lines above, or
+            # `to_json_dict()` — documented as read by the TUI without
+            # scraping human-readable lines — carries the internally
+            # contradictory `recovered=true needs_reset=true
+            # reset_performed=true` even though the plain-text CLI's "still
+            # wedged" warning happens to be gated on `not reset` and so never
+            # shows it.
+            res.needs_reset = False
+    return True
+
+
 def _recover_review(
     board, config, latest, state, res: DiagnoseResult, *, dry_run: bool
 ) -> None:

{code_coordinator-0.5.490 → code_coordinator-0.5.492}/coord/merge_queue.py

@@ -52,7 +52,13 @@ from coord.models import (
     trust_issue_closed_for,
 )
 from coord.pr_body_lint import downgrade_closing_keywords, find_closing_references
-from coord.state import COORD_DIR, dismiss_drive_escalation, record_uat_verdict
+from coord.state import (
+    COORD_DIR,
+    baseline_red_merge_blocked,
+    baseline_red_streak,
+    dismiss_drive_escalation,
+    record_uat_verdict,
+)
 from coord.uat_checks import UatCheckResult, evaluate_uat_checks
 
 _log = logging.getLogger(__name__)
@@ -1713,10 +1719,22 @@ def passes_merge_gates(a, config, board, gh_ops: "GhOps | None" = None) -> bool:
 # non-``None`` to run) straight to SMOKE_OK — a verdict this code never
 # actually confirmed still covers the current head. See
 # `UNKNOWN_BRANCH_HEAD_REASON`.
+#
+# #3386 adds a fourth: SMOKE_BASELINE_RED_BLOCKED — a `"skipped"` verdict
+# confirmed `baseline_red` (#3378 item 2) exists and is otherwise fresh, but
+# this repo has racked up `BASELINE_RED_STREAK_LIMIT` (or more) of them in a
+# row with no genuine `passed` verdict in between. #1732's "skipped never
+# goes stale" exemption is deliberately narrower than it looks: it covers a
+# STRUCTURAL skip (nothing to smoke-test) unconditionally, but a
+# `baseline_red` skip is a claim that the CURRENT merge base — not the
+# branch — is why the suite fails, and #3378 found that claim, satisfied
+# every time, merges a repo whose `main` has been red for 33 days without
+# anyone noticing. See `coord.state.baseline_red_merge_blocked`.
 SMOKE_OK = "ok"
 SMOKE_MISSING = "missing"
 SMOKE_STALE = "stale"
 SMOKE_UNKNOWN = "unknown"
+SMOKE_BASELINE_RED_BLOCKED = "baseline_red_blocked"
 
 
 def _short_sha(sha: str | None) -> str:
@@ -1773,6 +1791,9 @@ class SmokeVerdictStatus:
     # sentence. `None` for every other kind, and for a SMOKE_UNKNOWN whose
     # `gh_ops` stand-in didn't support `raise_on_transient` at all.
     probe_error: "GhTransientError | None" = None
+    # #3386: the repo's consecutive baseline-red streak that produced a
+    # SMOKE_BASELINE_RED_BLOCKED verdict — `None` for every other kind.
+    baseline_red_streak: int | None = None
 
     @property
     def short_reason(self) -> str | None:
@@ -1784,6 +1805,11 @@ class SmokeVerdictStatus:
             return None
         if self.kind == SMOKE_UNKNOWN:
             return unknown_branch_head_reason(self.probe_error)
+        if self.kind == SMOKE_BASELINE_RED_BLOCKED:
+            return (
+                f"{self.baseline_red_streak} consecutive baseline-red "
+                "classifications — merge base needs fixing (#3386)"
+            )
         if self.kind == SMOKE_STALE:
             if self.anchor == "run":
                 return (
@@ -1810,6 +1836,20 @@ class SmokeVerdictStatus:
             # `unknown_branch_head_reason` appends real status/request-id/
             # retry-after when `probe_error` carries any.
             return unknown_branch_head_reason(self.probe_error)
+        if self.kind == SMOKE_BASELINE_RED_BLOCKED:
+            # #3386: a bypass that still merges is not a bypass. This repo
+            # has recorded `baseline_red_streak` consecutive `baseline-red`
+            # (#2170) classifications with no genuine `passed` verdict in
+            # between — the merge base itself needs fixing before this or
+            # any other branch on this repo merges. Waiving requires
+            # `--skip-smoke`, same as any other smoke refusal; there is no
+            # per-branch fix, only a repo-level one.
+            return (
+                f"merge refused: {self.baseline_red_streak} consecutive "
+                "baseline-red (#2170) classifications on this repo with no "
+                "genuine passed verdict in between — the merge base itself "
+                "needs fixing, not another branch (#3386)"
+            )
         if self.kind == SMOKE_STALE:
             aid = self.assignment_id or "<assignment>"
             if self.anchor == "run":
@@ -3269,88 +3309,145 @@ def evaluate_smoke_verdict(
         # moves — a rename upstream, or new commits on the branch, can't
         # turn "there is nothing here a smoke test could exercise" into
         # false. Only `passed` verdicts go through the #1479 base/branch
-        # staleness check below; `skipped` is accepted unconditionally.
-        if test_state == "skipped":
+        # staleness check below; a STRUCTURAL `skipped` is accepted
+        # unconditionally, same as always.
+        #
+        # #3386: a `baseline_red`-confirmed skip (#3378 item 2) is NOT that
+        # structural claim — it asserts the merge BASE, not the branch, is
+        # why the suite fails, and that assertion is falsifiable two ways:
+        #   * item 3 — this repo has racked up too many of these in a row
+        #     with no genuine `passed` in between
+        #     (`coord.state.baseline_red_streak`), so even a fresh
+        #     one must not merge until the base itself is fixed. A bypass
+        #     that still merges every time is not a bypass, it is an outage
+        #     with a footnote — confirmed live on #3383 against a `main`
+        #     that had been red 33 days.
+        #   * item 4 — the branch has since moved on (a fix round pushed new
+        #     commits), so the classification no longer describes what is
+        #     actually on the branch (#3376's live gate defect: a skip cited
+        #     from a since-superseded assignment). Falls through to the same
+        #     branch-content check `passed` gets below.
+        # Deliberately does NOT run the base-move check just below even for
+        # a `baseline_red` skip: that check exists to catch a `passed`
+        # MEASUREMENT going stale, whereas "the base is red" is exactly what
+        # this classification already asserts — item 3's streak bound is
+        # what covers a chronically-moving red base instead.
+        test_confirmation = getattr(a, "test_confirmation", None)
+        # "baseline_red" mirrors `coord.confirm_test.TEST_CONFIRMATION_
+        # BASELINE_RED` — kept as a literal (not an import) to avoid a
+        # module-level import of `coord.confirm_test`, which imports
+        # `coord.revalidate`, which imports THIS module. Pinned against
+        # drift by `tests/test_merge_queue.py::TestStaleSmokeVerdictReporting::
+        # test_literal_matches_the_canonical_confirm_test_constant`.
+        is_baseline_red_skip = (
+            test_state == "skipped" and test_confirmation == "baseline_red"
+        )
+        if test_state == "skipped" and not is_baseline_red_skip:
             return SmokeVerdictStatus(
                 ok=True, kind=SMOKE_OK, assignment_id=getattr(a, "assignment_id", None)
             )
-
-        # Merge base moved: the tested combination (this branch + that base)
-        # no longer exists, even if the branch's own diff is unchanged.
-        test_base_sha = getattr(a, "test_base_sha", None)
-        if (
-            test_base_sha is not None
-            and current_base_sha is None
-            and not base_sha_attempted
-            and gh_ops is not None
-            and repo_github
-            and target_branch
-        ):
-            current_base_sha, base_sha_probe_failed, base_sha_probe_error = _gh_get_branch_sha(
-                gh_ops, repo_github, target_branch
-            )
-            base_sha_attempted = True
-
-        # #2704: the live probe just above positively confirmed it could not
-        # read GitHub, while a recorded verdict names a specific base SHA to
-        # compare against. Before #2704 a failed (or merely un-attempted)
-        # lookup was indistinguishable from a clean `None`, so this fell
-        # straight through to the "base moved" check below, which is a
-        # silent no-op on `current_base_sha is None` and lets execution
-        # reach SMOKE_OK further down: a verdict this call never actually
-        # confirmed still covers the current base. Fail closed instead — we
-        # do not KNOW whether the base moved, so we cannot vouch for it.
-        if test_base_sha is not None and base_sha_probe_failed:
-            if unknown is None:
-                unknown = SmokeVerdictStatus(
+        if is_baseline_red_skip:
+            # #3386 review: the streak store is keyed by the coordinator's
+            # internal short `repo_name` (what `record_baseline_red_
+            # classification`/`_record_test_verdict_local` write) — NOT by
+            # `repo_github` (an "owner/repo" GitHub slug). A prior version
+            # of this fell back to `repo_github` when `a.repo_name` was
+            # falsy; that fallback would have looked up the wrong key and
+            # silently read streak=0 (never block) had it ever actually
+            # fired. A board-recorded work assignment's `repo_name` should
+            # always be populated, so there is no real fallback value to
+            # have here — dropped rather than kept as dead code with wrong
+            # semantics.
+            repo_for_streak = getattr(a, "repo_name", None)
+            if repo_for_streak and baseline_red_merge_blocked(repo_for_streak):
+                return SmokeVerdictStatus(
                     ok=False,
-                    kind=SMOKE_UNKNOWN,
+                    kind=SMOKE_BASELINE_RED_BLOCKED,
                     assignment_id=getattr(a, "assignment_id", None),
-                    anchor="base",
-                    recorded_sha=test_base_sha,
-                    probe_error=base_sha_probe_error,
+                    baseline_red_streak=baseline_red_streak(repo_for_streak),
                 )
-            continue
 
-        # #1738/#1778/#1847: the base moved, but a moved SHA doesn't
-        # necessarily mean a content change that could affect a test result.
-        # `_base_move_spared` tries, in order: is the base move itself
-        # provably inert content (docs/scripts/issue-template only, #1738);
-        # failing that, is *this branch*'s entire diff (as actually tested,
-        # test_base_sha..test_head_sha) provably inert (#1778); failing that,
-        # do the two diffs simply touch disjoint files (#1847) — a
-        # substantive base move and a substantive branch that have nothing to
-        # do with each other. Any one being true means the tested combination
-        # is still covered — fall through to the branch-content check below
-        # instead of staling here. If the branch has since gained real
-        # content, that check still catches it independently via the
-        # patch-id compare (#1847 doesn't short-circuit it).
         base_move_spare_reason: str | None = None
-        if (
-            test_base_sha is not None
-            and current_base_sha is not None
-            and test_base_sha != current_base_sha
-        ):
-            spared, base_move_spare_reason = _base_move_spared(
-                gh_ops,
-                repo_github,
-                test_base_sha,
-                current_base_sha,
-                getattr(a, "test_head_sha", None),
-            )
-            if not spared:
-                # stale: re-verify against the new base
-                if stale is None:
-                    stale = SmokeVerdictStatus(
+        test_base_sha = getattr(a, "test_base_sha", None)
+        if test_state == "passed":
+            # Merge base moved: the tested combination (this branch + that
+            # base) no longer exists, even if the branch's own diff is
+            # unchanged. #3386: skipped entirely for a `baseline_red` skip —
+            # see the comment above.
+            if (
+                test_base_sha is not None
+                and current_base_sha is None
+                and not base_sha_attempted
+                and gh_ops is not None
+                and repo_github
+                and target_branch
+            ):
+                current_base_sha, base_sha_probe_failed, base_sha_probe_error = (
+                    _gh_get_branch_sha(gh_ops, repo_github, target_branch)
+                )
+                base_sha_attempted = True
+
+            # #2704: the live probe just above positively confirmed it could
+            # not read GitHub, while a recorded verdict names a specific
+            # base SHA to compare against. Before #2704 a failed (or merely
+            # un-attempted) lookup was indistinguishable from a clean
+            # `None`, so this fell straight through to the "base moved"
+            # check below, which is a silent no-op on `current_base_sha is
+            # None` and lets execution reach SMOKE_OK further down: a
+            # verdict this call never actually confirmed still covers the
+            # current base. Fail closed instead — we do not KNOW whether
+            # the base moved, so we cannot vouch for it.
+            if test_base_sha is not None and base_sha_probe_failed:
+                if unknown is None:
+                    unknown = SmokeVerdictStatus(
                         ok=False,
-                        kind=SMOKE_STALE,
+                        kind=SMOKE_UNKNOWN,
                         assignment_id=getattr(a, "assignment_id", None),
                         anchor="base",
                         recorded_sha=test_base_sha,
-                        current_sha=current_base_sha,
+                        probe_error=base_sha_probe_error,
                     )
                 continue
 
+            # #1738/#1778/#1847: the base moved, but a moved SHA doesn't
+            # necessarily mean a content change that could affect a test
+            # result. `_base_move_spared` tries, in order: is the base move
+            # itself provably inert content (docs/scripts/issue-template
+            # only, #1738); failing that, is *this branch*'s entire diff (as
+            # actually tested, test_base_sha..test_head_sha) provably inert
+            # (#1778); failing that, do the two diffs simply touch disjoint
+            # files (#1847) — a substantive base move and a substantive
+            # branch that have nothing to do with each other. Any one being
+            # true means the tested combination is still covered — fall
+            # through to the branch-content check below instead of staling
+            # here. If the branch has since gained real content, that check
+            # still catches it independently via the patch-id compare
+            # (#1847 doesn't short-circuit it).
+            if (
+                test_base_sha is not None
+                and current_base_sha is not None
+                and test_base_sha != current_base_sha
+            ):
+                spared, base_move_spare_reason = _base_move_spared(
+                    gh_ops,
+                    repo_github,
+                    test_base_sha,
+                    current_base_sha,
+                    getattr(a, "test_head_sha", None),
+                )
+                if not spared:
+                    # stale: re-verify against the new base
+                    if stale is None:
+                        stale = SmokeVerdictStatus(
+                            ok=False,
+                            kind=SMOKE_STALE,
+                            assignment_id=getattr(a, "assignment_id", None),
+                            anchor="base",
+                            recorded_sha=test_base_sha,
+                            current_sha=current_base_sha,
+                        )
+                    continue
+
         # Branch content changed since the test ran. Same SHA-then-patch-id
         # fallback as has_approved_review: a content-identical rebase (SHA
         # moved, patch-id didn't) does not invalidate the verdict.