fix: reset commit log on merge that interleaves commits past the prior head

The HEAD-refresh prepend path assumed the cached commit list was a
contiguous suffix of the fresh first page. A merge can insert
side-branch commits between the old head and the cached prefix, so
prepending would corrupt revwalk order and break future skip
pagination. The refresh now only prepends when the fresh page tail
exactly matches the cached prefix; otherwise it resets to the fresh
first page. Toggling back into Log mode now also compares the cached
head against the latest observed HEAD and refreshes when they
diverge, since Status mode does not keep the hidden commit list
in sync. Two regression tests cover the no-ff merge case and the
stale-Log-cache toggle path.

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

Author: code0xff

src/app.rs

@@ -986,6 +986,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn toggling_log_after_status_head_change_reloads_stale_cache() {
+        let (_dir, path) = make_repo();
+        run_git(&path, &["commit", "--allow-empty", "-m", "first"]);
+
+        let (snapshot, tx) = dummy_snapshot_channel();
+        let mut app = App {
+            snapshot,
+            ..app_with_files(vec![])
+        };
+        app.repo_path = path.clone();
+        app.mode = ViewMode::Status;
+        app.log_view
+            .set_commits(load_commit_log(&open_repo(&path), 500).unwrap());
+        app.last_head_oid = app.log_view.commits.first().map(|c| c.oid);
+        assert_eq!(app.log_view.commits[0].summary, "first");
+
+        run_git(&path, &["commit", "--allow-empty", "-m", "second"]);
+        tx.send(SnapshotMsg::Ok(snapshot_with_head(&path), HashMap::new()))
+            .unwrap();
+        app.poll_snapshot();
+
+        // Status mode leaves the hidden list untouched, but records the new
+        // HEAD. Entering Log mode must notice the mismatch and reconcile page 0
+        // rather than reusing the stale cached page as-is.
+        assert_eq!(app.log_view.commits.len(), 1);
+        assert_eq!(app.log_view.commits[0].summary, "first");
+
+        app.toggle_mode();
+
+        assert_eq!(app.mode, ViewMode::Log);
+        assert_eq!(app.log_view.commits.len(), 2);
+        assert_eq!(app.log_view.commits[0].summary, "second");
+        assert_eq!(app.log_view.selected, 1);
+        assert_eq!(app.log_view.commits[app.log_view.selected].summary, "first");
+        assert!(app.log_view.fully_loaded);
+        assert!(app.commit_log_page_rx.is_none());
+    }
+
     #[test]
     fn head_change_preserves_selected_commit_by_oid() {
         let (_dir, path) = make_repo();
@@ -1956,6 +1995,52 @@ mod tests {
         drop(dir);
     }
 
+    #[test]
+    fn refresh_after_head_change_keeps_merged_side_branch_commits() {
+        let (dir, path) = make_repo();
+        std::fs::write(Path::new(&path).join("base"), "0").unwrap();
+        run_git(&path, &["add", "."]);
+        run_git(&path, &["commit", "-m", "c0"]);
+
+        run_git(&path, &["checkout", "-b", "feature"]);
+        std::fs::write(Path::new(&path).join("feature"), "feature").unwrap();
+        run_git(&path, &["add", "."]);
+        run_git(&path, &["commit", "-m", "feature"]);
+
+        run_git(&path, &["checkout", "-"]);
+        std::fs::write(Path::new(&path).join("main"), "main").unwrap();
+        run_git(&path, &["add", "."]);
+        run_git(&path, &["commit", "-m", "c1"]);
+
+        let mut app = app_with_files(vec![]);
+        app.repo_path = path.clone();
+        app.mode = ViewMode::Log;
+        app.log_view
+            .set_commits(load_commit_log(&open_repo(&path), 500).unwrap());
+        assert_eq!(app.log_view.commits.len(), 2);
+        assert_eq!(app.log_view.commits[0].summary, "c1");
+
+        run_git(
+            &path,
+            &["merge", "--no-ff", "feature", "-m", "merge feature"],
+        );
+
+        app.refresh_commit_log_after_head_change();
+
+        let summaries: Vec<_> = app
+            .log_view
+            .commits
+            .iter()
+            .map(|c| c.summary.as_str())
+            .collect();
+        assert!(
+            summaries.contains(&"feature"),
+            "merged side-branch commit was dropped: {summaries:?}"
+        );
+        assert_eq!(app.log_view.commits.len(), 4);
+        drop(dir);
+    }
+
     #[test]
     fn refresh_after_head_change_resets_on_divergence() {
         let (dir, path) = make_repo();

src/app/diff_load.rs

@@ -284,19 +284,32 @@ impl App {
         };
 
         // If the previous head still appears in the freshly fetched first
-        // page, treat the change as a fast-forward / new commit: prepend the
-        // newer entries onto the existing list so all accumulated pages stay
-        // valid. Otherwise (rewrite, branch switch, force push, no prior list)
-        // discard everything and start from the new first page.
+        // page and the fresh tail lines up with the cached list, treat the
+        // change as a fast-forward / simple new commit: prepend the newer
+        // entries onto the existing list so all accumulated pages stay valid.
+        // A merge can interleave side-branch commits after the old head; in
+        // that case cached pages are no longer a contiguous prefix of the
+        // new revwalk, so reset to the freshly loaded first page instead.
         let prepend_idx = prior_head_oid.and_then(|oid| page.iter().position(|c| c.oid == oid));
+        let page_is_short = page.len() < page_size;
+        let can_prepend = prepend_idx.is_some_and(|idx| {
+            let fresh_tail = &page[idx..];
+            !self.log_view.commits.is_empty()
+                && fresh_tail.len() <= self.log_view.commits.len()
+                && fresh_tail
+                    .iter()
+                    .zip(self.log_view.commits.iter())
+                    .all(|(fresh, cached)| fresh.oid == cached.oid)
+        });
         if let Some(idx) = prepend_idx
-            && !self.log_view.commits.is_empty()
+            && can_prepend
         {
             let mut new_head_commits: Vec<_> = page.into_iter().take(idx).collect();
             let n_new = new_head_commits.len();
-            new_head_commits.extend(self.log_view.commits.drain(..));
+            new_head_commits.append(&mut self.log_view.commits);
             self.log_view.commits = new_head_commits;
             self.log_view.loaded_count = self.log_view.commits.len();
+            self.log_view.fully_loaded = page_is_short;
             self.log_view.commit_width_cache.set(None);
             // Slide the selection so the user keeps looking at the same
             // commit even though new entries appeared above it.

src/app/focus.rs

@@ -10,35 +10,44 @@ impl App {
                 self.mode = ViewMode::Log;
                 self.log_view.reset_drill_down();
                 self.log_view.commit_scroll_x = 0;
-                // Reuse cached pages on re-entry: refresh_commit_log_after_head_change
-                // keeps the list in sync during Status mode, so a non-empty
-                // `commits` already reflects the current HEAD.
-                if self.log_view.commits.is_empty() {
-                    let page_size = self.cfg_commit_log_page_size;
-                    match self.with_repo(|repo| load_commit_log(repo, page_size)) {
-                        Ok(commits) => {
-                            // Short first page means the entire history fits,
-                            // no further prefetch needed; a full page means
-                            // more may exist and the next move will pull it.
-                            let fully_loaded = commits.len() < page_size;
-                            self.log_view.set_commits(commits);
-                            self.log_view.fully_loaded = fully_loaded;
-                            self.log_view.selected = 0;
-                            // Sync last_head_oid to the freshly loaded HEAD so
-                            // the next snapshot tick doesn't immediately
-                            // re-trigger refresh_commit_log_after_head_change.
-                            self.last_head_oid = self.log_view.commits.first().map(|c| c.oid);
-                        }
-                        Err(e) => {
-                            tracing::warn!(error = %e, "failed to load commit log");
-                            self.log_view.set_commits(Vec::new());
-                            self.log_view.selected = 0;
-                            self.status = Some(format!("git error: {e}"));
+                // Reuse cached pages on re-entry only while they still match
+                // the latest HEAD observed by the snapshot worker. Status mode
+                // intentionally does not refresh the hidden commit list, so a
+                // HEAD change there must invalidate the cache on the next entry.
+                let cached_head = self.log_view.commits.first().map(|c| c.oid);
+                let cache_matches_head =
+                    !self.log_view.commits.is_empty() && cached_head == self.last_head_oid;
+                if !self.log_view.commits.is_empty() && !cache_matches_head {
+                    self.refresh_commit_log_after_head_change();
+                } else {
+                    if self.log_view.commits.is_empty() {
+                        self.cancel_commit_log_page_fetch();
+                        let page_size = self.cfg_commit_log_page_size;
+                        match self.with_repo(|repo| load_commit_log(repo, page_size)) {
+                            Ok(commits) => {
+                                // Short first page means the entire history fits,
+                                // no further prefetch needed; a full page means
+                                // more may exist and the next move will pull it.
+                                let fully_loaded = commits.len() < page_size;
+                                self.log_view.set_commits(commits);
+                                self.log_view.fully_loaded = fully_loaded;
+                                self.log_view.selected = 0;
+                                // Sync last_head_oid to the freshly loaded HEAD so
+                                // the next snapshot tick doesn't immediately
+                                // re-trigger refresh_commit_log_after_head_change.
+                                self.last_head_oid = self.log_view.commits.first().map(|c| c.oid);
+                            }
+                            Err(e) => {
+                                tracing::warn!(error = %e, "failed to load commit log");
+                                self.log_view.set_commits(Vec::new());
+                                self.log_view.selected = 0;
+                                self.status = Some(format!("git error: {e}"));
+                            }
                         }
                     }
+                    self.load_commit_diff_for_selected();
+                    self.maybe_prefetch_commit_log();
                 }
-                self.load_commit_diff_for_selected();
-                self.maybe_prefetch_commit_log();
             }
             ViewMode::Log => {
                 self.mode = ViewMode::Status;