code-coordinator 0.5.516__tar.gz → 0.5.518__tar.gz

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/PKG-INFO

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

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

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5.518",
+  "distance": 0,
+  "node": "gdba4bd13008ab845617ff22df60d1009a4ce15b9",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-26"
+}

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/coord/claim.py

@@ -454,6 +454,40 @@ def _default_branch_lookup(repo_github: str, issue_number: int) -> list[str]:
     return _drop_merged_branches(repo_github, branches)
 
 
+# #3442: bracket-tag issue_title prefixes (`f"[{tag}] {title}"`, see
+# `coord.review.dispatch_review` / `coord.review._dispatch_scoped_review` /
+# `coord.smoke.dispatch_pending_smoke` / `coord.gate_b`'s tracking-issue
+# dispatch) that a review/smoke/gate-b leg dispatch uses when it does NOT
+# pin `target_branch` to the real work branch — the agent then derives its
+# own throwaway branch name by slugifying that bracketed title
+# (`coord.agent._slugify`), landing on `issue-{N}-{tag}-...`. These legs
+# are read-only observers: a review posts a verdict comment, a smoke run
+# executes a command, gate-b posts a milestone verdict — none of them ever
+# commits to its own checkout, so that branch sits at `ahead_by == 0`
+# against the default branch from the moment it's created, forever,
+# regardless of whether the issue's REAL work has landed. It is not
+# evidence of anything. Every OTHER dispatcher that continues real work on
+# an issue (conflict-fix, retry, fix-N) pins `target_branch` to the actual
+# work branch instead of letting one of these get minted, so this list is
+# deliberately just the observer legs, not every bracket tag in the
+# codebase — though as #3442's own review round found for gate-b, that
+# distinction has to be verified per-dispatcher, not assumed; see the
+# issue's suggested structural alternative (branch never had commits, ever)
+# for a fix that wouldn't require keeping this list exhaustive by hand.
+_OBSERVER_LEG_TAGS = ("review", "scoped-review", "smoke", "gate-b")
+
+
+def _is_observer_leg_branch(branch: str, issue_number: int) -> bool:
+    """True when *branch* is a review/smoke leg's own throwaway checkout,
+    not a branch that could ever carry real work (see `_OBSERVER_LEG_TAGS`).
+    """
+    for tag in _OBSERVER_LEG_TAGS:
+        prefix = f"issue-{issue_number}-{tag}"
+        if branch == prefix or branch.startswith(prefix + "-"):
+            return True
+    return False
+
+
 def any_matching_branch_merged(
     repo_github: str, issue_number: int, *, branch: str | None = None
 ) -> bool:
