Lightweight coding agent that runs in your terminal
Rust
Add Vim undo to the TUI composer (#41941)
Benjamin Carlsson9c7edd4bc39f
diff --git a/codex-rs/config/src/tui_keymap.rs b/codex-rs/config/src/tui_keymap.rsindex 7e6d92de7d..1c1c998ce7 100644--- a/codex-rs/config/src/tui_keymap.rs+++ b/codex-rs/config/src/tui_keymap.rs@@ -269,6 +269,8 @@ pub struct TuiVimNormalKeymap {pub start_yank_operator: Option<KeybindingsSpec>,/// Begin change operator; next keys select a text object.pub start_change_operator: Option<KeybindingsSpec>,+ /// Undo the last complete edit (`u`).+ pub undo: Option<KeybindingsSpec>,/// Cancel a pending operator and return to normal mode.pub cancel_operator: Option<KeybindingsSpec>,}diff --git a/codex-rs/core/config.schema.json b/codex-rs/core/config.schema.jsonindex 54415cd19d..11e20bd67e 100644--- a/codex-rs/core/config.schema.json+++ b/codex-rs/core/config.schema.json@@ -3902,6 +3902,7 @@"substitute_char": null,"till_backward": null,"till_forward": null,+ "undo": null,"yank_line": null},"vim_operator": {@@ -4728,6 +4729,7 @@"substitute_char": null,"till_backward": null,"till_forward": null,+ "undo": null,"yank_line": null}},@@ -5246,6 +5248,14 @@],"description": "Stop before the next character on the current line (`t`)."},+ "undo": {+ "allOf": [+ {+ "$ref": "#/definitions/KeybindingsSpec"+ }+ ],+ "description": "Undo the last complete edit (`u`)."+ },"yank_line": {"allOf": [{diff --git a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rsindex 9df19ecda7..ae13d85a01 100644--- a/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs+++ b/codex-rs/ext/guardian-v2/src/async_scorer/extension_tests.rs@@ -1446,7 +1446,7 @@ max_recent_non_user_entries = 8.latest_scored_tool_call.load(Ordering::Acquire)== 0- || metrics.0.lock().unwrap().len() < 10+ || metrics.0.lock().unwrap().len() < 14{tokio::task::yield_now().await;}diff --git a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rsindex 17cc593a79..2da167a445 100644--- a/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs+++ b/codex-rs/tui/src/app/tests/navigation_reconnect_tests.rs@@ -24,6 +24,7 @@ async fn reconnect_daemon_command_center_after_socket_replacement_without_a_conv(Some(ThreadId::new()), true),] {let (mut app, mut events, _) = make_test_app_with_channels().await;+ app.keymap.app.open_agents = vec![crate::key_hint::alt(KeyCode::Char('a'))];let child = ThreadId::new();let child_recap = recap::RecapProgress {completed_turns: 3,diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rsindex ee3bf5a038..e1456aa679 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs@@ -63,6 +63,8 @@//! `Ctrl+R` opens a reverse incremental search mode. The footer becomes the search input; once the//! query is non-empty, the composer body previews the current match. `Enter` accepts the preview as//! an editable draft and `Esc` restores the draft that was active when search started.+//! Vim undo snapshots the complete draft and groups direct edits with active Vim transactions.+//! Canceled history previews restore both; accepting another prompt resets undo history.//! Vim queries stay draft-local.//!//! Slash commands are staged for local history instead of being recorded immediately. Command@@ -303,6 +305,7 @@ mod history_search;mod popup_state;mod reconnect;mod slash_input;+mod vim_history;mod vim_search;use self::attachment_state::AttachmentState;@@ -316,6 +319,7 @@ use self::popup_state::PopupState;use self::slash_input::SlashInput;use self::slash_input::SlashValidation;use self::slash_input::SubmissionValidation;+use self::vim_history::VimHistory;use crate::app_event::AppEvent;use crate::app_event::ConnectorsSnapshot;use crate::app_event_sender::AppEventSender;@@ -535,6 +539,7 @@ pub(crate) struct ChatComposer {windows_degraded_sandbox_active: bool,side_conversation_active: bool,history_search: Option<HistorySearchSession>,+ vim_history: VimHistory,submit_keys: Vec<KeyBinding>,queue_keys: Vec<KeyBinding>,toggle_shortcuts_keys: Vec<KeyBinding>,@@ -709,6 +714,7 @@ impl ChatComposer {windows_degraded_sandbox_active: false,side_conversation_active: false,history_search: None,+ vim_history: VimHistory::default(),submit_keys: vec![key_hint::plain(KeyCode::Enter)],queue_keys: vec![key_hint::plain(KeyCode::Tab)],toggle_shortcuts_keys: vec![@@ -1212,6 +1218,7 @@ impl ChatComposer {query.editor.insert_str(&pasted);return true;}+ let started_vim_edit = self.begin_direct_vim_edit();let char_count = pasted.chars().count();if char_count > LARGE_PASTE_CHAR_THRESHOLD {let placeholder = self.next_large_paste_placeholder(char_count);@@ -1229,6 +1236,9 @@ impl ChatComposer {}self.draft.paste_burst.clear_after_explicit_paste();self.sync_popups();+ if started_vim_edit {+ self.finish_vim_edit();+ }true}@@ -1290,6 +1300,7 @@ impl ChatComposer {/// are renumbered to `[Image #M+1]..[Image #N]` (where `M` is the number of/// remote images). Cursor is placed at the end after rebuilding elements.pub(crate) fn apply_external_edit(&mut self, text: String) {+ self.vim_history = VimHistory::default();self.draft.pending_pastes.clear();let (text, _) = self.imported_text_for_textarea(text, Vec::new());@@ -1375,6 +1386,7 @@ impl ChatComposer {pub(crate) fn set_vim_enabled(&mut self, enabled: bool) {self.draft.textarea.enable_vim_search();self.draft.textarea.set_vim_enabled(enabled);+ self.vim_history = VimHistory::default();self.draft.paste_burst.clear_after_explicit_paste();self.footer.mode = reset_mode_after_activity(self.footer.mode);}@@ -1565,6 +1577,7 @@ impl ChatComposer {mention_bindings: Vec<MentionBinding>,) {// Clear any existing content, placeholders, and attachments first.+ self.vim_history = VimHistory::default();self.draft.textarea.set_text_clearing_elements("");self.draft.is_bash_mode = false;self.draft.pending_pastes.clear();@@ -1833,8 +1846,12 @@ impl ChatComposer {/// Insert an attachment placeholder and track it for the next submission.pub fn attach_image(&mut self, path: PathBuf) {+ let started_vim_edit = self.begin_direct_vim_edit();self.attachments.attach_image(&mut self.draft.textarea, path);+ if started_vim_edit {+ self.finish_vim_edit();+ }}#[cfg(test)]@@ -1960,9 +1977,13 @@ impl ChatComposer {}pub(crate) fn insert_str(&mut self, text: &str) {+ let started_vim_edit = self.begin_direct_vim_edit();self.draft.textarea.insert_str(text);self.sync_bash_mode_from_text();self.sync_popups();+ if started_vim_edit {+ self.finish_vim_edit();+ }}/// Handle a key event coming from the main UI.@@ -1986,6 +2007,10 @@ impl ChatComposer {return self.handle_history_search_key(key_event);}+ if self.handle_vim_history_key(key_event) {+ return (InputResult::None, true);+ }+if Self::is_history_search_key(&key_event, &self.history_search_previous_keys) {return self.begin_history_search();}@@ -2491,6 +2516,7 @@ impl ChatComposer {}fn insert_selected_file_path(&mut self, token_range: Range<usize>, selected_path: &str) {+ let started_vim_edit = self.begin_direct_vim_edit();let token_range = self.separate_completion_from_adjacent_element(token_range);if Self::is_image_path(selected_path) {let path_buf = PathBuf::from(selected_path);@@ -2511,6 +2537,9 @@ impl ChatComposer {} else {self.insert_selected_path(token_range, selected_path);}+ if started_vim_edit {+ self.finish_vim_edit();+ }}fn trim_text_elements(@@ -3136,6 +3165,7 @@ impl ChatComposer {| InputResult::ServiceTierCommand(_)| InputResult::CommandWithArgs(_, _, _)) {+ self.vim_history = VimHistory::default();self.draft.textarea.enter_vim_insert_mode();}}@@ -3457,8 +3487,16 @@ impl ChatComposer {&mut self,key_event: &KeyEvent,) -> Option<(InputResult, bool)> {- self.attachments- .handle_remote_image_selection_key(key_event, &mut self.draft.textarea)+ let removes_remote_image = matches!(key_event.code, KeyCode::Delete | KeyCode::Backspace)+ && self.attachments.selected_remote_image_index.is_some();+ let started_vim_edit = removes_remote_image && self.begin_direct_vim_edit();+ let result = self+ .attachments+ .handle_remote_image_selection_key(key_event, &mut self.draft.textarea);+ if started_vim_edit {+ self.finish_vim_edit();+ }+ result}/// Handle key event when no popup is visible.@@ -3635,6 +3673,9 @@ impl ChatComposer {input: KeyEvent,now: Instant,) -> (InputResult, bool) {+ if !self.draft.textarea.is_vim_normal_mode() {+ self.begin_vim_edit(input);+ }// If we have a buffered non-bracketed paste burst and enough time has// elapsed since the last char, flush it before handling a new input.self.handle_paste_burst_flush(now);@@ -3744,16 +3785,22 @@ impl ChatComposer {&& matches!(input.code, KeyCode::Backspace)&& self.draft.textarea.cursor() == 0{+ let started_vim_edit = self.begin_direct_vim_edit();self.draft.is_bash_mode = false;+ if started_vim_edit {+ self.finish_vim_edit();+ }return (InputResult::None, true);}+ self.begin_vim_edit(input);self.draft.textarea.input(input);self.sync_bash_mode_from_text();if let Some(elements_before) = elements_before {self.reconcile_deleted_elements(elements_before);}+ self.finish_vim_edit();// Update the paste-burst heuristic for text, shortcut, and non-char events.match input.code {@@ -10663,6 +10710,8 @@ mod tests {let (mut composer, _rx) = new_test_composer();configure_bound_plugin_left_of_unbound_plugin(&mut composer);+ composer.set_vim_enabled(/*enabled*/ true);+ let before = composer.draft_snapshot();composer.insert_selected_file_path("@sample".len().."@sample@other".len(),image_path.to_str().expect("UTF-8 path"),@@ -10670,6 +10719,9 @@ mod tests {assert_eq!(composer.current_text(), "@sample [Image #1] ");assert_eq!(composer.local_image_paths(), vec![image_path]);+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));+ assert_eq!(composer.draft_snapshot(), before);}#[test]diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs b/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rsindex a79a10a362..9072f9d4b6 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer/history_search.rs@@ -1,9 +1,9 @@//! Composer-side Ctrl+R reverse history search state and rendering helpers.//!//! The persistent and local history stores live in `chat_composer_history`, but the composer owns-//! the active search session because it has to snapshot/restore the editable draft, preview matches-//! in the textarea, and render the footer prompt while the footer line is acting as the search-//! input.+//! the active search session because it has to snapshot/restore the editable draft and Vim edit+//! state, preview matches in the textarea, and render the footer prompt while the footer line is+//! acting as the search input.//!//! This module is responsible for the UI-facing lifecycle of a search session: recognizing the//! keys that enter and drive search mode, keeping the footer query separate from the textarea@@ -35,10 +35,12 @@ use super::super::chat_composer_history::HistorySearchDirection;use super::super::chat_composer_history::HistorySearchResult;use super::super::footer::footer_height;use super::super::footer::reset_mode_after_activity;+use super::super::textarea::VimPersistentState;use super::ActivePopup;use super::ChatComposer;use super::ComposerDraft;use super::InputResult;+use super::vim_history::VimHistory;use crate::app_event::AppEvent;use crate::key_hint;use crate::key_hint::KeyBinding;@@ -49,12 +51,16 @@ use crate::ui_consts::FOOTER_INDENT_COLS;/// Active composer-owned state for one Ctrl+R search interaction.////// The session is created only by [`ChatComposer::begin_history_search`] and is cleared only by-/// accepting, canceling, or replacing the search mode. It stores the original draft separately from-/// the footer query so transient previews never destroy the user's in-progress composer content.-#[derive(Clone, Debug)]+/// accepting, canceling, or replacing the search mode. It stores the original draft and Vim edit+/// state separately from the footer query so transient previews never destroy in-progress content.+#[derive(Debug)]pub(super) struct HistorySearchSession {/// Draft to restore when search is canceled or a query has no match.original_draft: ComposerDraft,+ /// Same-draft Vim edits to restore when a temporary preview is canceled.+ original_vim_history: VimHistory,+ /// Active and completed Vim commands suspended during temporary draft replacement.+ original_vim_state: VimPersistentState,/// Footer-owned query text typed while Ctrl+R search is active.query: String,/// User-visible search status used to choose footer hints and composer preview behavior.@@ -114,8 +120,16 @@ impl ChatComposer {}self.popups.active = ActivePopup::None;self.attachments.clear_remote_image_selection();+ let original_draft = self.snapshot_draft();+ let original_vim_history = std::mem::take(&mut self.vim_history);+ let mut original_vim_state = VimPersistentState::default();+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut original_vim_state);self.history_search = Some(HistorySearchSession {- original_draft: self.snapshot_draft(),+ original_draft,+ original_vim_history,+ original_vim_state,query: String::new(),status: HistorySearchStatus::Idle,});@@ -292,12 +306,16 @@ impl ChatComposer {/// as Ctrl+C, should use the boolean result to consume the key without also clearing the/// restored draft or triggering quit/interrupt behavior.pub(crate) fn cancel_history_search(&mut self) -> bool {- let Some(search) = self.history_search.take() else {+ let Some(mut search) = self.history_search.take() else {return false;};self.history.reset_navigation();self.footer.mode = reset_mode_after_activity(self.footer.mode);self.restore_draft(search.original_draft);+ self.vim_history = search.original_vim_history;+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut search.original_vim_state);true}diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rsnew file mode 100644index 0000000000..b750469b1f--- /dev/null+++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history.rs@@ -0,0 +1,198 @@+//! Bounded Vim undo history for the complete composer-owned draft.+//!+//! A textarea does not own pending paste payloads, image attachments, or mention targets. Keeping+//! edit transactions here lets one snapshot restore those values together with visible text. Keys+//! and direct composer-owned changes share the same bounded transaction state.++use std::collections::VecDeque;++use super::super::textarea::VimPersistentState;+use super::ChatComposer;+use super::ComposerDraft;+use crate::key_hint::KeyBindingListExt;+use crossterm::event::KeyEvent;++const MAX_VIM_UNDO_STEPS: usize = 64;+const MAX_VIM_UNDO_BYTES: usize = 1024 * 1024;++#[derive(Debug, Default)]+pub(super) struct VimHistory {+ undo: VecDeque<ComposerDraft>,+ pending: Option<ComposerDraft>,+}++impl ComposerDraft {+ fn vim_history_bytes(&self) -> usize {+ let mut bytes = self.text.len()+ + self.text_elements.len()+ * std::mem::size_of::<codex_protocol::user_input::TextElement>();+ for path in &self.local_image_paths {+ bytes += path.as_os_str().len();+ }+ for url in &self.remote_image_urls {+ bytes += url.len();+ }+ for binding in &self.mention_bindings {+ bytes += binding.mention.len() + binding.path.len();+ }+ for (placeholder, pasted) in &self.pending_pastes {+ bytes += placeholder.len() + pasted.len();+ }+ bytes+ }+}++impl VimHistory {+ fn trim(&mut self) {+ while self.undo.len() > MAX_VIM_UNDO_STEPS+ || self+ .undo+ .iter()+ .chain(self.pending.iter())+ .map(ComposerDraft::vim_history_bytes)+ .sum::<usize>()+ > MAX_VIM_UNDO_BYTES+ {+ self.undo.pop_front();+ }+ }+}++impl ChatComposer {+ /// Apply undo only before normal-mode commands begin.+ pub(super) fn handle_vim_history_key(&mut self, event: KeyEvent) -> bool {+ if !self.draft.textarea.is_vim_normal_mode()+ || self.draft.textarea.is_vim_operator_pending()+ || self.popups.active()+ || !self.vim_normal_keymap.undo.is_pressed(event)+ {+ return false;+ }++ if let Some(snapshot) = self.vim_history.undo.pop_back() {+ let history = std::mem::take(&mut self.vim_history);+ let mut vim_state = VimPersistentState::default();+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut vim_state);+ self.restore_draft(snapshot);+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut vim_state);+ self.vim_history = history;+ self.draft.textarea.enter_vim_normal_mode();+ self.vim_history.trim();+ }+ true+ }++ /// Snapshot only keys that can begin or complete a Vim edit transaction.+ pub(super) fn begin_vim_edit(&mut self, event: KeyEvent) {+ if !self.draft.textarea.is_vim_enabled()+ || self.vim_history.pending.is_some()+ || self.draft.textarea.is_vim_operator_pending()+ {+ return;+ }++ if self.draft.textarea.is_vim_normal_mode()+ && (self.vim_normal_keymap.move_left.is_pressed(event)+ || self.vim_normal_keymap.move_right.is_pressed(event)+ || self.vim_normal_keymap.move_up.is_pressed(event)+ || self.vim_normal_keymap.move_down.is_pressed(event)+ || self.vim_normal_keymap.move_word_forward.is_pressed(event)+ || self.vim_normal_keymap.move_word_backward.is_pressed(event)+ || self.vim_normal_keymap.move_word_end.is_pressed(event)+ || self.vim_normal_keymap.move_line_start.is_pressed(event)+ || self.vim_normal_keymap.move_line_end.is_pressed(event)+ || self.vim_normal_keymap.find_forward.is_pressed(event)+ || self.vim_normal_keymap.find_backward.is_pressed(event)+ || self.vim_normal_keymap.jump_top.is_pressed(event)+ || self.vim_normal_keymap.jump_bottom.is_pressed(event)+ || self.draft.textarea.wants_vim_search_key(event)+ || self.vim_normal_keymap.yank_line.is_pressed(event)+ || self.vim_normal_keymap.start_yank_operator.is_pressed(event)+ || self.vim_normal_keymap.cancel_operator.is_pressed(event))+ {+ return;+ }++ self.begin_vim_edit_transaction();+ }++ /// Start one standalone draft edit without splitting an active Vim command.+ pub(super) fn begin_direct_vim_edit(&mut self) -> bool {+ if !self.draft.textarea.is_vim_enabled()+ || self.draft.textarea.is_vim_operator_pending()+ || self.vim_history.pending.is_some()+ || self.history_search.is_some()+ {+ return false;+ }++ self.begin_vim_edit_transaction();+ if self.vim_history.pending.is_none() {+ return false;+ }+ let mut vim_state = VimPersistentState::default();+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut vim_state);+ vim_state.commands.last_change.clear();+ self.draft+ .textarea+ .swap_vim_persistent_state(&mut vim_state);+ true+ }++ fn begin_vim_edit_transaction(&mut self) {+ let visible_bytes = self.draft.textarea.text().len();+ let paste_bytes = self+ .draft+ .pending_pastes+ .iter()+ .map(|(placeholder, pasted)| placeholder.len() + pasted.len())+ .sum::<usize>();+ if visible_bytes.saturating_add(paste_bytes) > MAX_VIM_UNDO_BYTES {+ self.vim_history = VimHistory::default();+ return;+ }++ let snapshot = self.snapshot_draft();+ if snapshot.vim_history_bytes() <= MAX_VIM_UNDO_BYTES {+ self.vim_history.pending = Some(snapshot);+ self.vim_history.trim();+ } else {+ self.vim_history = VimHistory::default();+ }+ }++ /// Commit a complete normal-mode command or one insert-mode session.+ pub(super) fn finish_vim_edit(&mut self) {+ if !self.draft.textarea.is_vim_normal_mode()+ || self.draft.textarea.is_vim_operator_pending()+ {+ return;+ }++ let Some(snapshot) = self.vim_history.pending.take() else {+ return;+ };+ if snapshot.text == self.current_text()+ && snapshot.text_elements == self.current_text_elements()+ && snapshot.pending_pastes == self.draft.pending_pastes+ && snapshot.local_image_paths == self.attachments.local_image_paths()+ && snapshot.remote_image_urls == self.attachments.remote_image_urls()+ && snapshot.mention_bindings == self.snapshot_mention_bindings()+ {+ return;+ }++ self.vim_history.undo.push_back(snapshot);+ self.vim_history.trim();+ }+}++#[cfg(test)]+#[path = "vim_history_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rsnew file mode 100644index 0000000000..d9696c4f90--- /dev/null+++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_history_tests.rs@@ -0,0 +1,372 @@+//! Composer undo transactions preserve rich draft data and active Vim commands.++use std::path::PathBuf;++use codex_config::types::KeybindingSpec;+use codex_config::types::KeybindingsSpec;+use codex_config::types::TuiKeymap;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyModifiers;+use pretty_assertions::assert_eq;++use super::super::super::chat_composer_history::HistoryEntry;+use super::super::ChatComposer;+use super::super::InputResult;+use super::super::LARGE_PASTE_CHAR_THRESHOLD;+use super::super::tests::new_test_composer;+use crate::keymap::RuntimeKeymap;++fn vim_composer(text: &str) -> ChatComposer {+ let (mut composer, _receiver) = new_test_composer();+ composer.set_disable_paste_burst(/*disabled*/ true);+ composer.set_text_content(text.to_owned(), Vec::new(), Vec::new());+ composer.set_vim_enabled(/*enabled*/ true);+ composer.draft.textarea.set_cursor(/*pos*/ 0);+ composer+}++fn keys(composer: &mut ChatComposer, keys: &str) {+ for key in keys.chars() {+ let code = if key == '\n' {+ KeyCode::Enter+ } else {+ KeyCode::Char(key)+ };+ let _ = composer.handle_key_event(KeyEvent::new(code, KeyModifiers::NONE));+ }+}++fn escape(composer: &mut ChatComposer) {+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+}++fn ctrl_r(composer: &mut ChatComposer) {+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));+}++#[test]+fn undo_groups_complete_vim_edits() {+ for (original, command, edited) in [+ ("one two", "cwX", "X two"),+ ("abc", "iXYZ", "XYZabc"),+ ("", "i/review", "/review"),+ ("one two", "c/two\nX", "Xtwo"),+ ("one two", "d/two\n", "two"),+ ("abc-def", "df-", "def"),+ ("abc-def", "cf-X", "Xdef"),+ ] {+ let mut composer = vim_composer(original);+ keys(&mut composer, command);+ if composer.popups.active() {+ escape(&mut composer);+ }+ escape(&mut composer);+ assert_eq!(composer.current_text(), edited);+ assert_eq!(composer.vim_history.undo.len(), 1);++ keys(&mut composer, "u");+ assert_eq!(+ (composer.current_text(), composer.cursor()),+ (original.to_owned(), 0)+ );+ }+}++#[test]+fn undo_preserves_repeat_and_pending_operator_bindings() {+ let mut composer = vim_composer("alpha beta gamma");+ keys(&mut composer, "dw.u");+ assert_eq!(composer.current_text(), "beta gamma");+ keys(&mut composer, "u.");+ assert_eq!(composer.current_text(), "beta gamma");++ let mut composer = vim_composer("one two");+ let mut keymap = RuntimeKeymap::defaults();+ keymap.vim_operator.motion_word_forward = vec![crate::key_hint::plain(KeyCode::Char('u'))];+ composer.set_keymap_bindings(&keymap);+ keys(&mut composer, "duu");+ assert_eq!(composer.current_text(), "one two");+}++#[test]+fn undo_preserves_confirmed_vim_search() {+ let mut composer = vim_composer("alpha beta alpha");+ keys(&mut composer, "/alpha\n0xun");+ assert_eq!(+ (composer.current_text(), composer.cursor()),+ ("alpha beta alpha".to_owned(), 11)+ );++ keys(&mut composer, "0");+ composer.handle_paste("Z".to_owned());+ keys(&mut composer, "n");+ assert_eq!(+ (composer.current_text(), composer.cursor()),+ ("Zalpha beta alpha".to_owned(), 12)+ );+}++#[test]+fn externally_canceled_search_operator_finishes_the_undo_transaction() {+ let mut composer = vim_composer("abc");+ keys(&mut composer, "xd/");+ assert!(composer.cancel_vim_search());+ keys(&mut composer, "uxu");+ assert_eq!(composer.current_text(), "abc");+}++#[test]+fn normal_mode_explicit_paste_is_its_own_undoable_edit() {+ let mut composer = vim_composer("abc");+ keys(&mut composer, "x");+ composer.handle_paste("Z".to_owned());+ assert_eq!(composer.current_text(), "Zbc");+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "bc");+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "abc");+}++#[test]+fn normal_mode_direct_insert_and_image_attachment_are_undoable() {+ let mut composer = vim_composer("abc");+ composer.insert_str("Z");+ assert_eq!(composer.current_text(), "Zabc");+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "abc");++ let path = PathBuf::from("example.png");+ composer.attach_image(path.clone());+ assert_eq!(composer.local_image_paths(), vec![path]);+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "abc");+ assert!(composer.local_image_paths().is_empty());+ keys(&mut composer, "\nABC");+ assert_eq!(composer.current_text(), "ABC");+ escape(&mut composer);+ keys(&mut composer, "u");+ assert!(composer.is_empty());+ keys(&mut composer, "u");+ assert!(composer.is_empty());+}++#[test]+fn deleting_a_selected_remote_image_is_one_undoable_vim_edit() {+ for key in [KeyCode::Delete, KeyCode::Backspace] {+ let mut composer = vim_composer("abc");+ let url = "https://example.com/remote.png".to_owned();+ composer.set_remote_image_urls(vec![url.clone()]);+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));+ assert!(composer.vim_history.pending.is_none());+ let _ = composer.handle_key_event(KeyEvent::new(key, KeyModifiers::NONE));+ assert!(composer.remote_image_urls().is_empty());+ keys(&mut composer, "u");+ assert_eq!(composer.remote_image_urls(), vec![url]);+ assert_eq!(composer.current_text(), "abc");+ }+}++#[test]+fn direct_edits_join_the_active_vim_insert_transaction() {+ let mut composer = vim_composer("abc");+ composer.enable_vim_in_insert_mode();+ composer.handle_paste("ABC".to_owned());+ composer.attach_image(PathBuf::from("example.png"));+ keys(&mut composer, "D");+ escape(&mut composer);+ assert_eq!(composer.vim_history.undo.len(), 1);+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "abc");+ assert!(composer.local_image_paths().is_empty());+}++#[test]+fn removing_the_shell_prefix_is_its_own_undoable_edit() {+ let mut composer = vim_composer("");+ keys(&mut composer, "!foo");+ escape(&mut composer);+ keys(&mut composer, "0");+ let before = composer.draft_snapshot();+ let _ = composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));+ assert_eq!(composer.current_text(), "foo");+ keys(&mut composer, "u");+ assert_eq!(composer.draft_snapshot(), before);+}++#[test]+fn canceled_reverse_history_preview_preserves_vim_undo_and_repeat() {+ let mut composer = vim_composer("alpha beta alpha");+ composer+ .history+ .record_local_submission(HistoryEntry::new("archived prompt".to_owned()));+ keys(&mut composer, "/alpha\n0x");+ ctrl_r(&mut composer);+ keys(&mut composer, "archive");+ assert_eq!(composer.current_text(), "archived prompt");+ escape(&mut composer);+ assert_eq!(composer.current_text(), "lpha beta alpha");+ keys(&mut composer, "u");+ assert_eq!(composer.current_text(), "alpha beta alpha");+ keys(&mut composer, ".");+ assert_eq!(composer.current_text(), "lpha beta alpha");+ keys(&mut composer, "n");+ assert_eq!(composer.cursor(), 10);+}++#[test]+fn canceled_history_preview_preserves_active_vim_commands() {+ for query in ["", "archive", "missing"] {+ for (command, edited) in [("iX", "XYalpha beta"), ("cwX", "XY beta")] {+ let mut composer = vim_composer("alpha beta");+ composer+ .history+ .record_local_submission(HistoryEntry::new("archived prompt".to_owned()));+ keys(&mut composer, command);+ ctrl_r(&mut composer);+ keys(&mut composer, query);+ escape(&mut composer);+ keys(&mut composer, "Y");+ escape(&mut composer);+ assert_eq!(composer.current_text(), edited);+ keys(&mut composer, "u.");+ assert_eq!(composer.current_text(), edited);+ }+ }+}++#[test]+fn accepted_reverse_history_preview_starts_a_fresh_vim_edit_history() {+ let mut composer = vim_composer("abc");+ composer+ .history+ .record_local_submission(HistoryEntry::new("archived prompt".to_owned()));+ keys(&mut composer, "xiX");+ ctrl_r(&mut composer);+ keys(&mut composer, "archive\n");+ assert_eq!(composer.current_text(), "archived prompt");+ assert!(!composer.history_search_active());+ escape(&mut composer);+ keys(&mut composer, "u.");+ assert_eq!(composer.current_text(), "archived prompt");+}++#[test]+fn undo_uses_configured_bindings_and_supports_unbinding() {+ let mut composer = vim_composer("abc");+ let mut keymap = RuntimeKeymap::defaults();+ keymap.vim_normal.undo = vec![crate::key_hint::plain(KeyCode::Char('z'))];+ composer.set_keymap_bindings(&keymap);+ keys(&mut composer, "xu");+ assert_eq!(composer.current_text(), "bc");+ keys(&mut composer, "z");+ assert_eq!(composer.current_text(), "abc");+ keymap.vim_normal.undo.clear();+ composer.set_keymap_bindings(&keymap);+ keys(&mut composer, "xz");+ assert_eq!(composer.current_text(), "bc");++ let mut config = TuiKeymap::default();+ config.composer.history_search_previous =+ Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned())));+ composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap());+ keys(&mut composer, "u");+ assert!(composer.history_search_active());+ escape(&mut composer);+ config.vim_normal.undo = Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned())));+ composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap());+ keys(&mut composer, "u");+ assert!(!composer.history_search_active());++ let mut composer = vim_composer("abc");+ let mut config = TuiKeymap::default();+ config.composer.submit = Some(KeybindingsSpec::One(KeybindingSpec("u".to_owned())));+ composer.set_keymap_bindings(&RuntimeKeymap::from_config(&config).unwrap());+ assert_eq!(+ composer+ .handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE))+ .0,+ InputResult::Submitted {+ text: "abc".to_owned(),+ text_elements: Vec::new()+ }+ );+}++#[test]+fn undo_restores_deleted_large_paste_payload() {+ let mut composer = vim_composer("alpha ");+ composer.draft.textarea.set_cursor("alpha ".len());+ keys(&mut composer, "i");+ let pasted = "x".repeat(LARGE_PASTE_CHAR_THRESHOLD + 1);+ composer.handle_paste(pasted.clone());+ escape(&mut composer);+ let before = composer.draft_snapshot();+ keys(&mut composer, "x");+ assert_eq!(composer.current_text(), "alpha ");+ assert!(composer.draft.pending_pastes.is_empty());+ keys(&mut composer, "u");+ assert_eq!(composer.draft_snapshot(), before);+ assert_eq!(+ composer.current_text_with_pending(),+ format!("alpha {pasted}")+ );+}++#[test]+fn undo_restores_deleted_image_attachment() {+ let mut composer = vim_composer("alpha ");+ composer.draft.textarea.set_cursor("alpha ".len());+ composer.attach_image(PathBuf::from("example.png"));+ composer.draft.textarea.set_cursor("alpha ".len());+ let before = composer.draft_snapshot();+ keys(&mut composer, "x");+ assert_eq!(composer.current_text(), "alpha ");+ assert!(composer.local_image_paths().is_empty());+ keys(&mut composer, "u");+ assert_eq!(composer.draft_snapshot(), before);+}++#[test]+fn find_jump_and_search_navigation_never_snapshot_the_draft() {+ let mut composer = vim_composer("alpha beta\nalpha gamma");+ for key in ['f', 'F', 'G', '/', '?', 'n', 'N'] {+ composer.begin_vim_edit(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE));+ assert!(+ composer.vim_history.pending.is_none(),+ "navigation binding {key:?} snapshotted the draft"+ );+ }+ let (code, modifiers) = composer+ .vim_normal_keymap+ .jump_top+ .first()+ .expect("native jump-top chord")+ .parts();+ composer.begin_vim_edit(KeyEvent::new(code, modifiers));+ assert!(composer.vim_history.pending.is_none());++ for command in ["llwbh0$", "fb", "Fa", "G", "/beta\nnN", "?alpha\n"] {+ let text = "alpha beta\nalpha gamma";+ let mut composer = vim_composer(text);+ for key in command.chars() {+ keys(&mut composer, &key.to_string());+ assert!(+ composer.vim_history.pending.is_none(),+ "navigation command {command:?} snapshotted the draft"+ );+ assert!(composer.vim_history.undo.is_empty());+ }+ assert_eq!(composer.current_text(), text);+ }+ composer+ .history+ .record_local_submission(HistoryEntry::new("alpha archived".to_owned()));+ ctrl_r(&mut composer);+ keys(&mut composer, "alpha");+ assert_eq!(composer.current_text(), "alpha archived");+ assert!(composer.vim_history.pending.is_none());+ assert!(composer.vim_history.undo.is_empty());+ escape(&mut composer);+ assert_eq!(composer.current_text(), "alpha beta\nalpha gamma");+}diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs b/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rsindex c6d0af5092..35d5a5d18d 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer/vim_search.rs@@ -6,7 +6,11 @@ use ratatui::layout::Rect;impl ChatComposer {pub(crate) fn cancel_vim_search(&mut self) -> bool {- self.draft.textarea.cancel_vim_search()+ let canceled = self.draft.textarea.cancel_vim_search();+ if canceled {+ self.finish_vim_edit();+ }+ canceled}pub(super) fn vim_search_cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {diff --git a/codex-rs/tui/src/bottom_pane/textarea.rs b/codex-rs/tui/src/bottom_pane/textarea.rsindex 5e0d163233..8dd6d331be 100644--- a/codex-rs/tui/src/bottom_pane/textarea.rs+++ b/codex-rs/tui/src/bottom_pane/textarea.rs@@ -63,6 +63,7 @@ use self::vim_commands::VimAction;use self::vim_commands::VimCommandState;use self::vim_commands::VimEditTarget;use self::vim_commands::VimInsertPosition;+pub(crate) use self::vim_commands::VimPersistentState;const WORD_SEPARATORS: &str = "`~!@#$%^&*()-=+[{]}\\|;:'\",.<>/?";diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rsindex 1e3e290f8d..42df694a76 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim_commands.rs@@ -26,6 +26,13 @@ pub(crate) enum VimEdit {Text(String),}+/// Vim command recording and searches preserved across same-draft restoration.+#[derive(Debug, Default)]+pub(crate) struct VimPersistentState {+ pub(crate) commands: VimCommandState,+ search: crate::vim_search::SearchQuery,+}+#[derive(Clone, Debug)]pub(crate) struct VimEditorEdit(VimAction);@@ -84,14 +91,19 @@ pub(super) enum VimAction {}#[derive(Debug, Default)]-pub(super) struct VimCommandState {+pub(crate) struct VimCommandState {pub(super) pending_change: Vec<VimEdit>,- last_change: Vec<VimEdit>,+ pub(crate) last_change: Vec<VimEdit>,changed: bool,pub(super) replaying: bool,}impl TextArea {+ pub(crate) fn swap_vim_persistent_state(&mut self, state: &mut VimPersistentState) {+ std::mem::swap(&mut self.vim_commands, &mut state.commands);+ std::mem::swap(&mut self.vim_search.last, &mut state.search);+ }+pub(crate) fn vim_repeat_actions(&self) -> Option<Vec<VimEdit>> {(!self.vim_commands.last_change.is_empty()).then(|| self.vim_commands.last_change.clone())}diff --git a/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs b/codex-rs/tui/src/bottom_pane/textarea/vim_search.rsindex 2091ede8cc..4bc7451eb3 100644--- a/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs+++ b/codex-rs/tui/src/bottom_pane/textarea/vim_search.rs@@ -26,7 +26,7 @@ use std::ops::Range;#[derive(Debug, Default)]pub(super) struct VimSearch {input: Option<Box<SearchInput>>,- last: SearchQuery,+ pub(super) last: SearchQuery,}/// Footer query editor, boxed by its owning textarea to keep the draft and query independent.diff --git a/codex-rs/tui/src/keymap.rs b/codex-rs/tui/src/keymap.rsindex 2f95913b21..9adc438438 100644--- a/codex-rs/tui/src/keymap.rs+++ b/codex-rs/tui/src/keymap.rs@@ -210,6 +210,7 @@ pub(crate) struct VimNormalKeymap {pub(crate) start_delete_operator: Vec<KeyBinding>,pub(crate) start_yank_operator: Vec<KeyBinding>,pub(crate) start_change_operator: Vec<KeyBinding>,+ pub(crate) undo: Vec<KeyBinding>,pub(crate) cancel_operator: Vec<KeyBinding>,}@@ -757,6 +758,7 @@ impl RuntimeKeymap {vim_normal,start_change_operator),+ undo: resolve_local!(keymap, defaults, vim_normal, undo),cancel_operator: resolve_local!(keymap, defaults, vim_normal, cancel_operator),};@@ -889,6 +891,7 @@ impl RuntimeKeymap {keymap.vim_normal.start_change_operator.as_ref(),vim_normal.start_change_operator.as_slice(),),+ (keymap.vim_normal.undo.as_ref(), vim_normal.undo.as_slice()),(keymap.vim_normal.cancel_operator.as_ref(),vim_normal.cancel_operator.as_slice(),@@ -959,7 +962,6 @@ impl RuntimeKeymap {});}}-let mut vim_operator = VimOperatorKeymap {delete_line: resolve_local!(keymap, defaults, vim_operator, delete_line),yank_line: resolve_local!(keymap, defaults, vim_operator, yank_line),@@ -1350,7 +1352,12 @@ impl RuntimeKeymap {editor,vim_normal,vim_operator,- vim_search: VimSearchKeymap::default(),+ vim_search: VimSearchKeymap {+ forward: resolve_local!(keymap, defaults, vim_search, forward),+ backward: resolve_local!(keymap, defaults, vim_search, backward),+ next: resolve_local!(keymap, defaults, vim_search, next),+ previous: resolve_local!(keymap, defaults, vim_search, previous),+ },vim_text_object,pager,list,@@ -1358,6 +1365,23 @@ impl RuntimeKeymap {approval,};+ if keymap.vim_normal.undo.is_none() {+ let configured: Vec<_> = runtime_action_bindings(&resolved)+ .filter(|action| {+ action.id.context.overlaps(KeymapContext::VimNormal)+ && bindings::configured_binding_for_action(keymap, action.id)+ .is_some_and(Option::is_some)+ })+ .flat_map(|action| action.bindings.iter().copied())+ .collect();+ resolved.vim_normal.undo.retain(|binding| {+ !configured.contains(binding)+ && !resolved.chords.bindings.iter().any(|chord| {+ chord.action.context.overlaps(KeymapContext::VimNormal)+ && chord.chord.prefix.parts() == binding.parts()+ })+ });+ }resolved.configure_vim_search(keymap)?;resolved.validate_conflicts()?;chords::validate_chord_conflicts(&resolved)?;@@ -1534,6 +1558,7 @@ impl RuntimeKeymap {start_delete_operator: default_bindings![plain(KeyCode::Char('d'))],start_yank_operator: default_bindings![plain(KeyCode::Char('y'))],start_change_operator: default_bindings![plain(KeyCode::Char('c'))],+ undo: default_bindings![plain(KeyCode::Char('u'))],cancel_operator: default_bindings![plain(KeyCode::Esc)],},vim_search: VimSearchKeymap::default(),@@ -2955,6 +2980,47 @@ mod tests {}));}+ #[test]+ fn configured_legacy_bindings_prune_new_history_defaults() {+ for (context, action, binding) in [+ ("vim_normal", "move_left", "u"),+ ("vim_normal", "move_left", "u g"),+ ("vim_search", "forward", "u"),+ ("vim_search", "forward", "u g"),+ ("composer", "submit", "u"),+ ("global", "submit", "u"),+ ("global", "queue", "u"),+ ("global", "toggle_shortcuts", "u"),+ ] {+ let keymap = serde_json::from_value(serde_json::json!({+ (context): { (action): binding }+ }))+ .expect("config should deserialize");++ let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse");++ assert_eq!(runtime.vim_normal.undo, Vec::new());+ }+ }++ #[test]+ fn explicit_vim_history_bindings_still_conflict_with_legacy_bindings() {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.move_left = Some(one("u"));+ keymap.vim_normal.undo = Some(one("u"));+ expect_conflict(&keymap, "move_left", "undo");+ }++ #[test]+ fn explicit_empty_arrays_unbind_vim_history_actions() {+ let mut keymap = TuiKeymap::default();+ keymap.vim_normal.undo = Some(KeybindingsSpec::Many(vec![]));++ let runtime = RuntimeKeymap::from_config(&keymap).expect("config should parse");++ assert!(runtime.vim_normal.undo.is_empty());+ }+#[test]fn configured_legacy_vim_operator_bindings_prune_new_text_object_defaults() {let mut keymap = TuiKeymap::default();diff --git a/codex-rs/tui/src/keymap/bindings.rs b/codex-rs/tui/src/keymap/bindings.rsindex 5d58c02dd3..ca83f16327 100644--- a/codex-rs/tui/src/keymap/bindings.rs+++ b/codex-rs/tui/src/keymap/bindings.rs@@ -136,12 +136,21 @@ macro_rules! define_runtime_action_bindings {}}- /// Return the root-config slot for one runtime action.+ /// Return the configured slot for one runtime action, including global fallbacks.pub(super) fn configured_binding_for_action(keymap: &TuiKeymap,action: KeymapActionId,) -> Option<&Option<KeybindingsSpec>> {match (action.context.config_name(), action.action) {+ ("composer", "submit") if keymap.composer.submit.is_none() => {+ Some(&keymap.global.submit)+ }+ ("composer", "queue") if keymap.composer.queue.is_none() => {+ Some(&keymap.global.queue)+ }+ ("composer", "toggle_shortcuts") if keymap.composer.toggle_shortcuts.is_none() => {+ Some(&keymap.global.toggle_shortcuts)+ }$($(($context, stringify!($action)) => {@@ -310,6 +319,7 @@ define_runtime_action_bindings! {start_delete_operator,start_yank_operator,start_change_operator,+ undo,cancel_operator,],"vim_search" => VimSearch, vim_search, vim_search [forward, backward, next, previous],diff --git a/codex-rs/tui/src/keymap/vim_search.rs b/codex-rs/tui/src/keymap/vim_search.rsindex c9d54ed050..da9ca862cc 100644--- a/codex-rs/tui/src/keymap/vim_search.rs+++ b/codex-rs/tui/src/keymap/vim_search.rs@@ -45,7 +45,6 @@ impl RuntimeKeymap {];for (action, configured, bindings) in &mut actions {let path = format!("tui.keymap.vim_search.{action}");- **bindings = resolve_bindings(configured.as_ref(), bindings, &path)?;if configured.is_none() {bindings.retain(|key| {!others.iter().any(|other| {diff --git a/codex-rs/tui/src/keymap_setup/actions.rs b/codex-rs/tui/src/keymap_setup/actions.rsindex 1125c8349a..3ad272e0fd 100644--- a/codex-rs/tui/src/keymap_setup/actions.rs+++ b/codex-rs/tui/src/keymap_setup/actions.rs@@ -153,6 +153,7 @@ pub(super) const KEYMAP_ACTIONS: &[KeymapActionDescriptor] = &[action("vim_normal", "Vim normal", "start_delete_operator", "Begin a delete operator and wait for a motion."),action("vim_normal", "Vim normal", "start_yank_operator", "Begin a yank operator and wait for a motion."),action("vim_normal", "Vim normal", "start_change_operator", "Begin a change operator and wait for a motion or text object."),+ action("vim_normal", "Vim normal", "undo", "Undo the last complete edit."),action("vim_normal", "Vim normal", "cancel_operator", "Cancel a pending Vim operator."),action("vim_search", "Vim search", "forward", "Search forward in the active buffer."),action("vim_search", "Vim search", "backward", "Search backward in the active buffer."),@@ -323,6 +324,7 @@ pub(super) fn binding_slot<'a>(("vim_normal", "start_delete_operator") => Some(&mut keymap.vim_normal.start_delete_operator),("vim_normal", "start_yank_operator") => Some(&mut keymap.vim_normal.start_yank_operator),("vim_normal", "start_change_operator") => Some(&mut keymap.vim_normal.start_change_operator),+ ("vim_normal", "undo") => Some(&mut keymap.vim_normal.undo),("vim_normal", "cancel_operator") => Some(&mut keymap.vim_normal.cancel_operator),("vim_search", "forward") => Some(&mut keymap.vim_search.forward),("vim_search", "backward") => Some(&mut keymap.vim_search.backward),diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snapindex 58432b15bd..b057c11c90 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_custom.snap@@ -5,7 +5,7 @@ expression: "render_picker(params, 120)"KeymapAll configurable shortcuts.- 135 actions, 1 customized, 5 unbound.+ 136 actions, 1 customized, 5 unbound.[All] Common Customized (1) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debugdiff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snapindex f95f620048..2c4456772d 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_fast_mode_enabled.snap@@ -5,7 +5,7 @@ expression: "render_picker(params, 120)"KeymapAll configurable shortcuts.- 136 actions, 0 customized, 6 unbound.+ 137 actions, 0 customized, 6 unbound.[All] Common Customized (0) Unbound (6) App Composer Editor Vim Navigation Agents Approval Debugdiff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snapindex 2696436fc0..cf2365caab 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_first_actions.snap@@ -2,14 +2,14 @@source: tui/src/keymap_setup.rsexpression: snapshot----tab: All (135 selectable)+tab: All (136 selectable)tab: Common (20 selectable)tab: Customized (0) (0 selectable)tab: Unbound (5) (5 selectable)tab: App (14 selectable)tab: Composer (5 selectable)tab: Editor (17 selectable)-tab: Vim (66 selectable)+tab: Vim (67 selectable)tab: Navigation (20 selectable)tab: Agents (5 selectable)tab: Approval (8 selectable)diff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snapindex d74a43b933..3eb29aff66 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_global_chord.snap@@ -5,7 +5,7 @@ expression: "render_picker(params, 120)"KeymapAll configurable shortcuts.- 135 actions, 1 customized, 5 unbound.+ 136 actions, 1 customized, 5 unbound.[All] Common Customized (1) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debugdiff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snapindex 4cd05f21d8..651dc681e0 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_narrow.snap@@ -5,7 +5,7 @@ expression: "render_picker(params, 78)"KeymapAll configurable shortcuts.- 135 actions, 0 customized, 5 unbound.+ 136 actions, 0 customized, 5 unbound.[All] Common Customized (0) Unbound (5) App Composer Editor VimNavigation Agents Approval Debugdiff --git a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snapindex 8450e8527b..35e7d5f991 100644--- a/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__keymap_setup__tests__keymap_picker_wide.snap@@ -5,7 +5,7 @@ expression: "render_picker(params, 120)"KeymapAll configurable shortcuts.- 135 actions, 0 customized, 5 unbound.+ 136 actions, 0 customized, 5 unbound.[All] Common Customized (0) Unbound (5) App Composer Editor Vim Navigation Agents Approval Debug