Lightweight coding agent that runs in your terminal
Rust
Clear pending TUI questions when accepting a new prompt (#44328)
Ian MacLeod2808a9c348ee
diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rsindex 8f206c0605..5254d18af8 100644--- a/codex-rs/tui/src/app/thread_routing.rs+++ b/codex-rs/tui/src/app/thread_routing.rs@@ -917,6 +917,7 @@ impl App {let store = Arc::clone(&self.ensure_thread_channel(review_thread_id).store);let mut store = store.lock().await;store.set_active_turn_id(response.turn.id);+ self.chat_widget.on_review_started();Ok(true)}AppCommand::CleanBackgroundTerminals => {diff --git a/codex-rs/tui/src/bottom_pane/async_questions/state.rs b/codex-rs/tui/src/bottom_pane/async_questions/state.rsindex d7796c7549..0a4a82effa 100644--- a/codex-rs/tui/src/bottom_pane/async_questions/state.rs+++ b/codex-rs/tui/src/bottom_pane/async_questions/state.rs@@ -147,6 +147,17 @@ impl AsyncQuestions {self.composer.reset_vim_mode();}+ pub(crate) fn clear_pending(&mut self) {+ // Keep seen_ids so replay cannot restore questions from the previous prompt.+ self.state.pending.clear();+ self.state.current_idx = 0;+ self.expanded = false;+ self.submission = None;+ self.visible_options.set((0, 0));+ self.restore_current_draft();+ self.composer.reset_vim_mode();+ }+pub(crate) fn capture(&mut self) -> QuestionState {self.composer.cancel_history_search();self.save_current_draft();diff --git a/codex-rs/tui/src/bottom_pane/questions.rs b/codex-rs/tui/src/bottom_pane/questions.rsindex 1d375baa12..7645406e6a 100644--- a/codex-rs/tui/src/bottom_pane/questions.rs+++ b/codex-rs/tui/src/bottom_pane/questions.rs@@ -13,6 +13,13 @@ impl BottomPane {self.request_redraw();}+ pub(crate) fn clear_pending_questions(&mut self) {+ if let Some(questions) = &mut self.questions {+ questions.clear_pending();+ self.request_redraw();+ }+ }+fn question_editor(&mut self) -> &mut AsyncQuestions {self.questions.get_or_insert_with(|| {let mut questions = AsyncQuestions::new(diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 0ccb35e6e6..4e34536699 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -471,6 +471,7 @@ use self::user_messages::UserMessageDisplay;#[cfg(test)]use self::user_messages::UserMessageHistoryOverride;use self::user_messages::UserMessageHistoryRecord;+use self::user_messages::UserMessageSource;use self::user_messages::app_server_text_elements;pub(crate) use self::user_messages::create_initial_user_message;pub(crate) use self::user_messages::mention_bindings_from_user_inputs;@@ -724,6 +725,7 @@ pub(crate) struct ChatWidget {suppress_initial_user_message_submit: bool,input_queue: InputQueueState,safety_buffering_prompt: Option<UserMessage>,+ safety_buffering_source: UserMessageSource,/// Main chat-surface bindings resolved from `tui.keymap.chat`.chat_keymap: ChatKeymap,permission_shortcut_pending: bool,@@ -1847,10 +1849,14 @@ impl ChatWidget {match &self.codex_op_target {CodexOpTarget::Direct(codex_op_tx) => {crate::session_log::log_outbound_op(&op);+ let is_review = op.is_review();if let Err(e) = codex_op_tx.send(op) {tracing::error!("failed to submit op: {e}");return false;}+ if is_review {+ self.on_review_started();+ }}CodexOpTarget::AppEvent => {self.app_event_tx.send(AppEvent::CodexOp(op));diff --git a/codex-rs/tui/src/chatwidget/backend_banners.rs b/codex-rs/tui/src/chatwidget/backend_banners.rsindex 98192e8d57..6f2fac4cd0 100644--- a/codex-rs/tui/src/chatwidget/backend_banners.rs+++ b/codex-rs/tui/src/chatwidget/backend_banners.rs@@ -6,6 +6,7 @@//! Its entry notice is shared across chats until the backend confirms ordinary usage has recovered.use super::ChatWidget;+use super::QueuedUserMessage;use super::luna_reserve_return::ReserveReturnModel;use crate::app_command::AppCommand;use crate::backend_banners::BackendBanner;@@ -221,7 +222,10 @@ impl ChatWidget {self.finalize_turn();self.input_queue.queued_user_messages- .push_front(prompt.into());+ .push_front(QueuedUserMessage {+ source: self.safety_buffering_source,+ ..QueuedUserMessage::from(prompt)+ });self.input_queue.queued_user_message_history_records.push_front(super::UserMessageHistoryRecord::UserMessageText);diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rsindex 7be8282a2e..e0be308b80 100644--- a/codex-rs/tui/src/chatwidget/constructor.rs+++ b/codex-rs/tui/src/chatwidget/constructor.rs@@ -226,6 +226,7 @@ impl ChatWidget {interrupted_turn_notice_mode: InterruptedTurnNoticeMode::Default,input_queue: InputQueueState::default(),safety_buffering_prompt: None,+ safety_buffering_source: UserMessageSource::Prompt,chat_keymap,permission_shortcut_pending: false,queued_message_edit_hint_binding,diff --git a/codex-rs/tui/src/chatwidget/input_flow.rs b/codex-rs/tui/src/chatwidget/input_flow.rsindex 97d3e59401..d6ad607744 100644--- a/codex-rs/tui/src/chatwidget/input_flow.rs+++ b/codex-rs/tui/src/chatwidget/input_flow.rs@@ -5,6 +5,9 @@//! follow-ups, and restoring draft state across interrupts or thread switches.use super::*;+use crate::bottom_pane::prompt_args::parse_slash_name;+use crate::bottom_pane::slash_commands::SlashCommandItem;+use crate::bottom_pane::slash_commands::find_slash_command;impl ChatWidget {pub(crate) fn set_parent_owned_thread(&mut self) {@@ -95,8 +98,13 @@ impl ChatWidget {}}- pub(super) fn queue_user_message(&mut self, user_message: UserMessage) {- self.queue_user_message_with_options(user_message, QueuedInputAction::Plain, Vec::new());+ pub(super) fn queue_user_message(&mut self, user_message: UserMessage) -> bool {+ self.queue_user_message_with_options_and_source(+ user_message,+ QueuedInputAction::Plain,+ Vec::new(),+ UserMessageSource::Prompt,+ )}pub(crate) fn set_queue_submissions_until_session_configured(&mut self, queue: bool) {@@ -109,31 +117,82 @@ impl ChatWidget {user_message: UserMessage,action: QueuedInputAction,pending_pastes: Vec<(String, String)>,- ) {+ ) -> bool {+ self.queue_user_message_with_options_and_source(+ user_message,+ action,+ pending_pastes,+ UserMessageSource::Prompt,+ )+ }++ pub(super) fn queue_user_message_with_options_and_source(+ &mut self,+ user_message: UserMessage,+ action: QueuedInputAction,+ pending_pastes: Vec<(String, String)>,+ source: UserMessageSource,+ ) -> bool {if self.has_misalignment_policy_violation() {- return;+ return false;}let should_run_now = self.is_session_configured()&& !self.is_user_turn_pending_or_running()&& !self.input_queue.suppress_queue_autosend&& !self.input_queue.rate_limit_recovery_pending;if !should_run_now || action != QueuedInputAction::Plain {+ let queued_slash_prompt = action == QueuedInputAction::ParseSlash+ && parse_slash_name(&user_message.text).is_none_or(|(name, args, _)| {+ if name.contains('/') {+ return true;+ }+ !args.trim().is_empty()+ && find_slash_command(+ name,+ self.builtin_command_flags(),+ &self.current_model_service_tier_commands(),+ )+ .is_some_and(|command| {+ !command.supports_inline_args()+ || matches!(+ command,+ SlashCommandItem::Builtin(+ SlashCommand::Plan | SlashCommand::Review+ )+ )+ })+ });+ let model_prompt = source == UserMessageSource::Prompt+ && (action == QueuedInputAction::Literal+ || action == QueuedInputAction::Plain && !user_message.text.starts_with('!')+ || queued_slash_prompt);self.input_queue.queued_user_messages.push_back(QueuedUserMessage {user_message,action,pending_pastes,+ source,});self.input_queue.queued_user_message_history_records.push_back(UserMessageHistoryRecord::UserMessageText);self.refresh_pending_input_preview();+ if model_prompt && !should_run_now {+ self.bottom_pane.clear_pending_questions();+ }if should_run_now {self.maybe_send_next_queued_input();}+ true} else {- self.submit_user_message(user_message);+ self.submit_user_message_with_history_and_shell_escape_policy(+ user_message,+ UserMessageHistoryRecord::UserMessageText,+ ShellEscapePolicy::Allow,+ source,+ )+ .0}}@@ -160,16 +219,22 @@ impl ChatWidget {};match queued_message.action {QueuedInputAction::Plain => {- submitted_follow_up = self.submit_user_message_with_history_record(- queued_message.into_user_message(),- history_record,- );+ let source = queued_message.source;+ submitted_follow_up = self+ .submit_user_message_with_history_and_shell_escape_policy(+ queued_message.into_user_message(),+ history_record,+ ShellEscapePolicy::Allow,+ source,+ )+ .0;break;}QueuedInputAction::Literal => {let QueuedUserMessage {user_message,pending_pastes,+ source,..} = queued_message;let mut restored_pending_pastes = self.bottom_pane.composer_pending_pastes();@@ -196,11 +261,13 @@ impl ChatWidget {);}submitted_follow_up = self- .submit_user_message_with_shell_escape_policy(+ .submit_user_message_with_history_and_shell_escape_policy(user_message,+ history_record,ShellEscapePolicy::Disallow,+ source,)- .is_some();+ .0;if !submitted_follow_up {restored_pending_pastes.extend(pending_pastes);self.bottom_panediff --git a/codex-rs/tui/src/chatwidget/input_queue.rs b/codex-rs/tui/src/chatwidget/input_queue.rsindex 48a0916c0a..e4de46d51f 100644--- a/codex-rs/tui/src/chatwidget/input_queue.rs+++ b/codex-rs/tui/src/chatwidget/input_queue.rs@@ -9,6 +9,7 @@ use super::PendingSteer;use super::QueuedUserMessage;use super::UserMessage;use super::UserMessageHistoryRecord;+use super::UserMessageSource;use super::user_message_preview_text;#[derive(Debug, Default, PartialEq, Eq)]@@ -31,6 +32,8 @@ pub(super) struct InputQueueState {pub(super) user_turn_pending_start: bool,/// User messages that tried to steer a non-regular turn and must be retried first.pub(super) rejected_steers_queue: VecDeque<UserMessage>,+ /// The origin of each rejected steer, kept in lockstep with its message.+ pub(super) rejected_steer_sources: VecDeque<UserMessageSource>,/// History records for rejected steers. Slash commands such as `/goal` can/// render history that differs from the text submitted to core, so this stays/// in lockstep with `rejected_steers_queue`, with missing entries treated as@@ -58,6 +61,7 @@ impl InputQueueState {self.queued_user_message_history_records.clear();self.user_turn_pending_start = false;self.rejected_steers_queue.clear();+ self.rejected_steer_sources.clear();self.rejected_steer_history_records.clear();self.pending_steers.clear();self.submit_pending_steers_after_interrupt = false;@@ -119,6 +123,7 @@ mod tests {client_id: "test-submission".to_string(),user_message: UserMessage::from("pending"),history_record: UserMessageHistoryRecord::UserMessageText,+ source: UserMessageSource::Prompt,compare_key: crate::chatwidget::user_messages::PendingSteerCompareKey {message: "pending".to_string(),image_count: 0,diff --git a/codex-rs/tui/src/chatwidget/input_restore.rs b/codex-rs/tui/src/chatwidget/input_restore.rsindex e3a35cf663..f078146d2a 100644--- a/codex-rs/tui/src/chatwidget/input_restore.rs+++ b/codex-rs/tui/src/chatwidget/input_restore.rs@@ -162,6 +162,21 @@ impl ChatWidget {.rejected_steers_queue.drain(..).collect::<Vec<_>>();+ let sources = self+ .input_queue+ .rejected_steer_sources+ .drain(..)+ .collect::<Vec<_>>();+ let source = if !rejected_messages.is_empty()+ && sources.len() == rejected_messages.len()+ && sources+ .iter()+ .all(|source| *source == UserMessageSource::QuestionAnswer)+ {+ UserMessageSource::QuestionAnswer+ } else {+ UserMessageSource::Prompt+ };let mut history_records = self.input_queue.rejected_steer_history_records@@ -177,7 +192,13 @@ impl ChatWidget {.zip(history_records).collect::<Vec<_>>(),);- Some((QueuedUserMessage::from(message), history_record))+ Some((+ QueuedUserMessage {+ source,+ ..QueuedUserMessage::from(message)+ },+ history_record,+ ))}}@@ -201,6 +222,7 @@ impl ChatWidget {))} else {let user_message = self.input_queue.rejected_steers_queue.pop_back()?;+ self.input_queue.rejected_steer_sources.pop_back();self.input_queue.recovered_queue &= self.input_queue.has_queued_follow_up_messages()|| !self.input_queue.pending_steers.is_empty();let history_record = self@@ -225,6 +247,9 @@ impl ChatWidget {self.input_queue.rejected_steers_queue.push_back(pending_steer.user_message);+ self.input_queue+ .rejected_steer_sources+ .push_back(pending_steer.source);self.input_queue.rejected_steer_history_records.push_back(pending_steer.history_record);@@ -263,12 +288,28 @@ impl ChatWidget {.input_queue.pending_steers.drain(..)- .map(|pending| (pending.user_message, pending.history_record)).collect::<Vec<_>>();if !pending_steers.is_empty() {- let (user_message, history_record) =- merge_user_messages_with_history_record(pending_steers);- self.submit_user_message_with_history_record(user_message, history_record);+ let source = if pending_steers+ .iter()+ .all(|pending| pending.source == UserMessageSource::QuestionAnswer)+ {+ UserMessageSource::QuestionAnswer+ } else {+ UserMessageSource::Prompt+ };+ let (user_message, history_record) = merge_user_messages_with_history_record(+ pending_steers+ .into_iter()+ .map(|pending| (pending.user_message, pending.history_record))+ .collect(),+ );+ self.submit_user_message_with_history_and_shell_escape_policy(+ user_message,+ history_record,+ ShellEscapePolicy::Allow,+ source,+ );} else if let Some(combined) = self.drain_pending_messages_for_restore() {self.restore_composer_state(combined);}@@ -306,6 +347,7 @@ impl ChatWidget {.rejected_steers_queue.drain(..).collect::<Vec<_>>();+ self.input_queue.rejected_steer_sources.clear();let mut rejected_history_records = self.input_queue.rejected_steer_history_records@@ -455,8 +497,10 @@ impl ChatWidget {.map(crate::bottom_pane::AsyncQuestions::capture),composer: composer.has_content().then_some(composer),safety_buffering_prompt: self.safety_buffering_prompt.clone(),+ safety_buffering_source: self.safety_buffering_source,pending_steers: self.input_queue.pending_steers.clone(),rejected_steers_queue: self.input_queue.rejected_steers_queue.clone(),+ rejected_steer_sources: self.input_queue.rejected_steer_sources.clone(),rejected_steer_history_records: self.input_queue.rejected_steer_history_records.clone(),queued_user_messages: self.input_queue.queued_user_messages.clone(),queued_user_message_history_records: self@@ -489,6 +533,7 @@ impl ChatWidget {self.current_collaboration_mode = input_state.current_collaboration_mode;self.active_collaboration_mask = input_state.active_collaboration_mask;self.safety_buffering_prompt = input_state.safety_buffering_prompt;+ self.safety_buffering_source = input_state.safety_buffering_source;self.turn_lifecycle.restore_running(preserve_in_flight_turn && input_state.agent_turn_running,Instant::now(),@@ -509,11 +554,19 @@ impl ChatWidget {} else {self.input_queue.pending_steers.clear();for pending in pending_steers.into_iter().rev() {- queued_user_messages.push_front(pending.user_message.into());+ queued_user_messages.push_front(QueuedUserMessage {+ source: pending.source,+ ..QueuedUserMessage::from(pending.user_message)+ });queued_user_message_history_records.push_front(pending.history_record);}}self.input_queue.rejected_steers_queue = input_state.rejected_steers_queue;+ self.input_queue.rejected_steer_sources = input_state.rejected_steer_sources;+ self.input_queue.rejected_steer_sources.resize(+ self.input_queue.rejected_steers_queue.len(),+ UserMessageSource::Prompt,+ );self.input_queue.rejected_steer_history_records =input_state.rejected_steer_history_records;self.input_queue.rejected_steer_history_records.resize(@@ -531,6 +584,7 @@ impl ChatWidget {self.turn_lifecycle.restore_running(/*running*/ false, Instant::now());self.safety_buffering_prompt = None;+ self.safety_buffering_source = UserMessageSource::Prompt;self.input_queue.clear();self.restore_composer_state(Default::default());}diff --git a/codex-rs/tui/src/chatwidget/input_submission.rs b/codex-rs/tui/src/chatwidget/input_submission.rsindex b0ba5c7d1e..fdfe3f6ab6 100644--- a/codex-rs/tui/src/chatwidget/input_submission.rs+++ b/codex-rs/tui/src/chatwidget/input_submission.rs@@ -90,6 +90,7 @@ impl ChatWidget {user_message,history_record,ShellEscapePolicy::Allow,+ UserMessageSource::Prompt,).0}@@ -103,6 +104,7 @@ impl ChatWidget {user_message,UserMessageHistoryRecord::UserMessageText,shell_escape_policy,+ UserMessageSource::Prompt,).1}@@ -112,29 +114,48 @@ impl ChatWidget {user_message: UserMessage,history_record: UserMessageHistoryRecord,shell_escape_policy: ShellEscapePolicy,+ source: UserMessageSource,) -> (bool, Option<AppCommand>) {if self.has_misalignment_policy_violation() {return (false, None);}if self.input_queue.rate_limit_recovery_pending {+ let model_prompt = source == UserMessageSource::Prompt+ && (shell_escape_policy == ShellEscapePolicy::Disallow+ || !user_message.text.starts_with('!'));self.input_queue.queued_user_messages- .push_back(QueuedUserMessage::from(user_message));+ .push_back(QueuedUserMessage {+ source,+ ..QueuedUserMessage::from(user_message)+ });self.input_queue.queued_user_message_history_records.push_back(history_record);self.refresh_pending_input_preview();+ if model_prompt {+ self.bottom_pane.clear_pending_questions();+ }return (true, None);}if !self.is_session_configured() {+ let model_prompt = source == UserMessageSource::Prompt+ && (shell_escape_policy == ShellEscapePolicy::Disallow+ || !user_message.text.starts_with('!'));tracing::warn!("cannot submit user message before session is configured; queueing");self.input_queue.queued_user_messages- .push_front(QueuedUserMessage::from(user_message));+ .push_front(QueuedUserMessage {+ source,+ ..QueuedUserMessage::from(user_message)+ });self.input_queue.queued_user_message_history_records.push_front(history_record);self.refresh_pending_input_preview();+ if model_prompt {+ self.bottom_pane.clear_pending_questions();+ }return (true, None);}if user_message.text.is_empty()@@ -358,6 +379,7 @@ impl ChatWidget {mention_bindings: mention_bindings.clone(),},history_record: history_record.clone(),+ source,compare_key: Self::pending_steer_compare_key_from_items(&items),});let personality = self@@ -409,6 +431,9 @@ impl ChatWidget {if !self.submit_op(op.clone()) {return (false, None);}+ if source == UserMessageSource::Prompt {+ self.bottom_pane.clear_pending_questions();+ }self.dismiss_backend_banner_for_new_turn();self.note_realtime_typed_input(&submitted_message.text);if render_in_history {@@ -456,6 +481,7 @@ impl ChatWidget {if render_in_history {self.safety_buffering_prompt = Some(submitted_message.clone());+ self.safety_buffering_source = source;if !render_before_submit {self.on_user_message_display(user_message_display_for_history(submitted_message,diff --git a/codex-rs/tui/src/chatwidget/questions.rs b/codex-rs/tui/src/chatwidget/questions.rsindex ab3a9587c6..5313d25372 100644--- a/codex-rs/tui/src/chatwidget/questions.rs+++ b/codex-rs/tui/src/chatwidget/questions.rs@@ -117,13 +117,18 @@ impl ChatWidget {&& !self.turn_lifecycle.agent_turn_running|| self.only_user_shell_commands_running(){- self.queue_user_message(UserMessage::from(text));- true+ self.queue_user_message_with_options_and_source(+ UserMessage::from(text),+ QueuedInputAction::Plain,+ Vec::new(),+ UserMessageSource::QuestionAnswer,+ )} else {self.submit_user_message_with_history_and_shell_escape_policy(UserMessage::from(text),UserMessageHistoryRecord::UserMessageText,ShellEscapePolicy::Disallow,+ UserMessageSource::QuestionAnswer,).0};diff --git a/codex-rs/tui/src/chatwidget/reconnect.rs b/codex-rs/tui/src/chatwidget/reconnect.rsindex 3d88597f4b..0e94051794 100644--- a/codex-rs/tui/src/chatwidget/reconnect.rs+++ b/codex-rs/tui/src/chatwidget/reconnect.rs@@ -41,7 +41,10 @@ impl ChatWidget {if input.user_turn_pending_start&& let Some(prompt) = input.safety_buffering_prompt.take(){- input.queued_user_messages.push_front(prompt.into());+ input.queued_user_messages.push_front(QueuedUserMessage {+ source: input.safety_buffering_source,+ ..QueuedUserMessage::from(prompt)+ });input.queued_user_message_history_records.push_front(UserMessageHistoryRecord::UserMessageText);diff --git a/codex-rs/tui/src/chatwidget/review_popups.rs b/codex-rs/tui/src/chatwidget/review_popups.rsindex 846434d46f..7185e735b6 100644--- a/codex-rs/tui/src/chatwidget/review_popups.rs+++ b/codex-rs/tui/src/chatwidget/review_popups.rs@@ -3,6 +3,10 @@use super::*;impl ChatWidget {+ pub(crate) fn on_review_started(&mut self) {+ self.bottom_pane.clear_pending_questions();+ }+pub(crate) fn open_review_popup(&mut self) {let mut items: Vec<SelectionItem> = Vec::new();diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rsindex d9580abd57..1ee962f045 100644--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs@@ -1126,7 +1126,7 @@ impl ChatWidget {self.queued_command_drain_result(cmd)}- fn builtin_command_flags(&self) -> BuiltinCommandFlags {+ pub(super) fn builtin_command_flags(&self) -> BuiltinCommandFlags {#[cfg(target_os = "windows")]let allow_elevate_sandbox = {let windows_sandbox_level = crate::windows_sandbox::level_from_config(&self.config);diff --git a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs b/codex-rs/tui/src/chatwidget/tests/composer_submission.rsindex af912ae51f..7d184d880d 100644--- a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs+++ b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs@@ -352,6 +352,7 @@ async fn parent_owned_thread_preserves_queued_input_before_draining() {user_message: UserMessage::from("keep this queued prompt"),action: QueuedInputAction::Plain,pending_pastes: vec![("[Image 1]".to_string(), "pasted contents".to_string())],+ source: UserMessageSource::Prompt,};let history_record = UserMessageHistoryRecord::UserMessageText;chat.input_queue@@ -1762,11 +1763,13 @@ async fn restore_thread_input_state_applies_running_state_policy() {..Default::default()}),safety_buffering_prompt: Some(UserMessage::from("buffered prompt")),+ safety_buffering_source: UserMessageSource::Prompt,pending_steers: VecDeque::from([PendingSteer {history_record: pending_history.clone(),..pending_steer("submitted to the interrupted turn")}]),rejected_steers_queue: VecDeque::new(),+ rejected_steer_sources: VecDeque::new(),rejected_steer_history_records: VecDeque::new(),queued_user_messages: VecDeque::from([UserMessage::from("already queued").into()]),queued_user_message_history_records: VecDeque::from([queued_history.clone()]),diff --git a/codex-rs/tui/src/chatwidget/tests/helpers.rs b/codex-rs/tui/src/chatwidget/tests/helpers.rsindex 8ad907f2c9..3b54b8cfcb 100644--- a/codex-rs/tui/src/chatwidget/tests/helpers.rs+++ b/codex-rs/tui/src/chatwidget/tests/helpers.rs@@ -994,6 +994,7 @@ pub(super) fn pending_steer(text: &str) -> PendingSteer {client_id: "test-submission".to_string(),user_message: UserMessage::from(text),history_record: UserMessageHistoryRecord::UserMessageText,+ source: UserMessageSource::Prompt,compare_key: PendingSteerCompareKey {message: text.to_string(),image_count: 0,diff --git a/codex-rs/tui/src/chatwidget/tests/questions_tests.rs b/codex-rs/tui/src/chatwidget/tests/questions_tests.rsindex 77dd754a72..81e84ba8da 100644--- a/codex-rs/tui/src/chatwidget/tests/questions_tests.rs+++ b/codex-rs/tui/src/chatwidget/tests/questions_tests.rs@@ -58,6 +58,291 @@ async fn accepted_question_answer_uses_existing_delivery_and_keeps_main_draft()}}+#[tokio::test]+async fn ordinary_follow_up_clears_unanswered_questions_after_accepted_input() {+ for queued in [false, true] {+ 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.add_async_questions("old", &questions());+ if queued {+ chat.on_task_started();+ }+ chat.bottom_pane+ .set_composer_text("New prompt".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::from(if queued {+ KeyCode::Tab+ } else {+ KeyCode::Enter+ }));++ assert_eq!(question_count(&chat), 0);+ if queued {+ assert_eq!(+ chat.input_queue.queued_user_messages.front().unwrap().text,+ "New prompt"+ );+ assert!(op_rx.try_recv().is_err());+ } else {+ assert_answer(op_rx.try_recv().unwrap(), "New prompt");+ insta::assert_snapshot!(+ "questions_cleared_by_follow_up",+ render_bottom_popup(&chat, /*width*/ 80)+ .lines()+ .next()+ .unwrap()+ );+ }+ chat.add_async_questions("old", &questions());+ assert_eq!(question_count(&chat), 0);+ chat.add_async_questions("new", &[question("New question?", /*options*/ None)]);+ assert_eq!(question_count(&chat), 1);+ }+}++#[tokio::test]+async fn local_shell_command_preserves_unanswered_questions() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.bottom_pane+ .set_composer_text("!echo hi".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));++ assert_eq!(question_count(&chat), 2);+ assert_matches!(+ op_rx.try_recv(),+ Ok(Op::RunUserShellCommand { command }) if command == "echo hi"+ );+}++#[tokio::test]+async fn queued_prompt_clears_questions_arriving_after_enqueue_when_it_starts() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.on_task_started();+ chat.add_async_questions("old", &questions());+ chat.bottom_pane+ .set_composer_text("New prompt".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::from(KeyCode::Tab));+ assert_eq!(question_count(&chat), 0);++ chat.add_async_questions("late", &questions());+ assert_eq!(question_count(&chat), 2);+ chat.turn_lifecycle.finish();+ chat.update_task_running_state();+ assert!(chat.maybe_send_next_queued_input());+ assert_answer(op_rx.try_recv().unwrap(), "New prompt");+ assert_eq!(question_count(&chat), 0);+ chat.add_async_questions("late", &questions());+ assert_eq!(question_count(&chat), 0);+}++#[tokio::test]+async fn queued_question_answer_preserves_other_questions_on_delivery() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.input_queue.suppress_queue_autosend = true;+ chat.add_async_questions("old", &questions());+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));+ chat.bottom_pane.handle_paste("answer".into());+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ assert_eq!(question_count(&chat), 1);++ chat.input_queue.suppress_queue_autosend = false;+ assert!(chat.maybe_send_next_queued_input());+ assert_answer(op_rx.try_recv().unwrap(), "> Which way?\n\nanswer");+ assert_eq!(question_count(&chat), 1);+}++#[tokio::test]+async fn recovered_question_answers_preserve_other_questions() {+ for restore_thread in [false, true] {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.on_task_started();+ chat.add_async_questions("old", &questions());+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));+ chat.bottom_pane.handle_paste("answer".into());+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ assert_answer(op_rx.try_recv().unwrap(), "> Which way?\n\nanswer");+ assert_eq!(question_count(&chat), 1);+ chat.add_async_questions("late", &[question("Late?", /*options*/ None)]);++ if restore_thread {+ let state = chat.capture_thread_input_state().unwrap();+ chat.restore_thread_input_state(+ Some(state),+ ThreadInputStateRestoreMode {+ preserve_in_flight_turn: false,+ },+ );+ } else {+ assert!(chat.enqueue_rejected_steer());+ chat.turn_lifecycle.finish();+ chat.update_task_running_state();+ }+ assert!(chat.maybe_send_next_queued_input());+ assert_answer(op_rx.try_recv().unwrap(), "> Which way?\n\nanswer");+ assert_eq!(question_count(&chat), 2);+ }+}++#[tokio::test]+async fn slash_and_mode_prompts_clear_unanswered_questions_after_delivery() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.handle_composer_input_result(+ InputResult::CommandWithArgs(SlashCommand::Plan, "New plan".into(), Vec::new()),+ /*had_modal_or_popup*/ false,+ );+ assert_answer(op_rx.try_recv().unwrap(), "New plan");+ assert_eq!(question_count(&chat), 0);++ chat.input_queue.user_turn_pending_start = false;+ chat.add_async_questions("next", &questions());+ let mode = collaboration_modes::default_mask(chat.model_catalog.as_ref()).unwrap();+ chat.submit_user_message_with_mode("Implement".to_string(), mode);+ assert_answer(op_rx.try_recv().unwrap(), "Implement");+ assert_eq!(question_count(&chat), 0);+}++#[tokio::test]+async fn accepted_review_clears_questions_but_rejected_review_preserves_them() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.handle_composer_input_result(+ InputResult::CommandWithArgs(SlashCommand::Review, "check this".into(), Vec::new()),+ /*had_modal_or_popup*/ false,+ );+ assert_matches!(+ op_rx.try_recv(),+ Ok(Op::Review {+ target: ReviewTarget::Custom { instructions }+ }) if instructions == "check this"+ );+ assert_eq!(question_count(&chat), 0);++ chat.add_async_questions("new", &questions());+ chat.blocks_direct_input = true;+ chat.handle_composer_input_result(+ InputResult::CommandWithArgs(SlashCommand::Review, "try again".into(), Vec::new()),+ /*had_modal_or_popup*/ false,+ );+ assert_eq!(question_count(&chat), 2);+ assert!(op_rx.try_recv().is_err());+}++#[tokio::test]+async fn queued_model_slash_prompt_clears_questions_but_local_slash_command_does_not() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.on_task_started();+ chat.add_async_questions("old", &questions());+ for text in ["/model", "/goal clear"] {+ chat.handle_composer_input_result(+ InputResult::Queued {+ text: text.into(),+ text_elements: Vec::new(),+ action: QueuedInputAction::ParseSlash,+ pending_pastes: Vec::new(),+ },+ /*had_modal_or_popup*/ false,+ );+ assert_eq!(question_count(&chat), 2);+ }+ chat.handle_composer_input_result(+ InputResult::Queued {+ text: "/plan New work".into(),+ text_elements: Vec::new(),+ action: QueuedInputAction::ParseSlash,+ pending_pastes: Vec::new(),+ },+ /*had_modal_or_popup*/ false,+ );+ assert_eq!(question_count(&chat), 0);+ assert!(op_rx.try_recv().is_err());++ chat.add_async_questions("new", &questions());+ chat.handle_composer_input_result(+ InputResult::Queued {+ text: "/diff explain the change".into(),+ text_elements: Vec::new(),+ action: QueuedInputAction::ParseSlash,+ pending_pastes: Vec::new(),+ },+ /*had_modal_or_popup*/ false,+ );+ assert_eq!(question_count(&chat), 0);+}++#[tokio::test]+async fn rejected_synchronous_literal_prompt_keeps_questions() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.set_model("");+ chat.handle_composer_input_result(+ InputResult::Queued {+ text: "literal prompt".into(),+ text_elements: Vec::new(),+ action: QueuedInputAction::Literal,+ pending_pastes: Vec::new(),+ },+ /*had_modal_or_popup*/ false,+ );+ assert_eq!(question_count(&chat), 2);+ assert!(op_rx.try_recv().is_err());+}++#[tokio::test]+async fn reconnect_preserves_buffered_question_answer_source() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.handle_key_event(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT));+ chat.bottom_pane.handle_paste("answer".into());+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ assert_answer(op_rx.try_recv().unwrap(), "> Which way?\n\nanswer");+ assert_eq!(question_count(&chat), 1);+ chat.pause_for_disconnect();+ let state = chat.capture_thread_input_state();++ let (mut restored, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ restored.thread_id = Some(ThreadId::new());+ restored.restore_reconnected_input(state);+ assert_eq!(+ restored+ .input_queue+ .queued_user_messages+ .front()+ .unwrap()+ .source,+ UserMessageSource::QuestionAnswer,+ );+ // Recovered input stays paused until the user elects to retry it.+ restored.input_queue.recovered_queue = false;+ assert!(restored.maybe_send_next_queued_input());+ assert_answer(op_rx.try_recv().unwrap(), "> Which way?\n\nanswer");+ assert_eq!(question_count(&restored), 1);+}++#[tokio::test]+async fn blocked_follow_up_keeps_unanswered_questions() {+ let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.add_async_questions("old", &questions());+ chat.set_model("");+ chat.bottom_pane+ .set_composer_text("Blocked prompt".into(), Vec::new(), Vec::new());+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));++ assert_eq!(question_count(&chat), 2);+ assert!(op_rx.try_recv().is_err());+}+#[tokio::test]async fn disconnected_questions_remain_editable_without_sending() {let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;@@ -376,7 +661,7 @@ async fn question_key_repeats_do_not_consume_another_question() {}#[tokio::test]-async fn question_queue_pop_becomes_an_ordinary_composer_draft() {+async fn question_queue_pop_becomes_an_ordinary_composer_draft_and_clears_questions_on_send() {let (mut chat, _rx, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;for text in ["older", "newer"] {chat.input_queue@@ -402,7 +687,8 @@ async fn question_queue_pop_becomes_an_ordinary_composer_draft() {chat.handle_key_event(KeyEvent::from(KeyCode::Enter));assert_answer(ops.try_recv().unwrap(), "older");chat.handle_key_event(forward);- assert!(chat.bottom_pane.questions.as_ref().unwrap().expanded);+ assert_eq!(question_count(&chat), 0);+ assert!(!chat.bottom_pane.questions.as_ref().unwrap().expanded);assert!(!chat.bottom_panediff --git a/codex-rs/tui/src/chatwidget/tests/review_mode.rs b/codex-rs/tui/src/chatwidget/tests/review_mode.rsindex e5b643baa1..f947b364d2 100644--- a/codex-rs/tui/src/chatwidget/tests/review_mode.rs+++ b/codex-rs/tui/src/chatwidget/tests/review_mode.rs@@ -379,8 +379,10 @@ async fn restore_thread_input_state_restores_pending_steers_without_downgrading_questions: None,composer: None,safety_buffering_prompt: None,+ safety_buffering_source: UserMessageSource::Prompt,pending_steers: VecDeque::from([expected_pending.clone()]),rejected_steers_queue,+ rejected_steer_sources: VecDeque::new(),rejected_steer_history_records: VecDeque::new(),queued_user_messages,queued_user_message_history_records: VecDeque::new(),diff --git a/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__questions_cleared_by_follow_up.snap b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__questions_cleared_by_follow_up.snapnew file mode 100644index 0000000000..5fc368856d--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/snapshots/codex_tui__chatwidget__tests__questions_tests__questions_cleared_by_follow_up.snap@@ -0,0 +1,5 @@+---+source: tui/src/chatwidget/tests/questions_tests.rs+expression: "render_bottom_popup(&chat, 80).lines().next().unwrap()"+---+› Ask Codex to do anythingdiff --git a/codex-rs/tui/src/chatwidget/user_messages.rs b/codex-rs/tui/src/chatwidget/user_messages.rsindex 01112aaf74..59dec1f6d2 100644--- a/codex-rs/tui/src/chatwidget/user_messages.rs+++ b/codex-rs/tui/src/chatwidget/user_messages.rs@@ -58,11 +58,18 @@ pub(super) enum ShellEscapePolicy {Disallow,}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(super) enum UserMessageSource {+ Prompt,+ QuestionAnswer,+}+#[derive(Debug, Clone, PartialEq)]pub(super) struct QueuedUserMessage {pub(super) user_message: UserMessage,pub(super) action: QueuedInputAction,pub(super) pending_pastes: Vec<(String, String)>,+ pub(super) source: UserMessageSource,}impl QueuedUserMessage {@@ -71,6 +78,7 @@ impl QueuedUserMessage {user_message,action,pending_pastes: Vec::new(),+ source: UserMessageSource::Prompt,}}@@ -125,8 +133,10 @@ pub(crate) struct ThreadInputState {pub(crate) questions: Option<crate::bottom_pane::QuestionState>,pub(super) composer: Option<ThreadComposerState>,pub(super) safety_buffering_prompt: Option<UserMessage>,+ pub(super) safety_buffering_source: UserMessageSource,pub(crate) pending_steers: VecDeque<PendingSteer>,pub(super) rejected_steers_queue: VecDeque<UserMessage>,+ pub(super) rejected_steer_sources: VecDeque<UserMessageSource>,pub(super) rejected_steer_history_records: VecDeque<UserMessageHistoryRecord>,pub(super) queued_user_messages: VecDeque<QueuedUserMessage>,pub(super) queued_user_message_history_records: VecDeque<UserMessageHistoryRecord>,@@ -176,6 +186,7 @@ pub(crate) struct PendingSteer {pub(crate) client_id: String,pub(super) user_message: UserMessage,pub(super) history_record: UserMessageHistoryRecord,+ pub(super) source: UserMessageSource,pub(super) compare_key: PendingSteerCompareKey,}