@@ -476,17 +510,29 @@ def any_matching_branch_merged(
     merged" behaviour only when *branch* is `None` — a caller with nothing
     assigned yet (a pre-dispatch check before any branch exists) has no
     single branch to ask about, so the issue-scoped signal is the best one
-    available. Reuses the exact merge-detection `_drop_merged_branches`
-    already performs for claim detection (PR-merged OR `ahead_by == 0`
-    ancestry, survives squash merges — #3103): this is just "did filtering
-    drop anything", with the fail-open direction flipped to match a
-    REFUSAL predicate rather than a claim-signal — no matching branch at
-    all, or any lookup failure, returns `False` ("not merged, don't refuse
-    dispatch on this"), never `True`.
+    available. #3442: that fallback first drops every known
+    `_is_observer_leg_branch` candidate — #3436 only fixed the case where
+    the dispatch's OWN branch was already known; a plain `coord assign`
+    (or any other caller with no branch recorded yet, which is exactly when
+    this fallback runs) has no branch of its own to scope to, so without
+    this filter a single zero-commit `issue-{N}-review-*`/`issue-{N}-smoke-
+    *` leg branch still reads the WHOLE issue as merged and permanently
+    refuses dispatch — the same bug #3436 fixed for the branch-known case,
+    reopened for the branch-unknown one. Reuses the exact merge-detection
+    `_drop_merged_branches` already performs for claim detection (PR-merged
+    OR `ahead_by == 0` ancestry, survives squash merges — #3103): this is
+    just "did filtering drop anything", with the fail-open direction
+    flipped to match a REFUSAL predicate rather than a claim-signal — no
+    matching branch at all, or any lookup failure, returns `False` ("not
+    merged, don't refuse dispatch on this"), never `True`.
     """
     if branch is not None:
         return not _drop_merged_branches(repo_github, [branch])
-    branches = list_matching_remote_branches(repo_github, issue_number)
+    branches = [
+        b
+        for b in list_matching_remote_branches(repo_github, issue_number)
+        if not _is_observer_leg_branch(b, issue_number)
+    ]
     if not branches:
         return False
     unmerged = set(_drop_merged_branches(repo_github, branches))

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/coord/merge_queue.py

@@ -3169,6 +3169,19 @@ def evaluate_smoke_verdict(
     #821/#1475's existing convention), so rows/entries predating this
     feature behave exactly as before.
 
+    #3443: "the merge base moved" is not, by itself, "a rebase happened" —
+    the smoke runner tests the branch checked out as-is, never a merge with
+    the base, so a base that merely advanced underneath an UNREBASED branch
+    changed nothing the suite could see. Before consulting the #1738/#1778/
+    #1847 file-compare escape hatches below, a confirmed-unchanged branch
+    head (``test_head_sha == current_branch_sha``) spares the base move
+    outright — cheaper than any file compare, and exactly the signal that a
+    rebase (which always changes the branch's head SHA) did *not* happen.
+    Without it, `dispatch_pending_smoke` (#3309) re-tested an identical,
+    un-rebased branch head on every single commit landing on an active
+    target branch, converging on nothing but flakiness (vimcode#523/#526,
+    2026-09-24/25: ~20 re-runs of an unchanged branch head in a few hours).
+
     #1732: ``skipped`` is deliberately excluded from all of the above. It is
     not a measurement of code at a SHA the way ``passed`` is — it is a
     structural claim about the diff itself ("contract/fixture-only, nothing
@@ -3385,6 +3398,7 @@ def evaluate_smoke_verdict(
 
         base_move_spare_reason: str | None = None
         test_base_sha = getattr(a, "test_base_sha", None)
+        test_head_sha = getattr(a, "test_head_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
@@ -3425,32 +3439,78 @@ def evaluate_smoke_verdict(
                     )
                 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).
+            # #3443: before even asking whether the base move is content-
+            # relevant, ask the cheaper, load-bearing question first — did
+            # THIS branch actually move? The smoke runner checks the branch
+            # out as-is; it does not merge or rebase onto the base before
+            # testing (see the module-level #1479 note above), so a moved
+            # target tip only invalidates a `passed` verdict when the
+            # branch itself picked up new commits since the test ran (a
+            # rebase). A branch head confirmed identical to what was tested
+            # means its merge-base with the target cannot have changed
+            # either — the target only grows forward; it never rewrites the
+            # history the branch forked from — so re-dispatching a
+            # byte-identical branch head every time the target advances
+            # (#3309 looping against develop, vimcode#523/#526) is pure
+            # spend, not a re-test of anything new. Probed here, ahead of
+            # the base-move check, so a confirmed-unchanged branch spares it
+            # before `_base_move_spared`'s file-compare hatches even run;
+            # those stay as the fallback for what this can't confirm (probe
+            # unavailable) or the case where the branch genuinely moved.
+            if (
+                test_head_sha is not None
+                and current_branch_sha is None
+                and not branch_sha_attempted
+                and gh_ops is not None
+                and repo_github
+                and entry_branch
+            ):
+                current_branch_sha, branch_sha_probe_failed, branch_sha_probe_error = (
+                    _gh_get_branch_sha(gh_ops, repo_github, entry_branch)
+                )
+                branch_sha_attempted = True
+
             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 (
+                    test_head_sha is not None
+                    and current_branch_sha is not None
+                    and test_head_sha == current_branch_sha
+                ):
+                    spared, base_move_spare_reason = (
+                        True,
+                        "branch head unchanged since test — no rebase, "
+                        "base move alone does not stale (#3443)",
+                    )
+                else:
+                    # #1738/#1778/#1847: the base moved AND the branch head
+                    # also moved (or couldn't be confirmed unchanged), but a
+                    # moved base SHA still 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).
+                    spared, base_move_spare_reason = _base_move_spared(
+                        gh_ops,
+                        repo_github,
+                        test_base_sha,
+                        current_base_sha,
+                        test_head_sha,
+                    )
                 if not spared:
                     # stale: re-verify against the new base
                     if stale is None:
@@ -3467,7 +3527,11 @@ def evaluate_smoke_verdict(
         # 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.
-        test_head_sha = getattr(a, "test_head_sha", None)
+        # `test_head_sha` was already read above (#3443's branch-probe
+        # reordering); the probe below is a no-op here whenever the
+        # `passed` branch already ran it (`branch_sha_attempted` guards it),
+        # and is the FIRST attempt for a `skipped`/`baseline_red` row, which
+        # never enters that block.
         if (
             test_head_sha is not None
             and current_branch_sha is None

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/tests/test_claim.py

@@ -876,14 +876,15 @@ def test_any_matching_branch_merged_false_on_gh_error(monkeypatch) -> None:
 def test_any_matching_branch_merged_scoped_branch_ignores_merged_siblings(
     monkeypatch,
 ) -> None:
-    """#3436: reproduces vimcode#1156's shape — several MERGED, zero-commit
-    `issue-{N}-*` review-leg branches (cut from the default-branch tip,
-    never diverged) alongside the one real, unmerged work branch. The
-    issue-scoped (no ``branch=``) check is tripped by the merged siblings —
-    the documented fallback behaviour for a caller with nothing dispatched
-    yet — but a caller that names the ACTUAL branch in play must get an
+    """#3436/#3442: reproduces vimcode#1156's shape — several MERGED,
+    zero-commit `issue-{N}-*` review-leg branches (cut from the
+    default-branch tip, never diverged) alongside the one real, unmerged
+    work branch. A caller that names the ACTUAL branch in play must get an
     answer scoped to just that branch, not "did anything for this issue
-    ever merge"."""
+    ever merge" — and #3442: the issue-scoped fallback (no ``branch=``)
+    must ALSO see past a review-leg sibling now, since it's the fallback a
+    plain `coord assign` (nothing dispatched yet, no branch to scope to)
+    actually hits."""
     import coord.claim as claim_mod
 
     monkeypatch.setattr(
@@ -894,19 +895,107 @@ def test_any_matching_branch_merged_scoped_branch_ignores_merged_siblings(
             {"issue-1156-review-fix-1": 0, "issue-1156-real-work": 5},
         ),
     )
-    # No branch named: falls back to the issue-scoped check, which still
-    # trips on the merged sibling (unchanged pre-#3436 fallback behaviour).
-    assert claim_mod.any_matching_branch_merged("acme/api", 1156) is True
+    # No branch named: falls back to the issue-scoped check, which now
+    # excludes the review-leg sibling as not-evidence-of-anything (#3442)
+    # and finds the real work branch unmerged.
+    assert claim_mod.any_matching_branch_merged("acme/api", 1156) is False
     # Scoped to the real, unmerged work branch: must NOT report merged.
     assert claim_mod.any_matching_branch_merged(
         "acme/api", 1156, branch="issue-1156-real-work"
     ) is False
-    # Scoped to the merged sibling itself: correctly reports merged.
+    # Scoped to the merged sibling itself: correctly reports merged (an
+    # explicit ask about that exact branch is unaffected by the leg-branch
+    # exclusion the issue-scoped fallback applies).
     assert claim_mod.any_matching_branch_merged(
         "acme/api", 1156, branch="issue-1156-review-fix-1"
     ) is True
 
 
+def test_any_matching_branch_merged_issue_scoped_ignores_review_and_smoke_legs(
+    monkeypatch,
+) -> None:
+    """#3442: vimcode#523/#526's exact shape — an `issue-{N}-review-*` leg
+    branch (and an `issue-{N}-smoke-*` leg branch) at `ahead_by == 0`,
+    alongside the real, unmerged work branch. `any_matching_branch_merged`
+    with no *branch* (the `coord assign`/dispatch-liveness fallback that
+    trips before any branch is known) must refuse to treat either leg as
+    evidence the issue's real work merged."""
+    import coord.claim as claim_mod
+
+    monkeypatch.setattr(
+        "coord.github_ops._gh",
+        _gh_stub_with_matching_refs(
+            [
+                "issue-523-review-track-a-phase-0b-wire-board-actio",
+                "issue-523-smoke-track-a-phase-0b-wire-board-action",
+                "issue-523-track-a-phase-0b-wire-board-actions-to-p",
+            ],
+            "develop",
+            {
+                "issue-523-review-track-a-phase-0b-wire-board-actio": 0,
+                "issue-523-smoke-track-a-phase-0b-wire-board-action": 2,
+                "issue-523-track-a-phase-0b-wire-board-actions-to-p": 2,
+            },
+        ),
+    )
+    assert claim_mod.any_matching_branch_merged("acme/vimcode", 523) is False
+
+
+def test_any_matching_branch_merged_issue_scoped_ignores_gate_b_leg(
+    monkeypatch,
+) -> None:
+    """#3442 review follow-up: a milestone tracking issue with a completed
+    Gate B verdict (`coord.gate_b`'s dispatch is `type="review"`, doesn't
+    pin `target_branch`, and mints its own throwaway
+    `issue-{N}-gate-b-...` branch exactly like a `[review]`/`[smoke]`
+    leg) sitting at `ahead_by == 0` alongside the real, unmerged
+    milestone work branch. `any_matching_branch_merged` with no *branch*
+    (the `coord assign`/dispatch-liveness fallback that trips before any
+    branch is known — the exact path a fresh dispatch on a tracking issue
+    hits) must not treat the gate-b leg as evidence the real work
+    merged."""
+    import coord.claim as claim_mod
+
+    monkeypatch.setattr(
+        "coord.github_ops._gh",
+        _gh_stub_with_matching_refs(
+            [
+                "issue-900-gate-b-ms-900-milestone-verdict",
+                "issue-900-track-a-phase-1-milestone-work",
+            ],
+            "develop",
+            {
+                "issue-900-gate-b-ms-900-milestone-verdict": 0,
+                "issue-900-track-a-phase-1-milestone-work": 3,
+            },
+        ),
+    )
+    assert claim_mod.any_matching_branch_merged("acme/vimcode", 900) is False
+
+
+def test_is_observer_leg_branch_matches_review_scoped_review_smoke_and_gate_b() -> None:
+    """#3442: the exact prefixes review/smoke/gate-b legs mint, and nothing
+    else — a bare `issue-N-review` (no trailing content) and the slugified
+    `issue-N-review-...`/`issue-N-scoped-review-...`/`issue-N-smoke-...`/
+    `issue-N-gate-b-...` shapes all match; an unrelated branch, or one that
+    merely CONTAINS "review" past the issue-number prefix, must not."""
+    import coord.claim as claim_mod
+
+    assert claim_mod._is_observer_leg_branch("issue-9-review", 9) is True
+    assert claim_mod._is_observer_leg_branch("issue-9-review-fix-1", 9) is True
+    assert claim_mod._is_observer_leg_branch(
+        "issue-9-scoped-review-sealed-path", 9
+    ) is True
+    assert claim_mod._is_observer_leg_branch("issue-9-smoke-track-a", 9) is True
+    assert claim_mod._is_observer_leg_branch(
+        "issue-9-gate-b-ms-9-milestone-verdict", 9
+    ) is True
+    assert claim_mod._is_observer_leg_branch("issue-9-real-work", 9) is False
+    assert claim_mod._is_observer_leg_branch(
+        "issue-9-reviewer-onboarding", 9
+    ) is False
+
+
 # ── #1553: has_active_work_followup keys on the EFFECTIVE issue ─────────────
 
 

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/tests/test_cli_merge.py

@@ -2887,9 +2887,12 @@ class TestGateBlockedRowEntersQueueBlocked:
         assert mq.load_queue() == []
 
         def fake_get_branch_sha(repo, branch):
-            # The base moved since the verdict was recorded; the branch
-            # itself did not.
-            return "newbase111" if branch == "main" else "branchsha000"
+            # The base moved since the verdict was recorded, AND the branch
+            # itself was rebased (its head moved too) — #3443: a base move
+            # alone, with the branch head confirmed unchanged, no longer
+            # stales the verdict, so this needs both to still exercise a
+            # genuine STALE for the #1926 fallback-agreement check below.
+            return "newbase111" if branch == "main" else "branchsha111"
 
         with patch(
             "coord.github_ops.get_branch_sha", side_effect=fake_get_branch_sha

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/tests/test_coord_test_runner_toolchain.py

@@ -279,7 +279,7 @@ def test_a_genuinely_failing_fallback_suite_is_still_a_failure(
 
 
 def test_coordinator_route_never_invokes_cargo_or_a_quadraui_sibling(
-    tui_repo: Path, tmp_path: Path, full_bin: Path
+    tui_repo: Path, tmp_path: Path
 ) -> None:
     """#2899 (keeping #2804's guard alive after the arm it guarded left).
 
@@ -294,14 +294,17 @@ def test_coordinator_route_never_invokes_cargo_or_a_quadraui_sibling(
     runner does not call one it *could* have found is stronger than proving it
     fails without one.
     """
+    # A private mirror with any real `cargo` omitted: on a host with a system
+    # cargo (dell64's /usr/bin/cargo -> rustup) the shared `full_bin` already
+    # holds a symlink named `cargo`, and write_text() would follow it into the
+    # real binary — PermissionError when root owns it, a clobbered toolchain
+    # when the user does.
+    bin_dir = _mirror_bin_dir(tmp_path / "bin", omit_prefixes=("cargo",))
     marker = tmp_path / "cargo-was-invoked"
-    cargo = full_bin / "cargo"
+    cargo = bin_dir / "cargo"
     cargo.write_text(f"#!/bin/sh\ntouch {marker}\nexit 0\n")
     cargo.chmod(0o755)
-    try:
-        result = _run(tui_repo, tmp_path, full_bin, "--repo", "claude-coordinator")
-    finally:
-        cargo.unlink()
+    result = _run(tui_repo, tmp_path, bin_dir, "--repo", "claude-coordinator")
 
     out = result.stdout + result.stderr
     assert result.returncode == 0, out

{code_coordinator-0.5.516 → code_coordinator-0.5.518}/tests/test_gates.py

@@ -353,9 +353,15 @@ class TestDecision:
         assert by_gate["test"].anchor is None  # MISSING, not STALE
         assert by_gate["merge"].reason == SMOKE_REQUIRED
 
-    def test_stale_base_names_1479_and_shas(self, config: Config) -> None:
-        # #1479: the verdict was recorded against an old base SHA; the base
-        # has since moved. The branch's own head/patch-id are unchanged.
+    def test_base_move_alone_does_not_stale_1479(self, config: Config) -> None:
+        """#3443: the verdict was recorded against an old base SHA and the
+        base has since moved, but the branch's own head/patch-id are
+        CONFIRMED unchanged — no rebase happened, so the base move alone
+        must not stale a `passed` verdict (see
+        ``test_stale_base_names_1479_and_shas_when_branch_also_moved``
+        below for the case where the branch DID move). Superseded
+        ``test_stale_base_names_1479_and_shas``, which asserted the
+        opposite (the #3443 bug itself) before this fix."""
         work = _work(
             test_state="passed", test_reason="headless smoke",
             test_head_sha="branchsha", test_base_sha="oldbase",
@@ -365,6 +371,36 @@ class TestDecision:
         gh = FakeGh(branch_sha="branchsha", base_sha="newbase", patch_id="samepatch")
         report = build_gate_report(board, config, "api", 42, gh_ops=gh)
 
+        by_gate = {d.gate: d for d in report.decisions}
+        test_decision = by_gate["test"]
+        assert test_decision.ok is True
+        assert by_gate["merge"].reason != SMOKE_REQUIRED
+        # gh_ops was actually consulted for both the branch and the base —
+        # the #3443 spare is a POSITIVE confirmation, not a skipped check.
+        assert ("acme/api", "issue-42-foo") in gh.sha_calls
+        assert ("acme/api", "main") in gh.sha_calls
+
+    def test_stale_base_names_1479_and_shas_when_branch_also_moved(
+        self, config: Config,
+    ) -> None:
+        # #1479: the verdict was recorded against an old base SHA; the base
+        # has since moved, AND the branch itself was rebased (its head moved
+        # too) — #3443 spares a base move alone, so this needs both to still
+        # exercise the stale-verdict report.
+        work = _work(
+            test_state="passed", test_reason="headless smoke",
+            test_head_sha="branchsha-old", test_base_sha="oldbase",
+        )
+        # review_head_sha matches the CURRENT (post-rebase) branch head, so
+        # the review gate stays fresh and only the test/smoke gate is under
+        # test here.
+        review = _review("w1", verdict="approve", review_head_sha="branchsha-new")
+        board = Board(active=[], completed=[work, review])
+        gh = FakeGh(
+            branch_sha="branchsha-new", base_sha="newbase", patch_id="samepatch",
+        )
+        report = build_gate_report(board, config, "api", 42, gh_ops=gh)
+
         by_gate = {d.gate: d for d in report.decisions}
         test_decision = by_gate["test"]
         assert test_decision.ok is False
@@ -813,12 +849,18 @@ class TestIsInteractive:
 
 class TestFormatting:
     def test_format_includes_stale_wording(self, config: Config) -> None:
+        """#3443: the branch must also have moved (a rebase) — a base move
+        alone, with the branch head confirmed unchanged, no longer stales
+        the verdict at all, so this has nothing to render as STALE."""
         work = _work(
-            test_state="passed", test_head_sha="branchsha", test_base_sha="oldbase",
+            test_state="passed",
+            test_head_sha="branchsha-old", test_base_sha="oldbase",
         )
-        review = _review("w1", verdict="approve", review_head_sha="branchsha")
+        review = _review("w1", verdict="approve", review_head_sha="branchsha-new")
         board = Board(active=[], completed=[work, review])
-        gh = FakeGh(branch_sha="branchsha", base_sha="newbase", patch_id="samepatch")
+        gh = FakeGh(
+            branch_sha="branchsha-new", base_sha="newbase", patch_id="samepatch",
+        )
         report = build_gate_report(board, config, "api", 42, gh_ops=gh)
 
         text = format_gate_report(report)