fix: invalidate width caches on same-length list mutation

Length-keyed width caches missed same-length content swaps (e.g. a
file rename or commit-summary edit), leaving the right-scroll bound
clamped to the old longest entry. Route every list mutation through
set_files/set_commits/set_commit_files helpers that clear the cache
on every assignment.

Author: baudouin-iv

src/app.rs

@@ -751,6 +751,38 @@ mod tests {
         );
     }
 
+    #[test]
+    fn snapshot_invalidates_path_width_cache_on_same_length_rename() {
+        let (snapshot, tx) = dummy_snapshot_channel();
+        let mut app = App {
+            snapshot,
+            ..app_with_files(vec!["short.rs"])
+        };
+        // Prime the width cache by reading the right-scroll bound once.
+        app.file_scroll_right();
+        // Rename to a longer path while keeping the file count constant.
+        // Length-keyed invalidation alone would miss this; the cache must
+        // clear on every `set_files` assignment.
+        tx.send(SnapshotMsg::Ok(
+            RepoSnapshot {
+                files: vec![ChangedFile::new(
+                    "a_much_longer_renamed_path.rs".to_string(),
+                    ChangeStatus::Modified,
+                )],
+                tracking: None,
+            },
+            HashMap::new(),
+        ))
+        .unwrap();
+        app.poll_snapshot();
+        // Drive enough right-scrolls to reach the new max; if the cache were
+        // stale we would clamp at the old (shorter) bound.
+        for _ in 0..20 {
+            app.file_scroll_right();
+        }
+        assert!(app.status_view.file_scroll_x >= "short.rs".chars().count());
+    }
+
     #[test]
     fn snapshot_refresh_with_no_filter_matches_clears_stale_diff() {
         let (snapshot, tx) = dummy_snapshot_channel();

src/app/focus.rs

@@ -11,13 +11,13 @@ impl App {
                 self.log_view.commit_scroll_x = 0;
                 match self.with_repo(|repo| load_commit_log(repo, COMMIT_LOG_LIMIT)) {
                     Ok(commits) => {
-                        self.log_view.commits = commits;
+                        self.log_view.set_commits(commits);
                         self.log_view.selected = 0;
                         self.load_commit_diff_for_selected();
                     }
                     Err(e) => {
                         tracing::warn!(error = %e, "failed to load commit log");
-                        self.log_view.commits.clear();
+                        self.log_view.set_commits(Vec::new());
                         self.log_view.selected = 0;
                         self.status = Some(format!("git error: {e}"));
                     }

src/app/navigation.rs

@@ -313,7 +313,7 @@ impl App {
         };
         match self.with_repo(|repo| load_commit_files(repo, oid)) {
             Ok(files) => {
-                self.log_view.commit_files = files;
+                self.log_view.set_commit_files(files);
                 self.log_view.file_selected = 0;
                 self.log_view.drill_down = true;
                 if self.log_view.commit_files.is_empty() {

src/app/session_io.rs

@@ -88,7 +88,7 @@ impl App {
                 return;
             }
         };
-        self.log_view.commits = commits;
+        self.log_view.set_commits(commits);
         self.log_view.selected = state
             .log_selected
             .min(self.log_view.commits.len().saturating_sub(1));
@@ -112,7 +112,7 @@ impl App {
         };
         match self.with_repo(|repo| load_commit_files(repo, oid)) {
             Ok(files) => {
-                self.log_view.commit_files = files;
+                self.log_view.set_commit_files(files);
                 self.log_view.drill_down = true;
                 if self.log_view.commit_files.is_empty() {
                     self.log_view.file_selected = 0;

src/app/snapshot_io.rs

@@ -26,7 +26,7 @@ impl App {
             .files
             .get(self.status_view.selected)
             .map(|f| f.path.clone());
-        self.status_view.files = snapshot.files;
+        self.status_view.set_files(snapshot.files);
         self.status_view.recompute_filter();
         self.tracking = snapshot.tracking;
         self.merge_hot_table(mtimes);

src/ui/log_view.rs

@@ -20,12 +20,28 @@ pub struct LogView {
 }
 
 impl LogView {
+    /// Replace `commits` and invalidate the summary-width cache. See
+    /// `StatusView::set_files` for the same-length rationale.
+    pub(crate) fn set_commits(&mut self, commits: Vec<CommitEntry>) {
+        self.commits = commits;
+        self.commit_width_cache.set(None);
+    }
+
+    /// Replace `commit_files` and invalidate the file-width cache so a
+    /// same-length drill-in into a different commit doesn't reuse the
+    /// previous commit's max path width.
+    pub(crate) fn set_commit_files(&mut self, files: Vec<ChangedFile>) {
+        self.commit_files = files;
+        self.commit_files_width_cache.set(None);
+    }
+
     /// Exit drill-down so the upper pane shows the commit list again. Clears
     /// the file list and resets file-side cursors/scroll so a later drill-in
     /// starts from a clean state.
     pub fn reset_drill_down(&mut self) {
         self.drill_down = false;
         self.commit_files.clear();
+        self.commit_files_width_cache.set(None);
         self.file_selected = 0;
         self.file_scroll_x = 0;
     }

src/ui/status_view.rs

@@ -23,13 +23,22 @@ pub struct StatusView {
     pub hot_table: HashMap<String, SystemTime>,
     /// Memoized longest-path char width, keyed by `files.len()`. Used by
     /// `upper_scroll_x_max` so the right-arrow keystroke does not walk every
-    /// path on every press. Invalidated on length change; in this app the
-    /// snapshot worker replaces `files` wholesale every tick so length-keyed
-    /// invalidation is reliable enough for scroll bounds.
+    /// path on every press. Length-keyed invalidation alone misses
+    /// same-length content swaps (e.g. renames), so mutations must go through
+    /// `set_files`, which clears this cell on every assignment.
     pub(crate) path_width_cache: Cell<Option<(usize, usize)>>,
 }
 
 impl StatusView {
+    /// Replace `files` and invalidate the path-width cache so a same-length
+    /// snapshot whose contents changed (e.g. a file rename) does not leave a
+    /// stale right-scroll bound. Length-keyed invalidation alone misses the
+    /// rename case; clearing the cell on every assignment closes that hole.
+    pub(crate) fn set_files(&mut self, files: Vec<ChangedFile>) {
+        self.files = files;
+        self.path_width_cache.set(None);
+    }
+
     /// Clear the search query and its lowercase cache together so callers
     /// can't accidentally reset only one and leave the cache stale.
     pub fn clear_search(&mut self) {