Lightweight coding agent that runs in your terminal
Rust
Add compact transcript browsing and prompt navigation to the TUI (#46739)
Eric Traut551844b3efc4
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 8a7b37780f..b338e84376 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -215,6 +215,7 @@ mod app_server_events;pub(crate) mod app_server_requests;mod backend_banner_fallback;mod background_requests;+mod composer_hints;mod config_persistence;mod connector_mentions;mod daemon_menu;@@ -889,7 +890,7 @@ impl App {self.cancel_pending_key_chord();}- let event = if let TuiEvent::Key(mut key_event) = event {+ let mut event = if let TuiEvent::Key(mut key_event) = event {let escape = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);if self.should_recover_vim_insert_escape(key_event)&& !(tui.is_owned_screen()@@ -910,9 +911,29 @@ impl App {event};+ self.cancel_primed_browsing_for_event(&event);if self.handle_owned_transcript_event(tui, app_server, &event)? {return Ok(AppRunControl::Continue);}+ // Leave browsing before unhandled editing input reaches shortcuts or offline input.+ // Offline Enter cannot confirm a rewind and leaves the preview available to read.+ if tui.is_owned_screen()+ && self.overlay.is_none()+ && self.backtrack.overlay_preview_active+ && (matches!(&event, TuiEvent::Key(key)+ if matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat)+ && !(self.reconnect.offline && key.code == KeyCode::Enter))+ || matches!(&event, TuiEvent::Paste(text) if !text.is_empty()))+ {+ self.cancel_transcript_browsing(tui);+ // The first lookup used browsing contexts; retry after restoring composer contexts.+ if let TuiEvent::Key(key) = event {+ let Some(key) = self.route_key_chord_event(tui, key) else {+ return Ok(AppRunControl::Continue);+ };+ event = TuiEvent::Key(key);+ }+ }if self.reconnect.offline&& !matches!(&self.overlay, Some(Overlay::Transcript(_)))&& let TuiEvent::Key(key) = &event@@ -961,6 +982,13 @@ impl App {// [tui-textarea]: https://github.com/rhysd/tui-textarea/blob/4d18622eeac13b309e0ff6a55a46ac6706da68cf/src/textarea.rs#L782-L783// [iTerm2]: https://github.com/gnachman/iTerm2/blob/5d0c0d9f68523cbd0494dad5422998964a2ecd8d/sources/iTermPasteHelper.m#L206-L216let pasted = pasted.replace("\r\n", "\n").replace('\r', "\n");+ if self.backtrack.primed && !pasted.is_empty() {+ if self.backtrack.overlay_preview_active {+ self.cancel_transcript_browsing(tui);+ } else {+ self.reset_backtrack_state();+ }+ }self.chat_widget.handle_paste(pasted);if self.reconnect.offline&& self.reconnect.presentationdiff --git a/codex-rs/tui/src/app/activity_groups_tests.rs b/codex-rs/tui/src/app/activity_groups_tests.rsindex 6796b7b1ce..aa6ca11567 100644--- a/codex-rs/tui/src/app/activity_groups_tests.rs+++ b/codex-rs/tui/src/app/activity_groups_tests.rs@@ -107,6 +107,15 @@ async fn older_page_hydration_keeps_pending_computer_and_exploration_completion(.extend(project(&app, ¤t.items[1..2]));app.join_older_activity_group(/*boundary*/ 1, std::slice::from_ref(¤t));assert!(app.transcript_cells.is_empty());+ if matches!(kind, ActivityKind::Computer) {+ assert!(+ crate::chatwidget::tests::helpers::render_bottom_popup(+ &app.chat_widget,+ /*width*/ 80+ )+ .contains("Using computer · 3 actions")+ );+ }match kind {ActivityKind::Computer => app.chat_widget.handle_mcp_tool_call_completed_now(call("pending",diff --git a/codex-rs/tui/src/app/composer_hints.rs b/codex-rs/tui/src/app/composer_hints.rsnew file mode 100644index 0000000000..215f32455a--- /dev/null+++ b/codex-rs/tui/src/app/composer_hints.rs@@ -0,0 +1,68 @@+//! Stable, contextual discovery in unused composer-gap space.+//! Hints change with conversation state, never on a timer, and honor show_tooltips.++use super::*;+use crate::history_cell::SessionInfoCell;+use crate::history_cell::UserHistoryCell;+use crate::keymap::KeymapContext;+use crate::style::secondary_text_style;+use ratatui::style::Styled;+use ratatui::text::Line;++impl App {+ pub(super) fn composer_tip(&self) -> Option<Line<'static>> {+ if !self.local_settings.tui.show_tooltips+ || !self.chat_widget.composer_is_empty()+ || self.chat_widget.is_user_turn_pending_or_running()+ || !self.chat_widget.no_modal_or_popup_active()+ || !self.transcript_view.is_following()+ || self.transcript_view.has_active_interaction()+ || self.backtrack.primed+ || self.backtrack.overlay_preview_active+ {+ return None;+ }+ // Cosmetic tip rotation needs cell types, not a scan of every prompt's text.+ let count = self+ .transcript_cells+ .iter()+ .rev()+ .take_while(|cell| !cell.as_any().is::<SessionInfoCell>())+ .filter(|cell| cell.as_any().is::<UserHistoryCell>())+ .count();+ let (prefix, keys, label) = if count == 0 {+ (+ "Tip: ",+ crate::key_hint::key_label_spans("@"),+ " mentions files, skills, and plugins",+ )+ } else {+ match count % 3 {+ 0 => (+ "Tip: drag to select text · ",+ crate::key_hint::key_label_spans("ctrl+c"),+ " copies",+ ),+ 1 => {+ let key = self+ .keymap+ .primary_hint(KeymapContext::Global, "find_transcript")?;+ ("Tip: ", key.spans(), " searches this conversation")+ }+ _ => {+ return Some(Line::from(+ "Tip: /copy copies the last response".set_style(secondary_text_style()),+ ));+ }+ }+ };+ let mut tip = Line::from(prefix.set_style(secondary_text_style()));+ tip.spans.extend(keys);+ tip.spans.push(label.set_style(secondary_text_style()));+ Some(tip)+ }+}++#[cfg(test)]+#[path = "composer_hints_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/composer_hints_tests.rs b/codex-rs/tui/src/app/composer_hints_tests.rsnew file mode 100644index 0000000000..b397fc9fed--- /dev/null+++ b/codex-rs/tui/src/app/composer_hints_tests.rs@@ -0,0 +1,119 @@+//! Discovery yields to input and reflects configured shortcuts.++use super::*;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn hints_respect_settings_drafts_and_custom_shortcuts() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ app.local_settings.tui.show_tooltips = true;+ app.transcript_cells = vec![Arc::new(crate::history_cell::new_user_prompt(+ "question".into(),+ Vec::new(),+ Vec::new(),+ Vec::new(),+ ))];+ app.keymap.app.find_transcript = vec![crate::key_hint::plain(KeyCode::F(12))];+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let mut snapshots = Vec::new();+ for width in [80, 32] {+ let size = Size::new(width, /*height*/ 8);+ tui.terminal.resize(size)?;+ app.render_owned_transcript(&mut tui, size)?;+ let buffer = crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal);+ let rendered = (buffer.area.y..buffer.area.bottom())+ .map(|y| {+ (buffer.area.x..buffer.area.right())+ .map(|x| buffer[(x, y)].symbol())+ .collect::<String>()+ .trim_end()+ .to_string()+ })+ .collect::<Vec<_>>()+ .join("\n");+ snapshots.push(format!("{width} columns\n{rendered}"));+ }+ insta::assert_snapshot!(+ "composer_tip_layout",+ crate::chatwidget::tests::helpers::normalize_snapshot_paths(snapshots.join("\n\n")),+ );+ app.keymap.app.find_transcript.clear();+ assert_eq!(app.composer_tip(), None);+ app.transcript_cells.clear();+ app.chat_widget.apply_external_edit("draft".into());+ assert_eq!(app.composer_tip(), None);+ app.chat_widget.apply_external_edit(String::new());+ app.local_settings.tui.show_tooltips = false;+ assert_eq!(app.composer_tip(), None);+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn escape_closes_shortcut_help_before_transcript_backtracking() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.transcript_cells = vec![Arc::new(crate::history_cell::PlainHistoryCell::new(+ (0..60)+ .map(|row| format!("response row {row}").into())+ .collect(),+ ))];+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 24))?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -20);+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 8,+ );+ let mut before = ratatui::buffer::Buffer::empty(area);+ app.transcript_view+ .render(area, &mut before, &app.transcript_cells);+ let escape = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);+ let toggle = KeyEvent::new(KeyCode::Char('?'), KeyModifiers::NONE);+ assert!(app.should_handle_backtrack_esc(escape));+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(toggle))+ .await?;+ assert!(app.chat_widget.shortcut_overlay_visible());+ assert!(!app.should_handle_backtrack_esc(escape));+ assert!(!app.should_reject_side_backtrack_esc(escape));++ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(escape))+ .await?;+ assert!(!app.chat_widget.shortcut_overlay_visible());+ assert!(!app.backtrack.primed);+ assert!(!app.transcript_view.is_following());+ assert!(app.should_handle_backtrack_esc(escape));+ let mut after = ratatui::buffer::Buffer::empty(area);+ app.transcript_view+ .render(area, &mut after, &app.transcript_cells);+ assert_eq!(after, before);++ // Search and selection replace the help footer and keep their own first Escape.+ for search in [true, false] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(toggle))+ .await?;+ if search {+ app.transcript_view.begin_search();+ } else {+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL)),+ )+ .await?;+ }+ assert!(app.transcript_view.has_active_interaction());+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(escape))+ .await?;+ assert!(!app.transcript_view.has_active_interaction());+ assert!(app.chat_widget.shortcut_overlay_visible());+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(escape))+ .await?;+ assert!(!app.chat_widget.shortcut_overlay_visible());+ }+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex b23c52f389..75b2d32dfe 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -547,12 +547,22 @@ impl App {}AppEvent::RevertSessionForPromptEdit {thread_id,- nth_user_message,+ selected_cell,mut prompt,} => {if self.chat_widget.thread_id() != Some(thread_id) {return Ok(AppRunControl::Continue);}+ if self.app_server_target.uses_remote_workspace()+ && (!prompt.local_images.is_empty()+ || prompt.text.trim_start().starts_with(['/', '!']))+ {+ self.chat_widget.add_error_message(+ "This remote prompt contains local image paths or command syntax that cannot be restored safely. Write a new message and reattach any images.".into(),+ );+ tui.frame_requester().schedule_frame();+ return Ok(AppRunControl::Continue);+ }if self.pending_server_profiles.contains_key(&thread_id) {self.chat_widget.restore_user_message_to_composer(prompt);self.chat_widget.add_error_message(@@ -561,6 +571,12 @@ impl App {tui.frame_requester().schedule_frame();return Ok(AppRunControl::Continue);}+ let Some(index) = self.transcript_cells.iter().position(|cell| Arc::ptr_eq(cell, &selected_cell)) else {+ self.restore_backtrack_prompt_after_revert_error(prompt, "the selected prompt is no longer visible");+ tui.frame_requester().schedule_frame();+ return Ok(AppRunControl::Continue);+ };+ let nth_user_message = crate::app_backtrack::user_count(&self.transcript_cells[..index]);let selection: Result<(String, Vec<Turn>)> = async {let channel = self.thread_event_channels.get(&thread_id).ok_or_else(|| color_eyre::eyre::eyre!("the selected thread is no longer available"))?;diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rsindex ac53d3896f..32a606c24b 100644--- a/codex-rs/tui/src/app/history_pagination.rs+++ b/codex-rs/tui/src/app/history_pagination.rs@@ -105,14 +105,7 @@ impl App {RawReasoningVisibility::Hidden};let width = tui.terminal.last_known_screen_size.width;- self.remove_hidden_review_cells(- &turns,- &hidden_item_ids,- thread_id,- &cwd,- visibility,- width,- );+ self.remove_hidden_review_cells(tui, &turns, &hidden_item_ids, thread_id, &cwd, visibility);let cells = self.project_older_history_cells(items,&turns,@@ -121,7 +114,7 @@ impl App {&cwd,visibility,);- let inserted = self.prepend_older_transcript_cells(cells, width);+ let inserted = self.prepend_older_transcript_cells(cells);self.transcript_view.history_loaded(&self.transcript_cells, inserted.clone());if !inserted.is_empty() {@@ -129,6 +122,16 @@ impl App {}merge_older_turns(&mut store.lock().await.turns, turns);self.scrollback_has_older_history = app_server.has_older_history(thread_id);+ if self.backtrack.overlay_preview_active+ && self.backtrack.nth_user_message == usize::MAX+ && !self.scrollback_has_older_history+ {+ self.cancel_transcript_browsing(tui);+ self.chat_widget.add_info_message(+ "No previous message to edit.".to_string(),+ /*hint*/ None,+ );+ }if tui.is_owned_screen() {self.finish_owned_history_page(tui, app_server, thread_id);@@ -141,12 +144,12 @@ impl App {/// Remove prompts revealed as internal review input by an older page's review marker.fn remove_hidden_review_cells(&mut self,+ tui: &mut tui::Tui,turns: &[Turn],hidden_item_ids: &HashSet<&str>,thread_id: ThreadId,cwd: &AbsolutePathBuf,visibility: RawReasoningVisibility,- width: u16,) {if hidden_item_ids.is_empty() {return;@@ -182,17 +185,23 @@ impl App {&self.transcript_cells,self.backtrack.nth_user_message,);- let removed_visible_users = indices- .iter()- .filter(|&&index| {- selected_index.is_some_and(|selected| index < selected)- && self.transcript_cells[index].desired_height(width) != 0- })- .count();- self.backtrack.nth_user_message = self- .backtrack- .nth_user_message- .saturating_sub(removed_visible_users);+ if selected_index.is_some_and(|selected| indices.contains(&selected)) {+ self.cancel_transcript_browsing(tui);+ } else {+ let removed_visible_users = indices+ .iter()+ .filter(|&&index| {+ selected_index.is_some_and(|selected| index < selected)+ && crate::app_backtrack::user_count(std::slice::from_ref(+ &self.transcript_cells[index],+ )) != 0+ })+ .count();+ self.backtrack.nth_user_message = self+ .backtrack+ .nth_user_message+ .saturating_sub(removed_visible_users);+ }}for index in indices {self.transcript_cells.remove(index);@@ -240,20 +249,16 @@ impl App {}/// Insert each page once, keeping session headers and any backtrack selection in place.- fn prepend_older_transcript_cells(- &mut self,- cells: Vec<Arc<dyn HistoryCell>>,- width: u16,- ) -> Range<usize> {+ fn prepend_older_transcript_cells(&mut self, cells: Vec<Arc<dyn HistoryCell>>) -> Range<usize> {if self.backtrack.overlay_preview_active {- self.backtrack.nth_user_message = self.backtrack.nth_user_message.saturating_add(- cells- .iter()- .filter(|cell| {- cell.as_any().is::<UserHistoryCell>() && cell.desired_height(width) != 0- })- .count(),- );+ let added_prompts = crate::app_backtrack::user_count(&cells);+ self.backtrack.nth_user_message = if self.backtrack.nth_user_message == usize::MAX {+ added_prompts.checked_sub(1).unwrap_or(usize::MAX)+ } else {+ self.backtrack+ .nth_user_message+ .saturating_add(added_prompts)+ };}let index = if let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut() {overlay.prepend(cells.clone())@@ -290,7 +295,9 @@ impl App {.jump_to_entry(&self.transcript_cells, /*index*/ 0);}if self.scrollback_has_older_history- && (continue_to_start || self.transcript_view.needs_history(&self.transcript_cells))+ && (continue_to_start+ || self.browsing_needs_history()+ || self.transcript_view.needs_history(&self.transcript_cells))&& self.request_older_history_page(app_server, thread_id){self.transcript_view.history = if continue_to_start {diff --git a/codex-rs/tui/src/app/history_pagination_tests.rs b/codex-rs/tui/src/app/history_pagination_tests.rsindex 25c0537528..c3cbb00ef0 100644--- a/codex-rs/tui/src/app/history_pagination_tests.rs+++ b/codex-rs/tui/src/app/history_pagination_tests.rs@@ -173,3 +173,93 @@ async fn hidden_last_item_keeps_turn_groups_and_completion_boundaries() {);}}++#[tokio::test]+async fn browsing_waits_for_a_prompt_outside_the_initial_history_window() -> Result<()> {+ let mut app = make_test_app().await;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.scrollback_has_older_history = true;+ app.transcript_cells = vec![+ user_cell(""),+ Arc::new(crate::history_cell::PlainHistoryCell::new(vec![+ "recent answer".into(),+ ])),+ ];+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ assert!(app.backtrack.overlay_preview_active && app.browsing_needs_history());+ app.prepend_older_transcript_cells(vec![+ user_cell(""),+ Arc::new(crate::history_cell::PlainHistoryCell::new(vec![+ "earlier answer".into(),+ ])),+ ]);+ assert!(app.browsing_needs_history());+ app.prepend_older_transcript_cells(vec![+ user_cell(""),+ user_cell("older prompt"),+ user_cell("latest prompt"),+ ]);+ app.apply_backtrack_selection_internal(app.backtrack.nth_user_message);+ assert_eq!(+ (+ app.backtrack.nth_user_message,+ crate::app_backtrack::nth_user_position(+ &app.transcript_cells,+ app.backtrack.nth_user_message+ )+ ),+ (1, Some(2))+ );+ assert!(!app.browsing_needs_history());+ app.apply_backtrack_selection_internal(/*nth_user_message*/ 0);+ let mut review_turn = turn(+ "review",+ TurnStatus::Completed,+ &["older prompt", "latest prompt"],+ );+ for item in &mut review_turn.items {+ if let ThreadItem::UserMessage { id, content, .. } = item {+ *content = vec![UserInput::Text {+ text: id.clone(),+ text_elements: Vec::new(),+ }];+ }+ }+ review_turn.items.insert(+ /*index*/ 0,+ ThreadItem::EnteredReviewMode {+ id: "enter".to_string(),+ review: "review".to_string(),+ },+ );+ review_turn.items.insert(+ /*index*/ 2,+ ThreadItem::ExitedReviewMode {+ id: "exit".to_string(),+ review: "review".to_string(),+ },+ );+ let turns = [review_turn];+ app.remove_hidden_review_cells(+ &mut tui,+ &turns,+ &hidden_review_item_ids(&turns),+ ThreadId::new(),+ &app.config.cwd.clone(),+ RawReasoningVisibility::Hidden,+ );+ assert!(!app.backtrack.overlay_preview_active);+ assert_eq!(+ app.transcript_cells+ .iter()+ .filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())+ .filter(|cell| !cell.message.is_empty())+ .map(|cell| cell.message.as_str())+ .collect::<Vec<_>>(),+ vec!["latest prompt"]+ );+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}diff --git a/codex-rs/tui/src/app/input.rs b/codex-rs/tui/src/app/input.rsindex 8cd2d58abc..803d26641d 100644--- a/codex-rs/tui/src/app/input.rs+++ b/codex-rs/tui/src/app/input.rs@@ -179,7 +179,12 @@ impl App {} else {KeymapContext::Pager};- return KeymapContextSet::new(context);+ let contexts = KeymapContextSet::new(context);+ return if self.backtrack.overlay_preview_active && context == KeymapContext::Pager {+ KeymapContextSet::browsing()+ } else {+ contexts+ };}if self.transcript_view.is_search_active() && self.chat_widget.no_modal_or_popup_active() {return KeymapContextSet::new(KeymapContext::Editor);@@ -188,6 +193,9 @@ impl App {{return KeymapContextSet::activity();}+ if self.backtrack.overlay_preview_active && self.chat_widget.no_modal_or_popup_active() {+ return KeymapContextSet::browsing();+ }let voice_available = self.chat_widget.realtime_microphone_shortcut_available();let contexts = self.chat_widget.keymap_contexts();if self.chat_widget.no_modal_or_popup_active() {@@ -538,7 +546,7 @@ impl App {// with the composer focused and empty. In any other state, forward// Esc so the active UI (e.g. status indicator, modals, popups)// handles it.- if !tui.is_owned_screen() && self.should_handle_backtrack_esc(key_event) {+ if self.should_handle_backtrack_esc(key_event) {self.chat_widget.prepare_composer_sparkle_key(key_event);if key_event.kind == KeyEventKind::Press {self.handle_backtrack_esc_key(tui);@@ -575,7 +583,7 @@ impl App {// (even if they later backspace to empty).if key_event.code != KeyCode::Esc && self.backtrack.primed {if self.backtrack.overlay_preview_active {- self.close_transcript_overlay(tui);+ self.cancel_transcript_browsing(tui);} else {self.reset_backtrack_state();}@@ -671,7 +679,7 @@ impl App {&& matches!(key_event.code, KeyCode::Char('c' | 'd')))}- pub(super) fn should_handle_backtrack_esc(&self, key_event: KeyEvent) -> bool {+ pub(crate) fn should_handle_backtrack_esc(&self, key_event: KeyEvent) -> bool {!self.chat_widget.side_conversation_active()&& !self.chat_widget.shortcut_overlay_visible()&& self.chat_widget.is_normal_backtrack_mode()diff --git a/codex-rs/tui/src/app/native_history.rs b/codex-rs/tui/src/app/native_history.rsindex 07ffb4dd28..b34523e28f 100644--- a/codex-rs/tui/src/app/native_history.rs+++ b/codex-rs/tui/src/app/native_history.rs@@ -116,7 +116,7 @@ impl NativeHistory {impl App {pub(super) fn flush_native_history(&mut self, tui: &mut tui::Tui) {- if self.overlay.is_some() {+ if tui.is_owned_screen() || self.overlay.is_some() {return;}let mut ready = Vec::new();diff --git a/codex-rs/tui/src/app/owned_transcript.rs b/codex-rs/tui/src/app/owned_transcript.rsindex f6e9311aec..bf1f9ea84d 100644--- a/codex-rs/tui/src/app/owned_transcript.rs+++ b/codex-rs/tui/src/app/owned_transcript.rs@@ -49,6 +49,9 @@ impl App {"esc latest"};self.sync_owned_transcript(screen_size.width);+ let composer_tip = self.composer_tip();+ let mut prompt_footer =+ self.prompt_navigation_footer(screen_size.width.saturating_sub(/*rhs*/ 2));let chat_widget = &self.chat_widget;let transcript_width = chat_widget.history_wrap_width(screen_size.width);let view = &mut self.transcript_view;@@ -65,7 +68,7 @@ impl App {/*height*/ 1,));let footer = view.footer_with_navigation(footer_area.width, motion, latest_navigation);- let bottom = chat_widget.bottom_pane_renderable(footer.as_ref());+ let bottom = chat_widget.bottom_pane_renderable(prompt_footer.as_ref().or(footer.as_ref()));let dashboard_visible = chat_widget.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID).is_some();@@ -76,6 +79,7 @@ impl App {.desired_height(screen_size.width).min(screen_size.height)};+ drop(bottom);let available = screen_size.height.saturating_sub(bottom_height);let bottom_area = Rect::new(/*x*/ 0,@@ -110,12 +114,16 @@ impl App {/*height*/ 1,)});- feedback_tick = view.render_composer_gap(follow_area, /*hint*/ None, frame.buffer);+ feedback_tick =+ view.render_composer_gap(follow_area, composer_tip.as_ref(), frame.buffer);// Rendering resolves whether new activity is still hidden. Paint that result in// this frame so a revision change cannot flash a stale activity hint.let mut footer =view.footer_with_navigation(footer_area.width, motion, latest_navigation);- if let Some(footer) = footer.as_mut().filter(|footer| footer.is_interactive)+ if let Some(footer) = prompt_footer+ .as_mut()+ .or(footer.as_mut())+ .filter(|footer| footer.is_interactive)&& let Some(items) = self.key_chord_matcher.pending_hint_items(&self.keymap.chords, footer_area.width)@@ -123,7 +131,8 @@ impl App {{*progress = crate::bottom_pane::footer_hint_items_line(&items);}- let bottom = chat_widget.bottom_pane_renderable(footer.as_ref());+ let bottom =+ chat_widget.bottom_pane_renderable(prompt_footer.as_ref().or(footer.as_ref()));footer_height_changed = !dashboard_visible&& bottom.desired_height(screen_size.width)@@ -210,6 +219,34 @@ impl App {{return Ok(false);}+ // Prompt preview owns its navigation before ordinary Escape-to-latest scrolling.+ // Selection and search retain their existing priority and keep the prompt untouched.+ if self.backtrack.overlay_preview_active+ && !self.transcript_view.has_active_interaction()+ && self.handle_owned_backtrack_event(tui, event)?+ {+ self.request_owned_history(tui, app_server);+ return Ok(true);+ }+ // Capture the origin before the first Escape returns a paused viewport to latest.+ if !self.backtrack.overlay_preview_active+ && !self.transcript_view.has_active_interaction()+ && !self.reconnect.offline+ && let TuiEvent::Key(key) = event+ && key.code == KeyCode::Esc+ && key.modifiers.is_empty()+ && key.kind == KeyEventKind::Press+ && self.should_handle_backtrack_esc(*key)+ {+ if !self.handle_owned_backtrack_event(tui, event)? {+ self.handle_backtrack_esc_key(tui);+ if !self.backtrack.overlay_preview_active {+ self.transcript_view.jump_to_latest();+ }+ }+ tui.frame_requester().schedule_frame();+ return Ok(true);+ }if let TuiEvent::Key(key) = event&& !self.transcript_view.has_active_interaction()&& !self.backtrack.overlay_preview_active@@ -283,7 +320,17 @@ impl App {tui.frame_requester().schedule_frame();return Ok(true);}- return Ok(false);+ if self.reconnect.offline {+ if let TuiEvent::Key(key) = event+ && self.transcript_view.is_detailed()+ && self.keymap.pager.close_transcript.is_pressed(*key)+ {+ self.close_transcript_overlay(tui);+ return Ok(true);+ }+ return Ok(false);+ }+ return self.handle_owned_backtrack_event(tui, event);};let resume_following = matches!(action, ViewAction::CopyAndFollow(_));match action {@@ -328,8 +375,10 @@ impl App {if !self.scrollback_has_older_history {return;}+ let browsing_needs_history = self.browsing_needs_history();let view = &mut self.transcript_view;- if !view.needs_history(&self.transcript_cells)+ if !browsing_needs_history+ && !view.needs_history(&self.transcript_cells)&& view.history != TranscriptHistoryState::LoadingBeginning{return;diff --git a/codex-rs/tui/src/app/owned_transcript_browsing_tests.rs b/codex-rs/tui/src/app/owned_transcript_browsing_tests.rsnew file mode 100644index 0000000000..52e51d7bcf--- /dev/null+++ b/codex-rs/tui/src/app/owned_transcript_browsing_tests.rs@@ -0,0 +1,493 @@+//! Browsing restores its origin and gives selection/search priority over rewind keys.++use super::*;+use crate::history_cell::HistoryRenderMode;+use crate::history_cell::PlainHistoryCell;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn escape_restores_reading_origin_after_details_navigation_and_resize() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![+ user_cell("first prompt"),+ Arc::new(PlainHistoryCell::new(+ (0..30)+ .map(|row| format!("response row {row}").into())+ .collect(),+ )),+ user_cell("second prompt"),+ Arc::new(PlainHistoryCell::new(vec!["second response".into(); 30])),+ ];+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ for detailed in [false, true] {+ app.transcript_view+ .set_presentation(detailed, HistoryRenderMode::Rich);+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 16))?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -12);+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 8,+ );+ let mut before = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut before, &app.transcript_cells);+ let escape_count = if detailed { 1 } else { 2 };+ for _ in 0..escape_count {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ }+ assert_eq!(+ (+ app.backtrack.overlay_preview_active,+ app.transcript_view.is_detailed()+ ),+ (true, false)+ );+ for (key, expected_details) in [+ (KeyEvent::from(KeyCode::Left), false),+ (+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ true,+ ),+ (+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ false,+ ),+ ] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key))+ .await?;+ assert_eq!(app.transcript_view.is_detailed(), expected_details);+ let mut selected = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut selected, &app.transcript_cells);+ assert!(buffer_text(&selected).contains("first prompt"));+ }+ assert_eq!(app.backtrack.nth_user_message, 0);+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 40, /*height*/ 12))?;+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ let mut after = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut after, &app.transcript_cells);+ assert_eq!(buffer_text(&after), buffer_text(&before));+ assert_eq!(+ (+ app.backtrack.overlay_preview_active,+ app.transcript_view.is_detailed(),+ app.transcript_view.is_following()+ ),+ (false, detailed, false)+ );+ }+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn browsing_search_and_selection_consume_escape_before_mode_exit() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("first prompt"), user_cell("second prompt")];+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 16))?;+ app.transcript_view.begin_search();+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Paste("first".to_string()))+ .await?;+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert_eq!(+ (+ app.transcript_view.is_search_active(),+ app.backtrack.overlay_preview_active+ ),+ (false, true)+ );+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 16))?;+ for key in [+ KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL),+ KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT),+ ] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key))+ .await?;+ }+ assert!(app.transcript_view.has_active_interaction());+ assert_eq!(app.backtrack.nth_user_message, 1);+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert_eq!(+ (+ app.transcript_view.has_active_interaction(),+ app.backtrack.overlay_preview_active+ ),+ (false, true)+ );+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn browsing_footer_adapts_to_width() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("first prompt"), user_cell("second prompt")];+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ for width in [100, 80, 60, 40, 20, 8] {+ let footer = app+ .prompt_navigation_footer(width)+ .expect("browsing footer");+ assert_eq!(footer.text.lines.len(), 1);+ assert!(footer.text.width() <= usize::from(width));+ }+ app.transcript_view.history = TranscriptHistoryState::Failed;+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 12))?;+ assert!(+ buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(+ &tui.terminal,+ ))+ .contains("Retry history")+ );+ app.transcript_view.history = TranscriptHistoryState::Complete;+ app.cancel_transcript_browsing(&mut tui);+ tui.set_owned_screen(/*owned*/ false)?;+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ let mut snapshots = Vec::new();+ for width in [80, 32] {+ let area = Rect::new(/*x*/ 0, /*y*/ 0, width, /*height*/ 8);+ let footer = app+ .prompt_navigation_footer(width.saturating_sub(/*rhs*/ 2))+ .expect("browsing footer");+ let Some(Overlay::Transcript(overlay)) = &mut app.overlay else {+ panic!("expected inline browsing");+ };+ overlay.browsing_footer = footer.text.lines.into_iter().next();+ let mut buffer = Buffer::empty(area);+ overlay.render(area, &mut buffer);+ snapshots.push(format!("{width} columns\n{}", buffer_text(&buffer)));+ }+ insta::assert_snapshot!("browsing_footer", snapshots.join("\n\n"));+ let Some(Overlay::Transcript(overlay)) = &mut app.overlay else {+ panic!("expected inline browsing");+ };+ overlay.set_history_state(TranscriptHistoryState::Failed);+ let footer = app.prompt_navigation_footer(/*width*/ 78);+ let Some(Overlay::Transcript(overlay)) = &mut app.overlay else {+ panic!("expected inline browsing");+ };+ overlay.browsing_footer = footer.and_then(|footer| footer.text.lines.into_iter().next());+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 8,+ );+ let mut buffer = Buffer::empty(area);+ overlay.render(area, &mut buffer);+ assert!(buffer_text(&buffer).contains("Retry history"));+ app.close_transcript_overlay(&mut tui);+ Ok(())+}++#[tokio::test]+async fn inline_browsing_is_compact_and_escape_restores_the_existing_overlay() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("first prompt"), user_cell("second prompt")];+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.open_transcript_overlay(&mut tui);+ for (key, expected_details, browsing) in [+ (KeyEvent::from(KeyCode::Esc), false, true),+ (+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ true,+ true,+ ),+ (KeyEvent::from(KeyCode::Esc), true, false),+ ] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key))+ .await?;+ let Some(Overlay::Transcript(overlay)) = &app.overlay else {+ panic!("overlay must remain open")+ };+ assert_eq!(+ (overlay.is_detailed(), app.backtrack.overlay_preview_active),+ (expected_details, browsing)+ );+ }+ app.close_transcript_overlay(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert!(app.overlay.is_none());+ server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn browsing_details_use_the_remapped_chord_without_cancelling_preview() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![+ user_cell("first prompt"),+ user_cell(&"second prompt\n".repeat(80)),+ ];+ let config = toml::from_str(+ "[global]\nopen_transcript = [\"ctrl-x ctrl-t\", \"left f6\", \"enter f6\"]\ncopy = [\"ctrl-x ctrl-p\"]\n[pager]\nclose_transcript = [\"ctrl-x ctrl-t\"]\nscroll_up = []\nclose = [\"up ctrl-x\"]\npage_down = [\"ctrl-x ctrl-p\"]\njump_top = [\"ctrl-x ctrl-h\"]\n[composer]\nsubmit = []\n[editor]\nmove_left = []\ninsert_newline = []\n[vim_normal]\nmove_left = []",+ )?;+ app.keymap = RuntimeKeymap::from_config(&config).expect("valid transcript chord");+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ for owned in [true, false] {+ tui.set_owned_screen(owned)?;+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ assert!(+ app.prompt_navigation_footer(/*width*/ 100)+ .expect("footer")+ .text+ .to_string()+ .contains("ctrl+x ctrl+t")+ );+ for (keys, expected_details) in [+ (+ [+ KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL),+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ ],+ true,+ ),+ ([KeyCode::Left.into(), KeyCode::F(6).into()], false),+ ([KeyCode::Enter.into(), KeyCode::F(6).into()], true),+ ] {+ for key in keys {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key))+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ }+ let detailed = match &app.overlay {+ Some(Overlay::Transcript(overlay)) => overlay.is_detailed(),+ _ => app.transcript_view.is_detailed(),+ };+ assert_eq!(detailed, expected_details);+ }+ for completion in ['h', 'p'] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Draw)+ .await?;+ for code in ['x', completion] {+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Char(code), KeyModifiers::CONTROL)),+ )+ .await?;+ if code == 'x' {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Draw)+ .await?;+ let text = buffer_text(+ crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal),+ );+ assert!(text.contains("page down"), "pending pager chord is visible");+ }+ }+ }+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Draw)+ .await?;+ let text = buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(+ &tui.terminal,+ ));+ assert!(+ !text.contains("first prompt"),+ "configured page-down moved the viewport"+ );+ assert!(text.contains("second prompt"));+ assert!(app.backtrack.overlay_preview_active);+ for code in [KeyCode::Char('h'), KeyCode::Right] {+ if let Some(Overlay::Transcript(overlay)) = &mut app.overlay {+ overlay.set_history_state(TranscriptHistoryState::LoadingBeginning);+ } else {+ app.transcript_view.history = TranscriptHistoryState::LoadingBeginning;+ }+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(code.into()))+ .await?;+ let state = match &app.overlay {+ Some(Overlay::Transcript(overlay)) => overlay.history_state(),+ _ => app.transcript_view.history,+ };+ assert_eq!(state, TranscriptHistoryState::LoadingOlder);+ }+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Up.into()))+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL)),+ )+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ }+ server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn browsing_requires_fresh_escape_presses_and_ignores_confirmation_repeats() -> Result<()> {+ let (mut app, mut events, _operations) = make_test_app_with_channels().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("first prompt"), user_cell("second prompt")];+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.transcript_view+ .set_presentation(/*detailed*/ true, HistoryRenderMode::Rich);+ app.chat_widget.apply_external_edit("draft".to_string());+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ assert_eq!(app.chat_widget.composer_text_with_pending(), "draft");+ app.chat_widget.apply_external_edit(String::new());+ app.transcript_view+ .set_presentation(/*detailed*/ false, HistoryRenderMode::Rich);+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::new_with_kind(+ KeyCode::Esc,+ KeyModifiers::NONE,+ KeyEventKind::Repeat,+ )),+ )+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::PageUp.into()))+ .await?;+ assert!(!app.backtrack.primed);+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Mouse(crossterm::event::MouseEvent {+ kind: crossterm::event::MouseEventKind::Moved,+ column: 1,+ row: 1,+ modifiers: KeyModifiers::NONE,+ }),+ )+ .await?;+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Esc.into()))+ .await?;+ for (code, kind) in [+ (KeyCode::Esc, KeyEventKind::Repeat),+ (KeyCode::Enter, KeyEventKind::Repeat),+ (KeyCode::Enter, KeyEventKind::Release),+ ] {+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::new_with_kind(code, KeyModifiers::NONE, kind)),+ )+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ }+ // Enter during history loading has no selected prompt to confirm.+ app.backtrack.nth_user_message = usize::MAX;+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::Enter.into()))+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ assert!(+ !std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RevertSessionForPromptEdit { .. }))+ );+ app.keymap = RuntimeKeymap::from_config(&toml::from_str(+ "[global]\nopen_external_editor = [\"f6 f7\"]",+ )?)+ .expect("valid editor chord");+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::F(6).into()))+ .await?;+ assert!(!app.backtrack.overlay_preview_active);+ assert!(app.key_chord_matcher.is_pending());+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyCode::F(7).into()))+ .await?;+ assert_eq!(+ (+ app.backtrack.overlay_preview_active,+ app.chat_widget.external_editor_state()+ ),+ (false, ExternalEditorState::Requested)+ );+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn browsing_arrows_and_vim_keys_navigate_without_editing_the_draft() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![+ user_cell("first prompt"),+ Arc::new(PlainHistoryCell::new(+ (0..30)+ .map(|row| format!("response row {row}").into())+ .collect(),+ )),+ user_cell("second prompt"),+ ];+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.handle_backtrack_esc_key(&mut tui);+ app.handle_backtrack_esc_key(&mut tui);+ app.chat_widget+ .apply_external_edit("untouched draft".to_string());+ let size = Size::new(/*width*/ 80, /*height*/ 16);+ app.render_owned_transcript(&mut tui, size)?;+ let before = buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(+ &tui.terminal,+ ));+ for code in [KeyCode::Up, KeyCode::Char('k')] {+ assert!(app.handle_owned_backtrack_event(&mut tui, &TuiEvent::Key(code.into()))?);+ }+ app.render_owned_transcript(&mut tui, size)?;+ pretty_assertions::assert_ne!(+ buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(+ &tui.terminal+ )),+ before+ );+ for (code, selected) in [+ (KeyCode::Down, 1),+ (KeyCode::Char('j'), 1),+ (KeyCode::Char('h'), 0),+ (KeyCode::Char('l'), 1),+ (KeyCode::Left, 0),+ (KeyCode::Right, 1),+ ] {+ assert!(app.handle_owned_backtrack_event(&mut tui, &TuiEvent::Key(code.into()))?);+ assert_eq!(app.backtrack.nth_user_message, selected);+ }+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "untouched draft"+ );+ assert!(app.backtrack.overlay_preview_active);+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}diff --git a/codex-rs/tui/src/app/owned_transcript_input_tests.rs b/codex-rs/tui/src/app/owned_transcript_input_tests.rsindex 9ffaa2bae6..a7000997be 100644--- a/codex-rs/tui/src/app/owned_transcript_input_tests.rs+++ b/codex-rs/tui/src/app/owned_transcript_input_tests.rs@@ -1,6 +1,8 @@//! Composer input resumes after transcript selection without changing search or keymap ownership.use super::*;+use crate::app::tests::make_test_app_with_channels;+use crate::chatwidget::tests::helpers::normalize_snapshot_paths;use crate::history_cell::HistoryRenderMode;use crate::history_cell::PlainHistoryCell;use pretty_assertions::assert_eq;@@ -52,6 +54,276 @@ async fn select_transcript(Ok(())}+fn screen(tui: &tui::Tui) -> String {+ let buffer = crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal);+ let rendered = buffer+ .content()+ .chunks(usize::from(buffer.area.width))+ .map(|row| {+ row.iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>()+ .trim_end()+ .to_owned()+ })+ .collect::<Vec<_>>()+ .join("\n");+ normalize_snapshot_paths(rendered)+}++#[tokio::test]+async fn empty_enter_returns_to_latest_with_contextual_hints() -> Result<()> {+ let (mut app, mut events, mut operations) = make_test_app_with_channels().await;+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ for (width, detailed) in [(80, false), (40, true)] {+ let size = Size::new(width, /*height*/ 12);+ tui.terminal.resize(size)?;+ app.transcript_view = Default::default();+ app.transcript_view+ .set_presentation(detailed, HistoryRenderMode::Rich);+ app.transcript_cells = vec![Arc::new(PlainHistoryCell::new(+ (0..30).map(|row| format!("row {row}").into()).collect(),+ ))];+ app.render_owned_transcript(&mut tui, size)?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -10);+ app.render_owned_transcript(&mut tui, size)?;+ let cursor = tui.terminal.last_known_cursor_pos;+ assert!(screen(&tui).contains("enter/esc latest"));++ // Release/repeat events and modified Enter must not become a navigation command.+ for key in [+ KeyEvent::new_with_kind(KeyCode::Enter, KeyModifiers::NONE, KeyEventKind::Release),+ KeyEvent::new_with_kind(KeyCode::Enter, KeyModifiers::NONE, KeyEventKind::Repeat),+ KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT),+ ] {+ assert!(!app.handle_owned_transcript_event(+ &mut tui,+ &mut server,+ &TuiEvent::Key(key)+ )?);+ assert!(!app.transcript_view.is_following());+ }++ app.chat_widget.apply_external_edit("draft".to_string());+ app.render_owned_transcript(&mut tui, size)?;+ assert!(screen(&tui).contains("esc latest"));+ assert!(!screen(&tui).contains("enter/esc latest"));+ app.chat_widget.apply_external_edit(String::new());+ app.transcript_cells+ .push(Arc::new(PlainHistoryCell::new(vec!["new output".into()])));+ app.render_owned_transcript(&mut tui, size)?;+ while events.try_recv().is_ok() {}+ app.handle_tui_event(+ &mut tui,+ &mut server,+ TuiEvent::Key(KeyEvent::from(KeyCode::Enter)),+ )+ .await?;+ app.render_owned_transcript(&mut tui, size)?;+ assert!(app.transcript_view.is_following());+ assert_eq!(app.chat_widget.composer_text_with_pending(), "");+ assert_eq!(tui.terminal.last_known_cursor_pos, cursor);+ assert!(screen(&tui).contains("new output"));+ assert!(!screen(&tui).contains("latest"));+ assert!(events.try_recv().is_err());+ assert!(operations.try_recv().is_err());++ assert!(!app.handle_owned_transcript_event(+ &mut tui,+ &mut server,+ &TuiEvent::Key(KeyEvent::from(KeyCode::Enter))+ )?);+ }+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn enter_preserves_search_backtrack_and_modal_ownership_while_scrolled() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let size = Size::new(/*width*/ 80, /*height*/ 12);+ app.transcript_cells = vec![Arc::new(PlainHistoryCell::new(+ (0..30).map(|row| format!("row {row}").into()).collect(),+ ))];+ app.render_owned_transcript(&mut tui, size)?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -10);+ app.render_owned_transcript(&mut tui, size)?;+ let enter = TuiEvent::Key(KeyEvent::from(KeyCode::Enter));+ app.transcript_view.begin_search();+ assert!(app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ assert!(app.transcript_view.is_search_active());+ assert!(!app.transcript_view.is_following());+ app.handle_owned_transcript_event(+ &mut tui,+ &mut server,+ &TuiEvent::Key(KeyEvent::from(KeyCode::Esc)),+ )?;++ // An empty selection anchor consumes Enter without accessing the host clipboard.+ app.handle_owned_transcript_event(+ &mut tui,+ &mut server,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL)),+ )?;+ assert!(app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ assert!(!app.transcript_view.is_following());+ app.handle_owned_transcript_event(+ &mut tui,+ &mut server,+ &TuiEvent::Key(KeyEvent::from(KeyCode::Esc)),+ )?;++ app.backtrack.primed = true;+ assert!(!app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ app.backtrack.primed = false;+ app.backtrack.overlay_preview_active = true;+ assert!(!app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ app.backtrack.overlay_preview_active = false;++ app.chat_widget+ .set_remote_image_urls(vec!["https://example.com/image.png".into()]);+ assert!(!app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ app.chat_widget.set_remote_image_urls(Vec::new());+ app.chat_widget.open_feature_enable_prompt(Feature::Collab);+ assert!(!app.handle_owned_transcript_event(&mut tui, &mut server, &enter)?);+ assert!(!app.transcript_view.is_following());++ tui.set_owned_screen(/*owned*/ false)?;+ server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn escape_returns_to_latest_without_changing_the_composer_draft() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let size = Size::new(/*width*/ 80, /*height*/ 12);+ app.chat_widget+ .apply_external_edit("draft preserved".to_string());+ app.transcript_cells = vec![Arc::new(PlainHistoryCell::new(+ (0..30).map(|row| format!("row {row}").into()).collect(),+ ))];+ app.render_owned_transcript(&mut tui, size)?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -10);+ app.transcript_cells+ .push(Arc::new(PlainHistoryCell::new(vec!["new output".into()])));+ app.render_owned_transcript(&mut tui, size)?;+ let before = screen(&tui);+ assert!(before.contains("New activity · esc latest"));+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),+ )+ .await?;+ app.render_owned_transcript(&mut tui, size)?;+ assert!(app.transcript_view.is_following());+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "draft preserved"+ );+ insta::assert_snapshot!(+ "escape_returns_to_latest",+ format!("before\n{before}\n\nafter\n{}", screen(&tui))+ );++ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -10);+ app.render_owned_transcript(&mut tui, size)?;+ app.chat_widget.toggle_vim_mode_and_notify();+ app.chat_widget+ .handle_key_event(KeyEvent::new(KeyCode::Char('i'), KeyModifiers::NONE));+ let escape = KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE);+ assert!(app.chat_widget.should_handle_vim_insert_escape(escape));+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Key(escape))+ .await?;+ assert!(!app.chat_widget.should_handle_vim_insert_escape(escape));+ assert!(!app.transcript_view.is_following());+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Key(escape))+ .await?;+ assert!(app.transcript_view.is_following());+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "draft preserved"+ );++ app.render_owned_transcript(&mut tui, size)?;+ app.transcript_view+ .scroll(&app.transcript_cells, /*rows*/ -10);+ app.transcript_cells+ .push(Arc::new(PlainHistoryCell::new(vec![+ "visible after resize".into(),+ ])));+ let large = Size::new(/*width*/ 80, /*height*/ 24);+ tui.terminal.resize(large)?;+ app.render_owned_transcript(&mut tui, large)?;+ let resized = screen(&tui);+ assert!(resized.contains("visible after resize"));+ assert!(!resized.contains("New activity"));+ app_server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn composer_paste_releases_selection_and_retains_normal_cursor_movement() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let size = Size::new(/*width*/ 80, /*height*/ 12);+ for detailed in [false, true] {+ app.chat_widget.apply_external_edit("draft ".to_string());+ select_transcript(&mut app, &mut tui, &mut app_server, detailed).await?;+ app.render_owned_transcript(&mut tui, size)?;+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Paste("café\r\nbeta\rgamma".to_string()),+ )+ .await?;+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "draft café\nbeta\ngamma"+ );+ assert!(!app.transcript_view.has_active_interaction());+ assert!(!app.transcript_view.tick_selection(&app.transcript_cells));+ assert!(!app.handle_owned_transcript_event(+ &mut tui,+ &mut app_server,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))+ )?);+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)),+ )+ .await?;+ // A paste inserts immediately, avoiding the terminal's typing-burst timer in this fixture.+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Paste("X".to_string()))+ .await?;+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "draft café\nbeta\ngammXa"+ );+ app.render_owned_transcript(&mut tui, size)?;+ }+ app_server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}+#[tokio::test]async fn modified_arrows_and_editor_chords_resume_composer_movement() -> Result<()> {let mut app = crate::app::test_support::make_test_app().await;@@ -130,51 +402,3 @@ async fn modified_arrows_and_editor_chords_resume_composer_movement() -> Result<tui.set_owned_screen(/*owned*/ false)?;Ok(())}--#[tokio::test]-async fn composer_paste_releases_selection_and_retains_normal_cursor_movement() -> Result<()> {- let mut app = crate::app::test_support::make_test_app().await;- let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;- let mut tui = crate::tui::test_support::make_test_tui()?;- tui.set_owned_screen(/*owned*/ true)?;- let size = Size::new(/*width*/ 80, /*height*/ 12);- for detailed in [false, true] {- app.chat_widget.apply_external_edit("draft ".to_string());- select_transcript(&mut app, &mut tui, &mut app_server, detailed).await?;- app.render_owned_transcript(&mut tui, size)?;- app.handle_tui_event(- &mut tui,- &mut app_server,- TuiEvent::Paste("café\r\nbeta\rgamma".to_string()),- )- .await?;- assert_eq!(- app.chat_widget.composer_text_with_pending(),- "draft café\nbeta\ngamma"- );- assert!(!app.transcript_view.has_active_interaction());- assert!(!app.transcript_view.tick_selection(&app.transcript_cells));- assert!(!app.handle_owned_transcript_event(- &mut tui,- &mut app_server,- &TuiEvent::Key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL))- )?);- app.handle_tui_event(- &mut tui,- &mut app_server,- TuiEvent::Key(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)),- )- .await?;- // A paste inserts immediately, avoiding the terminal's typing-burst timer in this fixture.- app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Paste("X".to_string()))- .await?;- assert_eq!(- app.chat_widget.composer_text_with_pending(),- "draft café\nbeta\ngammXa"- );- app.render_owned_transcript(&mut tui, size)?;- }- app_server.shutdown().await?;- tui.set_owned_screen(/*owned*/ false)?;- Ok(())-}diff --git a/codex-rs/tui/src/app/owned_transcript_tests.rs b/codex-rs/tui/src/app/owned_transcript_tests.rsindex c5545e9c04..a8cab4ac4f 100644--- a/codex-rs/tui/src/app/owned_transcript_tests.rs+++ b/codex-rs/tui/src/app/owned_transcript_tests.rs@@ -1,6 +1,8 @@//! Owned transcript integration preserves composer spacing/input, prompt editing, and gestures.use super::*;+use crate::app::tests::make_test_app_with_channels;+use crate::app_command::AppCommand;use crate::chatwidget::tests::helpers::normalize_snapshot_paths;use crate::history_cell::HistoryCell;use crate::history_cell::UserHistoryCell;@@ -235,7 +237,11 @@ async fn owned_drag_stops_when_focus_or_input_ownership_is_lost() -> Result<()>let mut tui = crate::tui::test_support::make_test_tui()?;tui.set_owned_screen(/*owned*/ true)?;let size = Size::new(/*width*/ 40, /*height*/ 12);- for owner in ["focus", "overlay", "popup"] {+ app.chat_widget+ .apply_external_edit("retained draft 界".into());+ app.chat_widget.handle_key_event(KeyCode::Left.into());+ let draft = app.chat_widget.capture_thread_input_state();+ for owner in ["focus", "resume", "overlay", "popup"] {app.transcript_view = Default::default();app.overlay = None;app.render_owned_transcript(&mut tui, size)?;@@ -261,6 +267,7 @@ async fn owned_drag_stops_when_focus_or_input_ownership_is_lost() -> Result<()>let selected = app.transcript_view.selected_text(&app.transcript_cells);let event = match owner {"focus" => TuiEvent::FocusLost,+ "resume" => TuiEvent::Resume,"overlay" => {app.overlay = Some(Overlay::new_static_with_lines(vec!["overlay".into()],@@ -275,7 +282,13 @@ async fn owned_drag_stops_when_focus_or_input_ownership_is_lost() -> Result<()>}_ => unreachable!(),};- app.handle_owned_transcript_event(&mut tui, &mut app_server, &event)?;+ if matches!(event, TuiEvent::Resume) {+ app.handle_tui_event(&mut tui, &mut app_server, event)+ .await?;+ } else {+ app.handle_owned_transcript_event(&mut tui, &mut app_server, &event)?;+ }+ assert_eq!(app.chat_widget.capture_thread_input_state(), draft);assert!(!app.transcript_view.tick_selection(&app.transcript_cells),"{owner}"@@ -290,6 +303,55 @@ async fn owned_drag_stops_when_focus_or_input_ownership_is_lost() -> Result<()>Ok(())}+#[tokio::test]+async fn owned_details_keep_the_composer_cursor_and_screen() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("First prompt"), user_cell("Second prompt")];+ app.chat_widget+ .apply_external_edit("preserved draft".to_string());+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.open_transcript_overlay(&mut tui);+ let bottom_area =+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 24))?;+ let expected_cursor = app+ .chat_widget+ .bottom_pane_renderable(/*footer*/ None)+ .cursor_pos(bottom_area)+ .expect("composer cursor");+ assert_eq!(+ (+ app.overlay.is_none(),+ app.transcript_view.is_detailed(),+ tui.is_owned_screen(),+ tui.is_alt_screen_active()+ ),+ (true, true, true, true),+ );+ assert_eq!(tui.terminal.last_known_cursor_pos, expected_cursor.into());+ let rendered = normalize_snapshot_paths(buffer_text(+ crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal),+ ));+ assert!(rendered.contains("First prompt"));+ assert!(rendered.contains("Second prompt"));+ assert!(rendered.contains("preserved draft"));+ assert!(app.handle_owned_backtrack_event(+ &mut tui,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL)),+ )?);+ assert_eq!(+ (+ app.transcript_view.is_detailed(),+ tui.is_owned_screen(),+ app.chat_widget.composer_text_with_pending()+ ),+ (false, true, "preserved draft".to_string()),+ );+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}+#[tokio::test]async fn owned_transcript_keeps_text_out_of_the_pet_columns() -> Result<()> {let mut app = crate::app::test_support::make_test_app().await;@@ -320,6 +382,293 @@ async fn owned_transcript_keeps_text_out_of_the_pet_columns() -> Result<()> {Ok(())}+#[tokio::test]+async fn owned_details_escape_interrupts_work_without_starting_backtrack() -> Result<()> {+ let (mut app, mut events, _operations) = make_test_app_with_channels().await;+ let thread_id = ThreadId::new();+ attach_thread(&mut app, thread_id);+ app.transcript_cells = vec![user_cell("historical prompt")];+ app.chat_widget+ .apply_external_edit("draft survives interrupt".to_string());+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.open_transcript_overlay(&mut tui);+ app.chat_widget.handle_server_notification(+ ServerNotification::TurnStarted(codex_app_server_protocol::TurnStartedNotification {+ thread_id: thread_id.to_string(),+ turn: codex_app_server_protocol::Turn {+ id: "active-turn".to_string(),+ items_view: codex_app_server_protocol::TurnItemsView::Full,+ items: Vec::new(),+ status: codex_app_server_protocol::TurnStatus::InProgress,+ error: None,+ started_at: None,+ completed_at: None,+ duration_ms: None,+ },+ }),+ /*replay_kind*/ None,+ );+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),+ )+ .await?;+ let interrupts = std::iter::from_fn(|| events.try_recv().ok())+ .filter(|event| matches!(event, AppEvent::CodexOp(AppCommand::Interrupt)))+ .count();+ assert_eq!(+ (+ interrupts,+ app.backtrack.overlay_preview_active,+ app.transcript_view.is_detailed(),+ app.chat_widget.composer_text_with_pending(),+ ),+ (1, false, true, "draft survives interrupt".to_string()),+ );+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn owned_backtrack_keys_edit_the_selected_prompt_and_restore_compact_view() -> Result<()> {+ let (mut app, mut events, _operations) = make_test_app_with_channels().await;+ let thread_id = ThreadId::new();+ attach_thread(&mut app, thread_id);+ app.transcript_cells = vec![user_cell("first"), user_cell("second")];+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.open_transcript_overlay(&mut tui);+ for (code, selected) in [(KeyCode::Esc, 1), (KeyCode::Left, 0), (KeyCode::Right, 1)] {+ assert!(app.handle_owned_backtrack_event(+ &mut tui,+ &TuiEvent::Key(KeyEvent::new(code, KeyModifiers::NONE))+ )?);+ assert_eq!(+ (+ app.backtrack.overlay_preview_active,+ app.backtrack.nth_user_message+ ),+ (true, selected)+ );+ }+ assert!(app.handle_owned_backtrack_event(+ &mut tui,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))+ )?);+ let selection = std::iter::from_fn(|| events.try_recv().ok()).find_map(|event| match event {+ AppEvent::RevertSessionForPromptEdit {+ thread_id,+ selected_cell,+ prompt,+ } => Some((+ thread_id,+ Arc::ptr_eq(&selected_cell, &app.transcript_cells[1]),+ prompt,+ )),+ _ => None,+ });+ assert_eq!(+ selection,+ Some((+ thread_id,+ true,+ crate::chatwidget::UserMessage::from("second")+ ))+ );+ assert_eq!(+ (+ app.overlay.is_none(),+ app.transcript_view.is_detailed(),+ app.backtrack.overlay_preview_active,+ app.backtrack.base_id,+ tui.is_owned_screen()+ ),+ (true, false, false, None, true),+ );+ tui.set_owned_screen(/*owned*/ false)?;+ Ok(())+}++#[tokio::test]+async fn cancelling_owned_backtrack_returns_arrow_keys_to_the_composer() -> Result<()> {+ for input in [+ vec![TuiEvent::Paste("abc".to_string())],+ ['a', 'b', 'c']+ .map(|c| TuiEvent::Key(KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE)))+ .into(),+ ] {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("First prompt"), user_cell("Second prompt")];+ let mut app_server =+ Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.open_transcript_overlay(&mut tui);+ let size = Size::new(/*width*/ 80, /*height*/ 12);+ app.render_owned_transcript(&mut tui, size)?;+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyCode::Esc.into()),+ )+ .await?;+ for event in input {+ app.handle_tui_event(&mut tui, &mut app_server, event)+ .await?;+ }+ // An ordinary key cancels preview before reaching the composer. Its arrow-key owner must end+ // with the highlight, without requiring the user to toggle out of detailed presentation.+ // Moving the caret also flushes buffered typing without depending on platform paste timers.+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Left, KeyModifiers::NONE)),+ )+ .await?;+ assert_eq!(app.chat_widget.composer_text_with_pending(), "abc");+ for event in [+ TuiEvent::Paste("X".to_string()),+ TuiEvent::Key(KeyEvent::new(KeyCode::Right, KeyModifiers::NONE)),+ TuiEvent::Paste("Y".to_string()),+ ] {+ app.handle_tui_event(&mut tui, &mut app_server, event)+ .await?;+ }+ assert_eq!(app.chat_widget.composer_text_with_pending(), "abXcY");+ assert_eq!(+ (+ app.transcript_view.is_detailed(),+ app.backtrack.primed,+ app.backtrack.overlay_preview_active,+ app.backtrack.base_id,+ ),+ (true, false, false, None),+ );+ assert!(!app.handle_owned_backtrack_event(+ &mut tui,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),+ )?);+ app.render_owned_transcript(&mut tui, size)?;+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ }+ Ok(())+}++#[tokio::test]+async fn owned_search_and_selection_consume_input_before_composer_and_backtrack() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("needle in history")];+ app.chat_widget+ .apply_external_edit("composer draft".to_string());+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ app.open_transcript_overlay(&mut tui);+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 24))?;+ for event in [+ TuiEvent::Key(KeyEvent::new(KeyCode::F(3), KeyModifiers::NONE)),+ TuiEvent::Paste("needle".to_string()),+ ] {+ assert!(app.handle_owned_transcript_event(&mut tui, &mut app_server, &event)?);+ }+ app.handle_owned_transcript_event(&mut tui, &mut app_server, &TuiEvent::Draw)?;+ app.render_owned_transcript(&mut tui, Size::new(/*width*/ 80, /*height*/ 24))?;+ assert!(+ app.transcript_view+ .search_footer(/*width*/ 80)+ .expect("query footer")+ .0+ .to_string()+ .starts_with("Find: needle")+ );+ let escape = TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));+ assert!(app.handle_owned_transcript_event(&mut tui, &mut app_server, &escape)?);+ assert!(!app.backtrack.overlay_preview_active);+ // Start and extend a selection through the app, then inspect its copy action without touching+ // the host clipboard. The app's existing clipboard handler is tested with an injected writer.+ for key in [+ KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL),+ KeyEvent::new(KeyCode::Right, KeyModifiers::NONE),+ ] {+ assert!(app.handle_owned_transcript_event(+ &mut tui,+ &mut app_server,+ &TuiEvent::Key(key)+ )?);+ }+ let copy = app.transcript_view.handle_key(+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ &app.transcript_cells,+ );+ assert!(matches!(copy, Some(ViewAction::Copy(text)) if !text.is_empty()));+ assert!(app.handle_owned_transcript_event(&mut tui, &mut app_server, &escape)?);+ assert!(!app.backtrack.overlay_preview_active);+ assert!(app.handle_owned_transcript_event(&mut tui, &mut app_server, &escape)?);+ assert!(app.transcript_view.is_following());+ assert!(!app.backtrack.overlay_preview_active);+ assert!(!app.handle_owned_transcript_event(&mut tui, &mut app_server, &escape)?);+ assert!(!app.backtrack.overlay_preview_active);+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "composer draft"+ );+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn inline_transcript_search_draws_and_escape_precedes_backtrack() -> Result<()> {+ let mut app = crate::app::test_support::make_test_app().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("needle in history")];+ let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.open_transcript_overlay(&mut tui);+ for event in [+ TuiEvent::Key(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE)),+ TuiEvent::Paste("needle".to_string()),+ TuiEvent::Draw,+ ] {+ app.handle_backtrack_overlay_event(&mut tui, &mut app_server, event)+ .await?;+ }+ let rendered = buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(+ &tui.terminal,+ ));+ assert!(+ rendered.contains("enter next"),+ "search advances on the inline overlay draw path"+ );+ app.handle_backtrack_overlay_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),+ )+ .await?;+ assert!(+ matches!(&app.overlay, Some(Overlay::Transcript(overlay)) if !overlay.has_active_interaction())+ );+ assert!(!app.backtrack.overlay_preview_active);+ app.handle_backtrack_overlay_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),+ )+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ app.close_transcript_overlay(&mut tui);+ app_server.shutdown().await?;+ Ok(())+}+#[tokio::test]async fn find_owns_editor_chords_without_changing_the_composer_draft() -> Result<()> {let mut app = crate::app::test_support::make_test_app().await;@@ -481,42 +830,168 @@ async fn offline_find_closes_before_the_next_ctrl_c_quits() -> Result<()> {}#[tokio::test]-async fn inline_transcript_search_draws_and_escape_closes_find() -> Result<()> {- let mut app = crate::app::test_support::make_test_app().await;+async fn offline_backtrack_keeps_the_preview_and_draft_without_reverting() -> Result<()> {+ for owned in [true, false] {+ let (mut app, mut events, _operations) = make_test_app_with_channels().await;+ attach_thread(&mut app, ThreadId::new());+ app.transcript_cells = vec![user_cell("earlier prompt"), user_cell("historical prompt")];+ let mut app_server =+ Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(owned)?;+ app.open_transcript_overlay(&mut tui);+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),+ )+ .await?;+ app.chat_widget+ .apply_external_edit("offline draft".to_string());+ app.reconnect.offline = true;+ for key in [+ KeyEvent::new(KeyCode::Char('j'), KeyModifiers::NONE),+ KeyEvent::new(KeyCode::Char('h'), KeyModifiers::NONE),+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ ] {+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Key(key))+ .await?;+ }+ assert_eq!(app.backtrack.nth_user_message, 0);+ assert!(if owned {+ app.transcript_view.is_detailed()+ } else {+ matches!(&app.overlay, Some(Overlay::Transcript(overlay)) if overlay.is_detailed())+ });+ assert!(matches!(+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))+ )+ .await?,+ AppRunControl::Continue+ ));+ assert_eq!(+ (+ app.backtrack.overlay_preview_active,+ app.chat_widget.composer_text_with_pending()+ ),+ (true, "offline draft".to_string())+ );+ assert!(+ !std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RevertSessionForPromptEdit { .. }))+ );+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::F(3), KeyModifiers::NONE)),+ )+ .await?;+ assert!(if owned {+ app.transcript_view.is_search_active()+ } else {+ matches!(&app.overlay, Some(Overlay::Transcript(overlay)) if overlay.is_search_active())+ });+ for (key, preview_active, draft) in [+ (KeyCode::Esc, true, "offline draft"),+ (+ if owned {+ KeyCode::Backspace+ } else {+ KeyCode::Esc+ },+ false,+ if owned {+ "offline draf"+ } else {+ "offline draft"+ },+ ),+ ] {+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Key(key.into()))+ .await?;+ assert_eq!(app.backtrack.overlay_preview_active, preview_active);+ assert_eq!(app.chat_widget.composer_text_with_pending(), draft);+ }+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ }+ Ok(())+}++#[tokio::test]+async fn double_escape_browses_prompts_without_reverting_and_explains_editing() -> Result<()> {+ let (mut app, mut events, _operations) = make_test_app_with_channels().await;+ app.keymap = RuntimeKeymap::from_config(&toml::from_str(+ "[editor]\nmove_left=[]\nmove_line_start='left h'\n[global]\nopen_transcript='ctrl-x h'\n",+ )?)+ .unwrap();attach_thread(&mut app, ThreadId::new());- app.transcript_cells = vec![user_cell("needle in history")];- let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;+ app.transcript_cells = vec![+ user_cell("first question"),+ user_cell("second question"),+ user_cell("third question"),+ ];+ let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;let mut tui = crate::tui::test_support::make_test_tui()?;- app.open_transcript_overlay(&mut tui);- for event in [- TuiEvent::Key(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::NONE)),- TuiEvent::Paste("needle".to_string()),- TuiEvent::Draw,+ tui.set_owned_screen(/*owned*/ true)?;+ let size = Size::new(/*width*/ 80, /*height*/ 16);+ app.render_owned_transcript(&mut tui, size)?;+ for code in [KeyCode::Esc, KeyCode::Esc] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(KeyEvent::from(code)))+ .await?;+ }+ assert!(app.backtrack.overlay_preview_active);+ assert_eq!(app.backtrack.nth_user_message, 2);+ for key in [+ KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL),+ KeyCode::Char('h').into(),] {- app.handle_backtrack_overlay_event(&mut tui, &mut app_server, event)+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key)).await?;}- let rendered = buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(- &tui.terminal,- ));+ assert!(app.transcript_view.is_detailed());+ assert_eq!(app.backtrack.nth_user_message, 2);+ for key in [+ KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL),+ KeyCode::Char('h').into(),+ ] {+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(key))+ .await?;+ }+ assert!(!app.transcript_view.is_detailed());++ for (code, index) in [(KeyCode::Left, 1), (KeyCode::Left, 0), (KeyCode::Right, 1)] {+ app.render_owned_transcript(&mut tui, size)?;+ app.handle_tui_event(&mut tui, &mut server, TuiEvent::Key(code.into()))+ .await?;+ assert!(!app.key_chord_matcher.is_pending());+ assert_eq!(app.backtrack.nth_user_message, index);+ }assert!(- rendered.contains("enter next"),- "search advances on the inline overlay draw path"+ !std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::RevertSessionForPromptEdit { .. })));- app.handle_backtrack_overlay_event(- &mut tui,- &mut app_server,- TuiEvent::Key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE)),- )- .await?;- assert!(- matches!(&app.overlay, Some(Overlay::Transcript(overlay)) if !overlay.has_active_interaction())+ app.keymap = RuntimeKeymap::defaults();+ app.render_owned_transcript(&mut tui, size)?;+ insta::assert_snapshot!(+ "prompt_navigation",+ normalize_snapshot_paths(buffer_text(+ crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal)+ )));app.close_transcript_overlay(&mut tui);- app_server.shutdown().await?;+ assert!(!app.backtrack.overlay_preview_active);+ server.shutdown().await?;+ tui.set_owned_screen(/*owned*/ false)?;Ok(())}+#[path = "owned_transcript_browsing_tests.rs"]+mod browsing;+#[tokio::test]async fn find_refreshes_live_details_before_searching_the_first_query() -> Result<()> {let mut app = crate::app::test_support::make_test_app().await;diff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__composer_hints__tests__composer_tip_layout.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__composer_hints__tests__composer_tip_layout.snapnew file mode 100644index 0000000000..ca70414964--- /dev/null+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__composer_hints__tests__composer_tip_layout.snap@@ -0,0 +1,23 @@+---+source: tui/src/app/composer_hints_tests.rs+expression: "crate::chatwidget::tests::helpers::normalize_snapshot_paths(snapshots.join(\"\\n\\n\"))"+---+80 columns++› question++ Tip: f12 searches this conversation++› Ask Codex to do anything++ GPT-5.6-Sol default · /tmp/project++32 columns++› question++++› Ask Codex to do anything++ GPT-5.6-Sol default · /tmp/pr…diff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__input_tests__escape_returns_to_latest.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__input_tests__escape_returns_to_latest.snapnew file mode 100644index 0000000000..b4f64c7536--- /dev/null+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__input_tests__escape_returns_to_latest.snap@@ -0,0 +1,32 @@+---+source: tui/src/app/owned_transcript_input_tests.rs+assertion_line: 257+expression: "format!(\"before\\n{before}\\n\\nafter\\n{}\", screen(&tui))"+---+before+row 13+row 14+row 15+row 16+row 17+row 18+row 19+ New activity · ↓ Back to bottom · esc++› draft preserved++ New activity · esc latest++after+row 25+row 26+row 27+row 28+row 29++new output+++› draft preserved++ GPT-5.6-Sol default · /tmp/projectdiff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__browsing__browsing_footer.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__browsing__browsing_footer.snapnew file mode 100644index 0000000000..83174e878c--- /dev/null+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__browsing__browsing_footer.snap@@ -0,0 +1,24 @@+---+source: tui/src/app/owned_transcript_browsing_tests.rs+assertion_line: 169+expression: "snapshots.join(\"\\n\\n\")"+---+80 columns+/ T R A N S C R I P T / / / / / / / / / / / / / / / / / / / / / / / / / / / / /+› first prompt++++› second prompt++Browsing · ↑↓/jk scroll · ←→/hl prompts · ctrl+t details · ↵ rewind · esc back++32 columns+/ T R A N S C R I P T / / / / /+› first prompt++++› second prompt++Browsing · ↵ rewind · esc backdiff --git a/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__prompt_navigation.snap b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__prompt_navigation.snapnew file mode 100644index 0000000000..65f25e8fc8--- /dev/null+++ b/codex-rs/tui/src/app/snapshots/codex_tui__app__owned_transcript__tests__prompt_navigation.snap@@ -0,0 +1,21 @@+---+source: tui/src/app/owned_transcript_tests.rs+assertion_line: 1077+expression: "normalize_snapshot_paths(buffer_text(crate::custom_terminal::test_support::last_rendered_buffer(&tui.terminal)))"+---++› first question++++› second question++++› third question++++› Ask Codex to do anything++ Browsing · ↑↓/jk scroll · ←→/hl prompts · ctrl+t details · ↵ rewind · esc backdiff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex c8b5c33e88..ec1a34191b 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -51,6 +51,8 @@ mod permission_selection_tests;#[path = "tests/unavailable_commands_tests.rs"]mod unavailable_commands;+#[path = "tests/history_hydration_tests.rs"]+mod history_hydration_tests;#[path = "tests/permission_shortcuts_tests.rs"]mod permission_shortcuts_tests;mod plugin_catalog;@@ -78,6 +80,9 @@ mod stream_animation_tests;mod thread_usage;#[path = "tests/transcript_composer.rs"]mod transcript_composer;++#[path = "tests/transcript_selection.rs"]+mod transcript_selection;#[path = "tests/turn_submission.rs"]mod turn_submission;#[path = "tests/user_verification_routes_tests.rs"]@@ -88,6 +93,7 @@ mod worktree_background_terminals_tests;use super::*;use crate::app_backtrack::BacktrackSelection;use crate::app_backtrack::BacktrackState;+use crate::app_backtrack::nth_user_position;use crate::app_backtrack::user_count;use crate::app_event::HistoryBatchEntryResponse;@@ -5969,8 +5975,8 @@ async fn make_test_app() -> App {runtime_permission_profile_override: None,file_search,transcript_cells: Vec::new(),+ transcript_view: crate::transcript_view::TranscriptView::default(),native_history: Default::default(),- transcript_view: Default::default(),last_rendered_history_tail: None,last_thread_usage_status_cell: None,pending_thread_usage_history_refresh: false,@@ -6072,8 +6078,8 @@ pub(super) async fn make_test_app_with_channels() -> (runtime_permission_profile_override: None,file_search,transcript_cells: Vec::new(),+ transcript_view: crate::transcript_view::TranscriptView::default(),native_history: Default::default(),- transcript_view: Default::default(),last_rendered_history_tail: None,last_thread_usage_status_cell: None,pending_thread_usage_history_refresh: false,@@ -7512,10 +7518,10 @@ async fn backtrack_selection_preserves_selected_prompt_and_requests_branch() {event,AppEvent::RevertSessionForPromptEdit {thread_id,- nth_user_message,+ selected_cell,prompt,} if thread_id == expected.thread_id- && nth_user_message == expected.nth_user_message+ && Arc::ptr_eq(&selected_cell, &app.transcript_cells[nth_user_position(&app.transcript_cells, expected.nth_user_message).unwrap()])&& prompt == expected.prompt);@@ -8143,7 +8149,7 @@ async fn prompt_edit_reverts_earlier_and_first_visible_prompts_in_place() -> Reslet mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&config)).await?;// Leave the oldest prompt on an unloaded page.let mut local_settings = crate::local_settings::LocalSettings::from(&config);- local_settings.tui.terminal_resize_reflow_max_rows = Some(3);+ local_settings.tui.terminal_resize_reflow_max_rows = Some(2);let started = app_server.resume_thread(&local_settings,@@ -8192,7 +8198,7 @@ async fn prompt_edit_reverts_earlier_and_first_visible_prompts_in_place() -> Resapp.transcript_cells.push(Arc::from(cell));}}- assert_eq!(crate::app_backtrack::user_count(&app.transcript_cells), 3);+ assert_eq!(crate::app_backtrack::user_count(&app.transcript_cells), 2);let child_id = ThreadId::new();let child = Arc::clone(&app.ensure_thread_channel(child_id).store);let goal = app_server@@ -8222,16 +8228,71 @@ async fn prompt_edit_reverts_earlier_and_first_visible_prompts_in_place() -> ResAppEvent::UpdateModel("gpt-5.4".into()),)).await?;- let control = Box::pin(app.handle_event(+ app.app_server_target = crate::AppServerTarget::Remote {+ endpoint: crate::RemoteAppServerEndpoint::WebSocket {+ websocket_url: "ws://127.0.0.1:4500".to_string(),+ auth_token: None,+ },+ };+ let before = app_server+ .thread_read(source_thread_id, /*include_turns*/ true)+ .await?;+ for text in [None, Some("/help"), Some(" \t!")] {+ let mut remote_prompt = prompt.clone();+ if let Some(text) = text {+ remote_prompt.text = text.into();+ remote_prompt.local_images.clear();+ }+ Box::pin(app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::RevertSessionForPromptEdit {+ thread_id: source_thread_id,+ selected_cell: Arc::clone(+ &app.transcript_cells+ [nth_user_position(&app.transcript_cells, /*nth*/ 1).unwrap()],+ ),+ prompt: remote_prompt,+ },+ ))+ .await?;+ assert!(app.chat_widget.composer_is_empty());+ assert_eq!(+ app_server+ .thread_read(source_thread_id, /*include_turns*/ true)+ .await?,+ before+ );+ }+ app.app_server_target = crate::AppServerTarget::Embedded;+ let selection = AppEvent::RevertSessionForPromptEdit {+ thread_id: source_thread_id,+ selected_cell: Arc::clone(+ &app.transcript_cells[nth_user_position(&app.transcript_cells, /*nth*/ 1).unwrap()],+ ),+ prompt: prompt.clone(),+ };+ // A queued page shifts both identical prompts before confirmation is dispatched.+ let cursor = app_server+ .begin_older_history_page(source_thread_id)+ .expect("older page");+ let page = app_server+ .thread_items_page(+ source_thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ /*limit*/ 1,+ )+ .await?;+ app.handle_older_history_page(&mut tui,&mut app_server,- AppEvent::RevertSessionForPromptEdit {- thread_id: source_thread_id,- nth_user_message: 1,- prompt: prompt.clone(),- },- ))+ source_thread_id,+ &cursor,+ Ok(page),+ ).await?;+ let control = Box::pin(app.handle_event(&mut tui, &mut app_server, selection)).await?;while let Ok(event) = app_event_rx.try_recv() {match event {@@ -8267,7 +8328,7 @@ async fn prompt_edit_reverts_earlier_and_first_visible_prompts_in_place() -> Res.iter().map(|turn| turn.id.as_str()).collect::<Vec<_>>(),- vec!["turn-0", "turn-1"]+ vec!["turn-0", "turn-1", "turn-2"]);let history = app@@ -8303,7 +8364,9 @@ async fn prompt_edit_reverts_earlier_and_first_visible_prompts_in_place() -> Res&mut app_server,AppEvent::RevertSessionForPromptEdit {thread_id: source_thread_id,- nth_user_message: 0,+ selected_cell: Arc::clone(+ &app.transcript_cells[nth_user_position(&app.transcript_cells, /*nth*/ 0).unwrap()],+ ),prompt: "retained prompt".into(),},))diff --git a/codex-rs/tui/src/app/tests/history_hydration_tests.rs b/codex-rs/tui/src/app/tests/history_hydration_tests.rsnew file mode 100644index 0000000000..8e844a1258--- /dev/null+++ b/codex-rs/tui/src/app/tests/history_hydration_tests.rs@@ -0,0 +1,328 @@+//! Public history requests preserve bounded metadata loading, cursor ownership and retry settings.++use super::session_lifecycle_requests::recorded_params;+use super::session_lifecycle_requests::start_recording_app_server;+use super::*;+use crate::app_server_session::HistoryHydrationScope;+use crate::legacy_core::config::TerminalResizeReflowMaxRows;+use crate::pager_overlay::TranscriptHistoryState;+use crate::session_start::SessionStartAction;+use crate::session_start::SessionStartConfig;+use crate::session_start::SessionStartOutcome;+use crate::session_start::complete_session_start;+use crate::transcript_mode::TranscriptMode;+use app_test_support::create_fake_paginated_rollout;+use app_test_support::rollout_path;+use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::ThreadItemsListResponse;+use codex_app_server_protocol::ThreadReadParams;+use codex_app_server_protocol::ThreadResumeParams;+use codex_app_server_protocol::ThreadResumeResponse;+use codex_protocol::items::TurnItem;+use codex_protocol::items::UserMessageItem;+use codex_protocol::protocol::ItemCompletedEvent;+use codex_protocol::protocol::TurnCompleteEvent;+use codex_protocol::user_input::UserInput as CoreUserInput;+use codex_state::SqliteConfig;+use pretty_assertions::assert_eq;+use pretty_assertions::assert_ne;++async fn history_fixture(item_counts: &[usize]) -> Result<(App, tempfile::TempDir, SessionTarget)> {+ let mut app = make_test_app().await;+ let codex_home = tempdir()?;+ app.config.codex_home = codex_home.path().to_path_buf().abs();+ app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());+ let filename_timestamp = "2026-01-02T00-00-00";+ let timestamp = "2026-01-02T00:00:00Z";+ let id = create_fake_paginated_rollout(+ codex_home.path(),+ filename_timestamp,+ timestamp,+ "history hydration",+ Some(app.config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error))?;+ let thread_id = ThreadId::from_string(&id)?;+ let path = rollout_path(codex_home.path(), filename_timestamp, &id);+ let mut records = std::fs::read_to_string(&path)?+ .lines()+ .take(/*n*/ 1)+ .map(serde_json::from_str::<serde_json::Value>)+ .collect::<Result<Vec<_>, _>>()?;+ for (index, count) in item_counts.iter().enumerate() {+ let turn_id = format!("turn-{index}");+ let mut events = vec![EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: turn_id.clone(),+ root_turn_id: None,+ trace_id: None,+ started_at: None,+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ })];+ for item in 0..*count {+ events.push(EventMsg::ItemCompleted(ItemCompletedEvent {+ thread_id,+ turn_id: turn_id.clone(),+ started_at_ms: None,+ completed_at_ms: 0,+ item: TurnItem::UserMessage(UserMessageItem {+ id: format!("item-{index}-{item}"),+ client_id: None,+ content: vec![CoreUserInput::Text {+ text: format!("prompt {index} {item}"),+ text_elements: Vec::new(),+ }],+ }),+ }));+ }+ events.push(EventMsg::TurnComplete(TurnCompleteEvent {+ turn_id,+ last_agent_message: None,+ error: None,+ started_at: None,+ completed_at: None,+ duration_ms: None,+ time_to_first_token_ms: None,+ }));+ for event in events {+ records.push(serde_json::json!({+ "timestamp": timestamp, "ordinal": records.len(),+ "type": "event_msg", "payload": event,+ }));+ }+ }+ let contents = records+ .into_iter()+ .map(|record| record.to_string())+ .collect::<Vec<_>>()+ .join("\n");+ std::fs::write(&path, format!("{contents}\n"))?;+ let target = SessionTarget {+ path: Some(path),+ thread_id,+ cwd: None,+ history_mode: Some(codex_app_server_protocol::ThreadHistoryMode::Paginated),+ };+ Ok((app, codex_home, target))+}++#[tokio::test]+async fn history_hydration_metadata_tracks_missing_turns_and_stale_completions_keep_new_request()+-> Result<()> {+ let (mut app, _codex_home, target) =+ history_fixture(&[1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1]).await?;+ app.local_settings.transcript_mode = TranscriptMode::Terminal;+ app.local_settings.tui.terminal_resize_reflow_max_rows = Some(1);+ let (mut server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ // Resume materializes the hand-written rollout into the server's item projection.+ // Exclude turns so the explicit hydration below remains the only history load.+ let _: ThreadResumeResponse = server+ .request_handle()+ .request_typed(ClientRequest::ThreadResume {+ request_id: server.next_request_id(),+ params: ThreadResumeParams {+ thread_id: target.thread_id.to_string(),+ exclude_turns: true,+ ..ThreadResumeParams::default()+ },+ })+ .await?;+ let mut thread = server+ .thread_read(target.thread_id, /*include_turns*/ false)+ .await?;+ server+ .hydrate_initial_thread_history(+ &mut thread,+ /*turn_cursor*/ None,+ /*item_cursor*/ None,+ Some(&app.config),+ Some(&app.local_settings),+ HistoryHydrationScope::Initial,+ )+ .await?;+ assert_eq!(+ thread+ .turns+ .iter()+ .flat_map(|turn| &turn.items)+ .map(ThreadItem::id)+ .collect::<Vec<_>>(),+ vec!["item-12-0"]+ );+ let old_cursor = server+ .begin_older_history_page(target.thread_id)+ .expect("older page");+ let page = server+ .thread_items_page(+ target.thread_id,+ /*turn_id*/ None,+ Some(old_cursor.clone()),+ /*limit*/ 2,+ )+ .await?;+ let items = server+ .apply_older_history_page(target.thread_id, &old_cursor, page, &mut thread.turns)+ .await?;+ assert_eq!(+ items.iter().map(ThreadItem::id).collect::<Vec<_>>(),+ vec!["item-3-0", "item-5-0"]+ );+ assert_eq!(+ thread+ .turns+ .iter()+ .flat_map(|turn| &turn.items)+ .map(ThreadItem::id)+ .collect::<Vec<_>>(),+ vec!["item-3-0", "item-5-0", "item-12-0"]+ );+ let metadata = recorded_params(&requests, "thread/turns/list");+ assert_eq!(+ metadata+ .iter()+ .map(|params| params["limit"].as_u64().unwrap())+ .collect::<Vec<_>>(),+ vec![5, 2, 2, 1]+ );+ assert_eq!(+ recorded_params(&requests, "thread/read")+ .into_iter()+ .map(serde_json::from_value::<ThreadReadParams>)+ .collect::<Result<Vec<_>, _>>()?,+ vec![ThreadReadParams {+ thread_id: target.thread_id.to_string(),+ include_turns: false,+ }]+ );++ let cursor = server+ .begin_older_history_page(target.thread_id)+ .expect("next page");+ assert_ne!(old_cursor, cursor);+ let mut tui = crate::tui::test_support::make_test_tui()?;+ // The response is stale even when its thread is no longer displayed. Ignore its error first.+ app.transcript_view.history = TranscriptHistoryState::LoadingOlder;+ for result in [+ Err("obsolete transport failure".to_string()),+ Ok(ThreadItemsListResponse {+ data: Vec::new(),+ next_cursor: None,+ backwards_cursor: None,+ }),+ ] {+ app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::OlderThreadHistoryLoaded {+ thread_id: target.thread_id,+ cursor: old_cursor.clone(),+ result,+ },+ )+ .await?;+ assert!(server.is_older_history_page_pending(target.thread_id, &cursor));+ assert_eq!(+ app.transcript_view.history,+ TranscriptHistoryState::LoadingOlder+ );+ }+ server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn history_hydration_archived_retry_uses_first_attempt_runtime_settings() -> Result<()> {+ for action in [+ SessionStartAction::Resume(+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ ),+ SessionStartAction::Fork(crate::app_server_session::ForkPermissionMode::InheritSaved),+ ] {+ for mode in [TranscriptMode::Terminal, TranscriptMode::Owned] {+ let (mut app, codex_home, mut target) = history_fixture(&[500]).await?;+ app.config+ .features+ .set_enabled(Feature::TranscriptV2, !mode.is_owned())?;+ app.config.tui_alternate_screen = codex_config::types::AltScreenMode::Always;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(1);+ app.local_settings = crate::local_settings::LocalSettings::from(&app.config);+ app.local_settings.transcript_mode = mode;+ let active_path = target.path.take().unwrap();+ let archived = codex_home.path().join("archived_sessions");+ std::fs::create_dir_all(&archived)?;+ let path = archived.join(active_path.file_name().unwrap());+ std::fs::rename(active_path, &path)?;+ target.path = Some(path);+ let (mut server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let initial = match action {+ SessionStartAction::Resume(settings) => {+ server+ .resume_thread(+ &app.local_settings,+ app.config.clone(),+ target.thread_id,+ settings,+ )+ .await+ }+ SessionStartAction::Fork(permission) => {+ server+ .fork_thread_with_permission_mode(+ &app.local_settings,+ app.config.clone(),+ target.thread_id,+ permission,+ )+ .await+ }+ };+ assert!(initial.is_err());+ let outcome = complete_session_start(+ &mut server,+ SessionStartConfig {+ config: &app.config,+ local_settings: &app.local_settings,+ },+ &AppServerTarget::Embedded,+ &target,+ action,+ initial,+ async || Ok(crate::unarchive_prompt::UnarchiveChoice::Unarchive),+ )+ .await?;+ let SessionStartOutcome::Started(started) = outcome else {+ panic!("retry starts session")+ };+ let count = started+ .turns+ .iter()+ .map(|turn| turn.items.len())+ .sum::<usize>();+ if mode.is_owned() {+ assert!(count > 1, "owned retry must use viewport budget");+ } else {+ assert_eq!(count, 1);+ }+ assert!(server.has_older_history(started.session.thread_id));+ let item_requests = recorded_params(&requests, "thread/items/list");+ let initial_limit = item_requests[0]["limit"].as_u64().unwrap();+ assert_eq!(initial_limit == 1, !mode.is_owned());+ assert_eq!(recorded_params(&requests, "thread/unarchive").len(), 1);+ server.shutdown().await?;+ proxy.await??;+ }+ }+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/pagination_completion_tests.rs b/codex-rs/tui/src/app/tests/pagination_completion_tests.rsindex 61b32cfb09..ede94f0a16 100644--- a/codex-rs/tui/src/app/tests/pagination_completion_tests.rs+++ b/codex-rs/tui/src/app/tests/pagination_completion_tests.rs@@ -1,7 +1,8 @@-//! Completed older pages keep each footer after its answer, including overlapping pages.+//! Older page completion preserves answer order, navigation intent, and pending request ownership.use super::session_lifecycle_requests::start_recording_app_server;use super::*;+use crate::pager_overlay::TranscriptHistoryState;use app_test_support::create_fake_paginated_rollout;use app_test_support::rollout_path;use chrono::TimeZone;@@ -14,6 +15,7 @@ use codex_protocol::protocol::ItemCompletedEvent;use codex_protocol::protocol::TurnCompleteEvent;use codex_protocol::user_input::UserInput as CoreUserInput;use codex_state::SqliteConfig;+use pretty_assertions::assert_eq;pub(super) async fn completed_history_app(names: &[&str],@@ -179,3 +181,359 @@ async fn older_pagination_completion_footers_follow_answers_without_overlap_duplproxy.await??;Ok(())}++#[tokio::test]+async fn beginning_navigation_holds_the_view_until_the_last_page_arrives() -> Result<()> {+ for initial_scroll in [0, -1] {+ let (mut app, _codex_home, thread_id) =+ completed_history_app(&["Oldest", "Middle", "Newest"]).await?;+ let (mut app_server, _requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let started = app_server+ .resume_thread(+ &app.local_settings,+ app.config.clone(),+ thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ app.transcript_cells = crate::thread_transcript::thread_items_to_transcript_cells(+ Some(thread_id),+ &app.config.cwd,+ started.turns.iter().flat_map(|turn| turn.items.clone()),+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ Some(&app.config),+ );+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ let (event_tx, mut event_rx) = tokio::sync::mpsc::unbounded_channel();+ app.app_event_tx = crate::app_event_sender::AppEventSender::new(event_tx);+ app.scrollback_has_older_history = app_server.has_older_history(thread_id);+ app.transcript_view.history = TranscriptHistoryState::Partial;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let size = ratatui::layout::Size::new(/*width*/ 80, /*height*/ 12);+ let render = |app: &mut App, tui: &mut tui::Tui| -> Result<Buffer> {+ tui.screen_size_for_event(&TuiEvent::Resize(size))?;+ let bottom = app.render_owned_transcript(tui, size)?;+ let area = Rect::new(+ /*x*/ 0,+ /*y*/ 0,+ size.width,+ bottom.y.saturating_sub(/*rhs*/ 1),+ );+ let mut buffer = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut buffer, &app.transcript_cells);+ Ok(buffer)+ };+ render(&mut app, &mut tui)?;+ if initial_scroll != 0 {+ app.transcript_view+ .scroll(&app.transcript_cells, initial_scroll);+ }+ let before = render(&mut app, &mut tui)?;++ // Hold a small first page so the test can inspect each request/completion boundary.+ let cursor = app_server+ .begin_older_history_page(thread_id)+ .expect("older page");+ let first_page = app_server+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ /*limit*/ 1,+ )+ .await?;+ let final_cursor = first_page.next_cursor.clone().expect("another older page");+ tui.screen_size_for_event(&TuiEvent::Resize(size))?;+ assert!(app.handle_owned_transcript_event(+ &mut tui,+ &mut app_server,+ &TuiEvent::Key(KeyEvent::new(KeyCode::Char('<'), KeyModifiers::ALT)),+ )?);+ assert_eq!(+ (render(&mut app, &mut tui)?, app.transcript_view.history),+ (before.clone(), TranscriptHistoryState::LoadingBeginning),+ );+ app.handle_older_history_page(+ &mut tui,+ &mut app_server,+ thread_id,+ &cursor,+ Ok(first_page),+ )+ .await?;+ assert!(app_server.is_older_history_page_pending(thread_id, &final_cursor));+ let final_event = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), event_rx.recv())+ .await?+ .expect("final page completion");+ assert!(matches!(+ &final_event,+ AppEvent::OlderThreadHistoryLoaded { result: Ok(page), .. }+ if page.next_cursor.is_none()+ ));+ // A draw while the completion is waiting must leave the viewport and loading intent intact.+ app.handle_owned_transcript_event(&mut tui, &mut app_server, &TuiEvent::Draw)?;+ assert_eq!(+ (render(&mut app, &mut tui)?, app.transcript_view.history),+ (before, TranscriptHistoryState::LoadingBeginning),+ );+ Box::pin(app.handle_event(&mut tui, &mut app_server, final_event)).await?;+ let final_buffer = render(&mut app, &mut tui)?;+ let visible = final_buffer+ .content()+ .iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>();+ assert!(visible.contains("Oldest prompt"), "visible: {visible}");+ assert_eq!(+ (+ app.transcript_view.history,+ app.transcript_view.is_following(),+ app_server.has_older_history(thread_id),+ ),+ (TranscriptHistoryState::Complete, false, false),+ );+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ proxy.await??;+ }+ Ok(())+}++#[tokio::test]+async fn returning_to_latest_retains_pending_pages_without_continuing_to_the_beginning()+-> Result<()> {+ let (mut app, _codex_home, thread_id) =+ completed_history_app(&["Oldest", "Middle", "Newest"]).await?;+ let (mut app_server, _requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let started = app_server+ .resume_thread(+ &app.local_settings,+ app.config.clone(),+ thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ app.transcript_cells = crate::thread_transcript::thread_items_to_transcript_cells(+ Some(thread_id),+ &app.config.cwd,+ started.turns.iter().flat_map(|turn| turn.items.clone()),+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ Some(&app.config),+ );+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ app.scrollback_has_older_history = app_server.has_older_history(thread_id);+ app.transcript_view.history = TranscriptHistoryState::Partial;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;++ for (limit, expected_history) in [+ (1, TranscriptHistoryState::Partial),+ (100, TranscriptHistoryState::Complete),+ ] {+ app.transcript_view.handle_key(+ KeyEvent::new(KeyCode::Home, KeyModifiers::CONTROL),+ &app.transcript_cells,+ );+ let cursor = app_server+ .begin_older_history_page(thread_id)+ .expect("older page");+ let page = app_server+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ limit,+ )+ .await?;+ let next_cursor = page.next_cursor.clone();+ let before = app.transcript_cells.len();+ app.transcript_view.handle_key(+ KeyEvent::new(KeyCode::End, KeyModifiers::CONTROL),+ &app.transcript_cells,+ );+ app.handle_older_history_page(&mut tui, &mut app_server, thread_id, &cursor, Ok(page))+ .await?;+ assert!(+ app.transcript_cells.len() > before,+ "received history is retained"+ );+ assert_eq!(+ (+ app.transcript_view.history,+ app.transcript_view.is_following()+ ),+ (expected_history, true),+ );+ if let Some(next_cursor) = next_cursor {+ assert!(!app_server.is_older_history_page_pending(thread_id, &next_cursor));+ }+ }+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn stale_history_completions_preserve_the_current_request_and_failure_can_retry() -> Result<()>+{+ let (mut app, _codex_home, thread_id) =+ completed_history_app(&["Oldest", "Middle", "Newest"]).await?;+ let (mut app_server, _requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;+ let started = app_server+ .resume_thread(+ &app.local_settings,+ app.config.clone(),+ thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ app.scrollback_has_older_history = app_server.has_older_history(thread_id);+ app.transcript_view.history = TranscriptHistoryState::LoadingBeginning;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ tui.set_owned_screen(/*owned*/ true)?;+ let cursor = app_server+ .begin_older_history_page(thread_id)+ .expect("older page");+ let page = app_server+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ /*limit*/ 1,+ )+ .await?;+ for result in [Ok(page.clone()), Err("obsolete request failed".to_string())] {+ app.handle_older_history_page(+ &mut tui,+ &mut app_server,+ thread_id,+ "obsolete-cursor",+ result,+ )+ .await?;+ assert_eq!(+ (+ app.transcript_cells.len(),+ app.transcript_view.history,+ app_server.is_older_history_page_pending(thread_id, &cursor),+ ),+ (0, TranscriptHistoryState::LoadingBeginning, true),+ );+ }+ let failure = AppEvent::OlderThreadHistoryLoaded {+ thread_id,+ cursor: cursor.clone(),+ result: Err("current request failed".to_string()),+ };+ Box::pin(app.handle_event(&mut tui, &mut app_server, failure)).await?;+ app.handle_owned_transcript_event(&mut tui, &mut app_server, &TuiEvent::Draw)?;+ assert_eq!(+ (+ app.transcript_view.history,+ app_server.is_older_history_page_pending(thread_id, &cursor),+ ),+ (TranscriptHistoryState::Failed, false),+ );+ assert_eq!(+ app_server.begin_older_history_page(thread_id),+ Some(cursor.clone())+ );+ app_server.cancel_older_history_page(thread_id, "obsolete-cursor");+ assert!(app_server.is_older_history_page_pending(thread_id, &cursor));+ app.transcript_view.history = TranscriptHistoryState::LoadingOlder;+ // Initialize the viewport as the app's first draw does before accepting Find input.+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 1,+ );+ let mut buffer = Buffer::empty(area);+ app.transcript_view+ .render(area, &mut buffer, &app.transcript_cells);+ app.transcript_view+ .jump_to_entry(&app.transcript_cells, /*index*/ 0);+ app.transcript_view.begin_search();+ app.transcript_view.paste_search("Middle answer");+ app.transcript_view.advance_search(&app.transcript_cells);+ let next_cursor = page.next_cursor.clone().expect("another older page");+ app.handle_older_history_page(&mut tui, &mut app_server, thread_id, &cursor, Ok(page))+ .await?;+ assert_eq!(app.transcript_view.history, TranscriptHistoryState::Partial);+ assert!(!app.transcript_cells.is_empty());+ // The received page must be searched before another page can start, even near the top.+ assert!(!app_server.is_older_history_page_pending(thread_id, &next_cursor));+ // Scanning yields after the completion footer before reaching the answer in the same page.+ for _ in 0..8 {+ if !app.transcript_view.advance_search(&app.transcript_cells) {+ break;+ }+ }+ app.transcript_view+ .render(area, &mut buffer, &app.transcript_cells);+ let rendered = buffer+ .content()+ .iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>();+ assert!(rendered.contains("Middle answer"), "rendered: {rendered:?}",);++ assert_eq!(+ app_server.begin_older_history_page(thread_id),+ Some(next_cursor.clone())+ );+ app.handle_older_history_page(+ &mut tui,+ &mut app_server,+ thread_id,+ &cursor,+ Err("previous page failed late".to_string()),+ )+ .await?;+ assert!(app_server.is_older_history_page_pending(thread_id, &next_cursor));+ let history = app.transcript_view.history;+ let cell_count = app.transcript_cells.len();+ app.chat_widget.handle_thread_session(test_thread_session(+ ThreadId::new(),+ app.config.cwd.to_path_buf(),+ ));+ app.handle_older_history_page(+ &mut tui,+ &mut app_server,+ thread_id,+ &next_cursor,+ Err("previous thread failed late".to_string()),+ )+ .await?;+ assert_eq!(+ (+ app.transcript_view.history,+ app.transcript_cells.len(),+ app_server.is_older_history_page_pending(thread_id, &next_cursor),+ ),+ (history, cell_count, false),+ );+ tui.set_owned_screen(/*owned*/ false)?;+ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/safety_buffering.rs b/codex-rs/tui/src/app/tests/safety_buffering.rsindex ddd0a9a33c..22991f1cb5 100644--- a/codex-rs/tui/src/app/tests/safety_buffering.rs+++ b/codex-rs/tui/src/app/tests/safety_buffering.rs@@ -914,7 +914,9 @@ goals = truereturn Ok(());}- drive_until_request_count(&mut app, &mut app_server, &server, expected_request_count).await;+ let retry_thread_id = app.chat_widget.thread_id().expect("retry thread id");+ // Capture the completed retry before processing its automatic goal continuation.+ wait_for_turn_completed(&mut app, &mut app_server, retry_thread_id).await;let mut replayed_history = String::new();while let Ok(event) = app_event_rx.try_recv() {if let AppEvent::InsertHistoryCell(cell) = event {@@ -952,7 +954,7 @@ goals = trueinsta::assert_snapshot!("safety_retry_committed_steer_history", rendered_retry);}- let retry_thread_id = app.chat_widget.thread_id().expect("retry thread id");+ drive_until_request_count(&mut app, &mut app_server, &server, expected_request_count).await;let source = app_server.thread_read(source_thread_id, /*include_turns*/ true).await?;diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__transcript_composer__transcript_flag_off_viewer.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__transcript_composer__transcript_flag_off_viewer.snapindex 00f077b706..a5e84b95ea 100644--- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__transcript_composer__transcript_flag_off_viewer.snap+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__transcript_composer__transcript_flag_off_viewer.snap@@ -13,4 +13,4 @@ expression: buffer_text(&buffer)Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/app/tests/transcript_composer.rs b/codex-rs/tui/src/app/tests/transcript_composer.rsindex 2178d50451..f4aac4d92e 100644--- a/codex-rs/tui/src/app/tests/transcript_composer.rs+++ b/codex-rs/tui/src/app/tests/transcript_composer.rs@@ -268,7 +268,7 @@ async fn transcript_flag_off_preserves_viewer_and_backtracking() -> Result<()> {insta::assert_snapshot!("transcript_flag_off_viewer", buffer_text(&buffer));for (key, selected) in [(KeyCode::Esc, 1),- (KeyCode::Esc, 0),+ (KeyCode::Left, 0),(KeyCode::Right, 1),(KeyCode::Right, 1),] {@@ -296,9 +296,9 @@ async fn transcript_flag_off_preserves_viewer_and_backtracking() -> Result<()> {std::iter::from_fn(|| app_event_rx.try_recv().ok()).any(|event| matches!(event,AppEvent::RevertSessionForPromptEdit {- nth_user_message: 1,+ selected_cell,..- }+ } if Arc::ptr_eq(&selected_cell, &app.transcript_cells[crate::app_backtrack::nth_user_position(&app.transcript_cells, /*nth*/ 1).unwrap()]))));Ok(())diff --git a/codex-rs/tui/src/app/tests/transcript_selection.rs b/codex-rs/tui/src/app/tests/transcript_selection.rsnew file mode 100644index 0000000000..7e32a8f0e8--- /dev/null+++ b/codex-rs/tui/src/app/tests/transcript_selection.rs@@ -0,0 +1,183 @@+//! Selection keys remain inside the overlay while drafts and backtrack previews are pending.++use super::*;+use crate::chatwidget::UserMessage;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn text_selection_temporarily_replaces_the_rendered_backtrack_highlight() -> Result<()> {+ let (mut app, mut events, mut operations) = make_test_app_with_channels().await;+ let mut app_server = start_config_write_test_app_server(&app).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.chat_widget.apply_external_edit("retained draft".into());+ app.chat_widget.handle_key_event(KeyCode::Left.into());+ let draft = app.chat_widget.capture_thread_input_state();+ let prompt = "Selected prompt";+ app.transcript_cells = vec![Arc::new(UserHistoryCell {+ message: prompt.into(),+ text_elements: Vec::new(),+ local_image_paths: Vec::new(),+ remote_image_urls: Vec::new(),+ spoken: false,+ })];+ app.open_transcript_overlay(&mut tui);+ while events.try_recv().is_ok() {}+ while operations.try_recv().is_ok() {}+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyCode::Esc.into()),+ )+ .await?;+ assert!(app.backtrack.overlay_preview_active);+ let preview = (app.backtrack.base_id, app.backtrack.nth_user_message);+ let render = |app: &mut App| {+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 32, /*height*/ 12,+ );+ let mut buffer = Buffer::empty(area);+ // Match the App owner's footer projection before this fixed-size overlay render.+ let footer = app.prompt_navigation_footer(area.width);+ let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {+ panic!("expected transcript overlay");+ };+ overlay.browsing_footer = footer.and_then(|footer| footer.text.lines.into_iter().next());+ overlay.render(area, &mut buffer);+ let highlighted = buffer+ .content+ .iter()+ .filter(|cell| cell.modifier.contains(ratatui::style::Modifier::REVERSED))+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>();+ (buffer, highlighted)+ };+ let (backtrack, highlighted) = render(&mut app);+ assert_eq!(highlighted, prompt);++ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL)),+ )+ .await?;+ let (_, highlighted) = render(&mut app);+ assert_eq!(highlighted, "");+ // The display-only blank before a user message may be the selection's first source row.+ for _ in 0..2 {+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyCode::Right.into()),+ )+ .await?;+ }+ let (_, highlighted) = render(&mut app);+ assert!(!highlighted.is_empty());+ assert!(prompt.starts_with(&highlighted));+ assert!(highlighted.len() < prompt.len());++ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyCode::Esc.into()),+ )+ .await?;+ let (restored, highlighted) = render(&mut app);+ assert_eq!(highlighted, prompt);+ assert_eq!(restored, backtrack);+ assert!(app.backtrack.overlay_preview_active);+ assert_eq!(+ (app.backtrack.base_id, app.backtrack.nth_user_message),+ preview+ );+ assert_eq!(app.chat_widget.capture_thread_input_state(), draft);+ assert!(operations.try_recv().is_err());+ assert!(events.try_recv().is_err());+ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn offline_selection_reserves_keys_and_preserves_draft_and_backtrack_state() -> Result<()> {+ let (mut app, mut events, mut operations) = make_test_app_with_channels().await;+ let mut app_server = start_config_write_test_app_server(&app).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.keymap = RuntimeKeymap::from_config(&toml::from_str(+ "[pager]\nclose = 'ctrl-c x'\npage_up = 'ctrl-x p'\n",+ )?)+ .unwrap();+ app.chat_widget+ .restore_user_message_to_composer(UserMessage {+ text: "draft prompt".to_owned(),+ local_images: Vec::new(),+ remote_image_urls: vec!["https://example.com/draft.png".to_owned()],+ text_elements: Vec::new(),+ mention_bindings: Vec::new(),+ });+ app.chat_widget.handle_key_event(KeyCode::Left.into());+ let draft = app.chat_widget.capture_thread_input_state();+ app.transcript_cells = vec![plain_line_cell("selected text")];+ app.open_transcript_overlay(&mut tui);+ let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {+ panic!("transcript overlay");+ };+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 12,+ );+ overlay.render(area, &mut Buffer::empty(area));+ app.backtrack.overlay_preview_active = true;+ app.backtrack.nth_user_message = 3;+ while events.try_recv().is_ok() {}+ while operations.try_recv().is_ok() {}++ assert_eq!(+ app.route_key_chord_event(+ &mut tui,+ KeyEvent::new(KeyCode::Char('x'), KeyModifiers::CONTROL),+ ),+ None,+ );+ assert!(app.key_chord_matcher.is_pending());+ app.reconnect.offline = true;+ for key in [+ KeyEvent::new(KeyCode::Char(' '), KeyModifiers::CONTROL),+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ KeyCode::Enter.into(),+ KeyCode::Right.into(),+ KeyCode::Left.into(),+ KeyCode::Esc.into(),+ ] {+ assert!(matches!(+ app.handle_tui_event(&mut tui, &mut app_server, TuiEvent::Key(key))+ .await?,+ AppRunControl::Continue,+ ));+ assert!(app.overlay.is_some());+ assert!(!app.key_chord_matcher.is_pending());+ assert_eq!(app.chat_widget.capture_thread_input_state(), draft);+ assert_eq!(app.backtrack.nth_user_message, 3);+ assert!(app.backtrack.overlay_preview_active);+ assert!(operations.try_recv().is_err());+ assert!(events.try_recv().is_err());+ }+ let Some(Overlay::Transcript(overlay)) = app.overlay.as_ref() else {+ panic!("transcript overlay");+ };+ assert!(!overlay.has_active_interaction());+ app.chat_widget.insert_str("!");+ assert_eq!(+ app.chat_widget.composer_text_with_pending(),+ "draft promp!t"+ );+ assert!(matches!(+ app.handle_tui_event(+ &mut tui,+ &mut app_server,+ TuiEvent::Key(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)),+ )+ .await?,+ AppRunControl::Exit(ExitReason::UserRequested),+ ));+ app_server.shutdown().await?;+ Ok(())+}diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rsindex 379d6be171..67a7261128 100644--- a/codex-rs/tui/src/app_backtrack.rs+++ b/codex-rs/tui/src/app_backtrack.rs@@ -1,4 +1,4 @@-//! Backtracking and transcript overlay event routing.+//! Backtracking and detailed transcript event routing.//!//! This file owns backtrack mode (Esc/Enter navigation in the transcript overlay) and also//! mediates a key rendering boundary for the transcript overlay.@@ -9,19 +9,21 @@//!//! Backtrack operates as a small state machine://! - The first `Esc` in the main view "primes" the feature and captures a base thread id.-//! - A subsequent `Esc` opens the transcript overlay (`Ctrl+T`) and highlights a user message when-//! there is a prompt to reuse.+//! - A subsequent `Esc` starts compact transcript browsing and highlights the latest user prompt.+//! - Left/Right choose prompts, Ctrl+T toggles details, and Esc restores the browsing origin.//! - `Enter` requests a revert before the selected prompt and reopens it for editing.//!-//! The transcript overlay (`Ctrl+T`) renders committed transcript cells plus a render-only live-//! tail derived from the current in-flight `ChatWidget.active_cell`.+//! Owned sessions use the shared transcript viewport for `Ctrl+T`; inline sessions retain the+//! overlay. Both render committed cells and a live tail from the current `ChatWidget.active_cell`.//!//! That live tail is kept in sync during `TuiEvent::Draw` handling for `Overlay::Transcript` by//! asking `ChatWidget` for an active-cell cache key and transcript lines and by passing them into//! `TranscriptOverlay::sync_live_tail`. This preserves the invariant that the overlay reflects//! both committed history and in-flight activity without changing flush or coalescing behavior.+mod browsing;mod legacy_input;+mod prompt_navigation;use std::any::TypeId;use std::sync::Arc;@@ -37,6 +39,7 @@ use crate::chatwidget::mention_bindings_from_user_inputs;use crate::history_cell::AgentMessageCell;use crate::history_cell::SessionInfoCell;use crate::history_cell::UserHistoryCell;+use crate::history_cell::sanitize_user_text;use crate::pager_overlay::Overlay;use crate::pager_overlay::TranscriptHistoryState;use crate::tui;@@ -72,6 +75,7 @@ pub(crate) struct BacktrackState {pub(crate) nth_user_message: usize,/// True when the transcript overlay is showing a backtrack preview.pub(crate) overlay_preview_active: bool,+ origin: Option<browsing::BrowsingOrigin>,}/// A user-visible backtrack choice that can be reopened in the current thread.@@ -86,7 +90,7 @@ pub(crate) struct BacktrackSelection {impl App {/// Route overlay events, reserving backtracking for the transcript overlay.///- /// If backtrack preview is active, Esc / Left steps selection, Right steps forward, Enter+ /// If browsing is active, Left/Right steps selection, Esc cancels, and Enter/// confirms. Otherwise, Esc begins preview mode and all other events are forwarded to the/// overlay.pub(crate) async fn handle_backtrack_overlay_event(@@ -109,11 +113,10 @@ impl App {}if !self.backtrack.primed {+ self.remember_browsing_origin(tui);self.prime_backtrack();} else if self.overlay.is_none() {self.open_backtrack_preview(tui);- } else if self.backtrack.overlay_preview_active {- self.step_backtrack_and_highlight(tui);}}@@ -130,10 +133,14 @@ impl App {return;}+ let Some(index) = nth_user_position(&self.transcript_cells, selection.nth_user_message)+ else {+ return;+ };self.app_event_tx.send(AppEvent::RevertSessionForPromptEdit {thread_id: selection.thread_id,- nth_user_message: selection.nth_user_message,+ selected_cell: Arc::clone(&self.transcript_cells[index]),prompt: selection.prompt,});}@@ -148,7 +155,7 @@ impl App {.add_error_message(format!("Failed to edit the selected prompt: {err:#}"));}- /// Open transcript overlay (enters alternate screen and shows full transcript).+ /// Show detailed history in the owned viewport or the inline session's transcript overlay.pub(crate) fn open_transcript_overlay(&mut self, tui: &mut tui::Tui) {if tui.is_owned_screen() {self.transcript_view.set_presentation(@@ -221,7 +228,7 @@ impl App {/// Open overlay and begin backtrack preview flow (first step + highlight).fn open_backtrack_preview(&mut self, tui: &mut tui::Tui) {- if !has_backtrack_target(&self.transcript_cells) {+ if !has_backtrack_target(&self.transcript_cells) && !self.scrollback_has_older_history {self.reset_backtrack_state();self.chat_widget.add_info_message(NO_PREVIOUS_MESSAGE_TO_EDIT.to_string(), /*hint*/ None);@@ -231,14 +238,15 @@ impl App {self.open_transcript_overlay(tui);self.backtrack.overlay_preview_active = true;- // Composer is hidden by overlay; clear its hint.+ self.set_browsing_details(/*detailed*/ false);+ // The selected prompt now supplies the backtrack context instead of the composer hint.self.chat_widget.clear_esc_backtrack_hint();self.step_backtrack_and_highlight(tui);}/// When overlay is already open, begin preview mode and select latest user message.fn begin_overlay_backtrack_preview(&mut self, tui: &mut tui::Tui) {- if !has_backtrack_target(&self.transcript_cells) {+ if !has_backtrack_target(&self.transcript_cells) && !self.scrollback_has_older_history {self.close_transcript_overlay(tui);self.chat_widget.add_info_message(NO_PREVIOUS_MESSAGE_TO_EDIT.to_string(), /*hint*/ None);@@ -246,9 +254,12 @@ impl App {return;}+ self.remember_browsing_origin(tui);+ self.backtrack.nth_user_message = usize::MAX;self.backtrack.primed = true;self.backtrack.base_id = self.chat_widget.thread_id();self.backtrack.overlay_preview_active = true;+ self.set_browsing_details(/*detailed*/ false);let count = user_count(&self.transcript_cells);if let Some(last) = count.checked_sub(1) {self.apply_backtrack_selection_internal(last);@@ -307,11 +318,17 @@ impl App {if let Some(Overlay::Transcript(t)) = &mut self.overlay {t.set_highlight_cell(Some(cell_idx));}+ if self.overlay.is_none() {+ self.transcript_view.set_highlight(Some(cell_idx));+ self.transcript_view+ .ensure_entry_visible(&self.transcript_cells, cell_idx);+ }} else {self.backtrack.nth_user_message = usize::MAX;if let Some(Overlay::Transcript(t)) = &mut self.overlay {t.set_highlight_cell(/*cell*/ None);}+ self.transcript_view.set_highlight(/*index*/ None);}}@@ -329,6 +346,12 @@ impl App {/// source of truth for the active cell and its cache invalidation key, and because `App` owns/// overlay lifecycle and frame scheduling for animations.fn overlay_forward_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {+ let width = tui.terminal.last_known_screen_size.width.max(/*other*/ 1);+ let footer = self.prompt_navigation_footer(width.saturating_sub(/*rhs*/ 2));+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.browsing_footer =+ footer.and_then(|footer| footer.text.lines.into_iter().next());+ }let input = matches!(&event, TuiEvent::Key(key) if key.kind != KeyEventKind::Release)|| matches!(&event, TuiEvent::Mouse(mouse) if mouse.kind != crossterm::event::MouseEventKind::Moved);if (input@@ -338,22 +361,33 @@ impl App {))&& let Some(Overlay::Transcript(t)) = &mut self.overlay{- let active_key = self.chat_widget.active_cell_transcript_key();- let chat_widget = &self.chat_widget;tui.set_overlay_input(tui::OverlayInput::Transcript)?;t.motion = crate::motion::MotionMode::from_animations_enabled(self.local_settings.tui.animations,);+ let active_key = self.chat_widget.active_cell_transcript_key();+ let chat_widget = &self.chat_widget;+ let detailed = t.is_detailed();let size = tui.prepare_draw_size()?;t.sync_live_tail(size.width.max(/*other*/ 1), active_key, |width| {- chat_widget.active_cell_transcript_hyperlink_lines(width)+ if detailed {+ chat_widget.active_cell_transcript_hyperlink_lines(width)+ } else {+ chat_widget+ .active_cell_owned_transcript_lines(width, /*expanded*/ false)+ .map(|mut lines| {+ lines.activity.extend(lines.auxiliary);+ lines.activity+ })+ }});- // Selection must capture the same committed cells and live tail that were painted.- let result = if input { t.draw(tui) } else { Ok(()) };- if let Err(error) = result.and_then(|()| t.handle_event(tui, event)) {+ // Refresh visible rows before selection captures this live revision.+ let result =+ if input { t.draw(tui) } else { Ok(()) }.and_then(|()| t.handle_event(tui, event));+ if result.is_err() {let _ = tui.set_overlay_input(tui::OverlayInput::Default);- return Err(error.into());}+ result?;let close_overlay = t.is_done();if !close_overlay&& active_key.is_some_and(|key| key.animation_tick.is_some())@@ -382,36 +416,12 @@ impl App {/// Handle Enter in overlay backtrack preview: confirm selection and reset state.fn overlay_confirm_backtrack(&mut self, tui: &mut tui::Tui) {let nth_user_message = self.backtrack.nth_user_message;- let selection = self.backtrack_selection(nth_user_message);+ let Some(selection) = self.backtrack_selection(nth_user_message) else {+ return;+ };self.close_transcript_overlay(tui);- if let Some(selection) = selection {- self.apply_backtrack_selection(selection);- tui.frame_requester().schedule_frame();- }- }-- /// Handle Esc in overlay backtrack preview: step selection if armed, else forward.- fn overlay_step_backtrack(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {- if self.backtrack.base_id.is_some() {- self.step_backtrack_and_highlight(tui);- } else {- self.overlay_forward_event(tui, event)?;- }- Ok(())- }-- /// Handle Right in overlay backtrack preview: step selection forward if armed, else forward.- fn overlay_step_backtrack_forward(- &mut self,- tui: &mut tui::Tui,- event: TuiEvent,- ) -> Result<()> {- if self.backtrack.base_id.is_some() {- self.step_forward_backtrack_and_highlight(tui);- } else {- self.overlay_forward_event(tui, event)?;- }- Ok(())+ self.apply_backtrack_selection(selection);+ tui.frame_requester().schedule_frame();}/// Confirm a primed backtrack from the main view (no overlay visible).@@ -424,9 +434,12 @@ impl App {/// Clear all backtrack-related state and composer hints.pub(crate) fn reset_backtrack_state(&mut self) {+ self.backtrack.origin = None;self.backtrack.primed = false;+ self.backtrack.overlay_preview_active = false;self.backtrack.base_id = None;self.backtrack.nth_user_message = usize::MAX;+ self.transcript_view.set_highlight(/*index*/ None);// In case a hint is somehow still visible (e.g., race with overlay open/close).self.chat_widget.clear_esc_backtrack_hint();}@@ -547,7 +560,9 @@ pub(crate) fn backtrack_revert_before_turn_id(if hidden_nested_review_turn {continue;}- if display.message.trim().is_empty()+ if sanitize_user_text((&display.message).into())+ .trim()+ .is_empty()&& display.text_elements.is_empty()&& display.local_images.is_empty()&& display.remote_image_urls.is_empty()@@ -636,7 +651,6 @@ fn user_positions_iter(cells: &[Arc<dyn crate::history_cell::HistoryCell>],) -> impl Iterator<Item = usize> + '_ {let session_start_type = TypeId::of::<SessionInfoCell>();- let user_type = TypeId::of::<UserHistoryCell>();let type_of = |cell: &Arc<dyn crate::history_cell::HistoryCell>| cell.as_any().type_id();let start = cells@@ -648,7 +662,10 @@ fn user_positions_iter(.iter().enumerate().skip(start)- .filter_map(move |(idx, cell)| (type_of(cell) == user_type).then_some(idx))+ .filter_map(|(idx, cell)| {+ let user = cell.as_any().downcast_ref::<UserHistoryCell>()?;+ user.has_visible_content().then_some(idx)+ })}#[cfg(test)]@@ -737,7 +754,16 @@ mod tests {#[test]fn backtrack_revert_before_turn_id_resolves_first_and_later_prompts() {+ let mut hidden = turn("hidden", TurnStatus::Completed, /*user_messages*/ 1);+ let ThreadItem::UserMessage { content, .. } = &mut hidden.items[0] else {+ unreachable!()+ };+ *content = vec![UserInput::Text {+ text: "\u{0007}".into(),+ text_elements: Vec::new(),+ }];let turns = vec![+ hidden,turn("turn-1", TurnStatus::Completed, /*user_messages*/ 1),turn("turn-compaction",diff --git a/codex-rs/tui/src/app_backtrack/browsing.rs b/codex-rs/tui/src/app_backtrack/browsing.rsnew file mode 100644index 0000000000..dfef981169--- /dev/null+++ b/codex-rs/tui/src/app_backtrack/browsing.rs@@ -0,0 +1,96 @@+//! Browsing lifecycle: retain the origin, load earlier prompts, and cancel without rewinding.++use super::*;+use crate::transcript_view::TranscriptBookmark;++pub(super) enum BrowsingOrigin {+ Owned(TranscriptBookmark),+ Overlay(TranscriptBookmark),+ Inline,+}++impl App {+ /// A page can start inside an answer, leaving its oldest prompt far from the viewport edge.+ pub(crate) fn browsing_needs_history(&self) -> bool {+ self.backtrack.overlay_preview_active+ && matches!(self.backtrack.nth_user_message, 0 | usize::MAX)+ && match &self.overlay {+ Some(Overlay::Transcript(overlay)) => !overlay.has_active_interaction(),+ _ => !self.transcript_view.has_active_interaction(),+ }+ }++ pub(crate) fn cancel_primed_browsing_for_event(&mut self, event: &TuiEvent) {+ let interrupts_escape_pair = match event {+ TuiEvent::Key(key) => key.code != KeyCode::Esc && key.kind != KeyEventKind::Release,+ TuiEvent::Mouse(mouse) => mouse.kind != crossterm::event::MouseEventKind::Moved,+ TuiEvent::Paste(text) => !text.is_empty(),+ TuiEvent::Draw+ | TuiEvent::Resume+ | TuiEvent::Resize(_)+ | TuiEvent::FocusGained+ | TuiEvent::FocusLost => false,+ };+ if self.backtrack.primed+ && !self.backtrack.overlay_preview_active+ && self.backtrack.nth_user_message == usize::MAX+ && interrupts_escape_pair+ {+ self.reset_backtrack_state();+ }+ }++ pub(super) fn remember_browsing_origin(&mut self, tui: &tui::Tui) {+ if self.backtrack.origin.is_some() {+ return;+ }+ self.backtrack.origin = Some(match &mut self.overlay {+ Some(Overlay::Transcript(overlay)) => BrowsingOrigin::Overlay(overlay.bookmark()),+ _ if tui.is_owned_screen() => {+ BrowsingOrigin::Owned(self.transcript_view.bookmark(&self.transcript_cells))+ }+ _ => BrowsingOrigin::Inline,+ });+ }++ pub(crate) fn cancel_transcript_browsing(&mut self, tui: &mut tui::Tui) {+ let origin = self.backtrack.origin.take();+ self.reset_backtrack_state();+ match origin {+ Some(BrowsingOrigin::Owned(bookmark)) => {+ self.transcript_view.restore_bookmark(bookmark);+ }+ Some(BrowsingOrigin::Overlay(bookmark)) => {+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.restore_bookmark(bookmark);+ }+ }+ Some(BrowsingOrigin::Inline) => self.close_transcript_overlay(tui),+ None => {}+ }+ tui.frame_requester().schedule_frame();+ }++ pub(super) fn set_browsing_details(&mut self, detailed: bool) {+ let mode = self.chat_widget.history_render_mode();+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.set_presentation(detailed, mode);+ } else {+ self.transcript_view.set_presentation(detailed, mode);+ if let Some(index) =+ nth_user_position(&self.transcript_cells, self.backtrack.nth_user_message)+ {+ self.transcript_view+ .jump_to_entry(&self.transcript_cells, index);+ }+ }+ self.apply_backtrack_selection_internal(self.backtrack.nth_user_message);+ }++ pub(super) fn browsing_details(&self) -> bool {+ match &self.overlay {+ Some(Overlay::Transcript(overlay)) => overlay.is_detailed(),+ _ => self.transcript_view.is_detailed(),+ }+ }+}diff --git a/codex-rs/tui/src/app_backtrack/legacy_input.rs b/codex-rs/tui/src/app_backtrack/legacy_input.rsindex f508578499..dcd567de7d 100644--- a/codex-rs/tui/src/app_backtrack/legacy_input.rs+++ b/codex-rs/tui/src/app_backtrack/legacy_input.rs@@ -1,46 +1,69 @@-//! Input routing for the read-only transcript viewer.+//! Input routing for detailed transcripts in owned and inline sessions.//!//! Preview selection is shared with the interactive transcript path so both-//! modes retain the same prompt navigation and confirmation behavior.+//! modes retain the same prompt navigation and confirmation behavior. Owned+//! preview entry respects active work and modal input owners.use super::*;+use crate::key_hint::KeyBindingListExt;+use crate::keymap::KeymapContext;+use crate::keymap::bindings_for_action;+use crate::keymap::keymap_action_ids;+use crossterm::event::KeyModifiers;impl App {- fn request_legacy_transcript_history(+ /// Reuse prompt selection without forwarding draws to the inline transcript overlay.+ pub(crate) fn handle_owned_backtrack_event(&mut self,tui: &mut tui::Tui,- app_server: &mut AppServerSession,- request: Option<TranscriptHistoryState>,- ) {- if let Some(state) = request- && let Some(thread_id) = self.chat_widget.thread_id()- && app_server.has_older_history(thread_id)- && self.request_older_history_page(app_server, thread_id)- && let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut()- {- overlay.set_history_state(state);- tui.frame_requester().schedule_frame();+ event: &TuiEvent,+ ) -> Result<bool> {+ if !tui.is_owned_screen() || self.overlay.is_some() {+ return Ok(false);}- }-- fn legacy_history_key_request(&mut self, event: &TuiEvent) -> Option<TranscriptHistoryState> {- let (TuiEvent::Key(key), Some(Overlay::Transcript(overlay))) = (event, &mut self.overlay)- else {- return None;+ let TuiEvent::Key(key) = event else {+ return Ok(false);};- if overlay.has_active_interaction() {- return None;+ if !matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat) {+ return Ok(false);}- if overlay.should_load_from_start(*key) {- return Some(TranscriptHistoryState::LoadingBeginning);+ if self.backtrack.overlay_preview_active {+ if self.handle_backtrack_preview_key(tui, *key) {+ return Ok(true);+ }+ if self.keymap.pager.find.is_pressed(*key) {+ self.transcript_view.begin_search();+ } else if self.keymap.pager.close.is_pressed(*key)+ || self.keymap.pager.close_transcript.is_pressed(*key)+ {+ self.close_transcript_overlay(tui);+ } else if !self.transcript_view.navigate_pager(+ *key,+ &self.transcript_cells,+ &self.keymap.pager,+ ) {+ return Ok(false);+ }+ tui.frame_requester().schedule_frame();+ return Ok(true);}- let older_prompt = self.backtrack.overlay_preview_active- && self.backtrack.nth_user_message == 0- && matches!(key.code, KeyCode::Esc | KeyCode::Left)- && key.modifiers.is_empty()- && matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat);- (older_prompt || overlay.should_load_older(*key))- .then_some(TranscriptHistoryState::LoadingOlder)+ if !self.transcript_view.is_detailed() {+ return Ok(false);+ }+ if self.keymap.pager.close_transcript.is_pressed(*key) {+ if !self.transcript_view.has_active_interaction() {+ self.close_transcript_overlay(tui);+ }+ return Ok(true);+ }+ if key.code == KeyCode::Esc+ && key.kind == KeyEventKind::Press+ && self.should_handle_backtrack_esc(*key)+ {+ self.begin_overlay_backtrack_preview(tui);+ return Ok(true);+ }+ Ok(false)}pub(super) fn handle_legacy_transcript_event(@@ -62,7 +85,7 @@ impl App {let explicit_input = matches!(event, TuiEvent::Key(_))|| matches!(&event, TuiEvent::Mouse(mouse) if mouse.kind != crossterm::event::MouseEventKind::Moved);let interaction_active = matches!(&self.overlay, Some(Overlay::Transcript(overlay)) if overlay.has_active_interaction());- if interaction_active || self.is_offline() {+ if interaction_active || (self.is_offline() && !self.backtrack.overlay_preview_active) {self.overlay_forward_event(tui, event)?;} else if self.backtrack.overlay_preview_active {self.handle_backtrack_preview_event(tui, event)?;@@ -76,12 +99,15 @@ impl App {event => self.overlay_forward_event(tui, event)?,}}+ let browsing_needs_history = self.browsing_needs_history();let request = request.or_else(|| {let Some(Overlay::Transcript(overlay)) = &mut self.overlay else {return None;};let state = overlay.history_state();- if (overlay.needs_history() || state == TranscriptHistoryState::LoadingBeginning)+ if (browsing_needs_history+ || overlay.needs_history()+ || state == TranscriptHistoryState::LoadingBeginning)&& (explicit_input || state != TranscriptHistoryState::Failed){Some(if state == TranscriptHistoryState::LoadingBeginning {@@ -97,29 +123,122 @@ impl App {Ok(true)}+ fn legacy_history_key_request(&mut self, event: &TuiEvent) -> Option<TranscriptHistoryState> {+ let (TuiEvent::Key(key), Some(Overlay::Transcript(overlay))) = (event, &mut self.overlay)+ else {+ return None;+ };+ if overlay.has_active_interaction() {+ return None;+ }+ if overlay.should_load_from_start(*key) {+ return Some(TranscriptHistoryState::LoadingBeginning);+ }+ overlay+ .should_load_older(*key)+ .then_some(TranscriptHistoryState::LoadingOlder)+ }++ fn request_legacy_transcript_history(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ request: Option<TranscriptHistoryState>,+ ) {+ if let Some(state) = request+ && let Some(thread_id) = self.chat_widget.thread_id()+ && app_server.has_older_history(thread_id)+ && self.request_older_history_page(app_server, thread_id)+ && let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut()+ {+ overlay.set_history_state(state);+ tui.frame_requester().schedule_frame();+ }+ }+pub(super) fn handle_backtrack_preview_event(&mut self,tui: &mut tui::Tui,event: TuiEvent,) -> Result<bool> {- match event {- TuiEvent::Key(KeyEvent {- code: KeyCode::Esc | KeyCode::Left,- kind: KeyEventKind::Press | KeyEventKind::Repeat,- ..- }) => self.overlay_step_backtrack(tui, event)?,- TuiEvent::Key(KeyEvent {- code: KeyCode::Right,- kind: KeyEventKind::Press | KeyEventKind::Repeat,- ..- }) => self.overlay_step_backtrack_forward(tui, event)?,- TuiEvent::Key(KeyEvent {- code: KeyCode::Enter,- kind: KeyEventKind::Press,- ..- }) => self.overlay_confirm_backtrack(tui),- event => self.overlay_forward_event(tui, event)?,+ if let TuiEvent::Key(key) = &event+ && self.handle_backtrack_preview_key(tui, *key)+ {+ return Ok(true);}+ self.overlay_forward_event(tui, event)?;Ok(true)}++ fn handle_backtrack_preview_key(&mut self, tui: &mut tui::Tui, key: KeyEvent) -> bool {+ if !matches!(key.kind, KeyEventKind::Press | KeyEventKind::Repeat) {+ return false;+ }+ if self.keymap.app.open_transcript.is_pressed(key) {+ if key.kind == KeyEventKind::Press {+ self.set_browsing_details(!self.browsing_details());+ tui.frame_requester().schedule_frame();+ }+ return true;+ }+ if key.modifiers != KeyModifiers::NONE {+ return false;+ }+ if matches!(+ key.code,+ KeyCode::Up | KeyCode::Down | KeyCode::Char('h' | 'j' | 'k' | 'l')+ ) && keymap_action_ids()+ .filter(|action| action.context == KeymapContext::Pager)+ .any(|action| {+ bindings_for_action(&self.keymap, "pager", action.action)+ .is_some_and(|bindings| bindings.is_pressed(key))+ })+ {+ return false;+ }+ match (key.code, key.kind) {+ (KeyCode::Enter, KeyEventKind::Press) if self.backtrack.base_id.is_some() => {+ if !self.is_offline() {+ self.overlay_confirm_backtrack(tui);+ }+ }+ (KeyCode::Esc, KeyEventKind::Press) => {+ self.cancel_transcript_browsing(tui);+ }+ (+ code @ (KeyCode::Left | KeyCode::Right | KeyCode::Char('h' | 'l')),+ KeyEventKind::Press | KeyEventKind::Repeat,+ ) if self.backtrack.base_id.is_some() => {+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.cancel_pending_jump();+ } else {+ self.transcript_view.cancel_beginning();+ }+ if matches!(code, KeyCode::Left | KeyCode::Char('h')) {+ self.step_backtrack_and_highlight(tui);+ } else {+ self.step_forward_backtrack_and_highlight(tui);+ }+ }+ (+ code @ (KeyCode::Up | KeyCode::Down | KeyCode::Char('j' | 'k')),+ KeyEventKind::Press | KeyEventKind::Repeat,+ ) => {+ let rows = if matches!(code, KeyCode::Up | KeyCode::Char('k')) {+ -1+ } else {+ 1+ };+ if let Some(Overlay::Transcript(overlay)) = &mut self.overlay {+ overlay.scroll(rows);+ } else {+ self.transcript_view.scroll(&self.transcript_cells, rows);+ }+ tui.frame_requester().schedule_frame();+ }+ (KeyCode::Esc | KeyCode::Enter, KeyEventKind::Repeat) => {}+ _ => return false,+ }+ true+ }}diff --git a/codex-rs/tui/src/app_backtrack/prompt_navigation.rs b/codex-rs/tui/src/app_backtrack/prompt_navigation.rsnew file mode 100644index 0000000000..ea8a195eed--- /dev/null+++ b/codex-rs/tui/src/app_backtrack/prompt_navigation.rs@@ -0,0 +1,71 @@+//! A persistent mode label and responsive hints, using the configured action for details.++use super::*;+use crate::bottom_pane::TranscriptFooter;+use crate::footer_hint::first_fitting_line;+use ratatui::style::Stylize;+use ratatui::text::Line;++impl App {+ pub(crate) fn prompt_navigation_footer(&self, width: u16) -> Option<TranscriptFooter> {+ if !self.backtrack.overlay_preview_active+ || (self.overlay.is_none()+ && (self.transcript_view.has_active_interaction()+ || self.transcript_view.history == TranscriptHistoryState::Failed))+ {+ return None;+ }+ let details = self+ .keymap+ .primary_hint(crate::keymap::KeymapContext::Global, "open_transcript")+ .map(|key| (key.display_label(), "details"));+ let mut full_hints = vec![+ ("↑↓/jk".to_string(), "scroll"),+ ("←→/hl".to_string(), "prompts"),+ ];+ full_hints.extend(details.clone());+ full_hints.extend([("↵".to_string(), "rewind"), ("esc".to_string(), "back")]);+ let mut compact_hints = vec![("↑↓/jk ←→/hl".to_string(), "")];+ compact_hints.extend(details);+ compact_hints.extend([("↵".to_string(), "rewind"), ("esc".to_string(), "back")]);+ let line = first_fitting_line(+ [+ ("Browsing transcript", full_hints.clone()),+ ("Browsing", full_hints),+ ("Browsing", compact_hints),+ (+ "Browsing",+ vec![+ ("↑↓/jk ←→/hl".to_string(), ""),+ ("↵".to_string(), "rewind"),+ ("esc".to_string(), ""),+ ],+ ),+ (+ "Browsing",+ vec![("↵".to_string(), "rewind"), ("esc".to_string(), "back")],+ ),+ ("Browsing", vec![("esc".to_string(), "back")]),+ ("Browsing", vec![("esc".to_string(), "")]),+ ("Browsing", Vec::new()),+ ]+ .map(|(label, hints)| {+ let mut line = Line::from(label.fg(crate::style::accent_color()));+ for (keys, action) in hints {+ line.spans.push(" · ".dim());+ line.spans.extend(crate::key_hint::key_label_spans(&keys));+ if !action.is_empty() {+ line.spans.push(format!(" {action}").dim());+ }+ }+ line+ }),+ width,+ );+ Some(TranscriptFooter {+ text: line.into(),+ cursor_column: None,+ is_interactive: true,+ })+ }+}diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex e4529c4d65..c78c7b87bf 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -574,10 +574,10 @@ pub(crate) enum AppEvent {name: Option<String>,},- /// Branch before a selected prompt and reopen it in the new thread's composer.+ /// Revert before a selected prompt, retaining its identity across queued history pages.RevertSessionForPromptEdit {thread_id: ThreadId,- nth_user_message: usize,+ selected_cell: Arc<dyn HistoryCell>,prompt: UserMessage,},FinishPromptRevert {diff --git a/codex-rs/tui/src/app_server_session/history.rs b/codex-rs/tui/src/app_server_session/history.rsindex 0137c55d34..1668111ee1 100644--- a/codex-rs/tui/src/app_server_session/history.rs+++ b/codex-rs/tui/src/app_server_session/history.rs@@ -5,6 +5,7 @@ use std::collections::HashSet;use super::AppServerSession;use crate::history_cell::HistoryRenderMode;use crate::legacy_core::config::Config;+use crate::local_settings::LocalSettings;use crate::resize_reflow_cap::resize_reflow_max_rows;use crate::thread_transcript::RawReasoningVisibility;use crate::thread_transcript::thread_items_to_transcript_cells;@@ -36,6 +37,67 @@ pub(crate) enum HistoryHydrationScope<'a> {ThroughTurn(&'a str),}+/// Limits initial hydration independently from the number of items retained by later paging.+struct HistoryLoadBudget {+ rows: Option<usize>,+ items: Option<usize>,+}++impl HistoryLoadBudget {+ fn new(+ scope: HistoryHydrationScope<'_>,+ config: Option<&Config>,+ local_settings: Option<&crate::local_settings::LocalSettings>,+ terminal_height: u16,+ ) -> Self {+ let transcript_mode = local_settings+ .map(|settings| settings.transcript_mode)+ .or_else(|| config.map(|config| LocalSettings::from(config).transcript_mode));+ if scope == HistoryHydrationScope::Initial+ && transcript_mode.is_some_and(crate::transcript_mode::TranscriptMode::is_owned)+ {+ // A few screenfuls cover the first viewport and nearby reading without coupling+ // owned history to terminal scrollback settings, including unlimited scrollback.+ return Self {+ rows: Some(usize::from(terminal_height.max(/*other*/ 1)) * 3),+ items: Some(HISTORY_ITEM_SCAN_LIMIT),+ };+ }+ let rows = local_settings+ .and_then(|settings| resize_reflow_max_rows(settings.terminal_resize_reflow()));+ let items = match (scope, config, rows) {+ (HistoryHydrationScope::Complete, _, _)+ | (HistoryHydrationScope::ThroughTurn(_), _, _)+ | (HistoryHydrationScope::Initial, Some(_), None) => None,+ (HistoryHydrationScope::Initial, Some(_), Some(max_rows)) => {+ Some(max_rows.saturating_add(HISTORY_ITEM_SCAN_LIMIT))+ }+ (HistoryHydrationScope::Initial, None, _) => Some(HISTORY_ITEM_PAGE_LIMIT as usize),+ };+ Self { rows, items }+ }++ fn next_page_size(&self, rendered_rows: usize, scanned_items: usize) -> Option<u32> {+ let remaining_rows = self.rows.map(|budget| budget.saturating_sub(rendered_rows));+ let remaining_items = self+ .items+ .map(|budget| budget.saturating_sub(scanned_items));+ if remaining_rows == Some(0) || remaining_items == Some(0) {+ return None;+ }+ let limit = remaining_items+ .unwrap_or(HISTORY_ITEM_PAGE_LIMIT as usize)+ .min(HISTORY_ITEM_PAGE_LIMIT as usize);+ // After the first page, hidden items must not reduce requests to one item.+ let limit = if scanned_items != 0 {+ limit+ } else {+ limit.min(remaining_rows.unwrap_or(limit))+ };+ Some(limit as u32)+ }+}+pub(crate) fn thread_items_page_params(thread_id: ThreadId,turn_id: Option<&str>,@@ -286,36 +348,12 @@ impl AppServerSession {next_item_cursor: item_cursor,..ThreadHistoryPagination::default()};- let width = crossterm::terminal::size()- .map(|(width, _)| width.max(/*other*/ 1))- .unwrap_or(/*default*/ 80);- let row_budget = local_settings- .and_then(|settings| resize_reflow_max_rows(settings.terminal_resize_reflow()));- let item_budget = match (scope, config, row_budget) {- (HistoryHydrationScope::Complete, _, _)- | (HistoryHydrationScope::ThroughTurn(_), _, _)- | (HistoryHydrationScope::Initial, Some(_), None) => None,- (HistoryHydrationScope::Initial, Some(_), Some(max_rows)) => {- Some(max_rows.saturating_add(HISTORY_ITEM_SCAN_LIMIT))- }- (HistoryHydrationScope::Initial, None, _) => Some(HISTORY_ITEM_PAGE_LIMIT as usize),- };+ let (width, height) = crossterm::terminal::size().unwrap_or(/*default*/ (80, 24));+ let width = width.max(/*other*/ 1);+ let budget = HistoryLoadBudget::new(scope, config, local_settings, height);let mut scanned_items = 0;let mut rendered_rows = 0;- loop {- let remaining_rows = row_budget.map(|budget| budget.saturating_sub(rendered_rows));- let remaining_items = item_budget.map(|budget| budget.saturating_sub(scanned_items));- if remaining_rows == Some(0) || remaining_items == Some(0) {- break;- }- let limit = remaining_items- .unwrap_or(HISTORY_ITEM_PAGE_LIMIT as usize)- .min(HISTORY_ITEM_PAGE_LIMIT as usize);- let limit = if rendered_rows == 0 && scanned_items != 0 {- limit- } else {- limit.min(remaining_rows.unwrap_or(limit))- } as u32;+ while let Some(limit) = budget.next_page_size(rendered_rows, scanned_items) {let page = self.thread_items_page(thread_id,diff --git a/codex-rs/tui/src/app_server_session/history_tests.rs b/codex-rs/tui/src/app_server_session/history_tests.rsindex c498db3e8a..4818985e64 100644--- a/codex-rs/tui/src/app_server_session/history_tests.rs+++ b/codex-rs/tui/src/app_server_session/history_tests.rs@@ -1,4 +1,11 @@+use super::HistoryHydrationScope;+use super::HistoryLoadBudget;use super::advancing_cursor;+use crate::legacy_core::config::ConfigBuilder;+use crate::legacy_core::config::TerminalResizeReflowMaxRows;+use crate::local_settings::LocalSettings;+use codex_config::types::AltScreenMode;+use codex_features::Feature;use pretty_assertions::assert_eq;use std::collections::HashSet;@@ -26,3 +33,69 @@ fn advancing_cursor_rejects_repeated_cursors() {None);}++#[tokio::test]+async fn owned_initial_history_stops_after_viewport_or_scan_budget() {+ let codex_home = tempfile::tempdir().expect("temporary codex home");+ let mut config = ConfigBuilder::default()+ .codex_home(codex_home.path().to_path_buf())+ .build()+ .await+ .expect("config");+ config+ .features+ .enable(Feature::TranscriptV2)+ .expect("enable owned transcript");+ config.tui_alternate_screen = AltScreenMode::Always;+ config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Disabled;+ let local_settings = LocalSettings::from(&config);+ let budget = HistoryLoadBudget::new(+ HistoryHydrationScope::Initial,+ Some(&config),+ Some(&local_settings),+ /*terminal_height*/ 10,+ );++ assert_eq!(+ [+ budget.next_page_size(/*rendered_rows*/ 0, /*scanned_items*/ 0),+ budget.next_page_size(/*rendered_rows*/ 29, /*scanned_items*/ 10),+ budget.next_page_size(/*rendered_rows*/ 30, /*scanned_items*/ 11),+ budget.next_page_size(/*rendered_rows*/ 0, /*scanned_items*/ 399),+ budget.next_page_size(/*rendered_rows*/ 0, /*scanned_items*/ 400),+ ],+ [Some(30), Some(100), None, Some(1), None],+ );++ let complete = HistoryLoadBudget::new(+ HistoryHydrationScope::Complete,+ Some(&config),+ /*local_settings*/ None,+ /*terminal_height*/ 10,+ );+ assert_eq!(+ complete.next_page_size(/*rendered_rows*/ 10_000, /*scanned_items*/ 10_000),+ Some(100),+ );++ config+ .features+ .disable(Feature::TranscriptV2)+ .expect("disable owned transcript");+ // The mode selected at launch wins even if thread config changes or is unavailable.+ for config in [Some(&config), None] {+ let budget = HistoryLoadBudget::new(+ HistoryHydrationScope::Initial,+ config,+ Some(&local_settings),+ /*terminal_height*/ 10,+ );+ assert_eq!(+ [+ budget.next_page_size(/*rendered_rows*/ 0, /*scanned_items*/ 0),+ budget.next_page_size(/*rendered_rows*/ 30, /*scanned_items*/ 11),+ ],+ [Some(30), None],+ );+ }+}diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rsindex 75e92ba6dc..7b48b26a85 100644--- a/codex-rs/tui/src/bottom_pane/mod.rs+++ b/codex-rs/tui/src/bottom_pane/mod.rs@@ -131,7 +131,6 @@ mod effort_status_line;mod experimental_features_view;mod file_search_popup;mod footer;-pub(crate) use footer::footer_hint_items_line;mod list_selection_view;mod memories_settings_view;mod mentions_v2;@@ -165,6 +164,7 @@ pub(crate) use feedback_view::feedback_disabled_params;pub(crate) use feedback_view::feedback_selection_params;pub(crate) use feedback_view::feedback_success_cell;pub(crate) use feedback_view::feedback_upload_consent_params;+pub(crate) use footer::footer_hint_items_line;pub(crate) use footer::inset_footer_hint_area;pub(crate) use picker_style::selection_style;pub(crate) use skills_toggle_view::SkillsToggleItem;@@ -319,11 +319,6 @@ pub(crate) struct BottomPaneParams {}impl BottomPane {- pub(crate) fn show_footer_flash(&mut self, line: Line<'static>, duration: Duration) {- self.composer.show_footer_flash(line, duration);- self.request_redraw();- }-pub fn new(params: BottomPaneParams) -> Self {Self::new_with_composer_config(params, ChatComposerConfig::default())}@@ -1116,6 +1111,11 @@ impl BottomPane {self.request_redraw();}+ pub(crate) fn show_footer_flash(&mut self, line: Line<'static>, duration: Duration) {+ self.composer.show_footer_flash(line, duration);+ self.request_redraw();+ }+pub(crate) fn set_voice_strip(&mut self, state: Option<VoiceStripState>) {self.composer.set_voice_strip(state, self.frame_requester.clone());diff --git a/codex-rs/tui/src/chatwidget/tests.rs b/codex-rs/tui/src/chatwidget/tests.rsindex fc2b7374b4..00a05aa0ce 100644--- a/codex-rs/tui/src/chatwidget/tests.rs+++ b/codex-rs/tui/src/chatwidget/tests.rs@@ -297,6 +297,8 @@ mod status_surface_previews;mod terminal_title;#[path = "tests/tool_activity_tests.rs"]mod tool_activity_tests;+#[path = "tests/tool_details_tests.rs"]+mod tool_details_tests;mod usage;#[path = "tests/worktree_picker_tests.rs"]mod worktree_picker;diff --git a/codex-rs/tui/src/chatwidget/tests/dynamic_activity_tests.rs b/codex-rs/tui/src/chatwidget/tests/dynamic_activity_tests.rsindex 50bb3549a6..93b211e8ef 100644--- a/codex-rs/tui/src/chatwidget/tests/dynamic_activity_tests.rs+++ b/codex-rs/tui/src/chatwidget/tests/dynamic_activity_tests.rs@@ -1,8 +1,11 @@//! Dynamic calls must finish visibly whether transcript rows are retained or terminal-owned.use super::*;+use crate::local_settings::LocalSettings;+use crate::transcript_mode::TranscriptMode;use codex_app_server_protocol::DynamicToolCallOutputContentItem;use codex_app_server_protocol::DynamicToolCallStatus;+use codex_config::types::AltScreenMode;use pretty_assertions::assert_eq;use ratatui::buffer::Buffer;use ratatui::layout::Rect;@@ -28,31 +31,84 @@ fn dynamic_item(id: &str, status: DynamicToolCallStatus) -> AppServerThreadItem}#[tokio::test]-async fn dynamic_activity_retains_out_of_order_completions() {- let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;- drain_insert_history(&mut rx);+async fn terminal_dynamic_activity_retains_calls_across_both_fallbacks() {+ let mut outputs = Vec::new();+ for (owned_enabled, alternate_screen) in+ [(false, AltScreenMode::Always), (true, AltScreenMode::Never)]+ {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.config+ .features+ .set_enabled(Feature::TranscriptV2, owned_enabled)+ .expect("configure transcript feature");+ chat.config.tui_alternate_screen = alternate_screen;+ chat.local_settings = LocalSettings::from(&chat.config);+ assert_eq!(+ chat.local_settings.transcript_mode,+ TranscriptMode::Terminal+ );+ drain_insert_history(&mut rx);- for id in ["call-1", "call-2"] {- chat.on_dynamic_tool_item(dynamic_item(id, DynamicToolCallStatus::InProgress));+ for id in ["call-1", "call-2"] {+ chat.on_dynamic_tool_item(dynamic_item(id, DynamicToolCallStatus::InProgress));+ }+ let cells = std::iter::from_fn(|| rx.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => Some(cell),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(cells.len(), 2);+ assert_eq!(chat.transcript.dynamic_calls.len(), 2);++ chat.on_dynamic_tool_item(dynamic_item("call-2", DynamicToolCallStatus::Completed));+ chat.on_dynamic_tool_item(dynamic_item("call-1", DynamicToolCallStatus::Failed));+ assert!(drain_insert_history(&mut rx).is_empty());+ outputs.push(+ cells+ .iter()+ .flat_map(|cell| cell.display_lines(/*width*/ 80))+ .collect::<Vec<_>>(),+ );+ assert!(chat.transcript.dynamic_calls.is_empty());}- let cells = std::iter::from_fn(|| rx.try_recv().ok())+ assert_eq!(outputs[0], outputs[1]);+ insta::assert_snapshot!(+ "terminal_dynamic_activity",+ lines_to_single_string(&outputs[0])+ );+}++#[tokio::test]+async fn owned_dynamic_activity_updates_the_retained_row_after_config_refresh() {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.local_settings.transcript_mode = TranscriptMode::Owned;+ // A thread/config refresh cannot change ownership after the terminal starts.+ chat.config+ .features+ .disable(Feature::TranscriptV2)+ .expect("disable transcript feature in refreshed config");+ drain_insert_history(&mut rx);+ chat.on_dynamic_tool_item(dynamic_item("call-1", DynamicToolCallStatus::InProgress));+ let retained = std::iter::from_fn(|| rx.try_recv().ok()).filter_map(|event| match event {AppEvent::InsertHistoryCell(cell) => Some(cell),_ => None,}).collect::<Vec<_>>();- assert_eq!(cells.len(), 2);- assert_eq!(chat.transcript.dynamic_calls.len(), 2);+ assert_eq!(retained.len(), 1);+ assert_eq!(+ lines_to_single_string(&retained[0].display_lines(/*width*/ 80)),+ "• Calling test.lookup\n",+ );- chat.on_dynamic_tool_item(dynamic_item("call-2", DynamicToolCallStatus::Completed));- chat.on_dynamic_tool_item(dynamic_item("call-1", DynamicToolCallStatus::Failed));+ chat.on_dynamic_tool_item(dynamic_item("call-1", DynamicToolCallStatus::Completed));assert!(drain_insert_history(&mut rx).is_empty());- let output = cells- .iter()- .flat_map(|cell| cell.display_lines(/*width*/ 80))- .collect::<Vec<_>>();assert!(chat.transcript.dynamic_calls.is_empty());- insta::assert_snapshot!("terminal_dynamic_activity", lines_to_single_string(&output));+ assert_eq!(+ lines_to_single_string(&retained[0].display_lines(/*width*/ 80)),+ "• Called test.lookup · 25ms\n └ Result for call-1\n",+ );}#[tokio::test]diff --git a/codex-rs/tui/src/chatwidget/tests/tool_details_tests.rs b/codex-rs/tui/src/chatwidget/tests/tool_details_tests.rsnew file mode 100644index 0000000000..c380e67dc6--- /dev/null+++ b/codex-rs/tui/src/chatwidget/tests/tool_details_tests.rs@@ -0,0 +1,93 @@+//! Live completion, replay, and picker projection share retained tool details.++use super::*;+use crate::thread_transcript::RawReasoningVisibility;+use crate::thread_transcript::thread_items_to_transcript_cells;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn completed_tool_details_match_live_replay_and_picker_projection() {+ let output = (1..=12)+ .map(|line| format!("result line {line}"))+ .collect::<Vec<_>>()+ .join("\n");+ let command: AppServerThreadItem = serde_json::from_value(json!({+ "type": "commandExecution", "id": "command", "command": "cargo check",+ "cwd": test_path_buf("/workspace"), "source": "agent",+ "status": "completed", "commandActions": [{"type": "unknown", "command": "cargo check"}],+ "aggregatedOutput": output, "exitCode": 0, "durationMs": 5+ }))+ .expect("completed command");+ let mcp: AppServerThreadItem = serde_json::from_value(json!({+ "type": "mcpToolCall", "id": "mcp", "server": "example", "tool": "read",+ "status": "completed", "arguments": {"path": "source.rs"},+ "result": {"content": [{"type": "text", "text": output}]}, "durationMs": 5+ }))+ .expect("completed MCP result");+ for item in [command, mcp] {+ let mut projections = Vec::new();+ for replay in [false, true] {+ let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ drain_insert_history(&mut rx);+ chat.handle_paste("Unsent draft".to_owned());+ if replay {+ chat.replay_thread_item(+ item.clone(),+ "turn".to_owned(),+ ReplayKind::ThreadSnapshot,+ );+ } else {+ match item.clone() {+ item @ AppServerThreadItem::CommandExecution { .. } => {+ chat.handle_command_execution_completed_now(item)+ }+ item @ AppServerThreadItem::McpToolCall { .. } => {+ chat.handle_mcp_tool_call_completed_now(item)+ }+ _ => unreachable!("tool fixture"),+ }+ }+ chat.flush_active_cell();+ let mut retained = Vec::new();+ while let Ok(event) = rx.try_recv() {+ if let AppEvent::InsertHistoryCell(cell) = event {+ retained.push((+ cell.transcript_hyperlink_lines(/*width*/ 32),+ cell.raw_lines(),+ ));+ }+ }+ assert_eq!(chat.composer_text_with_pending(), "Unsent draft");+ projections.push(retained);+ }+ let picker = thread_items_to_transcript_cells(+ /*thread_id*/ None,+ &test_path_buf("/workspace").abs(),+ [item],+ RawReasoningVisibility::Hidden,+ /*config*/ None,+ );+ projections.push(+ picker+ .iter()+ .map(|cell| {+ (+ cell.transcript_hyperlink_lines(/*width*/ 32),+ cell.raw_lines(),+ )+ })+ .collect(),+ );+ assert_eq!(projections[0].len(), 1);+ for projection in &projections[1..] {+ assert_eq!(&projections[0], projection);+ }+ let raw = projections[0][0]+ .1+ .iter()+ .map(ToString::to_string)+ .collect::<Vec<_>>()+ .join("\n");+ assert!(raw.contains(&output));+ }+}diff --git a/codex-rs/tui/src/exec_cell/compact.rs b/codex-rs/tui/src/exec_cell/compact.rsindex bbdbf63fcb..87eb6d69a6 100644--- a/codex-rs/tui/src/exec_cell/compact.rs+++ b/codex-rs/tui/src/exec_cell/compact.rs@@ -16,7 +16,6 @@ use ratatui::style::Stylize;use ratatui::text::Line;impl ExecCell {- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]pub(super) fn command_has_hidden_details(&self, width: u16) -> bool {let [call] = self.group.calls.as_slice() else {return false;diff --git a/codex-rs/tui/src/exec_cell/render.rs b/codex-rs/tui/src/exec_cell/render.rsindex 00c180fe95..86d66a80d9 100644--- a/codex-rs/tui/src/exec_cell/render.rs+++ b/codex-rs/tui/src/exec_cell/render.rs@@ -52,7 +52,6 @@ pub(crate) struct OutputLinesParams {struct CommandDisplay {lines: Vec<HyperlinkLine>,- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]hidden_details: bool,}@@ -1309,4 +1308,53 @@ mod tests {"expected full URL-like token in one rendered line, got: {rendered:?}");}++ #[test]+ fn transcript_view_renders_wrapped_url_like_rows_without_clipping() {+ let url = "https://example.test/api/v1/projects/alpha-team/releases/2026-02-17/builds/1234567890/artifacts/reports/performance/summary/detail/with/a/very/long/path/that/keeps/going/for/testing/purposes";+ let call = ExecCall {+ call_id: "call-id".to_string(),+ command: vec!["bash".into(), "-lc".into(), "echo done".into()],+ parsed: Vec::new(),+ output: Some(CommandOutput::new(/*exit_code*/ 0, url.to_string())),+ source: ExecCommandSource::Agent,+ start_time: None,+ duration: None,+ interaction_input: None,+ };++ let cell = ExecCell::new(call, /*animations_enabled*/ false);+ let width: u16 = 36;+ let logical_height = cell.transcript_lines(width).len();+ let cells: Vec<std::sync::Arc<dyn HistoryCell>> = vec![std::sync::Arc::new(cell)];+ let mut view = crate::transcript_view::TranscriptView::default();+ view.set_presentation(+ /*detailed*/ true,+ crate::history_cell::HistoryRenderMode::Rich,+ );+ let area = Rect::new(/*x*/ 0, /*y*/ 0, width, /*height*/ 16);+ let mut buffer = Buffer::empty(area);+ view.render(area, &mut buffer, &cells);+ let rendered = buffer+ .content()+ .chunks(usize::from(width))+ .map(|row| {+ row.iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>()+ .trim()+ .to_string()+ })+ .filter(|row| !row.is_empty())+ .collect::<Vec<_>>();++ assert!(+ rendered.len() > logical_height,+ "expected the transcript viewport to wrap URL-like rows, got: {rendered:?}"+ );+ assert!(+ rendered.concat().contains(url),+ "expected the complete URL, got: {rendered:?}"+ );+ }}diff --git a/codex-rs/tui/src/history_cell/messages.rs b/codex-rs/tui/src/history_cell/messages.rsindex 36d51dfe4b..3d9e4681f8 100644--- a/codex-rs/tui/src/history_cell/messages.rs+++ b/codex-rs/tui/src/history_cell/messages.rs@@ -152,6 +152,15 @@ fn build_user_message_lines_with_elements(}impl UserHistoryCell {+ pub(crate) fn has_visible_content(&self) -> bool {+ !sanitize_user_text(Cow::Borrowed(&self.message))+ .trim()+ .is_empty()+ || !self.text_elements.is_empty()+ || !self.local_image_paths.is_empty()+ || !self.remote_image_urls.is_empty()+ }+fn image_labels_not_in_message(&self) -> impl Iterator<Item = String> + '_ {// Composer images already have placeholders; command-line images may not.// Both kinds must keep an image-only user turn visible after submission.diff --git a/codex-rs/tui/src/history_cell/mod.rs b/codex-rs/tui/src/history_cell/mod.rsindex d1fc5273bb..7b7f025f73 100644--- a/codex-rs/tui/src/history_cell/mod.rs+++ b/codex-rs/tui/src/history_cell/mod.rs@@ -247,20 +247,17 @@ pub(crate) trait HistoryCell: std::fmt::Debug + Send + Sync + Any {/// Stable, namespaced member identities used to retain disclosure across grouping and replay./// Empty identities indicate ordinary content without a local disclosure control.- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]fn activity_ids(&self) -> Vec<String> {Vec::new()}/// Available activity details, preserving source order and any upstream truncation notices.- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]fn expanded_hyperlink_lines(&self, width: u16) -> Vec<HyperlinkLine> {self.transcript_hyperlink_lines(width)}/// Whether an activity offers details beyond its compact presentation./// Prefer source metadata so collapsed rendering does not materialize hidden content.- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]fn has_hidden_activity_details(&self, _width: u16) -> bool {true}diff --git a/codex-rs/tui/src/history_cell/patches.rs b/codex-rs/tui/src/history_cell/patches.rsindex adab7e2605..3569c7c9ab 100644--- a/codex-rs/tui/src/history_cell/patches.rs+++ b/codex-rs/tui/src/history_cell/patches.rs@@ -11,7 +11,6 @@ mod tests;#[derive(Debug)]pub(crate) struct PatchHistoryCell {- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]activity_id: String,changes: HashMap<PathBuf, FileChange>,cwd: PathBuf,@@ -86,7 +85,6 @@ pub(crate) fn new_patch_apply_failure(stderr: String) -> PatchFailureCell {/// Failed patch attempts retain available diagnostics for local disclosure and full transcript.#[derive(Debug)]pub(crate) struct PatchFailureCell {- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]activity_id: String,stderr: String,}diff --git a/codex-rs/tui/src/history_cell/patches_tests.rs b/codex-rs/tui/src/history_cell/patches_tests.rsindex 585ff68593..9844d9b4ec 100644--- a/codex-rs/tui/src/history_cell/patches_tests.rs+++ b/codex-rs/tui/src/history_cell/patches_tests.rs@@ -75,3 +75,18 @@ fn viewed_image_narrow_summary() {));insta::assert_snapshot!(cell.display_lines(/*width*/ 32)[0].to_string());}++#[test]+fn failed_patch_keeps_diagnostics_beyond_the_legacy_preview() {+ let diagnostics = (1..=12)+ .map(|line| format!("diagnostic line {line}"))+ .collect::<Vec<_>>()+ .join("\n");+ let cell = new_patch_apply_failure(diagnostics.clone());+ assert_eq!(+ cell.raw_lines(),+ std::iter::once(Line::from("Failed to apply patch"))+ .chain(diagnostics.lines().map(|line| Line::from(line.to_owned())))+ .collect::<Vec<_>>()+ );+}diff --git a/codex-rs/tui/src/history_cell/plans.rs b/codex-rs/tui/src/history_cell/plans.rsindex 8ab8de2d4f..8cd272d8ce 100644--- a/codex-rs/tui/src/history_cell/plans.rs+++ b/codex-rs/tui/src/history_cell/plans.rs@@ -181,7 +181,6 @@ impl HistoryCell for ProposedPlanStreamCell {#[derive(Debug)]pub(crate) struct PlanUpdateCell {- #[allow(dead_code, reason = "Used by later layers of the TUI refresh stack.")]activity_id: String,explanation: Option<String>,plan: Vec<PlanItemArg>,diff --git a/codex-rs/tui/src/history_cell/session.rs b/codex-rs/tui/src/history_cell/session.rsindex adb34b1cb6..6abfc542dd 100644--- a/codex-rs/tui/src/history_cell/session.rs+++ b/codex-rs/tui/src/history_cell/session.rs@@ -427,3 +427,7 @@ impl HistoryCell for SessionHeaderHistoryCell {lines}}++#[cfg(test)]+#[path = "session_transcript_tests.rs"]+mod transcript_tests;diff --git a/codex-rs/tui/src/history_cell/session_transcript_tests.rs b/codex-rs/tui/src/history_cell/session_transcript_tests.rsnew file mode 100644index 0000000000..264c76833a--- /dev/null+++ b/codex-rs/tui/src/history_cell/session_transcript_tests.rs@@ -0,0 +1,108 @@+//! Session information appears only once all older transcript pages are available.++use super::*;+use crate::pager_overlay::TranscriptHistoryState;+use crate::transcript_view::TranscriptView;+use crossterm::event::KeyModifiers;+use crossterm::event::MouseEvent;+use crossterm::event::MouseEventKind;+use pretty_assertions::assert_eq;+use ratatui::buffer::Buffer;+use ratatui::layout::Rect;+use std::sync::Arc;++#[test]+fn wheel_at_hidden_session_header_keeps_the_loaded_message_anchor() {+ let header: Arc<dyn HistoryCell> = Arc::new(SessionInfoCell(CompositeHistoryCell {+ parts: vec![Box::new(PlainHistoryCell::new(vec![+ "session announcement".into(),+ ]))],+ }));+ let recent: Arc<dyn HistoryCell> = Arc::new(PlainHistoryCell::new(+ (0..6)+ .map(|row| format!("recent row {row}").into())+ .collect(),+ ));+ let mut cells = vec![header, recent];+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 30, /*height*/ 3,+ );+ let mut view = TranscriptView::default();+ view.history = TranscriptHistoryState::Partial;+ let mut before = Buffer::empty(area);+ view.render(area, &mut before, &cells);+ for _ in 0..2 {+ view.handle_mouse(+ MouseEvent {+ kind: MouseEventKind::ScrollUp,+ column: 0,+ row: 0,+ modifiers: KeyModifiers::NONE,+ },+ &cells,+ );+ view.render(area, &mut before, &cells);+ }+ assert!(view.needs_history(&cells));+ let page = (0..3).map(|row| {+ Arc::new(PlainHistoryCell::new(vec![+ format!("older row {row}").into(),+ ])) as Arc<dyn HistoryCell>+ });+ cells.splice(1..1, page);+ view.history_loaded(&cells, 1..4);+ assert!(+ !view.needs_history(&cells),+ "one wheel gesture must not keep requesting older pages"+ );+ let mut after = Buffer::empty(area);+ view.render(area, &mut after, &cells);+ assert_eq!(after, before);+}++#[test]+fn session_information_waits_for_older_pages_and_reappears_after_completion() {+ let header: Arc<dyn HistoryCell> = Arc::new(SessionInfoCell(CompositeHistoryCell {+ parts: vec![Box::new(PlainHistoryCell::new(vec![+ "session announcement".into(),+ ]))],+ }));+ let cells = vec![header];+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 30, /*height*/ 2,+ );+ let mut view = TranscriptView::default();+ let mut output = Vec::new();+ for history in [+ TranscriptHistoryState::Complete,+ TranscriptHistoryState::Partial,+ TranscriptHistoryState::LoadingOlder,+ TranscriptHistoryState::LoadingBeginning,+ TranscriptHistoryState::Failed,+ TranscriptHistoryState::Complete,+ ] {+ view.history = history;+ let mut buffer = Buffer::empty(area);+ view.render(area, &mut buffer, &cells);+ output.push(+ buffer+ .content+ .iter()+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>()+ .trim()+ .to_owned(),+ );+ }+ assert_eq!(+ output,+ [+ "session announcement",+ "",+ "",+ "",+ "",+ "session announcement"+ ]+ );+}diff --git a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__multiline_command_both_lines_wrap_with_correct_prefixes.snap b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__multiline_command_both_lines_wrap_with_correct_prefixes.snapindex 6b8ee52b85..1cd824891c 100644--- a/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__multiline_command_both_lines_wrap_with_correct_prefixes.snap+++ b/codex-rs/tui/src/history_cell/snapshots/codex_tui__history_cell__tests__multiline_command_both_lines_wrap_with_correct_prefixes.snap@@ -1,5 +1,5 @@----source: tui/src/history_cell.rs+source: tui/src/history_cell/tests.rsexpression: rendered---• Ran first_token_is_long_endiff --git a/codex-rs/tui/src/keymap/chords.rs b/codex-rs/tui/src/keymap/chords.rsindex ff758ff067..af9d09e917 100644--- a/codex-rs/tui/src/keymap/chords.rs+++ b/codex-rs/tui/src/keymap/chords.rs@@ -44,6 +44,8 @@ pub(crate) struct KeymapContextSet(u32);const ACTIVITY_FOCUS: u32 = 1 << 13;const TRANSCRIPT_CLOSE: u32 = 1 << 15;+const TRANSCRIPT_BROWSING: u32 = 1 << 14;+impl KeymapContextSet {pub(crate) const fn new(context: KeymapContext) -> Self {Self(context_bit(context))@@ -60,6 +62,16 @@ impl KeymapContextSet {Self(self.0 | context_bit(KeymapContext::Pager) | TRANSCRIPT_CLOSE)}+ /// Native browsing keeps pager actions and the configured detail toggle active.+ /// Other global actions must not steal keys from the pager.+ pub(crate) const fn browsing() -> Self {+ Self(+ context_bit(KeymapContext::Pager)+ | context_bit(KeymapContext::Global)+ | TRANSCRIPT_BROWSING,+ )+ }+/// Whether this input path can dispatch the action, including focus-specific exclusions.pub(crate) fn contains_action(self, action: KeymapActionId) -> bool {self.contains(action.context)@@ -69,6 +81,9 @@ impl KeymapContextSet {&& (self.0 & TRANSCRIPT_CLOSE == 0|| action.context != KeymapContext::Pager|| action.action == "close_transcript")+ && (self.0 & TRANSCRIPT_BROWSING == 0+ || action.context != KeymapContext::Global+ || action.action == "open_transcript")}pub(crate) const fn with(self, context: KeymapContext) -> Self {diff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_completed_stream.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_completed_stream.snapindex 475176c2fd..1e1ecdbcf2 100644--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_completed_stream.snap+++ b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_completed_stream.snap@@ -1,6 +1,6 @@---source: tui/src/pager_overlay/transcript_tests.rs-assertion_line: 614+assertion_line: 664expression: "buffer_to_text(&actual, area)"---/ T R A N S C R I P T / / / / / / / / /@@ -11,4 +11,4 @@ lastCtrl+Space select↑/↓ to scroll · pgup/pgdn to page · hom- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states.snapindex 03eb2fe078..94e53e1df6 100644--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states.snap+++ b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states.snap@@ -1,6 +1,6 @@---source: tui/src/pager_overlay/transcript_tests.rs-assertion_line: 373+assertion_line: 417expression: snapshots------ loading ---@@ -23,7 +23,7 @@ recent transcriptEarlier messages available. Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse prompts--- failed ---/ T R A N S C R I P T / / / / / / / / / / / / / / / / / / / / / / / / /@@ -45,4 +45,4 @@ recent transcriptCtrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states_non_macos.snap b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states_non_macos.snapindex 472a7b267d..94e53e1df6 100644--- a/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states_non_macos.snap+++ b/codex-rs/tui/src/pager_overlay/snapshots/codex_tui__pager_overlay__transcript_tests__transcript_overlay_paginated_history_states_non_macos.snap@@ -23,7 +23,7 @@ recent transcriptEarlier messages available. Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse prompts--- failed ---/ T R A N S C R I P T / / / / / / / / / / / / / / / / / / / / / / / / /@@ -45,4 +45,4 @@ recent transcriptCtrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/pager_overlay/transcript.rs b/codex-rs/tui/src/pager_overlay/transcript.rsindex 70b9733259..af5f6aa9d5 100644--- a/codex-rs/tui/src/pager_overlay/transcript.rs+++ b/codex-rs/tui/src/pager_overlay/transcript.rs@@ -9,6 +9,7 @@ use crate::history_cell::SessionHeaderHistoryCell;use crate::history_cell::SessionInfoCell;use crate::keymap::RuntimeKeymap;use crate::motion::MotionMode;+use crate::transcript_view::TranscriptBookmark;use crate::transcript_view::TranscriptView;use crate::transcript_view::ViewAction;use crossterm::event::KeyEventKind;@@ -25,10 +26,29 @@ pub(crate) struct TranscriptOverlay {cursor: Option<(u16, u16)>,notice: Option<String>,pub(crate) key_chord_hint: Option<Vec<(String, String)>>,+ pub(crate) browsing_footer: Option<Line<'static>>,is_done: bool,}impl TranscriptOverlay {+ pub(crate) fn bookmark(&mut self) -> TranscriptBookmark {+ self.view.bookmark(&self.cells)+ }++ pub(crate) fn restore_bookmark(&mut self, bookmark: TranscriptBookmark) {+ self.browsing_footer = None;+ self.set_highlight_cell(/*cell*/ None);+ self.view.restore_bookmark(bookmark);+ }++ pub(crate) fn set_presentation(&mut self, detailed: bool, mode: HistoryRenderMode) {+ self.view.set_presentation(detailed, mode);+ }++ pub(crate) fn is_detailed(&self) -> bool {+ self.view.is_detailed()+ }+pub(crate) fn new(cells: Vec<Arc<dyn HistoryCell>>, keymap: PagerKeymap) -> Self {let mut view = TranscriptView::default();view.set_presentation(/*detailed*/ true, HistoryRenderMode::Rich);@@ -43,13 +63,17 @@ impl TranscriptOverlay {cursor: None,notice: None,key_chord_hint: None,+ browsing_footer: None,is_done: false,}}pub(crate) fn render(&mut self, area: Rect, buf: &mut Buffer) {Clear.render(area, buf);- let chrome_height = 5;+ let browsing = self.browsing_footer.is_some()+ && !self.view.has_active_interaction()+ && self.view.history != TranscriptHistoryState::Failed;+ let chrome_height = if browsing { 2 } else { 5 };let content_height = area.height.saturating_sub(chrome_height);self.content_area = Rect::new(area.x,@@ -75,7 +99,14 @@ impl TranscriptOverlay {).intersection(area);self.cursor = None;-+ if browsing && let Some(footer) = &self.browsing_footer {+ if let Some(items) = &self.key_chord_hint {+ crate::bottom_pane::footer_hint_items_line(items).render(status, buf);+ } else {+ Widget::render(footer, status, buf);+ }+ return;+ }let hints = Rect::new(area.x, status.bottom(), area.width, /*height*/ 2).intersection(area);let latest_navigation = self.keymap@@ -354,6 +385,14 @@ impl TranscriptOverlay {self.view.set_highlight(self.highlight_cell);}+ /// Apply prompt navigation before scrolling, even when both keys precede the next draw.+ pub(crate) fn scroll(&mut self, rows: isize) {+ if let Some(index) = self.pending_highlight.take() {+ self.view.ensure_entry_visible(&self.cells, index);+ }+ self.view.scroll(&self.cells, rows);+ }+fn handle_key(&mut self, key: KeyEvent) -> Option<ViewAction> {if key.kind == KeyEventKind::Release {return None;@@ -374,7 +413,7 @@ impl TranscriptOverlay {self.is_done = true;return Some(ViewAction::Changed);}- if self.navigate(key) {+ if self.view.navigate_pager(key, &self.cells, &self.keymap) {return Some(ViewAction::Changed);}self.view.handle_key(key, &self.cells)@@ -384,34 +423,6 @@ impl TranscriptOverlay {self.view.cancel_beginning();}- fn navigate(&mut self, key: KeyEvent) -> bool {- if self.keymap.jump_top.is_pressed(key) {- self.view.jump_to_beginning(&self.cells);- return true;- }- if self.keymap.jump_bottom.is_pressed(key) {- self.view.jump_to_latest();- return true;- }- let page = self.content_area.height.max(/*other*/ 1) as isize;- let half = (page + 1) / 2;- let delta = [- (&self.keymap.scroll_up, -1),- (&self.keymap.scroll_down, 1),- (&self.keymap.page_up, -page),- (&self.keymap.page_down, page),- (&self.keymap.half_page_up, -half),- (&self.keymap.half_page_down, half),- ]- .into_iter()- .find_map(|(bindings, delta)| bindings.is_pressed(key).then_some(delta));- let Some(delta) = delta else {- return false;- };- self.view.scroll(&self.cells, delta);- true- }-fn apply_action(&mut self, tui: &mut tui::Tui, action: ViewAction) {self.notice = None;let resume_following = matches!(action, ViewAction::CopyAndFollow(_));@@ -427,6 +438,7 @@ impl TranscriptOverlay {&& matches!(result, Ok(crate::clipboard_copy::CopyStatus::Confirmed)){self.view.jump_to_latest();+ self.is_done = self.browsing_footer.is_some();}self.notice = Some(match result {Ok(status) => status.message("selection"),@@ -455,7 +467,7 @@ impl TranscriptOverlay {"find",));}- pairs.push((vec![key_hint::plain(KeyCode::Esc).into()], "edit previous"));+ pairs.push((vec![key_hint::plain(KeyCode::Esc).into()], "browse prompts"));if self.highlight_cell.is_some() {pairs.push((vec![key_hint::plain(KeyCode::Right).into()], "to edit next"));pairs.push((diff --git a/codex-rs/tui/src/snapshots/codex_tui__inline_visualization__tests__transcript_overlay_visualization_becomes_available.snap b/codex-rs/tui/src/snapshots/codex_tui__inline_visualization__tests__transcript_overlay_visualization_becomes_available.snapindex 4e86df2a47..63a6ebcadc 100644--- a/codex-rs/tui/src/snapshots/codex_tui__inline_visualization__tests__transcript_overlay_visualization_becomes_available.snap+++ b/codex-rs/tui/src/snapshots/codex_tui__inline_visualization__tests__transcript_overlay_visualization_becomes_available.snap@@ -14,7 +14,7 @@ before:Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsafter:@@ -28,4 +28,4 @@ after:Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/status/snapshots/codex_tui__status__tests__transcript_overlay_status_rate_limit_refresh.snap b/codex-rs/tui/src/status/snapshots/codex_tui__status__tests__transcript_overlay_status_rate_limit_refresh.snapindex cf3c75935b..0fb60fae57 100644--- a/codex-rs/tui/src/status/snapshots/codex_tui__status__tests__transcript_overlay_status_rate_limit_refresh.snap+++ b/codex-rs/tui/src/status/snapshots/codex_tui__status__tests__transcript_overlay_status_rate_limit_refresh.snap@@ -32,7 +32,7 @@ before:Ctrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsafter:@@ -64,4 +64,4 @@ next messageCtrl+Space select↑/↓ to scroll · pgup/pgdn to page · home/end to jump- q close · f3 find · esc edit previous+ q close · f3 find · esc browse promptsdiff --git a/codex-rs/tui/src/transcript_view.rs b/codex-rs/tui/src/transcript_view.rsindex 44b0d595be..d64e786570 100644--- a/codex-rs/tui/src/transcript_view.rs+++ b/codex-rs/tui/src/transcript_view.rs@@ -5,6 +5,7 @@//! them and rewrapping does not turn a reading position into an unrelated screen row.mod activity;+mod bookmark;mod composer_gap;mod disclosure;mod follow_control;@@ -12,6 +13,7 @@ mod footer;mod input;mod layout;mod mutations;+mod prompt_header;mod search;mod selection;mod snapshot;@@ -37,6 +39,7 @@ use selection::Selection;use snapshot::ViewSnapshot;use text::TextLayout;+pub(crate) use bookmark::TranscriptBookmark;pub(crate) use input::JumpTarget;pub(crate) use input::ViewAction;pub(crate) use layout::ActivityTranscriptLines;@@ -89,6 +92,7 @@ pub(crate) struct TranscriptView {live_key: Option<(u16, ActiveCellTranscriptKey)>,live_continuation: bool,area: Rect,+ suppressed_prompt_header: Option<prompt_header::SuppressedHeader>,visible: Vec<VisibleRow>,selection: Option<Selection>,held_reading: Option<ViewSnapshot>,@@ -117,6 +121,7 @@ impl Default for TranscriptView {live_key: None,live_continuation: false,area: Rect::default(),+ suppressed_prompt_header: None,visible: Vec::new(),selection: None,held_reading: None,@@ -142,6 +147,7 @@ impl TranscriptView {let current_cells = cells;let snapshot = self.snapshot_cells();let cells = snapshot.as_deref().unwrap_or(cells);+ let suppressed_prompt_header = self.suppressed_prompt_header.take();Clear.render(area, buf);self.prepare_width(area.width);self.area = area;@@ -151,7 +157,34 @@ impl TranscriptView {self.tail_visible = false;return;}- let start = self.start(cells);+ let initial_start = self.start(cells);+ let mut start = initial_start;+ let mut body = area;+ let header_position = prompt_header::SuppressedHeader {+ viewport: area,+ key: self.entry_key(cells, start.0),+ row: start.1,+ };+ if matches!(self.position, Position::Reading(_))+ && suppressed_prompt_header.as_ref() == Some(&header_position)+ {+ // Freezing follow must preserve a header that yielded to the next visible prompt.+ self.suppressed_prompt_header = Some(header_position);+ } else if area.height >= 4 && prompt_header::line(cells, start.0, area.width).is_some() {+ body = Rect::new(area.x, area.y + 1, area.width, area.height - 1);+ self.area = body;+ // Following may advance into the next turn after reserving the header row.+ start = self.start(cells);+ if let Some(header) = prompt_header::line(cells, start.0, area.width) {+ header.render(Rect::new(area.x, area.y, area.width, /*height*/ 1), buf);+ } else {+ body = area;+ self.area = area;+ start = initial_start;+ self.suppressed_prompt_header = Some(header_position);+ }+ }+ let area = body;let (mut index, mut row) = start;let mut entry_activity_ids: Option<(usize, Arc<[String]>)> = None;for y in area.top()..area.bottom() {@@ -273,6 +306,7 @@ impl TranscriptView {self.selection = None;self.release_live_reading();self.cache.clear();+ self.suppressed_prompt_header = None;self.live_key = None;// Search temporarily expands content without changing either presentation's position.if self.detailed != detailed && !self.search.is_active() {diff --git a/codex-rs/tui/src/transcript_view/bookmark.rs b/codex-rs/tui/src/transcript_view/bookmark.rsnew file mode 100644index 0000000000..681b69edcf--- /dev/null+++ b/codex-rs/tui/src/transcript_view/bookmark.rs@@ -0,0 +1,46 @@+//! Save a browsing origin independently of the compact/detailed position pair.+//! Retained cell identities and source offsets survive pagination and rewrapping.++use super::*;++pub(crate) struct TranscriptBookmark {+ position: Position,+ saved_position: Option<Position>,+ suppressed_prompt_header: Option<prompt_header::SuppressedHeader>,+ detailed: bool,+ mode: HistoryRenderMode,+ snapshot: Option<ViewSnapshot>,+ last_tail: Option<EntryKey>,+ unseen_activity: bool,+}++impl TranscriptView {+ pub(crate) fn bookmark(&mut self, cells: &[Arc<dyn HistoryCell>]) -> TranscriptBookmark {+ TranscriptBookmark {+ position: self.position,+ saved_position: self.saved_position,+ suppressed_prompt_header: self.suppressed_prompt_header,+ detailed: self.detailed,+ mode: self.mode,+ snapshot: (!self.is_following()).then(|| self.capture_snapshot(cells)),+ last_tail: self.last_tail,+ unseen_activity: self.unseen_activity,+ }+ }++ pub(crate) fn restore_bookmark(&mut self, bookmark: TranscriptBookmark) {+ self.jump_to_latest();+ self.set_presentation(bookmark.detailed, bookmark.mode);+ self.position = bookmark.position;+ self.saved_position = bookmark.saved_position;+ self.suppressed_prompt_header = bookmark.suppressed_prompt_header;+ self.held_reading = bookmark.snapshot;+ self.rewrap_snapshot(self.area.width);+ self.highlight = None;+ self.unseen_activity = bookmark.unseen_activity || self.last_tail != bookmark.last_tail;+ }+}++#[cfg(test)]+#[path = "bookmark_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/transcript_view/bookmark_tests.rs b/codex-rs/tui/src/transcript_view/bookmark_tests.rsnew file mode 100644index 0000000000..7bda2afdae--- /dev/null+++ b/codex-rs/tui/src/transcript_view/bookmark_tests.rs@@ -0,0 +1,75 @@+use super::*;+use crate::transcript_view::tests::cell;+use crate::transcript_view::tests::render;+use crate::transcript_view::tests::text;+use pretty_assertions::assert_eq;++#[test]+fn cancel_restores_both_positions_after_resize_and_pagination() {+ let mut cells = vec![+ cell("first prompt\nfirst response"),+ cell("second prompt\nsecond response"),+ ];+ let mut view = TranscriptView::default();+ render(&mut view, &cells, /*width*/ 30, /*height*/ 3);+ view.jump_to_entry(&cells, /*index*/ 0);+ let before = text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 3,+ ));+ let positions = (view.position, view.saved_position);+ let bookmark = view.bookmark(&cells);+ view.set_presentation(/*detailed*/ true, HistoryRenderMode::Rich);+ view.jump_to_entry(&cells, /*index*/ 1);+ render(&mut view, &cells, /*width*/ 12, /*height*/ 4);+ cells.insert(/*index*/ 0, cell("older page"));+ cells.push(cell("new response"));+ view.restore_bookmark(bookmark);+ assert_eq!((view.position, view.saved_position), positions);+ assert_eq!(view.is_detailed(), false);+ assert_eq!(+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 3+ )),+ before+ );+}++#[test]+fn following_origin_returns_to_new_output_in_original_presentation() {+ let mut cells = vec![cell("first prompt"), cell("second prompt")];+ let mut view = TranscriptView::default();+ view.set_presentation(/*detailed*/ true, HistoryRenderMode::Rich);+ let bookmark = view.bookmark(&cells);+ view.set_presentation(/*detailed*/ false, HistoryRenderMode::Rich);+ view.jump_to_entry(&cells, /*index*/ 0);+ cells.push(cell("new output"));+ view.restore_bookmark(bookmark);+ assert_eq!((view.is_detailed(), view.is_following()), (true, true));+ assert!(+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 2+ ))+ .contains("new output")+ );+}++#[test]+fn cancel_restores_a_group_replaced_during_browsing() {+ let mut cells = vec![cell("original group\noriginal output"), cell("next prompt")];+ let mut view = TranscriptView::default();+ render(&mut view, &cells, /*width*/ 30, /*height*/ 2);+ view.jump_to_entry(&cells, /*index*/ 0);+ let before = text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 2,+ ));+ let bookmark = view.bookmark(&cells);+ view.jump_to_latest();+ cells[0] = cell("replacement group\nreplacement output");+ view.restore_bookmark(bookmark);+ assert_eq!(+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 2+ )),+ before+ );+}diff --git a/codex-rs/tui/src/transcript_view/input.rs b/codex-rs/tui/src/transcript_view/input.rsindex 66090cc38d..834cb57768 100644--- a/codex-rs/tui/src/transcript_view/input.rs+++ b/codex-rs/tui/src/transcript_view/input.rs@@ -1,5 +1,6 @@//! Transcript gestures leave ordinary typing and composer editing with the existing input path.+use crate::key_hint::KeyBindingListExt;use crossterm::event::KeyCode;use crossterm::event::KeyEvent;use crossterm::event::KeyEventKind;@@ -76,6 +77,39 @@ impl JumpTarget {}impl TranscriptView {+ pub(crate) fn navigate_pager(+ &mut self,+ key: KeyEvent,+ cells: &[Arc<dyn HistoryCell>],+ keymap: &crate::keymap::PagerKeymap,+ ) -> bool {+ if keymap.jump_top.is_pressed(key) {+ self.jump_to_beginning(cells);+ return true;+ }+ if keymap.jump_bottom.is_pressed(key) {+ self.jump_to_latest();+ return true;+ }+ let page = self.area.height.max(/*other*/ 1) as isize;+ let half = (page + 1) / 2;+ let delta = [+ (&keymap.scroll_up, -1),+ (&keymap.scroll_down, 1),+ (&keymap.page_up, -page),+ (&keymap.page_down, page),+ (&keymap.half_page_up, -half),+ (&keymap.half_page_down, half),+ ]+ .into_iter()+ .find_map(|(bindings, delta)| bindings.is_pressed(key).then_some(delta));+ let Some(delta) = delta else {+ return false;+ };+ self.scroll(cells, delta);+ true+ }+/// Keep selection and Find control keys ahead of configurable chord prefixes.pub(crate) fn owns_interaction_key(&self, key: KeyEvent) -> bool {if key.kind == KeyEventKind::Release {diff --git a/codex-rs/tui/src/transcript_view/prompt_header.rs b/codex-rs/tui/src/transcript_view/prompt_header.rsnew file mode 100644index 0000000000..9e60b8e158--- /dev/null+++ b/codex-rs/tui/src/transcript_view/prompt_header.rs@@ -0,0 +1,56 @@+//! Keep the prompt associated with the first visible answer in a presentation-only top row.+//! The header is never transcript content, so copying, searching and exporting stay exact.+//! A header that yields at a turn boundary stays hidden while that viewport and top row are held.++use super::*;+use crate::history_cell::UserHistoryCell;+use crate::history_cell::sanitize_user_text;+use crate::line_truncation::truncate_line_with_ellipsis_if_overflow;++/// Remember only a header canceled at a turn boundary, not a missing preceding prompt.+#[derive(Clone, Copy, PartialEq, Eq)]+pub(super) struct SuppressedHeader {+ pub(super) viewport: Rect,+ pub(super) key: EntryKey,+ pub(super) row: usize,+}++pub(super) fn line(+ cells: &[Arc<dyn HistoryCell>],+ first: usize,+ width: u16,+) -> Option<Line<'static>> {+ // A prompt that is still visible supplies its own context. Only pin a preceding prompt.+ if width < 16+ || cells+ .get(first)+ .and_then(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())+ .is_some_and(UserHistoryCell::has_visible_content)+ {+ return None;+ }+ let prompt = cells[..first.min(cells.len())]+ .iter()+ .rev()+ .filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())+ .find(|prompt| prompt.has_visible_content())?;+ // Bound work even for pasted multi-megabyte prompts; sanitize before painting controls.+ let prefix: String = prompt.message.chars().take(/*n*/ 512).collect();+ let message = sanitize_user_text(prefix.into())+ .split_whitespace()+ .collect::<Vec<_>>()+ .join(" ");+ let message = if message.is_empty() {+ "[attachments]".to_owned()+ } else {+ message+ };+ Some(truncate_line_with_ellipsis_if_overflow(+ Line::from(message).style(crate::style::history_prompt_style()),+ usize::from(width),+ ))+}++#[cfg(test)]+#[path = "prompt_header_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/transcript_view/prompt_header_tests.rs b/codex-rs/tui/src/transcript_view/prompt_header_tests.rsnew file mode 100644index 0000000000..827b569496--- /dev/null+++ b/codex-rs/tui/src/transcript_view/prompt_header_tests.rs@@ -0,0 +1,214 @@+//! Sticky context follows the visible turn while leaving source text and hit rows intact.++use super::*;+use crate::history_cell::new_user_prompt;+use crate::transcript_view::tests::cell;+use crate::transcript_view::tests::render;+use crate::transcript_view::tests::text;+use crossterm::event::KeyCode;+use crossterm::event::KeyEvent;+use crossterm::event::KeyModifiers;+use crossterm::event::MouseButton;+use crossterm::event::MouseEvent;+use crossterm::event::MouseEventKind;+use pretty_assertions::assert_eq;+use ratatui::style::Modifier;++fn user(message: &str) -> Arc<dyn HistoryCell> {+ Arc::new(new_user_prompt(+ message.into(),+ Vec::new(),+ Vec::new(),+ Vec::new(),+ ))+}++#[test]+fn prompt_header_tracks_reading_and_yields_to_visible_prompts_and_short_screens() {+ let mut cells = vec![+ user("First question"),+ cell("one\ntwo\nthree\nfour\nfive"),+ user("Second café\nquestion"),+ user("\u{0007}"),+ cell("six\nseven\neight\nnine\nten"),+ ];+ let mut view = TranscriptView::default();+ let mut snapshots = Vec::new();+ snapshots.push(format!(+ "Latest\n{}",+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 5+ ))+ ));+ assert_eq!(view.area.y, 1);+ view.jump_to_entry(&cells, /*index*/ 1);+ snapshots.push(format!(+ "Earlier answer\n{}",+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 5+ ))+ ));+ assert_eq!(view.visible[0].index, 1);+ cells.insert(/*index*/ 0, user("Prepend history"));+ view.history_loaded(&cells, 0..1);+ snapshots.push(format!(+ "After prepend\n{}",+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 5+ ))+ ));+ view.jump_to_entry(&cells, /*index*/ 1);+ snapshots.push(format!(+ "Prompt visible\n{}",+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 5+ ))+ ));+ assert_eq!(view.area.y, 0);+ view.jump_to_latest();+ snapshots.push(format!(+ "Short screen\n{}",+ text(&render(+ &mut view, &cells, /*width*/ 30, /*height*/ 3+ ))+ ));+ assert_eq!(view.area.y, 0);+ insta::assert_snapshot!(snapshots.join("\n\n"));+}++#[test]+fn header_sanitizes_controls_and_truncates_by_display_width() {+ let cells = vec![user("\x1b[31m界 café\r\nnext question"), cell("answer")];+ let line = line(&cells, /*first*/ 1, /*width*/ 18).unwrap();+ assert!(line.width() <= 18);+ insta::assert_snapshot!(line.to_string());+}++#[test]+fn mouse_selection_preserves_header_reservation_at_turn_boundaries() {+ let cells = vec![+ user("First question"),+ cell("first answer"),+ user("Second question"),+ cell("done 10:16 AM"),+ ];+ for width in [40, 15] {+ for height in [6, 7, 8] {+ for drag in [false, true] {+ let mut view = TranscriptView::default();+ let before = render(&mut view, &cells, width, height);+ let down = MouseEvent {+ kind: MouseEventKind::Down(MouseButton::Left),+ column: 5,+ row: height - 1,+ modifiers: KeyModifiers::NONE,+ };+ view.handle_mouse(down, &cells);+ assert_eq!(+ render(&mut view, &cells, width, height),+ before,+ "mouse down at {width}x{height}"+ );+ if !drag {+ view.handle_mouse(+ MouseEvent {+ kind: MouseEventKind::Up(MouseButton::Left),+ ..down+ },+ &cells,+ );+ assert_eq!(+ (+ render(&mut view, &cells, width, height),+ view.selected_text(&cells),+ view.is_following(),+ ),+ (before, None, true),+ "empty release at {width}x{height}"+ );+ continue;+ }+ let end = MouseEvent {+ kind: MouseEventKind::Drag(MouseButton::Left),+ column: 13,+ ..down+ };+ view.handle_mouse(end, &cells);+ let selected = render(&mut view, &cells, width, height);+ assert_eq!(text(&selected), text(&before));+ assert_eq!(view.selected_text(&cells).as_deref(), Some("10:16 AM"));+ view.handle_mouse(+ MouseEvent {+ kind: MouseEventKind::Up(MouseButton::Left),+ ..end+ },+ &cells,+ );+ assert_eq!(render(&mut view, &cells, width, height), selected);+ let Some(ViewAction::Copy(copied)) = view.handle_key(+ KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL),+ &cells,+ ) else {+ panic!("copy selection at {width}x{height}");+ };+ assert_eq!(copied, "10:16 AM");+ assert_eq!(+ selected+ .content+ .iter()+ .filter(|cell| cell.modifier.contains(Modifier::REVERSED))+ .map(ratatui::buffer::Cell::symbol)+ .collect::<String>(),+ copied+ );+ }+ }+ }+}++#[test]+fn paused_header_reservation_survives_copy_until_scroll_or_resize() {+ let cells = vec![+ user("First question"),+ cell("first answer"),+ user("Second question"),+ cell("done 10:16 AM"),+ ];+ for scroll in [false, true] {+ let mut view = TranscriptView::default();+ let before = render(&mut view, &cells, /*width*/ 40, /*height*/ 7);+ view.begin_selection(&cells, /*column*/ 0, /*row*/ 6, /*clicks*/ 2);+ assert_eq!(+ text(&render(+ &mut view, &cells, /*width*/ 40, /*height*/ 7+ )),+ text(&before)+ );+ let selected = view.selected_text(&cells).expect("selected word");+ assert_eq!(selected, "done");+ view.copy_selected_text_with(&cells, &selected, |_| {+ Ok(crate::clipboard_copy::CopyStatus::Confirmed)+ })+ .expect("confirmed copy");+ let bookmark = view.bookmark(&cells);+ view.set_presentation(/*detailed*/ true, HistoryRenderMode::Rich);+ view.jump_to_entry(&cells, /*index*/ 0);+ render(&mut view, &cells, /*width*/ 40, /*height*/ 7);+ view.restore_bookmark(bookmark);+ assert_eq!(+ (+ render(&mut view, &cells, /*width*/ 40, /*height*/ 7),+ view.is_following(),+ ),+ (before, false)+ );+ let height = if scroll {+ view.scroll(&cells, /*rows*/ -1);+ 7+ } else {+ 8+ };+ render(&mut view, &cells, /*width*/ 40, height);+ assert_eq!(view.area.y, 1);+ }+}diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__header_sanitizes_controls_and_truncates_by_display_width.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__header_sanitizes_controls_and_truncates_by_display_width.snapnew file mode 100644index 0000000000..a0a5c35f7d--- /dev/null+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__header_sanitizes_controls_and_truncates_by_display_width.snap@@ -0,0 +1,6 @@+---+source: tui/src/transcript_view/prompt_header_tests.rs+assertion_line: 76+expression: line.to_string()+---+界 café next ques…diff --git a/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__prompt_header_tracks_reading_and_yields_to_visible_prompts_and_short_screens.snap b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__prompt_header_tracks_reading_and_yields_to_visible_prompts_and_short_screens.snapnew file mode 100644index 0000000000..d96fd4221a--- /dev/null+++ b/codex-rs/tui/src/transcript_view/snapshots/codex_tui__transcript_view__prompt_header__tests__prompt_header_tracks_reading_and_yields_to_visible_prompts_and_short_screens.snap@@ -0,0 +1,37 @@+---+source: tui/src/transcript_view/prompt_header_tests.rs+assertion_line: 68+expression: "snapshots.join(\"\\n\\n\")"+---+Latest+Second café question+seven+eight+nine+ten++Earlier answer+First question+one+two+three+four++After prepend+First question+one+two+three+four++Prompt visible++› First question+++one++Short screen+eight+nine+ten