test(code-review): pin diff-base selection under local/origin divergence

Coverage previously exercised the two staleness kinds separately (stale
local ref; unpushed local commits). When local main and origin/main
diverge, both happen at once: the branch is cut from one of the two tips,
and _base_rev must pick that tip. Two complementary tests — branch off the
local tip, branch off the remote tip — each pinned by mutation checks: an
always-local base fails the off-remote case, always-origin fails the
off-local case, only the per-run later-merge-base selection passes both.

The v3.6.1 changelog bullet gains one clause stating the divergence case
is handled, since that is a real property of the shipped selection.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: wongk

CHANGELOG.md

@@ -7,7 +7,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 ### code-review v3.6.1
 
 #### Fixed
-- **Local branch review no longer bases its diff on a stale ref, which folded unrelated commits into the review.** `resolve-scope` hardcoded the diff scope to `main...HEAD`. That `main` is the local branch ref, which every worktree of a clone shares, so a worktree inherits whatever commit the primary checkout last left it on. Because `A...B` diffs from `merge-base(A, B)`, a local ref sitting behind the branch's fork point dragged the merge base backwards and pulled every commit that landed on the base in between into the diff — reviewing other people's work as if it were the branch's. The base is now chosen per run between the local ref and `origin/<base>`: both merge bases are ancestors of HEAD along the base branch, so the ref producing the later one is the true fork point. This is correct under either kind of staleness — a local ref behind the fork point, or an `origin/<base>` behind it because the base has unpushed local commits (where preferring the remote ref would fold those commits in instead). A repo with no remote has no second view and keeps its local ref, so remote-less reviews are unchanged.
+- **Local branch review no longer bases its diff on a stale ref, which folded unrelated commits into the review.** `resolve-scope` hardcoded the diff scope to `main...HEAD`. That `main` is the local branch ref, which every worktree of a clone shares, so a worktree inherits whatever commit the primary checkout last left it on. Because `A...B` diffs from `merge-base(A, B)`, a local ref sitting behind the branch's fork point dragged the merge base backwards and pulled every commit that landed on the base in between into the diff — reviewing other people's work as if it were the branch's. The base is now chosen per run between the local ref and `origin/<base>`: both merge bases are ancestors of HEAD along the base branch, so the ref producing the later one is the true fork point. This is correct under either kind of staleness — a local ref behind the fork point, or an `origin/<base>` behind it because the base has unpushed local commits (where preferring the remote ref would fold those commits in instead) — and under both at once, when the local ref and `origin/<base>` have diverged: whichever tip the branch was cut from yields the deeper merge base, so it is selected regardless of which ref that is. A repo with no remote has no second view and keeps its local ref, so remote-less reviews are unchanged.
 - The base branch is now detected — `origin/HEAD`, then `main`/`master` remotely, then locally — rather than assumed to be `main`, so repositories whose default branch is `master` (or any name `origin/HEAD` reports) resolve their scope correctly instead of failing against a nonexistent `main`. `--base-ref-override` runs through the same selection, and falls back to the local branch when the named base has no remote-tracking ref rather than emitting an `origin/<ref>` that git cannot resolve.
 - `fetch-intent` now reads branch commit subjects from the same fork point instead of the raw local base ref, so intent classification and injection detection no longer receive commits that landed on the base branch and were never part of the change under review.
 

plugins/code-review/tools/python/test_code_review_helpers.py

@@ -6427,6 +6427,68 @@ def test_unpushed_base_commits_keep_the_local_ref_as_base(
         ).split()
         assert reviewed == ["MINE.txt"]
 
+    def _build_diverged_base_repo(self, repo: Path) -> None:
+        """Local ``main`` and ``origin/main`` diverge from a common ancestor.
+
+        Both kinds of staleness at once::
+
+                        A1 ── A2         <- origin/main (pushed by someone else)
+                       /
+            ... ── B0 ─┤
+                       \\
+                        L1 ── L2         <- local main (unpushed)
+
+        Neither ref alone can base every branch cut from this repo: a branch
+        off ``L2`` needs the local ref, a branch off ``A2`` needs the remote
+        one. The later merge base with HEAD identifies the correct tip.
+        """
+        repo.mkdir()
+        git_fixture(repo, "init", "--quiet", "-b", "main")
+        _commit_file(repo, "base.txt", "B0\n")  # common ancestor
+        git_fixture(repo, "checkout", "--quiet", "-b", "origin-work")
+        _commit_file(repo, "A1.txt", "pushed by someone else\n")
+        a2 = _commit_file(repo, "A2.txt", "pushed by someone else\n")
+        git_fixture(repo, "update-ref", "refs/remotes/origin/main", a2)
+        git_fixture(repo, "checkout", "--quiet", "main")
+        _commit_file(repo, "L1.txt", "unpushed local base commit\n")
+        _commit_file(repo, "L2.txt", "unpushed local base commit\n")
+
+    def test_diverged_base_branch_off_local_tip_uses_local_ref(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        # Cut from the unpushed local tip: origin/main lags, so basing on it
+        # would fold the unpushed L1/L2 into the diff.
+        repo = tmp_path / "repo"
+        self._build_diverged_base_repo(repo)
+        git_fixture(repo, "checkout", "--quiet", "-b", "feat-x", "main")
+        _commit_file(repo, "MINE.txt", "the change under review\n")
+        monkeypatch.chdir(repo)
+        with patch("code_review_helpers._detect_open_pr", return_value=None):
+            result = TestResolveScope()._run("local", tmp_path=tmp_path)
+        assert result["diff_scope"] == "main...HEAD"
+        reviewed = git_fixture(
+            repo, "diff", "--name-only", result["diff_scope"],
+        ).split()
+        assert reviewed == ["MINE.txt"]
+
+    def test_diverged_base_branch_off_remote_tip_uses_remote_ref(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        # Cut from origin/main while local main is also ahead with its own
+        # unpushed commits: basing on the local ref would fold A1/A2 in.
+        repo = tmp_path / "repo"
+        self._build_diverged_base_repo(repo)
+        git_fixture(repo, "checkout", "--quiet", "-b", "feat-x", "origin/main")
+        _commit_file(repo, "MINE.txt", "the change under review\n")
+        monkeypatch.chdir(repo)
+        with patch("code_review_helpers._detect_open_pr", return_value=None):
+            result = TestResolveScope()._run("local", tmp_path=tmp_path)
+        assert result["diff_scope"] == "origin/main...HEAD"
+        reviewed = git_fixture(
+            repo, "diff", "--name-only", result["diff_scope"],
+        ).split()
+        assert reviewed == ["MINE.txt"]
+
     def test_identical_base_views_resolve_to_the_remote_ref(
         self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
     ) -> None: