Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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-L216
let 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.presentation
diff --git a/codex-rs/tui/src/app/activity_groups_tests.rs b/codex-rs/tui/src/app/activity_groups_tests.rs
index 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, &current.items[1..2]));
app.join_older_activity_group(/*boundary*/ 1, std::slice::from_ref(&current));
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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.snap
new file mode 100644
index 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.snap
new file mode 100644
index 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/project
diff --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.snap
new file mode 100644
index 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 back
diff --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.snap
new file mode 100644
index 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 back
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 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() -> Res
let 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() -> Res
app.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() -> Res
AppEvent::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.rs
new file mode 100644
index 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.rs
index 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_dupl
proxy.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.rs
index 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 = true
return 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 = true
insta::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.snap
index 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 prompts
diff --git a/codex-rs/tui/src/app/tests/transcript_composer.rs b/codex-rs/tui/src/app/tests/transcript_composer.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.snap
index 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.rs
expression: rendered
---
• Ran first_token_is_long_en
diff --git a/codex-rs/tui/src/keymap/chords.rs b/codex-rs/tui/src/keymap/chords.rs
index 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.snap
index 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: 664
expression: "buffer_to_text(&actual, area)"
---
/ T R A N S C R I P T / / / / / / / / /
@@ -11,4 +11,4 @@ last
Ctrl+Space select
↑/↓ to scroll · pgup/pgdn to page · hom
- q close · f3 find · esc edit previous
+ q close · f3 find · esc browse prompts
diff --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.snap
index 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: 417
expression: snapshots
---
--- loading ---
@@ -23,7 +23,7 @@ recent transcript
Earlier 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 transcript
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
diff --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.snap
index 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 transcript
Earlier 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 transcript
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
diff --git a/codex-rs/tui/src/pager_overlay/transcript.rs b/codex-rs/tui/src/pager_overlay/transcript.rs
index 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.snap
index 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 prompts
after:
@@ -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 prompts
diff --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.snap
index 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 prompts
after:
@@ -64,4 +64,4 @@ next message
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
diff --git a/codex-rs/tui/src/transcript_view.rs b/codex-rs/tui/src/transcript_view.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.snap
new file mode 100644
index 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.snap
new file mode 100644
index 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