Lightweight coding agent that runs in your terminal
Rust
Improve paginated TUI history loading (#36949)
Felipe Coury3b8d22ec2c75
diff --git a/codex-rs/app-server/README.md b/codex-rs/app-server/README.mdindex 49d5ee83ae..9a01e92b9e 100644--- a/codex-rs/app-server/README.md+++ b/codex-rs/app-server/README.md@@ -349,7 +349,7 @@ Valid `personality` values are `"friendly"`, `"pragmatic"`, and `"none"`. When `To continue a stored session, call `thread/resume` with the `thread.id` you previously recorded. The response shape matches `thread/start`. When the stored session includes persisted token usage, the server emits `thread/tokenUsage/updated` immediately after the response so clients can render restored usage before the next turn starts. You can also pass the same configuration overrides supported by `thread/start`, including `approvalsReviewer`.-By default, `thread/resume` includes the reconstructed turn history in `thread.turns`. Experimental clients can pass `excludeTurns: true` to return only thread metadata and live resume state, then call `thread/turns/list` separately if they want to page the turn history over the network. In that mode the server also skips replaying restored `thread/tokenUsage/updated`, which avoids rebuilding turns just to attribute historical usage.+By default, `thread/resume` includes the reconstructed turn history in `thread.turns`. Experimental clients can pass `excludeTurns: true` to return only thread metadata and live resume state, then call `thread/turns/list` separately if they want to page the turn history over the network. A cold paginated resume can still replay persisted `thread/tokenUsage/updated` when it can identify the corresponding stored turn; resuming an already-loaded thread waits for the next live update.Paginated threads keep the same resume contract as legacy threads. A default resume materializes the full projected history into `thread.turns`; `excludeTurns: true` keeps that array empty and includes `turnsBackwardsCursor` and `itemsBackwardsCursor` for the durable history visible at the resume boundary. Pass each cursor directly to its matching list API with `sortDirection: "desc"`; the first page includes the cursor's head row, while newer records arrive through live notifications. Either cursor is `null` when there is no durable row yet.@@ -405,7 +405,7 @@ To branch from a stored session, call `thread/fork` with the `thread.id`. This c{ "method": "thread/started", "params": { "thread": { … } } }```-Like `thread/resume`, experimental clients can pass `excludeTurns: true` to `thread/fork` to return only thread metadata in `thread.turns` and page history with `thread/turns/list`. In that mode the server skips replaying restored `thread/tokenUsage/updated`, which keeps the fork path from rebuilding turns just to attribute historical usage. Ephemeral forks of paginated threads require `excludeTurns: true`.+Like `thread/resume`, experimental clients can pass `excludeTurns: true` to `thread/fork` to return only thread metadata in `thread.turns` and page history with `thread/turns/list`. Metadata-only forks do not replay restored `thread/tokenUsage/updated`. Ephemeral forks of paginated threads require `excludeTurns: true`.### Example: List threads (with pagination & filters)diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 047cdd1736..13f3ea109c 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -1090,6 +1090,7 @@ See the Codex keymap documentation for supported actions and examples."if let Some(entry) = startup_hooks_browser {app.chat_widget.open_hooks_browser(entry);}+ app.update_visible_history_rows(tui.terminal.last_known_screen_size);let initial_session_started_at = Instant::now();if let Some(started) = initial_started_thread {let thread_id = started.session.thread_id;diff --git a/codex-rs/tui/src/app/resize_reflow.rs b/codex-rs/tui/src/app/resize_reflow.rsindex 266d3aa602..823596a12a 100644--- a/codex-rs/tui/src/app/resize_reflow.rs+++ b/codex-rs/tui/src/app/resize_reflow.rs@@ -19,6 +19,7 @@ use std::sync::Arc;use std::time::Instant;use color_eyre::eyre::Result;+use ratatui::layout::Size;use ratatui::text::Line;use super::App;@@ -192,7 +193,8 @@ impl App {return;}- let max_rows = self.resize_reflow_max_rows();+ let max_rows =+ crate::resize_reflow_cap::resize_reflow_max_rows(self.config.terminal_resize_reflow);if let Some(buffer) = &mut self.initial_history_replay_buffer {if let Some(max_rows) = max_rows {Self::buffer_initial_history_replay_display_lines(buffer, display, max_rows);@@ -239,6 +241,19 @@ impl App {crate::resize_reflow_cap::resize_reflow_max_rows(self.config.terminal_resize_reflow)}+ pub(super) fn update_visible_history_rows(&mut self, screen_size: Size) {+ let width = screen_size.width.max(/*other*/ 1);+ let viewport_height = self+ .with_chat_widget_frame(width, |desired_height, _| desired_height)+ .min(screen_size.height);+ self.transcript_reflow.set_visible_history_rows(+ screen_size+ .height+ .saturating_sub(viewport_height)+ .max(/*other*/ 1),+ );+ }+fn clear_terminal_for_resize_replay(&mut self, tui: &mut tui::Tui) -> Result<()> {if tui.is_alt_screen_active() {tui.terminal.clear_visible_screen()?;@@ -316,6 +331,10 @@ impl App {last_known_screen_size: ratatui::layout::Size,frame_requester: &tui::FrameRequester,) -> bool {+ if size != last_known_screen_size || self.transcript_reflow.visible_history_rows().is_none()+ {+ self.update_visible_history_rows(size);+ }let width = self.transcript_reflow.note_width(size.width);let reflow_needed = self.transcript_reflow.reflow_needed_for_width(size.width);let height_changed = size.height != last_known_screen_size.height;@@ -570,3 +589,7 @@ impl App {< self.transcript_cells.len()}}++#[cfg(test)]+#[path = "resize_reflow_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/resize_reflow_tests.rs b/codex-rs/tui/src/app/resize_reflow_tests.rsnew file mode 100644index 0000000000..8caa683033--- /dev/null+++ b/codex-rs/tui/src/app/resize_reflow_tests.rs@@ -0,0 +1,144 @@+use super::*;+use crate::app::test_support::make_test_app;+use crate::history_cell::PlainHistoryCell;+use crate::legacy_core::config::TerminalResizeReflowMaxRows;+use pretty_assertions::assert_eq;++fn plain_history_cells(count: usize) -> Vec<Arc<dyn HistoryCell>> {+ (0..count)+ .map(|index| {+ Arc::new(PlainHistoryCell::new(vec![Line::from(format!(+ "cell {index}"+ ))])) as Arc<dyn HistoryCell>+ })+ .collect()+}++fn rendered_line_text(line: &HyperlinkLine) -> String {+ line.line+ .spans+ .iter()+ .map(|span| span.content.as_ref())+ .collect()+}++#[tokio::test]+async fn resize_reflow_preserves_configured_scrollback_beyond_the_visible_viewport() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);+ app.transcript_cells = plain_history_cells(/*count*/ 64);+ let screen_size = Size::new(/*width*/ 80, /*height*/ 24);+ let chat_height = app.with_chat_widget_frame(screen_size.width, |height, _| height);+ let visible_history_rows = screen_size+ .height+ .saturating_sub(chat_height)+ .max(/*other*/ 1);++ app.update_visible_history_rows(screen_size);+ let rendered = app.render_transcript_lines_for_reflow(screen_size.width);++ assert_eq!(app.resize_reflow_max_rows(), Some(32));+ assert_eq!(rendered.lines.len(), 32);+ assert!(rendered.lines.len() > usize::from(visible_history_rows));+ assert_eq!(+ rendered.lines.last().map(rendered_line_text),+ Some("cell 63".to_string())+ );+}++#[tokio::test]+async fn initial_resume_replay_retains_scrollback_beyond_the_visible_viewport() -> Result<()> {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);+ let screen_size = Size::new(/*width*/ 80, /*height*/ 24);+ app.update_visible_history_rows(screen_size);+ let visible_history_rows = app+ .transcript_reflow+ .visible_history_rows()+ .expect("visible history row budget");++ app.begin_initial_history_replay_buffer();+ let mut tui = crate::tui::test_support::make_test_tui()?;+ for cell in plain_history_cells(/*count*/ 24) {+ app.insert_history_cell_lines_with_initial_replay_buffer(+ &mut tui,+ cell.as_ref(),+ screen_size.width,+ );+ }++ let retained_lines = &app+ .initial_history_replay_buffer+ .as_ref()+ .expect("initial replay buffer should remain active")+ .retained_lines;+ assert_eq!(retained_lines.len(), 32);+ assert!(retained_lines.len() > usize::from(visible_history_rows));+ insta::assert_snapshot!(+ retained_lines+ .iter()+ .rev()+ .take(/*n*/ 3)+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ @r"+ cell 23++ cell 22+ "+ );+ Ok(())+}++#[tokio::test]+async fn resize_reflow_preserves_configured_scrollback_when_the_terminal_height_changes() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(48);+ app.transcript_cells = plain_history_cells(/*count*/ 64);++ app.update_visible_history_rows(Size::new(/*width*/ 80, /*height*/ 24));+ let smaller = app.render_transcript_lines_for_reflow(/*width*/ 80);+ app.update_visible_history_rows(Size::new(/*width*/ 80, /*height*/ 48));+ let larger = app.render_transcript_lines_for_reflow(/*width*/ 80);++ assert_eq!(smaller.lines.len(), 48);+ assert_eq!(larger.lines.len(), 48);+ assert_eq!(+ smaller+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>(),+ larger+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ );+ assert_eq!(+ larger.lines.last().map(rendered_line_text),+ Some("cell 63".to_string())+ );+}++#[tokio::test]+async fn resize_reflow_preserves_explicitly_unlimited_history() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Disabled;+ app.transcript_cells = plain_history_cells(/*count*/ 20);++ app.update_visible_history_rows(Size::new(/*width*/ 80, /*height*/ 24));+ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);++ assert_eq!(app.resize_reflow_max_rows(), None);+ assert_eq!(rendered.lines.len(), 39);+ assert_eq!(+ rendered.lines.first().map(rendered_line_text),+ Some("cell 0".to_string())+ );+ assert_eq!(+ rendered.lines.last().map(rendered_line_text),+ Some("cell 19".to_string())+ );+}diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex d8af260df4..b835095277 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -186,6 +186,7 @@ async fn older_pagination_reconciles_review_prompts_across_page_boundaries() ->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());+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(100);let thread_id = create_fake_paginated_rollout(codex_home.path(),"2026-01-02T00-00-00",diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rsindex b85769b45b..110226c6ed 100644--- a/codex-rs/tui/src/app_backtrack.rs+++ b/codex-rs/tui/src/app_backtrack.rs@@ -28,6 +28,7 @@ use crate::app::App;use crate::app_event::AppEvent;use crate::app_server_session::AppServerSession;use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;+use crate::app_server_session::thread_items_page_params;use crate::bottom_pane::LocalImageAttachment;use crate::chatwidget::ChatWidget;use crate::chatwidget::UserMessage;@@ -40,9 +41,7 @@ use crate::pager_overlay::Overlay;use crate::tui;use crate::tui::TuiEvent;use codex_app_server_protocol::ClientRequest;-use codex_app_server_protocol::SortDirection;use codex_app_server_protocol::ThreadItem;-use codex_app_server_protocol::ThreadItemsListParams;use codex_app_server_protocol::ThreadItemsListResponse;use codex_app_server_protocol::Turn;use codex_app_server_protocol::TurnStatus;@@ -114,13 +113,12 @@ impl App {let result = request_handle.request_typed::<ThreadItemsListResponse>(ClientRequest::ThreadItemsList {request_id,- params: ThreadItemsListParams {- thread_id: thread_id.to_string(),- turn_id: None,- cursor: Some(cursor.clone()),- limit: Some(HISTORY_ITEM_PAGE_LIMIT),- sort_direction: Some(SortDirection::Desc),- },+ params: thread_items_page_params(+ thread_id,+ /*turn_id*/ None,+ Some(cursor.clone()),+ HISTORY_ITEM_PAGE_LIMIT,+ ),}).await.map_err(|err| err.to_string());diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 3c8db59e47..d3bf82d2cd 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -7,6 +7,9 @@ mod fs;mod history;pub(crate) use history::HISTORY_ITEM_PAGE_LIMIT;+pub(crate) use history::HISTORY_ITEM_SCAN_LIMIT;+pub(crate) use history::HistoryHydrationScope;+pub(crate) use history::thread_items_page_params;use crate::bottom_pane::FeedbackAudience;use crate::legacy_core::config::Config;@@ -578,6 +581,7 @@ impl AppServerSession {response.turns_backwards_cursor.clone(),response.items_backwards_cursor.clone(),Some(&config),+ HistoryHydrationScope::Initial,).await?;let fork_parent_title = self@@ -691,6 +695,7 @@ impl AppServerSession {/*turn_cursor*/ None,/*item_cursor*/ None,Some(&config),+ HistoryHydrationScope::Initial,).await?;}@@ -824,6 +829,7 @@ impl AppServerSession {/*turn_cursor*/ None,/*item_cursor*/ None,/*config*/ None,+ HistoryHydrationScope::Initial,).await?;Ok(response.thread)diff --git a/codex-rs/tui/src/app_server_session/history.rs b/codex-rs/tui/src/app_server_session/history.rsindex 01cf943da3..93a44f35f6 100644--- a/codex-rs/tui/src/app_server_session/history.rs+++ b/codex-rs/tui/src/app_server_session/history.rs@@ -1,11 +1,13 @@//! Bounded app-server transcript loading for resume, fork, and transcript views.+use std::collections::HashSet;+use super::AppServerSession;use crate::history_cell::HistoryRenderMode;use crate::legacy_core::config::Config;use crate::resize_reflow_cap::resize_reflow_max_rows;use crate::thread_transcript::RawReasoningVisibility;-use crate::thread_transcript::thread_to_transcript_cells;+use crate::thread_transcript::thread_items_to_transcript_cells;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::SortDirection;use codex_app_server_protocol::Thread;@@ -23,12 +25,47 @@ use color_eyre::eyre::WrapErr;pub(crate) const INITIAL_HISTORY_TURN_LIMIT: u32 = 5;pub(crate) const HISTORY_ITEM_PAGE_LIMIT: u32 = 100;+pub(crate) const HISTORY_ITEM_SCAN_LIMIT: usize = 4 * HISTORY_ITEM_PAGE_LIMIT as usize;++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum HistoryHydrationScope {+ Initial,+ Complete,+}++pub(crate) fn thread_items_page_params(+ thread_id: ThreadId,+ turn_id: Option<&str>,+ cursor: Option<String>,+ limit: u32,+) -> ThreadItemsListParams {+ ThreadItemsListParams {+ thread_id: thread_id.to_string(),+ turn_id: turn_id.map(str::to_string),+ cursor,+ limit: Some(limit),+ sort_direction: Some(SortDirection::Desc),+ }+}++fn advancing_cursor(+ current: Option<&str>,+ next: Option<String>,+ seen_cursors: &mut HashSet<String>,+) -> Option<String> {+ if let Some(current) = current {+ seen_cursors.insert(current.to_string());+ }+ next.filter(|next| seen_cursors.insert(next.clone()))+}#[derive(Clone, Debug, Default)]pub(crate) struct ThreadHistoryPagination {pub(super) history_mode: ThreadHistoryMode,next_turn_cursor: Option<String>,next_item_cursor: Option<String>,+ seen_turn_cursors: HashSet<String>,+ seen_item_cursors: HashSet<String>,loading_older: bool,}@@ -76,6 +113,23 @@ impl AppServerSession {Ok(items)}+ pub(crate) async fn thread_items_page(+ &mut self,+ thread_id: ThreadId,+ turn_id: Option<&str>,+ cursor: Option<String>,+ limit: u32,+ ) -> Result<ThreadItemsListResponse> {+ let request_id = self.next_request_id();+ self.client+ .request_typed(ClientRequest::ThreadItemsList {+ request_id,+ params: thread_items_page_params(thread_id, turn_id, cursor, limit),+ })+ .await+ .wrap_err("failed to load a bounded thread item page")+ }+async fn thread_turns_page(&mut self,thread_id: ThreadId,@@ -104,15 +158,25 @@ impl AppServerSession {state: &mut ThreadHistoryPagination,turns: &mut Vec<Turn>,) -> Result<Vec<ThreadItem>> {- state.next_item_cursor = page.next_cursor;+ state.next_item_cursor = advancing_cursor(+ state.next_item_cursor.as_deref(),+ page.next_cursor,+ &mut state.seen_item_cursors,+ );let mut items = Vec::new();for entry in page.data {while !turns.iter().any(|turn| turn.id == entry.turn_id) {let Some(cursor) = state.next_turn_cursor.take() else {break;};- let page = self.thread_turns_page(thread_id, Some(cursor)).await?;- state.next_turn_cursor = page.next_cursor;+ let page = self+ .thread_turns_page(thread_id, Some(cursor.clone()))+ .await?;+ state.next_turn_cursor = advancing_cursor(+ Some(&cursor),+ page.next_cursor,+ &mut state.seen_turn_cursors,+ );turns.splice(0..0, page.data.into_iter().rev());}if let Some(turn) = turns.iter_mut().find(|turn| turn.id == entry.turn_id)@@ -133,6 +197,7 @@ impl AppServerSession {turn_cursor: Option<String>,item_cursor: Option<String>,config: Option<&Config>,+ scope: HistoryHydrationScope,) -> Result<()> {let thread_id = ThreadId::from_string(&thread.id).wrap_err("invalid thread id in bounded history response")?;@@ -154,53 +219,57 @@ impl AppServerSession {next_item_cursor: item_cursor,..ThreadHistoryPagination::default()};- let row_budget =- config.and_then(|config| resize_reflow_max_rows(config.terminal_resize_reflow));- let item_budget = if config.is_some() && row_budget.is_none() {- None- } else {- Some(HISTORY_ITEM_PAGE_LIMIT as usize)- };let width = crossterm::terminal::size().map(|(width, _)| width.max(/*other*/ 1)).unwrap_or(/*default*/ 80);+ let row_budget =+ config.and_then(|config| resize_reflow_max_rows(config.terminal_resize_reflow));+ let item_budget = match (scope, config, row_budget) {+ (HistoryHydrationScope::Complete, _, _)+ | (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 mut scanned_items = 0;+ let mut rendered_rows = 0;loop {- let remaining_rows = row_budget.map(|budget| {- budget.saturating_sub(config.map_or(/*default*/ 0, |config| {- rendered_history_rows(thread, config, width)- }))- });+ 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_rows+ let limit = remaining_items.unwrap_or(HISTORY_ITEM_PAGE_LIMIT as usize)- .min(remaining_items.unwrap_or(HISTORY_ITEM_PAGE_LIMIT as usize))- .min(HISTORY_ITEM_PAGE_LIMIT as usize) as u32;- let request_id = self.next_request_id();- let page: ThreadItemsListResponse = self- .client- .request_typed(ClientRequest::ThreadItemsList {- request_id,- params: ThreadItemsListParams {- thread_id: thread_id.to_string(),- turn_id: None,- cursor: state.next_item_cursor.clone(),- limit: Some(limit),- sort_direction: Some(SortDirection::Desc),- },- })- .await- .wrap_err("failed to load a bounded thread item page")?;+ .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;+ let page = self+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ state.next_item_cursor.clone(),+ limit,+ )+ .await?;if page.data.is_empty() {state.next_item_cursor = None;break;}scanned_items = scanned_items.saturating_add(page.data.len());- self.merge_thread_item_page(thread_id, page, &mut state, &mut thread.turns)+ let items = self+ .merge_thread_item_page(thread_id, page, &mut state, &mut thread.turns).await?;+ if let Some(config) = config {+ rendered_rows =+ rendered_history_rows(thread_id, thread, items, config, width, rendered_rows);+ } else {+ rendered_rows = rendered_rows.saturating_add(items.len());+ }if state.next_item_cursor.is_none() {break;}@@ -212,10 +281,14 @@ impl AppServerSession {}}-fn rendered_history_rows(thread: &Thread, config: &Config, width: u16) -> usize {- if thread.turns.iter().all(|turn| turn.items.is_empty()) {- return 0;- }+fn rendered_history_rows(+ thread_id: ThreadId,+ thread: &Thread,+ items: Vec<ThreadItem>,+ config: &Config,+ width: u16,+ rendered_rows: usize,+) -> usize {let visibility = if config.show_raw_agent_reasoning {RawReasoningVisibility::Visible} else {@@ -226,14 +299,20 @@ fn rendered_history_rows(thread: &Thread, config: &Config, width: u16) -> usize} else {HistoryRenderMode::Rich};- thread_to_transcript_cells(- thread.clone(),+ thread_items_to_transcript_cells(+ Some(thread_id),+ &thread.cwd,+ items,visibility,Some(config.codex_home.as_path()),).into_iter()- .fold(/*init*/ 0, |rows, cell| {+ .fold(rendered_rows, |rows, cell| {let height = usize::from(cell.desired_height_for_mode(width, mode));rows + height + usize::from(height != 0 && rows != 0 && !cell.is_stream_continuation())})}++#[cfg(test)]+#[path = "history_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app_server_session/history_tests.rs b/codex-rs/tui/src/app_server_session/history_tests.rsnew file mode 100644index 0000000000..c498db3e8a--- /dev/null+++ b/codex-rs/tui/src/app_server_session/history_tests.rs@@ -0,0 +1,28 @@+use super::advancing_cursor;+use pretty_assertions::assert_eq;+use std::collections::HashSet;++#[test]+fn advancing_cursor_rejects_repeated_cursors() {+ let mut seen_cursors = HashSet::new();+ assert_eq!(+ advancing_cursor(+ /*current*/ None,+ Some("first".to_string()),+ &mut seen_cursors,+ ),+ Some("first".to_string())+ );+ assert_eq!(+ advancing_cursor(Some("first"), Some("second".to_string()), &mut seen_cursors,),+ Some("second".to_string())+ );+ assert_eq!(+ advancing_cursor(Some("second"), Some("first".to_string()), &mut seen_cursors,),+ None+ );+ assert_eq!(+ advancing_cursor(Some("second"), /*next*/ None, &mut seen_cursors),+ None+ );+}diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex 1f7e563231..4e25dc90e2 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -3239,6 +3239,123 @@ mod tests {Ok(())}+ #[tokio::test]+ async fn resume_picker_loads_complete_paginated_and_legacy_transcripts()+ -> color_eyre::Result<()> {+ let temp_dir = TempDir::new()?;+ let mut config = build_config(&temp_dir).await?;+ config.terminal_resize_reflow.max_rows =+ crate::legacy_core::config::TerminalResizeReflowMaxRows::Limit(2);+ let mut app_server = AppServerSession::new(+ AppServerClient::InProcess(start_test_embedded_app_server(config.clone()).await?),+ ThreadParamsMode::Embedded,+ );+ let filename_ts = "2025-01-05T12-00-00";+ let rollout_line = |ordinal: usize, payload: serde_json::Value| {+ serde_json::json!({+ "timestamp": "2025-01-05T12:00:00Z",+ "type": "event_msg",+ "payload": payload,+ "ordinal": ordinal,+ })+ };+ for (history_mode, create_rollout) in [+ app_test_support::create_fake_rollout,+ app_test_support::create_fake_paginated_rollout,+ ]+ .into_iter()+ .enumerate()+ {+ let thread_id = create_rollout(+ temp_dir.path(),+ filename_ts,+ "2025-01-05T12:00:00Z",+ "message 0",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create session rollout");+ let path = app_test_support::rollout_path(temp_dir.path(), filename_ts, &thread_id);+ let mut contents = std::fs::read_to_string(&path)?;+ let started = rollout_line(+ /*ordinal*/ 3,+ serde_json::json!({ "type": "task_started", "turn_id": "history-turn", "model_context_window": null }),+ );+ contents.push_str(&format!("{started}\n"));+ for index in 0..=100 {+ let message = format!("message {index}");+ let payload = if history_mode == 1 {+ serde_json::json!({+ "type": "item_completed",+ "thread_id": thread_id,+ "turn_id": "history-turn",+ "item": { "type": "UserMessage", "id": format!("user-{index}"),+ "content": [{ "type": "text", "text": message }] },+ })+ } else {+ serde_json::json!({ "type": "user_message", "message": message })+ };+ let item = rollout_line(index + 4, payload);+ contents.push_str(&format!("{item}\n"));+ }+ if history_mode == 1 {+ for index in 0..125 {+ let item = rollout_line(+ index + 105,+ serde_json::json!({+ "type": "item_completed",+ "thread_id": thread_id,+ "turn_id": "history-turn",+ "item": { "type": "Reasoning", "id": format!("hidden-{index}"),+ "summary_text": [], "raw_content": [] },+ }),+ );+ contents.push_str(&format!("{item}\n"));+ }+ }+ std::fs::write(path, contents)?;+ let thread_id = ThreadId::from_string(&thread_id)?;+ let started = app_server+ .resume_thread(+ config.clone(),+ thread_id,+ app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ if history_mode == 1 {+ assert!(+ started+ .turns+ .iter()+ .flat_map(|turn| &turn.items)+ .any(|item| {+ matches!(+ item,+ codex_app_server_protocol::ThreadItem::UserMessage { .. }+ )+ })+ );+ let preview = crate::resume_picker::load_transcript_preview(+ &mut app_server,+ thread_id,+ /*codex_home*/ None,+ )+ .await?;+ assert!(!preview.is_empty());+ }+ let cells = crate::thread_transcript::load_session_transcript(+ &mut app_server,+ thread_id,+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ /*codex_home*/ None,+ )+ .await?;+ assert!(cells.len() > 100);+ }+ app_server.shutdown().await?;+ Ok(())+ }+#[tokio::test]async fn lookup_session_target_by_name_uses_backend_title_search() -> color_eyre::Result<()> {Box::pin(async {diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex 00f69e342f..2a0e13940b 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -5,6 +5,8 @@ use std::path::PathBuf;use std::sync::Arc;use crate::app_server_session::AppServerSession;+use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;+use crate::app_server_session::HISTORY_ITEM_SCAN_LIMIT;use crate::clipboard_paste::normalize_pasted_search_query;use crate::color::blend;use crate::color::is_light;@@ -37,6 +39,7 @@ use crate::wrapping::adaptive_wrap_lines;use chrono::DateTime;use chrono::Utc;use codex_app_server_protocol::Thread;+use codex_app_server_protocol::ThreadHistoryMode;use codex_app_server_protocol::ThreadItem;use codex_app_server_protocol::ThreadListCwdFilter;use codex_app_server_protocol::ThreadListParams;@@ -62,6 +65,7 @@ use ratatui::text::Span;use ratatui::widgets::Clear;use ratatui::widgets::Widget;use tokio::sync::mpsc;+use tokio::sync::oneshot;use tokio_stream::StreamExt;use tokio_stream::wrappers::UnboundedReceiverStream;use tracing::warn;@@ -159,8 +163,13 @@ struct PageLoadRequest {enum PickerLoadRequest {Page(PageLoadRequest),- Preview { thread_id: ThreadId },- Transcript { thread_id: ThreadId },+ Preview {+ thread_id: ThreadId,+ },+ Transcript {+ thread_id: ThreadId,+ cancellation: oneshot::Receiver<()>,+ },}#[derive(Clone)]@@ -620,18 +629,24 @@ fn spawn_app_server_page_loader(.await;let _ = bg_tx.send(BackgroundEvent::Preview { thread_id, preview });}- PickerLoadRequest::Transcript { thread_id } => {- let transcript = load_session_transcript(- &mut app_server,- thread_id,- raw_reasoning_visibility,- codex_home.as_deref(),- )- .await;- let _ = bg_tx.send(BackgroundEvent::Transcript {- thread_id,- transcript,- });+ PickerLoadRequest::Transcript {+ thread_id,+ cancellation,+ } => {+ tokio::select! {+ transcript = load_session_transcript(+ &mut app_server,+ thread_id,+ raw_reasoning_visibility,+ codex_home.as_deref(),+ ) => {+ let _ = bg_tx.send(BackgroundEvent::Transcript {+ thread_id,+ transcript,+ });+ }+ _ = cancellation => {}+ }}}}@@ -706,6 +721,7 @@ struct PickerState {transcript_previews: HashMap<ThreadId, TranscriptPreviewState>,transcript_cells: HashMap<ThreadId, SessionTranscriptState>,pending_transcript_open: Option<ThreadId>,+ pending_transcript_cancellation: Option<oneshot::Sender<()>>,transcript_loading_frame_shown: bool,overlay: Option<Overlay>,pager_keymap: PagerKeymap,@@ -735,7 +751,7 @@ enum SessionTranscriptState {}#[derive(Clone)]-struct TranscriptPreviewLine {+pub(crate) struct TranscriptPreviewLine {speaker: TranscriptPreviewSpeaker,text: String,}@@ -785,81 +801,145 @@ async fn load_app_server_page(})}-async fn load_transcript_preview(+pub(crate) async fn load_transcript_preview(app_server: &mut AppServerSession,thread_id: ThreadId,codex_home: Option<&Path>,) -> std::io::Result<Vec<TranscriptPreviewLine>> {const MAX_PREVIEW_LINES: usize = 6;- let thread = app_server- .thread_read(thread_id, /*include_turns*/ true)+ let mut thread = app_server+ .thread_read(thread_id, /*include_turns*/ false).await.map_err(std::io::Error::other)?;+ if thread.history_mode == ThreadHistoryMode::Legacy {+ app_server+ .hydrate_initial_thread_history(+ &mut thread,+ /*turn_cursor*/ None,+ /*item_cursor*/ None,+ /*config*/ None,+ crate::app_server_session::HistoryHydrationScope::Initial,+ )+ .await+ .map_err(std::io::Error::other)?;+ }let cwd = thread.cwd.as_path();let inline_visualization_context = codex_home.and_then(|codex_home| {ThreadId::from_string(&thread.id).ok().and_then(|thread_id| InlineVisualizationContext::new(codex_home, thread_id))});- let mut lines = thread- .turns- .iter()- .flat_map(|turn| turn.items.iter())- .filter_map(|item| match item {- ThreadItem::UserMessage { content, .. } => Some(TranscriptPreviewLine {- speaker: TranscriptPreviewSpeaker::User,- text: content- .iter()- .filter_map(|input| match input {- codex_app_server_protocol::UserInput::Text { text, .. } => {- Some(text.as_str())- }- _ => None,- })- .collect::<Vec<_>>()- .join(" "),- }),- ThreadItem::AgentMessage { text, .. } => {- let visible_markdown = parse_assistant_markdown(text, cwd).visible_markdown;- let rewritten = crate::inline_visualization::rewrite_inline_visualizations(- &visible_markdown,+ let mut lines = if thread.history_mode == ThreadHistoryMode::Paginated {+ let mut groups = Vec::new();+ let mut visible_lines = 0_usize;+ let mut scanned_items = 0_usize;+ let mut cursor = None;+ let mut seen_cursors = HashSet::new();+ loop {+ let page = app_server+ .thread_items_page(+ thread_id,+ /*turn_id*/ None,+ cursor.clone(),+ HISTORY_ITEM_PAGE_LIMIT,+ )+ .await+ .map_err(std::io::Error::other)?;+ scanned_items = scanned_items.saturating_add(page.data.len());+ for entry in page.data {+ let item_lines = transcript_preview_lines_for_item(+ &entry.item,+ cwd,inline_visualization_context.as_ref(),);- let mut text = rewritten.markdown.into_owned();- for (placeholder, link) in &rewritten.trusted_file_links {- text = text.replace(- &format!(- "{} \n[{}]({placeholder})",- link.markdown_label, link.markdown_destination_label- ),- &format!("{} \n{}", link.display_label, link.destination),- );+ visible_lines = visible_lines.saturating_add(item_lines.len());+ if !item_lines.is_empty() {+ groups.push(item_lines);+ }+ if visible_lines >= MAX_PREVIEW_LINES {+ break;}- Some(TranscriptPreviewLine {- speaker: TranscriptPreviewSpeaker::Assistant,- text,- })}- _ => None,- })- .flat_map(|line| {- line.text- .lines()- .filter(|text| !text.trim().is_empty())- .map(move |text| TranscriptPreviewLine {- speaker: line.speaker,- text: text.trim().to_string(),- })- .collect::<Vec<_>>()- })- .collect::<Vec<_>>();+ if visible_lines >= MAX_PREVIEW_LINES || scanned_items >= HISTORY_ITEM_SCAN_LIMIT {+ break;+ }+ let Some(next_cursor) = page+ .next_cursor+ .filter(|next| seen_cursors.insert(next.clone()))+ else {+ break;+ };+ cursor = Some(next_cursor);+ }+ groups.into_iter().rev().flatten().collect::<Vec<_>>()+ } else {+ thread+ .turns+ .iter()+ .flat_map(|turn| turn.items.iter())+ .flat_map(|item| {+ transcript_preview_lines_for_item(item, cwd, inline_visualization_context.as_ref())+ })+ .collect::<Vec<_>>()+ };if lines.len() > MAX_PREVIEW_LINES {lines.drain(..lines.len() - MAX_PREVIEW_LINES);}Ok(lines)}+fn transcript_preview_lines_for_item(+ item: &ThreadItem,+ cwd: &Path,+ inline_visualization_context: Option<&InlineVisualizationContext>,+) -> Vec<TranscriptPreviewLine> {+ let line = match item {+ ThreadItem::UserMessage { content, .. } => TranscriptPreviewLine {+ speaker: TranscriptPreviewSpeaker::User,+ text: content+ .iter()+ .filter_map(|input| match input {+ codex_app_server_protocol::UserInput::Text { text, .. } => Some(text.as_str()),+ _ => None,+ })+ .collect::<Vec<_>>()+ .join(" "),+ },+ ThreadItem::AgentMessage { text, .. } => {+ let visible_markdown = parse_assistant_markdown(text, cwd).visible_markdown;+ let rewritten = crate::inline_visualization::rewrite_inline_visualizations(+ &visible_markdown,+ inline_visualization_context,+ );+ let mut text = rewritten.markdown.into_owned();+ for (placeholder, link) in &rewritten.trusted_file_links {+ text = text.replace(+ &format!(+ "{} \n[{}]({placeholder})",+ link.markdown_label, link.markdown_destination_label+ ),+ &format!("{} \n{}", link.display_label, link.destination),+ );+ }+ TranscriptPreviewLine {+ speaker: TranscriptPreviewSpeaker::Assistant,+ text,+ }+ }+ _ => return Vec::new(),+ };++ line.text+ .lines()+ .filter(|text| !text.trim().is_empty())+ .map(|text| TranscriptPreviewLine {+ speaker: line.speaker,+ text: text.trim().to_string(),+ })+ .collect()+}+impl SearchState {fn active_token(&self) -> Option<usize> {match self {@@ -978,6 +1058,7 @@ impl PickerState {transcript_previews: HashMap::new(),transcript_cells: HashMap::new(),pending_transcript_open: None,+ pending_transcript_cancellation: None,transcript_loading_frame_shown: false,overlay: None,pager_keymap: RuntimeKeymap::defaults().pager,@@ -1084,7 +1165,12 @@ impl PickerState {self.transcript_cells.insert(thread_id, SessionTranscriptState::Loading);self.begin_transcript_loading(thread_id);- (self.picker_loader)(PickerLoadRequest::Transcript { thread_id });+ let (cancellation_tx, cancellation) = oneshot::channel();+ self.pending_transcript_cancellation = Some(cancellation_tx);+ (self.picker_loader)(PickerLoadRequest::Transcript {+ thread_id,+ cancellation,+ });}}}@@ -1096,6 +1182,22 @@ impl PickerState {modifiers,..} if modifiers.contains(KeyModifiers::CONTROL) => Some(SessionSelection::Exit),+ key if self.list_keymap.cancel.is_pressed(key) => {+ if let Some(thread_id) = self.pending_transcript_open.take()+ && matches!(+ self.transcript_cells.get(&thread_id),+ Some(SessionTranscriptState::Loading)+ )+ {+ self.transcript_cells.remove(&thread_id);+ }+ if let Some(cancellation) = self.pending_transcript_cancellation.take() {+ let _ = cancellation.send(());+ }+ self.transcript_loading_frame_shown = false;+ self.request_frame();+ None+ }_ => None,}}@@ -1404,6 +1506,7 @@ impl PickerState {self.transcript_cells.insert(thread_id, SessionTranscriptState::Loaded(cells.clone()));if should_open {+ self.pending_transcript_cancellation = None;self.open_pending_transcript_if_ready();}self.request_frame();@@ -1412,6 +1515,7 @@ impl PickerState {self.transcript_cells.insert(thread_id, SessionTranscriptState::Failed);if self.pending_transcript_open == Some(thread_id) {+ self.pending_transcript_cancellation = None;self.pending_transcript_open = None;self.transcript_loading_frame_shown = false;self.inline_error = Some("Could not load transcript preview".to_string());@@ -4389,7 +4493,7 @@ mod tests {let recorded_requests: Arc<Mutex<Vec<ThreadId>>> = Arc::new(Mutex::new(Vec::new()));let request_sink = recorded_requests.clone();let loader: PickerLoader = Arc::new(move |request| {- if let PickerLoadRequest::Transcript { thread_id } = request {+ if let PickerLoadRequest::Transcript { thread_id, .. } = request {request_sink.lock().unwrap().push(thread_id);}});@@ -4480,6 +4584,61 @@ mod tests {assert_eq!(state.query, "");}+ #[tokio::test]+ async fn escape_cancels_transcript_loading_and_restores_picker_navigation() {+ let thread_id = ThreadId::new();+ let cancellation = Arc::new(Mutex::new(None));+ let cancellation_sink = cancellation.clone();+ let loader: PickerLoader = Arc::new(move |request| {+ if let PickerLoadRequest::Transcript { cancellation, .. } = request {+ *cancellation_sink.lock().unwrap() = Some(cancellation);+ }+ });+ let mut state = PickerState::new(+ FrameRequester::test_dummy(),+ loader,+ ProviderFilter::MatchDefault(String::from("openai")),+ /*show_all*/ true,+ /*filter_cwd*/ None,+ SessionPickerAction::Resume,+ );+ let mut first = make_row("/tmp/1.jsonl", "2026-05-02T12:00:00Z", "one");+ first.thread_id = Some(thread_id);+ state.filtered_rows = vec![+ first,+ make_row("/tmp/2.jsonl", "2026-05-02T12:00:00Z", "two"),+ ];++ state+ .handle_key(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL))+ .await+ .unwrap();+ assert_eq!(state.pending_transcript_open, Some(thread_id));++ state+ .handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE))+ .await+ .unwrap();++ assert_eq!(state.pending_transcript_open, None);+ assert!(!state.transcript_cells.contains_key(&thread_id));+ assert!(+ cancellation+ .lock()+ .unwrap()+ .as_mut()+ .expect("transcript cancellation receiver")+ .try_recv()+ .is_ok()+ );++ state+ .handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE))+ .await+ .unwrap();+ assert_eq!(state.selected, 1);+ }+#[tokio::test]async fn transcript_loading_still_allows_ctrl_c_exit() {let loader = page_only_loader(|_| {});@@ -4571,7 +4730,7 @@ mod tests {let recorded_requests: Arc<Mutex<Vec<ThreadId>>> = Arc::new(Mutex::new(Vec::new()));let request_sink = recorded_requests.clone();let loader: PickerLoader = Arc::new(move |request| {- if let PickerLoadRequest::Transcript { thread_id } = request {+ if let PickerLoadRequest::Transcript { thread_id, .. } = request {request_sink.lock().unwrap().push(thread_id);}});diff --git a/codex-rs/tui/src/thread_transcript.rs b/codex-rs/tui/src/thread_transcript.rsindex a2f74e7933..f2142cc1de 100644--- a/codex-rs/tui/src/thread_transcript.rs+++ b/codex-rs/tui/src/thread_transcript.rs@@ -3,6 +3,7 @@use std::sync::Arc;use crate::app_server_session::AppServerSession;+use crate::app_server_session::HistoryHydrationScope;use crate::git_action_directives::parse_assistant_markdown;use crate::history_cell::AgentMarkdownCell;use crate::history_cell::HistoryCell;@@ -35,8 +36,18 @@ pub(crate) async fn load_session_transcript(raw_reasoning_visibility: RawReasoningVisibility,codex_home: Option<&std::path::Path>,) -> std::io::Result<TranscriptCells> {- let thread = app_server- .thread_read(thread_id, /*include_turns*/ true)+ let mut thread = app_server+ .thread_read(thread_id, /*include_turns*/ false)+ .await+ .map_err(std::io::Error::other)?;+ app_server+ .hydrate_initial_thread_history(+ &mut thread,+ /*turn_cursor*/ None,+ /*item_cursor*/ None,+ /*config*/ None,+ HistoryHydrationScope::Complete,+ ).await.map_err(std::io::Error::other)?;Ok(thread_to_transcript_cells(diff --git a/codex-rs/tui/src/transcript_reflow.rs b/codex-rs/tui/src/transcript_reflow.rsindex d95d99c944..3924e8ae1c 100644--- a/codex-rs/tui/src/transcript_reflow.rs+++ b/codex-rs/tui/src/transcript_reflow.rs@@ -29,6 +29,7 @@ pub(crate) struct TranscriptReflowState {last_reflow_width: Option<u16>,pending_reflow_width: Option<u16>,pending_until: Option<Instant>,+ visible_history_rows: Option<u16>,ran_during_stream: bool,resize_requested_during_stream: bool,}@@ -43,6 +44,16 @@ impl TranscriptReflowState {*self = Self::default();}+ /// Cache the history rows left above the composer for the current terminal size.+ pub(crate) fn set_visible_history_rows(&mut self, rows: u16) {+ self.visible_history_rows = Some(rows.max(/*other*/ 1));+ }++ /// Return the last viewport budget without querying the terminal during cell replay.+ pub(crate) fn visible_history_rows(&self) -> Option<u16> {+ self.visible_history_rows+ }+/// Record the width observed during a draw and report whether it is new or changed.////// The first observed width initializes the state without scheduling a rebuild because no@@ -178,6 +189,24 @@ pub(crate) struct TranscriptWidthChange {mod tests {use super::*;+ #[test]+ fn visible_history_rows_are_cached_for_resize_replay() {+ let mut state = TranscriptReflowState::default();++ state.set_visible_history_rows(/*rows*/ 19);++ assert_eq!(state.visible_history_rows(), Some(19));+ }++ #[test]+ fn visible_history_rows_keep_one_row_for_a_full_height_composer() {+ let mut state = TranscriptReflowState::default();++ state.set_visible_history_rows(/*rows*/ 0);++ assert_eq!(state.visible_history_rows(), Some(1));+ }+#[test]fn schedule_debounced_postpones_existing_reflow() {let mut state = TranscriptReflowState::default();