fix(tui): prioritize pending input on escape

Author: LEON-gittech

codex-rs/tui/src/app/input.rs

@@ -254,6 +254,7 @@ impl App {
     pub(super) fn should_handle_backtrack_esc(&self, key_event: KeyEvent) -> bool {
         self.chat_widget.is_normal_backtrack_mode()
             && self.chat_widget.composer_is_empty()
+            && !self.chat_widget.has_pending_or_queued_input()
             && !self.chat_widget.should_handle_vim_insert_escape(key_event)
     }
 

codex-rs/tui/src/app/tests.rs

@@ -5299,6 +5299,56 @@ async fn backtrack_esc_does_not_steal_empty_vim_insert_escape() {
     assert!(app.should_handle_backtrack_esc(esc));
 }
 
+#[tokio::test]
+async fn backtrack_esc_does_not_steal_queued_follow_up() {
+    let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await;
+    let thread_id = ThreadId::new();
+    let session = test_thread_session(thread_id, test_path_buf("/tmp/project"));
+    app.chat_widget.handle_thread_session(session.clone());
+    app.chat_widget.handle_server_notification(
+        turn_started_notification(thread_id, "turn-1"),
+        /*replay_kind*/ None,
+    );
+    app.chat_widget.handle_server_notification(
+        agent_message_delta_notification(thread_id, "turn-1", "agent-1", "streaming"),
+        /*replay_kind*/ None,
+    );
+    app.chat_widget
+        .apply_external_edit("queued follow-up".to_string());
+    app.chat_widget
+        .handle_key_event(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
+    let input_state = app
+        .chat_widget
+        .capture_thread_input_state()
+        .expect("expected queued follow-up state");
+
+    let (chat_widget, _app_event_tx, _rx, mut new_op_rx) =
+        make_chatwidget_manual_with_sender().await;
+    app.chat_widget = chat_widget;
+    app.chat_widget.handle_thread_session(session.clone());
+    while new_op_rx.try_recv().is_ok() {}
+    app.replay_thread_snapshot(
+        ThreadEventSnapshot {
+            session: None,
+            turns: Vec::new(),
+            events: vec![ThreadBufferedEvent::Notification(
+                turn_completed_notification(thread_id, "turn-1", TurnStatus::Completed),
+            )],
+            input_state: Some(input_state),
+        },
+        /*resume_restored_queue*/ false,
+    );
+
+    let esc = crossterm::event::KeyEvent::new(crossterm::event::KeyCode::Esc, KeyModifiers::NONE);
+
+    assert_eq!(
+        app.chat_widget.queued_user_message_texts(),
+        vec!["queued follow-up".to_string()]
+    );
+    assert!(app.chat_widget.composer_is_empty());
+    assert!(!app.should_handle_backtrack_esc(esc));
+}
+
 #[tokio::test]
 async fn session_summary_skips_when_no_usage_or_resume_hint() {
     assert!(

codex-rs/tui/src/chatwidget.rs

@@ -3245,16 +3245,7 @@ impl ChatWidget {
         // interrupted turn reaches the UI, so any unacknowledged steers still
         // tracked here must be restored locally instead of waiting for a later commit.
         if send_pending_steers_immediately {
-            let pending_steers = self
-                .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);
-            } else {
+            if !self.submit_pending_steers_immediately() {
                 self.maybe_send_next_queued_input();
             }
         } else if let Some(combined) = self.drain_pending_messages_for_restore() {
@@ -3265,6 +3256,23 @@ impl ChatWidget {
         self.request_redraw();
     }
 
+    fn submit_pending_steers_immediately(&mut self) -> bool {
+        let pending_steers = self
+            .pending_steers
+            .drain(..)
+            .map(|pending| (pending.user_message, pending.history_record))
+            .collect::<Vec<_>>();
+        if pending_steers.is_empty() {
+            return false;
+        }
+
+        let (user_message, history_record) =
+            merge_user_messages_with_history_record(pending_steers);
+        let submitted = self.submit_user_message_with_history_record(user_message, history_record);
+        self.refresh_pending_input_preview();
+        submitted
+    }
+
     /// Merge pending steers, queued drafts, and the current composer state into a single message.
     ///
     /// Each pending message numbers attachments from `[Image #1]` relative to its own remote
@@ -5317,12 +5325,14 @@ impl ChatWidget {
             && self.bottom_pane.no_modal_or_popup_active()
             && !self.should_handle_vim_insert_escape(key_event)
         {
-            self.submit_pending_steers_after_interrupt = true;
             if self.is_cancellable_work_active() {
+                self.submit_pending_steers_after_interrupt = true;
                 if !self.submit_op(AppCommand::interrupt()) {
                     self.submit_pending_steers_after_interrupt = false;
                 }
-            } else if !self.maybe_send_next_queued_input() {
+            } else if !self.submit_pending_steers_immediately()
+                && !self.maybe_send_next_queued_input()
+            {
                 self.submit_pending_steers_after_interrupt = false;
             }
             return;
@@ -10797,6 +10807,10 @@ impl ChatWidget {
         self.bottom_pane.is_normal_backtrack_mode()
     }
 
+    pub(crate) fn has_pending_or_queued_input(&self) -> bool {
+        !self.pending_steers.is_empty() || self.has_queued_follow_up_messages()
+    }
+
     pub(crate) fn should_handle_vim_insert_escape(&self, key_event: KeyEvent) -> bool {
         self.bottom_pane
             .composer_should_handle_vim_insert_escape(key_event)

codex-rs/tui/src/chatwidget/tests/composer_submission.rs

@@ -879,7 +879,7 @@ async fn empty_enter_during_task_does_not_queue() {
     let (mut chat, _rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
 
     // Simulate running task so submissions would normally be queued.
-    chat.bottom_pane.set_task_running(/*running*/ true);
+    chat.on_task_started();
 
     // Press Enter with an empty composer.
     chat.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
@@ -893,7 +893,7 @@ async fn pending_steer_esc_does_not_steal_vim_insert_escape() {
     let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
     let esc = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);
 
-    chat.bottom_pane.set_task_running(/*running*/ true);
+    chat.on_task_started();
     chat.pending_steers.push_back(pending_steer("queued steer"));
     chat.toggle_vim_mode_and_notify();
     chat.handle_key_event(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));

codex-rs/tui/src/chatwidget/tests/review_mode.rs

@@ -798,6 +798,30 @@ async fn esc_interrupt_sends_all_pending_steers_immediately_and_keeps_existing_d
     );
 }
 
+#[tokio::test]
+async fn esc_submits_pending_steers_when_no_cancellable_work_is_active() {
+    let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;
+    chat.thread_id = Some(ThreadId::new());
+    chat.pending_steers.push_back(pending_steer("first steer"));
+    chat.pending_steers.push_back(pending_steer("second steer"));
+    chat.refresh_pending_input_preview();
+
+    chat.handle_key_event(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
+
+    match next_submit_op(&mut op_rx) {
+        Op::UserTurn { items, .. } => assert_eq!(
+            items,
+            vec![UserInput::Text {
+                text: "first steer\nsecond steer".to_string(),
+                text_elements: Vec::new(),
+            }]
+        ),
+        other => panic!("expected merged pending steers to submit, got {other:?}"),
+    }
+    assert!(chat.pending_steers.is_empty());
+    assert!(!chat.submit_pending_steers_after_interrupt);
+}
+
 #[tokio::test]
 async fn esc_with_pending_steers_overrides_agent_command_interrupt_behavior() {
     let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(/*model_override*/ None).await;