Add DiffPane improvements: auto-refresh, selection, keyboard nav, dock integration

- Auto-refresh DiffPane via background git poller (no main-thread blocking)
- Only update when diff content actually changes (generation skip)
- Preserve expanded/collapsed state across refreshes
- Fix editor text selection off-by-one (gutter width 5→6)
- Add DiffPane selection highlight rendering
- Add DiffPane text selection and Cmd+C copy support
- Add keyboard navigation (j/k, Enter/Space toggle)
- Per-file horizontal scroll instead of global
- Open DiffPane in dock instead of split
- File header click to toggle expand/collapse with pointer cursor
- Fix scroll overscroll clamping

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

Author: eatnug

Cargo.lock

@@ -6,7 +6,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.41.0"
+version = "0.42.0"
 license = "MIT"
 repository = "https://github.com/eatnug/tide"
 authors = ["eatnug"]

Cargo.toml

@@ -308,7 +308,15 @@ pub(crate) fn compute_hover_target(
         );
         if content.contains(pos) {
             match ctx.pane(id) {
-                Some(PaneKind::Terminal(_)) | Some(PaneKind::Editor(_)) | Some(PaneKind::Diff(_)) => {
+                Some(PaneKind::Terminal(_)) | Some(PaneKind::Editor(_)) => {
+                    return Some(HoverTarget::PaneContent);
+                }
+                Some(PaneKind::Diff(dp)) => {
+                    let cell_size = ctx.cell_size();
+                    let visual_row = ((pos.y - content.y) / cell_size.height).floor() as usize;
+                    if dp.is_file_header_row(visual_row) {
+                        return Some(HoverTarget::DiffFileHeader);
+                    }
                     return Some(HoverTarget::PaneContent);
                 }
                 _ => {}

crates/tide-app/src/adapter/inward/click_adapter/hit_test.rs

@@ -252,6 +252,37 @@ pub(crate) fn handle_mouse_down(ctx: &mut impl MousePorts, button: MouseButton,
         }
     }
 
+    // Diff pane file header click (toggle expand/collapse) — only on header rows
+    if button == MouseButton::Left {
+        let pos = ctx.last_cursor_pos();
+        let cell_size = ctx.cell_size();
+        let content_top = TAB_BAR_HEIGHT;
+        let rects: Vec<_> = ctx.visual_pane_rects().to_vec();
+        for &(id, rect) in &rects {
+            let content = crate::tide_core::Rect::new(
+                rect.x + PANE_PADDING,
+                rect.y + content_top,
+                rect.width - 2.0 * PANE_PADDING,
+                rect.height - content_top - PANE_PADDING,
+            );
+            if content.contains(pos) {
+                if let Some(crate::pane::PaneKind::Diff(dp)) = ctx.pane_mut(id) {
+                    let visual_row = ((pos.y - content.y) / cell_size.height).floor() as usize;
+                    if dp.is_file_header_row(visual_row) {
+                        dp.click_row(visual_row);
+                        ctx.focus_pane(id);
+                        ctx.set_focus_area(crate::state::FocusArea::Dock);
+                        ctx.request_redraw();
+                        return;
+                    }
+                    // Non-header: focus the pane but let text selection handle the rest
+                    ctx.focus_pane(id);
+                    ctx.set_focus_area(crate::state::FocusArea::Dock);
+                }
+            }
+        }
+    }
+
     // Config page
     if button == MouseButton::Left && ctx.modal().config_page.is_some() {
         crate::adapter::inward::click_adapter::pane::handle_config_page_click(ctx, ctx.last_cursor_pos());

crates/tide-app/src/adapter/inward/mouse_adapter/mod.rs

@@ -43,7 +43,7 @@ pub(super) fn start_text_selection(ctx: &mut (impl AppCorePort + InputStatePort
     let editor_cell = {
         let cs = cell_size_cached;
         if let Some((_, rect)) = rects.iter().find(|(id, _)| *id == pid) {
-            let gutter = 5.0 * cs.width;
+            let gutter = crate::pane::editor::GUTTER_WIDTH_CELLS as f32 * cs.width;
             let cx = rect.x + PANE_PADDING + gutter;
             let cy = rect.y + content_top_offset;
             let rc = ((pos.x - cx) / cs.width).floor() as isize;
@@ -58,6 +58,30 @@ pub(super) fn start_text_selection(ctx: &mut (impl AppCorePort + InputStatePort
         }
     };
 
+    // Diff pane cell: virtual row (scroll + visual), col
+    let diff_cell = {
+        let cs = cell_size_cached;
+        if let Some((_, rect)) = rects.iter().find(|(id, _)| *id == pid) {
+            let cx = rect.x + PANE_PADDING;
+            let cy = rect.y + content_top_offset;
+            let rc = ((pos.x - cx) / cs.width).floor() as isize;
+            let rr = ((pos.y - cy) / cs.height).floor() as isize;
+            if rr >= 0 && rc >= 0 {
+                // Convert visual row to virtual row using scroll offset
+                if let Some(PaneKind::Diff(dp)) = ctx.pane(pid) {
+                    let virtual_row = dp.scroll as usize + rr as usize;
+                    Some((virtual_row, rc as usize))
+                } else {
+                    None
+                }
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    };
+
     // Shift+click: extend existing selection instead of starting a new one
     if shift_held {
         match ctx.pane_mut(pid) {
@@ -115,6 +139,12 @@ pub(super) fn start_text_selection(ctx: &mut (impl AppCorePort + InputStatePort
                     }
                 }
             }
+            Some(PaneKind::Diff(dp)) => {
+                if let (Some(ref mut sel), Some((vr, vc))) = (&mut dp.selection, diff_cell) {
+                    sel.end = (vr, vc);
+                    return true;
+                }
+            }
             _ => {}
         }
         // No existing selection to extend — fall through to create a new one
@@ -183,7 +213,14 @@ pub(super) fn start_text_selection(ctx: &mut (impl AppCorePort + InputStatePort
                 });
             }
         }
-        Some(PaneKind::Diff(_)) => {}
+        Some(PaneKind::Diff(dp)) => {
+            if let Some((vr, vc)) = diff_cell {
+                dp.selection = Some(Selection {
+                    anchor: (vr, vc),
+                    end: (vr, vc),
+                });
+            }
+        }
         Some(PaneKind::Launcher(_)) => {}
         None => {}
     }
@@ -272,7 +309,18 @@ pub(super) fn handle_selection_drag(ctx: &mut (impl AppCorePort + PaneAccessPort
                     );
                 }
             }
-            Some(PaneKind::Diff(_)) => {}
+            Some(PaneKind::Diff(dp)) => {
+                let cx = rect.x + PANE_PADDING;
+                let cy = rect.y + drag_top_offset;
+                let rc = ((pos.x - cx) / cell_size.width).floor() as isize;
+                let rr = ((pos.y - cy) / cell_size.height).floor() as isize;
+                if rr >= 0 && rc >= 0 {
+                    let virtual_row = dp.scroll as usize + rr as usize;
+                    if let Some(ref mut sel) = dp.selection {
+                        sel.end = (virtual_row, rc as usize);
+                    }
+                }
+            }
             Some(PaneKind::Launcher(_)) => {}
             None => {}
         }

crates/tide-app/src/adapter/inward/mouse_adapter/selection.rs

@@ -139,14 +139,18 @@ pub(crate) fn handle_scroll(
                 }
                 Some(PaneKind::Diff(dp)) => {
                     let delta = (editor_dx.abs() * 3.0).ceil() as usize;
-                    let vis_cols = {
-                        (rect.width / cs.width).floor() as usize
-                    };
-                    let max_h = dp.max_line_len().saturating_sub(vis_cols.saturating_sub(4));
-                    if editor_dx > 0.0 {
-                        dp.h_scroll = dp.h_scroll.saturating_sub(delta);
-                    } else {
-                        dp.h_scroll = (dp.h_scroll + delta).min(max_h);
+                    let vis_cols = (rect.width / cs.width).floor() as usize;
+                    let content_y = rect.y + scroll_top_off;
+                    let visual_row = ((cursor_pos.y - content_y) / cs.height).floor().max(0.0) as usize;
+                    if let Some(fi) = dp.file_index_at_row(visual_row) {
+                        let max_h = dp.max_line_len().saturating_sub(vis_cols.saturating_sub(4));
+                        let cur = dp.h_scroll.get(&fi).copied().unwrap_or(0);
+                        let new_val = if editor_dx > 0.0 {
+                            cur.saturating_sub(delta)
+                        } else {
+                            (cur + delta).min(max_h)
+                        };
+                        dp.h_scroll.insert(fi, new_val);
                     }
                     dp.generation = dp.generation.wrapping_add(1);
                 }

crates/tide-app/src/adapter/inward/scroll_adapter/mod.rs

@@ -159,7 +159,11 @@ pub(crate) fn render_cursor_and_highlights(
                 let sb_hovered = matches!(app.interaction.hover_target, Some(crate::state::drag_types::HoverTarget::EditorScrollbar(hid)) if hid == id);
                 pane.render_scrollbar(inner, renderer, pane.search.as_ref(), p, sb_hovered);
             }
-            Some(PaneKind::Diff(_)) => {}
+            Some(PaneKind::Diff(dp)) => {
+                if let Some(ref sel) = dp.selection {
+                    render_diff_selection(dp, inner, renderer, p, sel);
+                }
+            }
             Some(PaneKind::Browser(_)) => {}
             Some(PaneKind::Launcher(_)) => {}
             None => {}
@@ -260,6 +264,52 @@ fn render_editor_search_highlights(
     }
 }
 
+/// Render selection highlight for a diff pane.
+/// Selection coordinates use virtual rows (scroll offset + visual row) and columns.
+fn render_diff_selection(
+    dp: &crate::pane::diff::DiffPane,
+    inner: Rect,
+    renderer: &mut crate::tide_renderer::WgpuRenderer,
+    p: &ThemePalette,
+    sel: &crate::pane::Selection,
+) {
+    let cell_size = renderer.cell_size();
+    let (start, end) = if sel.anchor <= sel.end {
+        (sel.anchor, sel.end)
+    } else {
+        (sel.end, sel.anchor)
+    };
+    if start == end {
+        return;
+    }
+    let sel_color = p.selection;
+    let scroll = dp.scroll as usize;
+    let visible_rows = (inner.height / cell_size.height).ceil() as usize;
+    let visible_cols = (inner.width / cell_size.width).ceil() as usize;
+    let flat = dp.flat_lines();
+
+    for row in start.0..=end.0 {
+        if row < scroll || row >= scroll + visible_rows {
+            continue;
+        }
+        let visual_row = row - scroll;
+        let col_start = if row == start.0 { start.1 } else { 0 };
+        let col_end = if row == end.0 {
+            end.1
+        } else {
+            flat.get(row).map_or(visible_cols, |l| l.chars().count().max(visible_cols))
+        };
+        if col_start >= col_end {
+            continue;
+        }
+        let vis_end = col_end.min(visible_cols);
+        let rx = inner.x + col_start as f32 * cell_size.width;
+        let ry = inner.y + visual_row as f32 * cell_size.height;
+        let rw = (vis_end - col_start) as f32 * cell_size.width;
+        renderer.draw_rect(Rect::new(rx, ry, rw, cell_size.height), sel_color);
+    }
+}
+
 /// Render selection highlight for a markdown preview pane.
 fn render_preview_selection(
     pane: &crate::pane::editor::EditorPane,

crates/tide-app/src/adapter/outward/view/cursor.rs

@@ -179,6 +179,9 @@ pub(crate) fn render_hover(
                 crate::state::drag_types::HoverTarget::PaneContent => {
                     // No visual overlay — only affects cursor icon (IBeam)
                 }
+                crate::state::drag_types::HoverTarget::DiffFileHeader => {
+                    // No visual overlay — only affects cursor icon (Pointer)
+                }
             }
         }
     }

crates/tide-app/src/adapter/outward/view/hover.rs

@@ -697,7 +697,8 @@ impl crate::application::ports::inward::PaneAccessPort for App {
             match pane {
                 PaneKind::Terminal(p) => p.selection = None,
                 PaneKind::Editor(p) => p.selection = None,
-                PaneKind::Diff(_) | PaneKind::Browser(_) | PaneKind::Launcher(_) => {}
+                PaneKind::Diff(p) => p.selection = None,
+                PaneKind::Browser(_) | PaneKind::Launcher(_) => {}
             }
         }
     }