feat: add records-mode drill-down with staged edits

Introduce records-mode drill-down functionality that allows users to
edit individual records without immediately modifying the underlying model.

Key changes:
- Added DrillState struct to hold frozen records snapshot and pending edits
- New effects: StartDrill, ApplyAndClearDrill, SetDrillPendingEdit
- Extended CmdContext with records_col and records_value for records mode
- CommitCellEdit now stages edits in pending_edits when in records mode
- DrillIntoCell captures a snapshot before switching to drill view
- GridLayout supports frozen records for stable view during edits
- GridWidget renders with drill_state for pending edit display

In records mode, edits are staged and only applied to the model when
the user navigates away or commits. This prevents data loss and allows
batch editing of records.

Co-Authored-By: fiddlerwoaroof/git-smart-commit (unsloth/Qwen3.5-35B-A3B-GGUF:Q5_K_M)

src/ui/app.rs

@@ -13,6 +13,20 @@ use crate::model::Model;
 use crate::persistence;
 use crate::view::GridLayout;
 
+/// Drill-down state: frozen record snapshot + pending edits that have not
+/// yet been applied to the model.
+#[derive(Debug, Clone, Default)]
+pub struct DrillState {
+    /// Frozen snapshot of records shown in the drill view.
+    pub records: Vec<(
+        crate::model::cell::CellKey,
+        crate::model::cell::CellValue,
+    )>,
+    /// Pending edits keyed by (record_idx, column_name) → new string value.
+    /// column_name is either "Value" or a category name.
+    pub pending_edits: std::collections::HashMap<(usize, String), String>,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum AppMode {
     Normal,
@@ -72,6 +86,11 @@ pub struct App {
     pub view_back_stack: Vec<String>,
     /// Views that were "back-ed" from, available for forward navigation (`>`).
     pub view_forward_stack: Vec<String>,
+    /// Frozen records list for the drill view. When present, this is the
+    /// snapshot that records-mode layouts iterate — records don't disappear
+    /// when filters would change. Pending edits are stored alongside and
+    /// applied to the model on commit/navigate-away.
+    pub drill_state: Option<DrillState>,
     /// Named text buffers for text-entry modes
     pub buffers: HashMap<String, String>,
     /// Transient keymap for Emacs-style prefix key sequences (g→gg, y→yy, etc.)
@@ -101,6 +120,7 @@ impl App {
             tile_cat_idx: 0,
             view_back_stack: Vec::new(),
             view_forward_stack: Vec::new(),
+            drill_state: None,
             buffers: HashMap::new(),
             transient_keymap: None,
             keymap_set: KeymapSet::default_keymaps(),
@@ -109,7 +129,8 @@ impl App {
 
     pub fn cmd_context(&self, key: KeyCode, _mods: KeyModifiers) -> CmdContext<'_> {
         let view = self.model.active_view();
-        let layout = GridLayout::new(&self.model, view);
+        let frozen_records = self.drill_state.as_ref().map(|s| s.records.clone());
+        let layout = GridLayout::with_frozen_records(&self.model, view, frozen_records);
         let (sel_row, sel_col) = view.selected;
         CmdContext {
             model: &self.model,
@@ -135,6 +156,21 @@ impl App {
             none_cats: layout.none_cats.clone(),
             view_back_stack: self.view_back_stack.clone(),
             view_forward_stack: self.view_forward_stack.clone(),
+            records_col: if layout.is_records_mode() {
+                Some(layout.col_label(sel_col))
+            } else {
+                None
+            },
+            records_value: if layout.is_records_mode() {
+                // Check pending edits first, then fall back to original
+                let col_name = layout.col_label(sel_col);
+                let pending = self.drill_state.as_ref().and_then(|s| {
+                    s.pending_edits.get(&(sel_row, col_name.clone())).cloned()
+                });
+                pending.or_else(|| layout.records_display(sel_row, sel_col))
+            } else {
+                None
+            },
             key_code: key,
         }
     }

src/ui/effect.rs

@@ -337,6 +337,91 @@ impl Effect for SetTileCatIdx {
     }
 }
 
+/// Populate the drill state with a frozen snapshot of records.
+/// Clears any previous drill state.
+#[derive(Debug)]
+pub struct StartDrill(pub Vec<(CellKey, CellValue)>);
+impl Effect for StartDrill {
+    fn apply(&self, app: &mut App) {
+        app.drill_state = Some(super::app::DrillState {
+            records: self.0.clone(),
+            pending_edits: std::collections::HashMap::new(),
+        });
+    }
+}
+
+/// Apply any pending edits to the model and clear the drill state.
+#[derive(Debug)]
+pub struct ApplyAndClearDrill;
+impl Effect for ApplyAndClearDrill {
+    fn apply(&self, app: &mut App) {
+        let Some(drill) = app.drill_state.take() else {
+            return;
+        };
+        // For each pending edit, update the cell
+        for ((record_idx, col_name), new_value) in &drill.pending_edits {
+            let Some((orig_key, _)) = drill.records.get(*record_idx) else {
+                continue;
+            };
+            if col_name == "Value" {
+                // Update the cell's value
+                let value = if new_value.is_empty() {
+                    app.model.clear_cell(orig_key);
+                    continue;
+                } else if let Ok(n) = new_value.parse::<f64>() {
+                    CellValue::Number(n)
+                } else {
+                    CellValue::Text(new_value.clone())
+                };
+                app.model.set_cell(orig_key.clone(), value);
+            } else {
+                // Rename a coordinate: remove old cell, insert new with updated coord
+                let value = match app.model.get_cell(orig_key) {
+                    Some(v) => v.clone(),
+                    None => continue,
+                };
+                app.model.clear_cell(orig_key);
+                // Build new key by replacing the coord
+                let new_coords: Vec<(String, String)> = orig_key
+                    .0
+                    .iter()
+                    .map(|(c, i)| {
+                        if c == col_name {
+                            (c.clone(), new_value.clone())
+                        } else {
+                            (c.clone(), i.clone())
+                        }
+                    })
+                    .collect();
+                let new_key = CellKey::new(new_coords);
+                // Ensure the new item exists in that category
+                if let Some(cat) = app.model.category_mut(col_name) {
+                    cat.add_item(new_value.clone());
+                }
+                app.model.set_cell(new_key, value);
+            }
+        }
+        app.dirty = true;
+    }
+}
+
+/// Stage a pending edit in the drill state.
+#[derive(Debug)]
+pub struct SetDrillPendingEdit {
+    pub record_idx: usize,
+    pub col_name: String,
+    pub new_value: String,
+}
+impl Effect for SetDrillPendingEdit {
+    fn apply(&self, app: &mut App) {
+        if let Some(drill) = &mut app.drill_state {
+            drill
+                .pending_edits
+                .insert((self.record_idx, self.col_name.clone()), self.new_value.clone());
+        }
+    }
+}
+
 // ── Side effects ─────────────────────────────────────────────────────────────
 
 #[derive(Debug)]

src/ui/grid.rs

@@ -21,6 +21,7 @@ pub struct GridWidget<'a> {
     pub mode: &'a AppMode,
     pub search_query: &'a str,
     pub buffers: &'a std::collections::HashMap<String, String>,
+    pub drill_state: Option<&'a crate::ui::app::DrillState>,
 }
 
 impl<'a> GridWidget<'a> {
@@ -29,19 +30,22 @@ impl<'a> GridWidget<'a> {
         mode: &'a AppMode,
         search_query: &'a str,
         buffers: &'a std::collections::HashMap<String, String>,
+        drill_state: Option<&'a crate::ui::app::DrillState>,
     ) -> Self {
         Self {
             model,
             mode,
             search_query,
             buffers,
+            drill_state,
         }
     }
 
     fn render_grid(&self, area: Rect, buf: &mut Buffer) {
         let view = self.model.active_view();
 
-        let layout = GridLayout::new(self.model, view);
+        let frozen = self.drill_state.map(|s| s.records.clone());
+        let layout = GridLayout::with_frozen_records(self.model, view, frozen);
         let (sel_row, sel_col) = view.selected;
         let row_offset = view.row_offset;
         let col_offset = view.col_offset;
@@ -542,7 +546,7 @@ mod tests {
         let area = Rect::new(0, 0, width, height);
         let mut buf = Buffer::empty(area);
         let bufs = std::collections::HashMap::new();
-        GridWidget::new(model, &AppMode::Normal, "", &bufs).render(area, &mut buf);
+        GridWidget::new(model, &AppMode::Normal, "", &bufs, None).render(area, &mut buf);
         buf
     }