A reopened cell editor shows the cell it landed on (improvise-fy9o)

The cell-editing commits own their buffer clear at their head instead of
the keymap welding one after them, so the re-seed survives and Enter,
Enter writes nothing.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VdfEGXA7aJ6ftMsCc9PJze

crates/improvise-command/src/command/cmd/commit.rs

@@ -5,7 +5,7 @@ use crate::ui::effect::{self, Effect};
 use crate::view::RecordCol;
 use improvise_protocol::{OpenedEditor, untouched};
 
-use super::core::{Cmd, CmdContext, read_buffer};
+use super::core::{Cmd, CmdContext, read_buffer, write_buffer};
 use super::grid::AddRecordRow;
 use super::navigation::{CursorState, EnterAdvance, viewport_effects};
 
@@ -805,6 +805,72 @@ mod tests {
             "the reopened editor did not capture the cell it landed on"
         );
     }
+
+    /// Every cell of the 2×2 fixture, by its key.
+    fn every_cell(app: &crate::ui::app::App) -> Vec<Option<CellValue>> {
+        use crate::model::cell::CellKey;
+        let mut cells = Vec::new();
+        for region in ["North", "West"] {
+            for measure in ["Cost", "Revenue"] {
+                let key = CellKey::new(vec![
+                    ("Region".into(), region.into()),
+                    ("_Measure".into(), measure.into()),
+                ]);
+                cells.push(app.model_state.workbook.model.get_cell(&key).cloned());
+            }
+        }
+        cells
+    }
+
+    /// BUG (improvise-fy9o) — see `context/test-evidence/command.md`.
+    #[test]
+    fn enter_enter_leaves_every_cell_unchanged() {
+        use improvise_protocol::key::KeyCode;
+        for (records, start) in [(false, (1, 0)), (true, (1, 2))] {
+            let mut app = grid_holding(CellValue::Number(4.0), records);
+            if records {
+                app.view_state.mode = AppMode::RecordsNormal;
+            }
+            app.cursor_mut().selected = start;
+            let before = every_cell(&app);
+            press(&mut app, KeyCode::Char('i'));
+            press(&mut app, KeyCode::Enter);
+            let reopened = app.view_state.buffers.get("edit").cloned();
+            press(&mut app, KeyCode::Enter);
+            assert_eq!(
+                every_cell(&app),
+                before,
+                "records={records}: i, Enter, Enter changed a cell (the reopened editor held {reopened:?})"
+            );
+        }
+    }
+
+    /// The reopened editor shows the cell it landed on, so typing extends it.
+    /// BUG (improvise-fy9o) — see `context/test-evidence/command.md`.
+    #[test]
+    fn typing_after_the_reopen_still_writes() {
+        use crate::model::cell::CellKey;
+        use improvise_protocol::key::KeyCode;
+        let mut app = grid_holding(CellValue::Number(4.0), false);
+        app.cursor_mut().selected = (1, 0);
+        press(&mut app, KeyCode::Char('i'));
+        press(&mut app, KeyCode::Enter);
+        assert_eq!(
+            app.view_state.buffers.get("edit").map(String::as_str),
+            Some("2"),
+            "the editor reopened on (North, Revenue) is not seeded with its value"
+        );
+        press(&mut app, KeyCode::Char('5'));
+        press(&mut app, KeyCode::Enter);
+        let landed = CellKey::new(vec![
+            ("Region".into(), "North".into()),
+            ("_Measure".into(), "Revenue".into()),
+        ]);
+        assert_eq!(
+            app.model_state.workbook.model.get_cell(&landed),
+            Some(&CellValue::Number(25.0))
+        );
+    }
 }
 
 // ── Commit commands (mode-specific buffer consumers) ────────────────────────
@@ -951,6 +1017,11 @@ impl Cmd for CommitAndAdvance {
         // Drop to normal **before** the commit, which can abort: tidy-up goes where
         // an abort cannot reach it (improvise-2zq, gotcha 21).
         effects.push(effect::change_mode(exit_mode_for(&self.edit_mode)));
+        // This command owns its buffer's clear, at the head, so the re-entry
+        // below re-seeds after it rather than being blanked (improvise-fy9o).
+        if let Some(mb) = self.edit_mode.minibuffer() {
+            effects.push(write_buffer(&mb.buffer_key, String::new()));
+        }
         // An untouched editor writes nothing; everything around the write still runs.
         let writes = !untouched(self.opened.as_ref(), &self.value);
         if writes {