Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Add inline Other answers to async question choices (#42897)

Ian MacLeodc126b0d8ef87
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/input.rs b/codex-rs/tui/src/bottom_pane/async_questions/input.rs
index 79175a7a74..2c815ed5d3 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/input.rs
+++ b/codex-rs/tui/src/bottom_pane/async_questions/input.rs
@@ -1,12 +1,40 @@
//! Route question actions through the shared composer, preserving drafts until delivery accepts them.
+//! Inline Other reserves Up/Down for choices; j/k retain their Vim behavior.
use super::*;
+use ratatui::layout::Rect;
impl AsyncQuestions {
pub(crate) fn handles_key_as_editing(&self, key: KeyEvent) -> bool {
self.focus_is_notes() && self.composer.handles_key_as_editing(key)
}
+ pub(super) fn other_selected(&self) -> bool {
+ self.has_options() && self.selected_option_index() == Some(self.options().len())
+ }
+
+ pub(super) fn other_label(&self) -> String {
+ self.current_answer()
+ .filter(|_| !self.other_selected())
+ .map(|answer| answer.draft.text.trim())
+ .filter(|text| !text.is_empty())
+ .map(|text| &text[..text.floor_char_boundary(512)])
+ .map(|text| crate::text_formatting::truncate_text(text, /*max_graphemes*/ 128))
+ .unwrap_or_else(|| self.other_placeholder().to_string())
+ }
+
+ pub(super) fn focus_other(&mut self) {
+ self.select_option(self.options().len());
+ }
+
+ pub(super) fn select_option(&mut self, index: usize) {
+ self.save_current_draft();
+ self.state.pending[self.state.current_idx]
+ .options_state
+ .selected_idx = Some(index);
+ self.sync_composer_placeholder();
+ }
+
pub(super) fn edit(&mut self, key: KeyEvent) {
if key.kind == KeyEventKind::Repeat && self.keymap.composer.queue.is_pressed(key) {
return;
@@ -17,7 +45,6 @@ impl AsyncQuestions {
}
let before = self.composer.snapshot_draft();
let (result, _) = self.composer.handle_key_event(key);
- self.composer.cancel_history_search();
let queued = matches!(result, InputResult::Queued { .. });
if matches!(
result,
@@ -31,12 +58,74 @@ impl AsyncQuestions {
}
}
- pub(super) fn select_option(&mut self, index: usize) {
- self.state.pending[self.state.current_idx]
- .options_state
- .selected_idx = Some(index);
+ pub(super) fn other_prefix_width(&self, width: u16) -> u16 {
+ let full = format!("› {}. ", self.options_len()).width() as u16;
+ if full + 2 <= width {
+ full
+ } else {
+ width.saturating_sub(2).min(2)
+ }
+ }
+
+ pub(super) fn other_input_area(&self, options_area: Rect) -> Rect {
+ let prefix_width = self.other_prefix_width(options_area.width);
+ let width = options_area.width.saturating_sub(prefix_width);
+ let height = self
+ .composer
+ .inline_input_height(width)
+ .clamp(1, 8)
+ .min(options_area.height);
+ Rect::new(
+ options_area.x.saturating_add(prefix_width),
+ options_area.bottom().saturating_sub(height),
+ width,
+ height,
+ )
}
+ pub(super) fn render_inline_options(&self, area: Rect, buf: &mut ratatui::buffer::Buffer) {
+ use ratatui::text::Line;
+ use ratatui::widgets::Widget;
+
+ let row_width = area.width.saturating_add(1);
+ let input = self.other_input_area(area);
+ let named_area = Rect::new(area.x, area.y, area.width, input.y.saturating_sub(area.y));
+ let mut rows = self.option_rows();
+ rows.pop();
+ let mut state = ScrollState::default();
+ while state.scroll_top + 1 < rows.len()
+ && measure_rows_height(&rows, &state, rows.len(), row_width) > named_area.height
+ {
+ state.scroll_top += 1;
+ }
+ if measure_rows_height(&rows, &state, rows.len(), row_width) <= named_area.height {
+ self.visible_options
+ .set((state.scroll_top, rows.len() - state.scroll_top));
+ }
+ crate::bottom_pane::request_user_input::render::render_rows_bottom_aligned(
+ named_area,
+ buf,
+ &rows,
+ &state,
+ rows.len(),
+ "",
+ );
+ let margin = Rect::new(
+ area.x,
+ input.y,
+ input.x.saturating_sub(area.x),
+ input.height.min(1),
+ );
+ let prefix = format!("› {}. ", self.options_len());
+ Line::from(if usize::from(margin.width) < prefix.width() {
+ "› ".to_string()
+ } else {
+ prefix
+ })
+ .style(crate::style::accent_style())
+ .render(margin, buf);
+ self.composer.render_inline_input(input, buf);
+ }
pub(crate) fn set_keymap(&mut self, keymap: &RuntimeKeymap) {
self.keymap = keymap.clone();
self.composer.set_keymap_bindings(keymap);
@@ -49,14 +138,26 @@ impl AsyncQuestions {
impl BottomPaneView for AsyncQuestions {
fn keymap_contexts(&self) -> crate::keymap::KeymapContextSet {
- if self.has_options() {
- crate::keymap::KeymapContextSet::new(KeymapContext::List).with(KeymapContext::Chat)
- } else {
+ if self.focus_is_notes() {
self.composer.keymap_contexts().with(KeymapContext::Chat)
+ } else {
+ crate::keymap::KeymapContextSet::new(KeymapContext::List).with(KeymapContext::Chat)
}
}
+ fn prefer_esc_to_handle_key_event(&self) -> bool {
+ true
+ }
+
+ fn will_interrupt_turn_on_key_event(&self, key: KeyEvent) -> bool {
+ !self.handles_key_as_editing(key) && self.keymap.chat.interrupt_turn.is_pressed(key)
+ }
+
fn handle_key_event(&mut self, key: KeyEvent) {
+ if key.kind == KeyEventKind::Repeat && self.other_selector == Some(key.code) {
+ return;
+ }
+ self.other_selector = None;
if key.kind == KeyEventKind::Release || self.is_complete() {
return;
}
@@ -82,44 +183,91 @@ impl BottomPaneView for AsyncQuestions {
self.navigate(/*forward*/ false);
return;
}
- if !self.has_options() {
- if key.kind == KeyEventKind::Press || !self.keymap.composer.submit.is_pressed(key) {
+ if self.focus_is_notes() && self.keymap.composer.submit.is_pressed(key) {
+ if key.kind != KeyEventKind::Press {
+ return;
+ }
+ let empty = self.composer.current_text_with_pending().trim().is_empty();
+ if empty && !self.composer.is_in_paste_burst() {
+ if !self.other_selected() {
+ self.go_next_or_submit();
+ }
+ } else {
self.edit(key);
}
return;
}
- let count = self.options_len();
- let visible = self.visible_options.get().1.max(1);
- let mut state = self.state.pending[self.state.current_idx].options_state;
- match self.keymap.list.action_for(key) {
- Some(ListAction::MoveUp) => state.move_up_wrap(count),
- Some(ListAction::MoveDown) => state.move_down_wrap(count),
- Some(ListAction::PageUp) => state.page_up_clamped(count, visible),
- Some(ListAction::PageDown) => state.page_down_clamped(count, visible),
- Some(ListAction::JumpTop) => state.jump_top(count, visible),
- Some(ListAction::JumpBottom) => state.jump_bottom(count, visible),
- Some(ListAction::Accept) => {
- if key.kind == KeyEventKind::Press {
- self.go_next_or_submit();
+ if self.has_options() {
+ // Default j/k start Other; explicit printable list remaps keep their meaning.
+ let printable = matches!(key.code, KeyCode::Char(_))
+ && !crate::key_hint::has_ctrl_or_alt(key.modifiers);
+ let remapped = self.keymap.list.action_for(key).is_some_and(|action| {
+ self.keymap.list.bindings_for(action)
+ != RuntimeKeymap::defaults().list.bindings_for(action)
+ });
+ if (!printable || remapped)
+ && (!self.focus_is_notes() || matches!(key.code, KeyCode::Up | KeyCode::Down))
+ {
+ let count = self.options_len();
+ let visible = self.visible_options.get().1.max(1);
+ let mut state = self.state.pending[self.state.current_idx].options_state;
+ match self.keymap.list.action_for(key) {
+ Some(ListAction::MoveUp) => state.move_up_wrap(count),
+ Some(ListAction::MoveDown) => state.move_down_wrap(count),
+ Some(ListAction::PageUp) => state.page_up_clamped(count, visible),
+ Some(ListAction::PageDown) => state.page_down_clamped(count, visible),
+ Some(ListAction::JumpTop) => state.jump_top(count, visible),
+ Some(ListAction::JumpBottom) => state.jump_bottom(count, visible),
+ Some(ListAction::Cancel) => {
+ self.set_expanded(/*expanded*/ false);
+ return;
+ }
+ Some(ListAction::MoveLeft | ListAction::MoveRight) => return,
+ Some(ListAction::Accept) | None => {}
+ }
+ if !matches!(
+ self.keymap.list.action_for(key),
+ Some(ListAction::Accept) | None
+ ) {
+ self.select_option(state.selected_idx.unwrap_or(0));
+ self.state.pending[self.state.current_idx].options_state = state;
+ return;
}
}
- Some(ListAction::Cancel) => self.set_expanded(/*expanded*/ false),
- Some(ListAction::MoveLeft | ListAction::MoveRight) => {}
- None => {
- if key.kind == KeyEventKind::Press
- && !crate::key_hint::has_ctrl_or_alt(key.modifiers)
- && let KeyCode::Char(ch) = key.code
- && let Some(index) = self.option_index_for_digit(ch)
- {
- self.select_option(index);
- self.go_next_or_submit();
+ }
+ if self.focus_is_notes() {
+ self.edit(key);
+ return;
+ }
+ if self.keymap.list.action_for(key) == Some(ListAction::Accept) {
+ if key.kind != KeyEventKind::Press {
+ return;
+ }
+ self.go_next_or_submit();
+ } else if let KeyCode::Char(ch) = key.code
+ && !crate::key_hint::has_ctrl_or_alt(key.modifiers)
+ {
+ if let Some(index) = self.option_index_for_digit(ch) {
+ if key.kind != KeyEventKind::Press {
return;
}
+ self.select_option(index);
+ if self.other_selected() {
+ self.other_selector = Some(key.code);
+ } else {
+ self.go_next_or_submit();
+ }
+ } else {
+ self.focus_other();
+ self.composer.resume_text_entry();
+ self.edit(key);
}
}
- self.state.pending[self.state.current_idx].options_state = state;
}
+ fn terminal_title_requires_action(&self) -> bool {
+ !self.is_complete()
+ }
fn is_complete(&self) -> bool {
self.unanswered_count() == 0
}
@@ -127,8 +275,9 @@ impl BottomPaneView for AsyncQuestions {
if self.composer.cancel_vim_search() || self.composer.cancel_history_search() {
return CancellationEvent::Handled;
}
- if self.composer.clear_for_ctrl_c().is_some() {
+ if self.focus_is_notes() && self.composer.clear_for_ctrl_c().is_some() {
self.save_current_draft();
+ self.sync_composer_placeholder();
} else {
return CancellationEvent::NotHandled;
}
@@ -138,16 +287,20 @@ impl BottomPaneView for AsyncQuestions {
if self.is_complete() || text.is_empty() {
return false;
}
+ if !self.focus_is_notes() {
+ self.focus_other();
+ }
self.composer.flush_pending_input();
- !self.has_options() && self.composer.handle_paste(text)
+ self.composer.handle_paste(text)
}
fn flush_paste_burst_if_due(&mut self) -> bool {
self.composer.flush_paste_burst_if_due()
}
- fn next_frame_delay(&self) -> Option<std::time::Duration> {
- self.composer.footer_flash_delay()
- }
fn is_in_paste_burst(&self) -> bool {
self.composer.is_in_paste_burst()
}
+
+ fn next_frame_delay(&self) -> Option<Duration> {
+ self.composer.footer_flash_delay()
+ }
}
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/layout.rs b/codex-rs/tui/src/bottom_pane/async_questions/layout.rs
index d4317d095c..6316ec939e 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/layout.rs
+++ b/codex-rs/tui/src/bottom_pane/async_questions/layout.rs
@@ -34,7 +34,9 @@ impl AsyncQuestions {
let progress_pref = u16::from(self.unanswered_count() > 1);
let min_notes = u16::from(!has_options).min(area.height);
let available = area.height.saturating_sub(min_notes);
- let question_height = question_lines.len().min(usize::from(available)) as u16;
+ let question_height = question_lines.len().min(usize::from(
+ available.saturating_sub(u16::from(self.other_selected())),
+ )) as u16;
question_lines.truncate(usize::from(question_height));
let mut remaining = available.saturating_sub(question_height);
let mut options_height = 0;
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/mod.rs b/codex-rs/tui/src/bottom_pane/async_questions/mod.rs
index 6fdbdf7d8f..8d7b0c4bfa 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/async_questions/mod.rs
@@ -20,6 +20,7 @@ use crossterm::event::KeyCode;
use crossterm::event::KeyEvent;
use crossterm::event::KeyEventKind;
use std::collections::HashSet;
+use std::time::Duration;
use unicode_width::UnicodeWidthStr;
mod input;
@@ -27,6 +28,7 @@ mod layout;
mod render;
mod state;
+const OTHER_OPTION_LABEL: &str = "Other";
pub(super) const TIP_SEPARATOR: &str = " ";
pub(super) const DESIRED_SPACERS_BETWEEN_SECTIONS: u16 = 2;
@@ -59,6 +61,8 @@ pub(crate) struct AsyncQuestions {
visible_options: std::cell::Cell<(usize, usize)>,
pub(crate) next_hint: Option<crate::key_hint::ShortcutHint>,
keymap: RuntimeKeymap,
+ // Ignore autorepeat from the number key that opened Other.
+ other_selector: Option<KeyCode>,
pub(super) composer: ChatComposer,
}
@@ -89,6 +93,7 @@ impl AsyncQuestions {
visible_options: std::cell::Cell::new((0, 0)),
next_hint: None,
keymap,
+ other_selector: None,
composer,
}
}
@@ -116,12 +121,13 @@ impl AsyncQuestions {
.and_then(|q| q.options.as_deref())
.unwrap_or_default()
}
+
fn has_options(&self) -> bool {
!self.options().is_empty()
}
fn options_len(&self) -> usize {
- self.options().len()
+ self.options().len() + usize::from(self.has_options())
}
fn option_index_for_digit(&self, ch: char) -> Option<usize> {
@@ -146,12 +152,17 @@ impl AsyncQuestions {
}
fn focus_is_notes(&self) -> bool {
- !self.has_options()
+ !self.has_options() || self.other_selected()
}
pub(super) fn option_rows(&self) -> Vec<GenericDisplayRow> {
+ if !self.has_options() {
+ return Vec::new();
+ };
+ let other = self.other_label();
self.options()
.iter()
+ .chain(std::iter::once(&other))
.enumerate()
.map(|(index, label)| {
let prefix = if self.selected_option_index() == Some(index) {
@@ -174,20 +185,36 @@ impl AsyncQuestions {
if !self.has_options() {
return 0;
}
+ let row_width = width.saturating_add(1);
let rows = self.option_rows();
- let state = ScrollState::default();
- measure_rows_height(&rows, &state, rows.len(), width.saturating_add(1))
+ if self.other_selected() {
+ let prefix = self.other_prefix_width(width);
+ measure_rows_height(
+ &rows[..rows.len() - 1],
+ &ScrollState::default(),
+ rows.len(),
+ row_width,
+ ) + self
+ .composer
+ .inline_input_height(width.saturating_sub(prefix).max(1))
+ .clamp(1, 8)
+ } else {
+ measure_rows_height(&rows, &ScrollState::default(), rows.len(), row_width)
+ }
}
fn save_current_draft(&mut self) {
self.composer.flush_pending_input();
- let draft = self.composer.snapshot_draft();
- if let Some(answer) = self.current_answer_mut() {
- answer.draft = draft;
+ if self.focus_is_notes() {
+ let draft = self.composer.snapshot_draft();
+ if let Some(answer) = self.current_answer_mut() {
+ answer.draft = draft;
+ }
}
}
fn restore_current_draft(&mut self) {
+ self.sync_composer_placeholder();
let draft = self
.current_answer()
.map(|answer| answer.draft.clone())
@@ -195,6 +222,27 @@ impl AsyncQuestions {
self.composer.restore_inline_draft(draft);
}
+ fn other_placeholder(&self) -> &'static str {
+ if self
+ .options()
+ .iter()
+ .any(|label| label.eq_ignore_ascii_case("Other"))
+ {
+ "Other (write an answer)"
+ } else {
+ OTHER_OPTION_LABEL
+ }
+ }
+
+ fn sync_composer_placeholder(&mut self) {
+ let text = if self.other_selected() {
+ self.other_placeholder()
+ } else {
+ "Type your answer"
+ };
+ self.composer.set_placeholder_text(text.to_string());
+ }
+
pub(crate) fn unanswered_count(&self) -> usize {
self.state.pending.len()
}
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/render.rs b/codex-rs/tui/src/bottom_pane/async_questions/render.rs
index eb4313d880..094de5fbb0 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/render.rs
+++ b/codex-rs/tui/src/bottom_pane/async_questions/render.rs
@@ -57,7 +57,9 @@ impl Renderable for AsyncQuestions {
// The shared measurer reserves a scrollbar column; this renderer uses the full width.
let option_rows = self.option_rows();
- if self.has_options() && sections.options_area.height > 0 {
+ if self.other_selected() {
+ self.render_inline_options(sections.options_area, buf);
+ } else if self.has_options() && sections.options_area.height > 0 {
let mut options_state = self.state.pending[self.state.current_idx].options_state;
let selected = options_state.selected_idx.unwrap_or(0);
let heights: Vec<_> = option_rows
@@ -109,6 +111,25 @@ impl Renderable for AsyncQuestions {
content_area.width,
sections.footer_lines,
);
+ let input_bottom = if self.other_selected() {
+ sections.options_area.bottom()
+ } else {
+ sections.notes_area.bottom()
+ };
+ if self.focus_is_notes()
+ && footer_area.y > input_bottom
+ && let Some(mode) = self.composer.vim_mode_indicator_span()
+ {
+ Line::from(mode).right_aligned().render(
+ Rect::new(
+ content_area.x,
+ footer_area.y - 1,
+ content_area.width,
+ /*height*/ 1,
+ ),
+ buf,
+ );
+ }
let option_tip = (self.has_options()
&& sections.options_area.height > 0
&& self.options_required_height(content_area.width) > sections.options_area.height)
@@ -130,7 +151,11 @@ impl Renderable for AsyncQuestions {
return None;
}
let sections = self.layout_sections(content_area);
- let input_area = sections.notes_area;
+ let input_area = if self.other_selected() {
+ self.other_input_area(sections.options_area)
+ } else {
+ sections.notes_area
+ };
if input_area.width == 0 || input_area.height == 0 {
return None;
}
@@ -171,15 +196,7 @@ impl AsyncQuestions {
.bold(),
);
}
- if self.focus_is_notes()
- && let Some(mode) = self.composer.vim_mode_indicator_span()
- {
- tips.push(Span::from(mode.content.into_owned()).dim());
- }
- if let Some(key) = self
- .keymap
- .primary_hint(KeymapContext::Chat, "skip_question")
- {
+ if let Some(key) = chat_hint("skip_question") {
tips.push(format!("{} skip", key.display_label()).dim());
}
tips.extend(option_tip);
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_capped_other.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_capped_other.snap
new file mode 100644
index 0000000000..6e0a26e293
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_capped_other.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ Second
+
+ 1. A suggested answer that is long enough to
+ wrap across multiple rows
+ › 2. long draft
+ long draft
+ long draft
+ long draft
+ long draft
+ long draft
+ long draft
+
+
+ enter submit ctrl + ] skip
+ ⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_named_other.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_named_other.snap
new file mode 100644
index 0000000000..bceeebde78
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_named_other.snap
@@ -0,0 +1,13 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ 2 of 2
+ Second
+
+ › 1. Other
+ 2. Other (write an answer)
+
+ enter submit ctrl + ] skip
+ ⌥ + ↓ prev question
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_narrow_other.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_narrow_other.snap
new file mode 100644
index 0000000000..ea22bbc560
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_narrow_other.snap
@@ -0,0 +1,11 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ 2 of
+ Secon
+ d
+ › x
+ ente…
+ ctrl…
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_remapped_choice_footer.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_remapped_choice_footer.snap
new file mode 100644
index 0000000000..f4a07f722a
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_remapped_choice_footer.snap
@@ -0,0 +1,15 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ 2 of 2
+ Second
+
+ › 1. Option 1 is long enough to wrap across
+ rows
+ 2. Option 2 is long enough to wrap across
+ rows
+
+ f9 submit ctrl + ] skip option 1/13
+ ⌥ + ↓ prev question
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_named_option.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_named_option.snap
index c32deb7429..ee4c3d579d 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_named_option.snap
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_named_option.snap
@@ -8,6 +8,7 @@ expression: buffer_text(&buffer)
› 1. A suggested answer that is
long enough to wrap across
multiple rows
+ 2. Other
enter submit ctrl + ] skip
⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_other.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_other.snap
new file mode 100644
index 0000000000..423d83438e
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_other.snap
@@ -0,0 +1,16 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ Second
+
+ 1. A suggested answer that is
+ long enough to wrap across
+ multiple rows
+ › 2. An alternative answer that
+ wraps across several option
+ rows
+
+ enter submit ctrl + ] skip
+ ⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_selected_option.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_selected_option.snap
index e5efffabc0..5b1c3c3609 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_selected_option.snap
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__question_wrapped_selected_option.snap
@@ -10,4 +10,4 @@ expression: buffer_text(&clipped)
multiple rows
enter submit ctrl + ] skip
- option 2/2 ⌥ + ↓ main prompt
+ option 2/3 ⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__selected_other_placeholder.snap b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__selected_other_placeholder.snap
new file mode 100644
index 0000000000..324419be1e
--- /dev/null
+++ b/codex-rs/tui/src/bottom_pane/async_questions/snapshots/codex_tui__bottom_pane__async_questions__tests__selected_other_placeholder.snap
@@ -0,0 +1,13 @@
+---
+source: tui/src/bottom_pane/async_questions/state_tests.rs
+expression: buffer_text(&buffer)
+---
+
+ Long question Long question Long question
+ Long question Long question Long question
+ Long question Long question Long question
+ Long question Long question Long question
+ Long question Long question Long question
+ Long question Long question Long question
+ Long question Long question Long question
+ › 2. Other
diff --git a/codex-rs/tui/src/bottom_pane/async_questions/state_tests.rs b/codex-rs/tui/src/bottom_pane/async_questions/state_tests.rs
index 3363b29ae8..692b60de4e 100644
--- a/codex-rs/tui/src/bottom_pane/async_questions/state_tests.rs
+++ b/codex-rs/tui/src/bottom_pane/async_questions/state_tests.rs
@@ -6,6 +6,7 @@ use crossterm::event::KeyModifiers;
use pretty_assertions::assert_eq;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
+use ratatui::style::Modifier;
fn editor() -> AsyncQuestions {
let (tx, _rx) = tokio::sync::mpsc::unbounded_channel();
@@ -76,6 +77,55 @@ fn long_prompt_keeps_the_active_input_visible() {
insta::assert_snapshot!("long_prompt_active_input", text);
}
+#[test]
+fn selected_other_renders_as_a_dim_placeholder() {
+ let mut editor = editor();
+ editor.navigate(/*forward*/ true);
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('2')));
+ let mut repeat = KeyEvent::from(KeyCode::Char('2'));
+ repeat.kind = KeyEventKind::Repeat;
+ editor.handle_key_event(repeat);
+ assert!(editor.composer.is_empty());
+ editor.handle_paste("saved".into());
+ editor.handle_key_event(KeyEvent::from(KeyCode::Up));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('2')));
+ editor.handle_key_event(repeat);
+ assert_eq!(editor.composer.current_text(), "saved");
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('2')));
+ editor.handle_key_event(repeat);
+ assert_eq!(editor.composer.current_text(), "saved22");
+ editor.on_ctrl_c();
+ editor.state.pending[1].question.title = "Long question ".repeat(40);
+ let buffer = render_editor(&editor, /*width*/ 50, /*height*/ 10);
+ let area = buffer.area;
+ assert!(editor.cursor_pos(area).is_some());
+ let input = editor.other_input_area(
+ editor
+ .layout_sections(crate::bottom_pane::selection_popup_common::menu_surface_inset(area))
+ .options_area,
+ );
+ for offset in 0..5 {
+ assert_eq!(buffer[(input.x + offset, input.y)].modifier, Modifier::DIM);
+ }
+ insta::assert_snapshot!("selected_other_placeholder", buffer_text(&buffer));
+ editor.state.pending[1].question.title = "Second".into();
+ render_editor(&editor, /*width*/ 50, /*height*/ 10);
+ editor.set_vim_enabled(/*enabled*/ true);
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('i')));
+ editor.handle_paste("draft".into());
+ editor.handle_key_event(KeyEvent::from(KeyCode::Esc));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Up));
+ assert_eq!(editor.selected_option_index(), Some(0));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert!(editor.submission.take().is_some());
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('x')));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Esc));
+ for _ in 0..2 {
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('u')));
+ }
+ assert_eq!(editor.composer.current_text(), "");
+}
+
fn buffer_text(buffer: &ratatui::buffer::Buffer) -> String {
(buffer.area.y..buffer.area.bottom())
.map(|y| {
@@ -89,6 +139,60 @@ fn buffer_text(buffer: &ratatui::buffer::Buffer) -> String {
.join("\n")
}
+#[test]
+fn question_choice_remaps_paging_and_inline_feedback() {
+ use codex_config::types::KeybindingSpec;
+ use codex_config::types::KeybindingsSpec;
+ use codex_config::types::TuiKeymap;
+ let mut editor = editor();
+ editor.navigate(/*forward*/ true);
+ editor.state.pending[1].question.options = Some(
+ (1..=12)
+ .map(|i| format!("Option {i} is long enough to wrap across rows"))
+ .collect(),
+ );
+ let mut config = TuiKeymap::default();
+ config.list.move_down = Some(KeybindingsSpec::One(KeybindingSpec("x".into())));
+ config.list.accept = Some(KeybindingsSpec::One(KeybindingSpec("f9".into())));
+ config.list.jump_top = Some(KeybindingsSpec::One(KeybindingSpec("7".into())));
+ editor.set_keymap(&RuntimeKeymap::from_config(&config).unwrap());
+ editor.handle_key_event(KeyEvent::from(KeyCode::Down));
+ assert_eq!(editor.selected_option_index(), Some(0));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('x')));
+ assert_eq!(editor.selected_option_index(), Some(1));
+ let mut buffer = render_editor(&editor, /*width*/ 50, /*height*/ 12);
+ let area = buffer.area;
+ let visible = editor.visible_options.get().1;
+ assert_eq!(visible, 2);
+ editor.handle_key_event(KeyEvent::from(KeyCode::PageDown));
+ assert_eq!(editor.selected_option_index(), Some(1 + visible));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('7')));
+ assert_eq!(editor.selected_option_index(), Some(0));
+ editor.handle_key_event(KeyEvent::from(KeyCode::Char('7')));
+ assert_eq!(editor.selected_option_index(), Some(0));
+ editor.render(area, &mut buffer);
+ insta::assert_snapshot!("question_remapped_choice_footer", buffer_text(&buffer));
+}
+
+#[test]
+fn question_other_remains_visible_at_nine_columns_and_distinguishes_named_other() {
+ let mut editor = editor();
+ editor.navigate(/*forward*/ true);
+ editor.state.pending[1].question.options = Some(vec!["Other".into()]);
+ editor.handle_paste("other".into());
+ editor.on_ctrl_c();
+ editor.handle_key_event(KeyEvent::from(KeyCode::Up));
+ let buffer = render_editor(&editor, /*width*/ 50, /*height*/ 12);
+ insta::assert_snapshot!("question_named_other", buffer_text(&buffer));
+ editor.select_option(/*index*/ 1);
+ editor.handle_paste("x".into());
+ let buffer = render_editor(&editor, /*width*/ 9, /*height*/ 8);
+ let narrow = buffer.area;
+ assert!(editor.cursor_pos(narrow).is_some());
+ assert!(buffer.content.iter().any(|cell| cell.symbol() == "x"));
+ insta::assert_snapshot!("question_narrow_other", buffer_text(&buffer));
+}
+
#[test]
fn question_wrapped_options_and_other_share_the_text_indent() {
let mut editor = editor();
@@ -136,12 +240,13 @@ fn question_wrapped_options_and_other_share_the_text_indent() {
assert_eq!(
editor.current_answer().unwrap().options_state,
ScrollState {
- selected_idx: Some(31),
- scroll_top: 32 - editor.visible_options.get().1,
+ selected_idx: Some(editor.options_len() - 1),
+ scroll_top: editor.options_len() - editor.visible_options.get().1,
}
);
+ editor.handle_key_event(KeyEvent::from(KeyCode::Up));
render_editor(&editor, /*width*/ 80, /*height*/ 80);
- assert_eq!(editor.visible_options.get(), (0, 32));
+ assert_eq!(editor.visible_options.get(), (0, editor.options_len()));
editor.state.pending[editor.state.current_idx]
.question
.title = "Long question ".repeat(3 * 65_536);
@@ -166,6 +271,35 @@ fn question_wrapped_options_and_other_share_the_text_indent() {
}
}
+#[test]
+fn question_wrapped_other_shares_the_text_indent() {
+ let mut editor = editor();
+ editor.state.pending.remove(0);
+ editor.state.pending[0].question.options = Some(vec![
+ "A suggested answer that is long enough to wrap across multiple rows".into(),
+ ]);
+ editor.select_option(/*index*/ 1);
+ editor.handle_paste("An alternative answer that wraps across several option rows".into());
+ let buffer = render_editor(&editor, /*width*/ 36, /*height*/ 16);
+ insta::assert_snapshot!("question_wrapped_other", buffer_text(&buffer));
+ editor.composer.clear_for_ctrl_c();
+ editor.handle_paste(" \n ".into());
+ editor.select_option(/*index*/ 0);
+ assert_eq!(editor.other_label(), "Other");
+ editor.select_option(/*index*/ 1);
+ editor
+ .composer
+ .set_text_content("long draft\n".repeat(1000), Vec::new(), Vec::new());
+ editor.composer.move_cursor_to_end();
+ let buffer = render_editor(&editor, /*width*/ 50, /*height*/ 18);
+ assert_eq!(editor.cursor_pos(buffer.area), Some((7, 12)));
+ insta::assert_snapshot!("question_capped_other", buffer_text(&buffer));
+ editor.select_option(/*index*/ 0);
+ assert!(editor.other_label().len() <= 128);
+ editor.state.pending[0].draft.text = format!("a{}", "\u{301}".repeat(10_000));
+ assert!(editor.other_label().len() <= 512);
+}
+
fn question(title: &str, options: Option<Vec<String>>) -> AsyncUserInputQuestion {
AsyncUserInputQuestion {
title: title.into(),
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.rs
index 3f767d3ca9..892e8d00fd 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
@@ -463,7 +463,7 @@ impl ChatComposer {
/// footer area is collapsed or too narrow, the x coordinate is clamped inside the hint rect so
/// terminal backends do not receive an off-screen cursor position.
pub(super) fn history_search_cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
- let search = self.history_search.as_ref()?;
+ self.history_search.as_ref()?;
let [_, _, _, popup_rect] = self.layout_areas(area);
if popup_rect.is_empty() {
return None;
@@ -488,17 +488,27 @@ impl ChatComposer {
return None;
}
+ let indent = (FOOTER_INDENT_COLS as u16).min(hint_rect.width.saturating_sub(1));
+ self.history_search_query_cursor_pos(Rect {
+ x: hint_rect.x.saturating_add(indent),
+ width: hint_rect.width.saturating_sub(indent),
+ ..hint_rect
+ })
+ }
+
+ pub(super) fn history_search_query_cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
+ let search = self.history_search.as_ref()?;
+ if area.is_empty() {
+ return None;
+ }
let prompt_width = Line::from("reverse-i-search: ").width() as u16;
let query_width = Line::from(search.query.clone()).width() as u16;
- let desired_x = hint_rect
+ let desired_x = area
.x
- .saturating_add(FOOTER_INDENT_COLS as u16)
.saturating_add(prompt_width)
.saturating_add(query_width);
- let max_x = hint_rect
- .x
- .saturating_add(hint_rect.width.saturating_sub(1));
- Some((desired_x.min(max_x), hint_rect.y))
+ let max_x = area.x.saturating_add(area.width.saturating_sub(1));
+ Some((desired_x.min(max_x), area.y))
}
}
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/inline_input.rs b/codex-rs/tui/src/bottom_pane/chat_composer/inline_input.rs
index f8f49ca495..2800465429 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer/inline_input.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer/inline_input.rs
@@ -33,12 +33,14 @@ impl ChatComposer {
}
/// Give modal editing precedence over a containing view's submit/navigation keys.
+ /// Up/Down remain available to inline choices; j/k keep their Vim editing behavior.
pub(crate) fn handles_key_as_editing(&self, key: KeyEvent) -> bool {
self.history_search.is_some()
|| self.should_handle_vim_insert_escape(key)
|| self.draft.textarea.is_vim_operator_pending()
|| self.draft.textarea.wants_vim_search_key(key)
|| (self.draft.textarea.is_vim_normal_mode()
+ && !matches!(key.code, KeyCode::Up | KeyCode::Down)
&& !self.submit_keys.is_pressed(key)
&& !self.queue_keys.is_pressed(key)
&& (self.vim_normal_keymap.move_up.is_pressed(key)
@@ -72,6 +74,9 @@ impl ChatComposer {
if let Some(query) = self.draft.textarea.vim_query() {
return query.cursor_pos(query_area);
}
+ if self.history_search.is_some() {
+ return self.history_search_query_cursor_pos(query_area);
+ }
self.draft
.textarea
.cursor_pos_with_state(area, *self.draft.textarea_state.borrow())
@@ -101,6 +106,12 @@ impl ChatComposer {
Rect::new(area.x, area.bottom(), area.width, /*height*/ 1),
buf,
);
+ } else if let Some(line) = self.history_search_footer_line() {
+ area.height = area.height.saturating_sub(1);
+ line.render(
+ Rect::new(area.x, area.bottom(), area.width, /*height*/ 1),
+ buf,
+ );
}
let mut state = self.draft.textarea_state.borrow_mut();
let highlights: Vec<_> = self
diff --git a/codex-rs/tui/src/chatwidget/tests/questions_tests.rs b/codex-rs/tui/src/chatwidget/tests/questions_tests.rs
index 76ce8b1d7b..5852a451da 100644
--- a/codex-rs/tui/src/chatwidget/tests/questions_tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests/questions_tests.rs
@@ -115,6 +115,84 @@ async fn selected_answers_preserve_long_labels_and_reject_oversized_submissions(
}
}
+#[tokio::test]
+async fn question_inputs_support_vim_editing_and_search() {
+ for (name, options) in [("single", None), ("other", Some(vec!["Named".to_string()]))] {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ chat.show_welcome_banner = false;
+ chat.bottom_pane.set_vim_enabled(/*enabled*/ true);
+ chat.add_async_questions("message", &[question("Which way?", options.clone())]);
+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));
+ if options.is_some() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char('2')));
+ }
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char('i')));
+ chat.bottom_pane
+ .handle_paste("alpha beta\nalpha gamma".into());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));
+ for ch in "0k".chars() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
+ }
+ assert!(chat.bottom_pane.questions.as_ref().unwrap().expanded);
+ let normal = render_bottom_popup(&chat, /*width*/ 80);
+ for ch in "dw".chars() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
+ }
+ assert!(!render_bottom_popup(&chat, /*width*/ 80).contains("alpha beta"));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char('u')));
+ assert!(render_bottom_popup(&chat, /*width*/ 80).contains("alpha beta"));
+ chat.handle_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));
+ assert!(!render_bottom_popup(&chat, /*width*/ 80).contains("alpha beta"));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char('u')));
+ for ch in "/gamma".chars() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
+ }
+ let search = render_bottom_popup(&chat, /*width*/ 80);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert_eq!(question_count(&chat), 1);
+ assert!(op_rx.try_recv().is_err());
+ for ch in "ciw".chars() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char(ch)));
+ }
+ chat.bottom_pane.handle_paste("delta".into());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert_answer(
+ op_rx.try_recv().unwrap(),
+ "> Which way?\n\nalpha beta\nalpha delta",
+ );
+ insta::assert_snapshot!(
+ format!("question_vim_{name}"),
+ format!("NORMAL\n{normal}\n\nSEARCH\n{search}")
+ );
+ }
+}
+
+#[tokio::test]
+async fn async_questions_reject_blank_answers_but_allow_explicit_skip() {
+ for options in [None, Some(vec!["Named".to_string()])] {
+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ chat.add_async_questions("message", &[question("Which way?", options.clone())]);
+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));
+ if options.is_some() {
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char('2')));
+ }
+ for text in ["", " \t\n"] {
+ chat.bottom_pane.handle_paste(text.into());
+ let before = render_bottom_popup(&chat, /*width*/ 80);
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), before);
+ assert!(chat.input_queue.queued_user_messages.is_empty());
+ assert!(op_rx.try_recv().is_err());
+ }
+ chat.handle_key_event(KeyEvent::new(KeyCode::Char('5'), KeyModifiers::CONTROL));
+ assert_eq!(question_count(&chat), 0);
+ assert!(op_rx.try_recv().is_err());
+ }
+}
+
fn open_questions(chat: &mut ChatWidget, options: Option<Vec<String>>) {
chat.thread_id = Some(ThreadId::new());
chat.on_agent_message_item_completed(
@@ -160,6 +238,25 @@ async fn question_queue_key_does_not_steer_the_running_turn() {
assert!(ops.try_recv().is_err());
}
+#[tokio::test]
+async fn question_choices_deliver_digits_and_leading_letters() {
+ for (key, text, expected) in [
+ ('2', "", "Second"),
+ ('j', "ust text", "just text"),
+ ('k', "eep it", "keep it"),
+ ] {
+ let (mut chat, _rx, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ open_questions(&mut chat, Some(vec!["First".into(), "Second".into()]));
+ chat.handle_key_event(KeyEvent::from(KeyCode::Char(key)));
+ if !text.is_empty() {
+ chat.bottom_pane.handle_paste(text.into());
+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
+ }
+ assert_answer(ops.try_recv().unwrap(), &format!("> First?\n\n{expected}"));
+ assert_eq!(question_count(&chat), 1);
+ }
+}
+
#[tokio::test]
async fn question_key_repeats_do_not_consume_another_question() {
for key in [KeyCode::Enter, KeyCode::Char('1')] {
@@ -216,3 +313,27 @@ fn question(title: &str, options: Option<Vec<String>>) -> AsyncUserInputQuestion
options,
}
}
+
+#[tokio::test]
+async fn questions_and_queued_messages_share_the_resolved_shortcut() {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.input_queue
+ .queued_user_messages
+ .push_back(UserMessage::from("queued".to_string()).into());
+ chat.refresh_pending_input_preview();
+ for binding in [key_hint::shift(KeyCode::Left), key_hint::alt(KeyCode::Up)] {
+ chat.bottom_pane
+ .set_queued_message_edit_binding(Some(binding.into()));
+ let hint = binding.display_label();
+ assert!(render_bottom_popup(&chat, /*width*/ 100).contains(&hint));
+ chat.add_async_questions(&hint, &questions());
+ assert!(render_bottom_popup(&chat, /*width*/ 100).contains(&format!("{hint} to answer")));
+ let (key, modifiers) = binding.parts();
+ chat.handle_key_event(KeyEvent::new(key, modifiers));
+ insta::assert_snapshot!(
+ format!("question_queue_hint_{}", key),
+ render_bottom_popup(&chat, /*width*/ 100)
+ );
+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));
+ }
+}
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__named_question.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__named_question.snap
index cb4c1c64b2..ad8a373fcb 100644
--- a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__named_question.snap
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__named_question.snap
@@ -10,5 +10,6 @@ expression: "render_bottom_popup(&chat, 80)"
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx but do not deploy
+ 2. Other
enter submit ctrl + ] skip ⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Left.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Left.snap
new file mode 100644
index 0000000000..1e3b65e3a9
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Left.snap
@@ -0,0 +1,15 @@
+---
+source: tui/src/chatwidget/tests/questions_tests.rs
+expression: "render_bottom_popup(&chat, 100)"
+---
+• Queued follow-up inputs
+ ↳ queued
+ shift + ← edit last queued message
+
+ 1 of 2
+
+ Which way?
+
+ Type your answer
+
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt shift + ← next question
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Up.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Up.snap
new file mode 100644
index 0000000000..4c459c6d42
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_queue_hint_Up.snap
@@ -0,0 +1,15 @@
+---
+source: tui/src/chatwidget/tests/questions_tests.rs
+expression: "render_bottom_popup(&chat, 100)"
+---
+• Queued follow-up inputs
+ ↳ queued
+ ⌥ + ↑ edit last queued message
+
+ 1 of 4
+
+ Which way?
+
+ Type your answer
+
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt ⌥ + ↑ next question
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_other.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_other.snap
new file mode 100644
index 0000000000..194b67103b
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_other.snap
@@ -0,0 +1,22 @@
+---
+source: tui/src/chatwidget/tests/questions_tests.rs
+expression: "format!(\"NORMAL\\n{normal}\\n\\nSEARCH\\n{search}\")"
+---
+NORMAL
+ Which way?
+
+ 1. Named
+ › 2. alpha beta
+ alpha gamma
+ Vim: Normal
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt
+
+SEARCH
+ Which way?
+
+ 1. Named
+ › 2. alpha beta
+ alpha gamma
+ /gamma
+ Vim: Normal
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt
diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_single.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_single.snap
new file mode 100644
index 0000000000..9e0ce2c531
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__question_vim_single.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/chatwidget/tests/questions_tests.rs
+expression: "format!(\"NORMAL\\n{normal}\\n\\nSEARCH\\n{search}\")"
+---
+NORMAL
+ Which way?
+
+ alpha beta
+ alpha gamma
+ Vim: Normal
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt
+
+SEARCH
+ Which way?
+
+ alpha beta
+ alpha gamma
+ /gamma
+ Vim: Normal
+ enter submit ctrl + ] skip ⌥ + ↓ main prompt