fix: address crosscheck review findings

- Follow mode: anchor to current file when preceding files disappear,
  clamp to adjacent position only when current file is gone
- Follow mode: replace goto with labeled break for idiomatic Go
- Baseline reset: clear LastChangedPath to prevent stale follow jumps
- Baseline reset: send empty update on ComputeDiff failure to clear UI
- Add TODO(v2) comments for isIgnored and getUntrackedDiff performance

Author: Astro-Han

internal/git/diff.go

@@ -62,6 +62,8 @@ func getTrackedDiff(repoDir, baselineSHA string) ([]internal.FileDiff, error) {
 }
 
 // getUntrackedDiff expands untracked files and directories to synthetic added diffs.
+// TODO(v2): reads entire file into memory; consider capping read size for large
+// generated files and delegating binary detection to git.
 func getUntrackedDiff(repoDir string) ([]internal.FileDiff, error) {
 	cmd := exec.Command("git", "status", "--porcelain", "-z", "--untracked-files=all")
 	cmd.Dir = repoDir

internal/ui/model.go

@@ -64,6 +64,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.Notification = "baseline reset"
 		m.NewCount = 0
 		m.NewFiles = make(map[string]bool)
+		m.LastChangedPath = ""
 		return m, tea.Tick(2*time.Second, func(time.Time) tea.Msg {
 			return ClearNotificationMsg{}
 		})
@@ -107,19 +108,38 @@ func (m Model) applyFilesUpdate(msg FilesUpdatedMsg) Model {
 	m.Files = msg.Files
 
 	if m.FollowOn && len(m.Files) > 0 {
-		target := len(m.Files) - 1
+		// Try to follow the most recently changed file that still exists in the list.
+		target := -1
+	findTarget:
 		for i := len(msg.ChangedPaths) - 1; i >= 0; i-- {
-			changedPath := msg.ChangedPaths[i]
 			for j, file := range m.Files {
-				if file.Path == changedPath {
+				if file.Path == msg.ChangedPaths[i] {
 					target = j
-					goto followTargetFound
+					break findTarget
 				}
 			}
 		}
-	followTargetFound:
-		m.CurrentIdx = target
-		m.ScrollOffset = 0
+		if target >= 0 {
+			m.CurrentIdx = target
+			m.ScrollOffset = 0
+		} else {
+			// No changed file matched; try to stay on the current file.
+			anchored := false
+			for i, file := range m.Files {
+				if file.Path == currentPath {
+					m.CurrentIdx = i
+					anchored = true
+					break
+				}
+			}
+			if !anchored {
+				// Current file disappeared; clamp to adjacent position.
+				if m.CurrentIdx >= len(m.Files) {
+					m.CurrentIdx = len(m.Files) - 1
+				}
+				m.ScrollOffset = 0
+			}
+		}
 		m.NewFiles = make(map[string]bool)
 		m.LastChangedPath = ""
 		m.NewCount = 0

internal/ui/model_test.go

@@ -230,6 +230,57 @@ func TestModelDropsQueuedOverlayUpdateAfterBaselineReset(t *testing.T) {
 	}
 }
 
+// TestModelFollowAnchorsWhenPrecedingFilesDisappear verifies that follow mode
+// keeps the current file selected when earlier files are removed from the list.
+func TestModelFollowAnchorsWhenPrecedingFilesDisappear(t *testing.T) {
+	model := NewModel("repo", "/tmp/repo", "sha", []internal.FileDiff{
+		file("a.txt", 1),
+		file("b.txt", 1),
+		file("c.txt", 1),
+		file("d.txt", 1),
+	})
+	model.CurrentIdx = 2 // viewing c.txt
+
+	updated, _ := model.Update(FilesUpdatedMsg{
+		Files: []internal.FileDiff{
+			file("b.txt", 1),
+			file("c.txt", 1),
+			file("d.txt", 1),
+		},
+		ChangedPaths: []string{"a.txt"}, // reverted, no longer in list
+	})
+
+	got := updated.(Model)
+	if got.CurrentIdx != 1 || got.Files[got.CurrentIdx].Path != "c.txt" {
+		t.Fatalf("CurrentIdx = %d (%s), want 1 (c.txt)", got.CurrentIdx, got.Files[got.CurrentIdx].Path)
+	}
+}
+
+// TestModelFollowClampsWhenCurrentFileDisappears verifies that follow mode
+// selects the adjacent file when the currently viewed file is reverted.
+func TestModelFollowClampsWhenCurrentFileDisappears(t *testing.T) {
+	model := NewModel("repo", "/tmp/repo", "sha", []internal.FileDiff{
+		file("a.txt", 1),
+		file("b.txt", 1),
+		file("c.txt", 1),
+	})
+	model.CurrentIdx = 2 // viewing c.txt
+
+	updated, _ := model.Update(FilesUpdatedMsg{
+		Files: []internal.FileDiff{
+			file("a.txt", 1),
+			file("b.txt", 1),
+		},
+		ChangedPaths: []string{"c.txt"}, // reverted, gone
+	})
+
+	got := updated.(Model)
+	// Old CurrentIdx was 2, list now has 2 items, clamp to 1 (b.txt).
+	if got.CurrentIdx != 1 {
+		t.Fatalf("CurrentIdx = %d, want 1", got.CurrentIdx)
+	}
+}
+
 // TestModelViewSmallHeightDoesNotPanic verifies tiny terminal heights do not
 // trigger negative content heights in overlay rendering.
 func TestModelViewSmallHeightDoesNotPanic(t *testing.T) {

internal/watcher/watcher.go

@@ -165,6 +165,8 @@ func isHeadOrRefPath(path, gitDir string) bool {
 }
 
 // isIgnored checks whether git would ignore this path.
+// TODO(v2): forks a git process per event; consider caching .gitignore rules
+// or using an in-process ignore matcher to reduce overhead under high-frequency writes.
 func (fw *FileWatcher) isIgnored(path string) bool {
 	rel := path
 	if computed, err := filepath.Rel(fw.repoDir, path); err == nil {

main.go

@@ -124,5 +124,16 @@ func sendBaselineReset(stderr io.Writer, sender messageSender, root, newSHA stri
 	// Bubble Tea preserves send order, so the reset lands before the fresh diff
 	// recomputation for the new baseline.
 	sender.Send(ui.BaselineResetMsg{NewSHA: newSHA})
-	sendFilesUpdated(stderr, sender, root, newSHA, nil)
+
+	newFiles, computeErr := gitpkg.ComputeDiff(root, newSHA)
+	if computeErr != nil {
+		_, _ = fmt.Fprintf(stderr, "Error computing diff: %v\n", computeErr)
+		// Clear stale files so the UI does not show diffs from the old baseline.
+		sender.Send(ui.FilesUpdatedMsg{BaselineSHA: newSHA})
+		return
+	}
+	sender.Send(ui.FilesUpdatedMsg{
+		BaselineSHA: newSHA,
+		Files:       newFiles,
+	})
 }