Lightweight coding agent that runs in your terminal
Rust
Harden paginated history handling in the TUI (#36951)
Felipe Coury449f099f1cad
diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork.rs b/codex-rs/app-server/tests/suite/v2/thread_fork.rsindex ba837e1f01..defe31c833 100644--- a/codex-rs/app-server/tests/suite/v2/thread_fork.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_fork.rs@@ -1279,7 +1279,7 @@ async fn thread_fork_creates_reference_backed_paginated_thread() -> Result<()> {let turn_id = mcp.send_turn_start_request(TurnStartParams {- thread_id: forked_thread_id,+ thread_id: forked_thread_id.clone(),input: vec![UserInput::Text {text: "Continue from the fork".to_string(),text_elements: Vec::new(),@@ -1322,6 +1322,33 @@ async fn thread_fork_creates_reference_backed_paginated_thread() -> Result<()> {let excluded_turns_path = excluded_turns_thread.path.expect("forked rollout path");let excluded_turns_meta = read_session_meta_line(excluded_turns_path.as_path()).await?;assert_eq!(excluded_turns_meta.meta.history_base, Some(history_base));++ let ThreadForkResponse {+ thread: nested_thread,+ ..+ } = mcp+ .request(|request_id| ClientRequest::ThreadFork {+ request_id,+ params: ThreadForkParams {+ thread_id: forked_thread_id.clone(),+ exclude_turns: true,+ ..ThreadForkParams::default()+ },+ })+ .await?;+ assert_eq!(nested_thread.forked_from_id, Some(forked_thread_id.clone()));+ assert_eq!(nested_thread.history_mode, ThreadHistoryMode::Paginated);+ assert!(nested_thread.turns.is_empty());+ let nested_path = nested_thread.path.expect("nested fork rollout path");+ let nested_meta = read_session_meta_line(nested_path.as_path()).await?;+ assert_eq!(+ nested_meta+ .meta+ .history_base+ .expect("nested fork history base")+ .thread_id,+ ThreadId::from_string(forked_thread_id.as_str())?+ );Ok(())}diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 8cb63995da..1b3e6f2305 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -506,6 +506,7 @@ struct SessionSummary {struct InitialHistoryReplayBuffer {retained_lines: VecDeque<crate::terminal_hyperlinks::HyperlinkLine>,render_from_transcript_tail: bool,+ was_truncated: bool,}pub(crate) struct App {diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex ce33194523..1a29db4c55 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -34,6 +34,14 @@ impl App {self.handle_startup_thread_started(app_server, result).await?;}+ AppEvent::RequestOlderScrollbackHistory { thread_id } => {+ if self.chat_widget.thread_id() == Some(thread_id)+ && self.overlay.is_none()+ && self.scrollback_has_older_history+ {+ self.request_older_history_page(app_server, thread_id);+ }+ }AppEvent::OlderThreadHistoryLoaded {thread_id,cursor,diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rsindex d47b5a13fd..ebc31ccbb3 100644--- a/codex-rs/tui/src/app/history_pagination.rs+++ b/codex-rs/tui/src/app/history_pagination.rs@@ -5,6 +5,7 @@ use std::collections::HashSet;use super::*;use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;use crate::app_server_session::thread_items_page_params;+use crate::history_cell::SessionInfoCell;use crate::history_cell::UserHistoryCell;use crate::pager_overlay::TranscriptHistoryState;use crate::thread_transcript::RawReasoningVisibility;@@ -13,7 +14,7 @@ use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::ThreadItemsListResponse;impl App {- /// Start one bounded page request shared by transcript-history navigation.+ /// Start one bounded page request shared by scrollback refill and the transcript overlay.pub(crate) fn request_older_history_page(&self,app_server: &mut AppServerSession,@@ -61,9 +62,7 @@ impl App {cursor: &str,result: Result<ThreadItemsListResponse, String>,) -> Result<()> {- if self.chat_widget.thread_id() != Some(thread_id)- || !matches!(self.overlay, Some(Overlay::Transcript(_)))- {+ if self.chat_widget.thread_id() != Some(thread_id) {app_server.cancel_older_history_page(thread_id);return Ok(());}@@ -229,6 +228,24 @@ impl App {});continue_to_start = previous_state == TranscriptHistoryState::LoadingBeginning&& self.scrollback_has_older_history;+ } else {+ let index = self+ .transcript_cells+ .iter()+ .rposition(|cell| cell.as_any().is::<SessionInfoCell>())+ .map_or(/*default*/ 0, |index| index.saturating_add(/*rhs*/ 1));+ self.transcript_cells.splice(index..index, cells);+ let wrap_width = self.chat_widget.history_wrap_width(width);+ let rendered_rows = self+ .render_transcript_lines_for_reflow(wrap_width)+ .lines+ .len();+ self.schedule_immediate_resize_reflow(tui);+ if self.scrollback_history_needs_top_up(rendered_rows)+ && self.request_older_history_page(app_server, thread_id)+ {+ return Ok(());+ }}if continue_to_start&& self.request_older_history_page(app_server, thread_id)diff --git a/codex-rs/tui/src/app/resize_reflow.rs b/codex-rs/tui/src/app/resize_reflow.rsindex 823596a12a..5c9eaea8e9 100644--- a/codex-rs/tui/src/app/resize_reflow.rs+++ b/codex-rs/tui/src/app/resize_reflow.rs@@ -20,6 +20,7 @@ use std::time::Instant;use color_eyre::eyre::Result;use ratatui::layout::Size;+use ratatui::style::Stylize;use ratatui::text::Line;use super::App;@@ -141,6 +142,7 @@ impl App {self.initial_history_replay_buffer = Some(InitialHistoryReplayBuffer {retained_lines: VecDeque::new(),render_from_transcript_tail: true,+ was_truncated: false,});}}@@ -163,14 +165,21 @@ impl App {}if buffer.retained_lines.is_empty() {+ self.request_scrollback_history_top_up(/*rendered_rows*/ 0);return;}- let retained_lines = buffer.retained_lines.into_iter().collect::<Vec<_>>();+ let mut retained_lines = buffer.retained_lines.into_iter().collect::<Vec<_>>();+ let width = self+ .chat_widget+ .history_wrap_width(tui.terminal.last_known_screen_size.width);+ self.prepend_scrollback_history_notice(&mut retained_lines, buffer.was_truncated, width);+ let retained_rows = retained_lines.len();tui.insert_history_hyperlink_lines_with_wrap_policy(retained_lines,self.history_line_wrap_policy(),);+ self.request_scrollback_history_top_up(retained_rows);}pub(super) fn insert_history_cell_lines_with_initial_replay_buffer(@@ -230,6 +239,7 @@ impl App {buffer.retained_lines.extend(display);while buffer.retained_lines.len() > max_rows {buffer.retained_lines.pop_front();+ buffer.was_truncated = true;}}@@ -286,7 +296,7 @@ impl App {Ok(())}- fn schedule_immediate_resize_reflow(&mut self, tui: &mut tui::Tui) {+ pub(super) fn schedule_immediate_resize_reflow(&mut self, tui: &mut tui::Tui) {self.transcript_reflow.schedule_immediate();tui.frame_requester().schedule_frame();}@@ -457,6 +467,7 @@ impl App {let reflow_result = self.render_transcript_lines_for_reflow(width);let reflowed_lines = reflow_result.lines;+ let reflowed_rows = reflowed_lines.len();// Drop any queued pre-resize/pre-consolidation inserts before rebuilding from cells.tui.clear_pending_history_lines();@@ -469,10 +480,35 @@ impl App {self.history_line_wrap_policy(),);}+ self.request_scrollback_history_top_up(reflowed_rows);Ok(terminal_width)}+ /// Return whether older paginated source can fill unused configured scrollback rows.+ pub(super) fn scrollback_history_needs_top_up(&self, rendered_rows: usize) -> bool {+ self.overlay.is_none()+ && self.scrollback_has_older_history+ && self+ .resize_reflow_max_rows()+ .is_some_and(|max_rows| rendered_rows < max_rows)+ }++ fn request_scrollback_history_top_up(&self, rendered_rows: usize) {+ if self.scrollback_history_needs_top_up(rendered_rows)+ && let Some(thread_id) = self.chat_widget.thread_id()+ {+ tracing::debug!(+ %thread_id,+ rendered_rows,+ max_rows = self.resize_reflow_max_rows(),+ "refilling underfilled terminal scrollback from paginated history"+ );+ self.app_event_tx+ .send(crate::app_event::AppEvent::RequestOlderScrollbackHistory { thread_id });+ }+ }+/// Rebuild scrollback after rollback removes transcript cells.////// Unlike resize reflow, rollback must clear the terminal even when no cells remain. Otherwise@@ -517,6 +553,7 @@ impl App {let mut cell_displays = VecDeque::new();let mut rendered_rows = 0usize;let mut start = self.transcript_cells.len();+ let mut history_was_truncated = false;while start > 0 {start -= 1;@@ -530,6 +567,7 @@ impl App {});if row_cap.is_some_and(|max_rows| rendered_rows > max_rows) {+ history_was_truncated = true;break;}}@@ -565,9 +603,11 @@ impl App {if let Some(max_rows) = row_cap&& reflowed_lines.len() > max_rows{+ history_was_truncated = true;let trimmed_line_count = reflowed_lines.len() - max_rows;reflowed_lines = reflowed_lines.split_off(trimmed_line_count);}+ self.prepend_scrollback_history_notice(&mut reflowed_lines, history_was_truncated, width);self.has_emitted_history_lines = !reflowed_lines.is_empty();ReflowRenderResult {@@ -575,6 +615,37 @@ impl App {}}+ fn prepend_scrollback_history_notice(+ &self,+ lines: &mut Vec<HyperlinkLine>,+ history_was_truncated: bool,+ width: u16,+ ) {+ if lines.is_empty() || (!history_was_truncated && !self.scrollback_has_older_history) {+ return;+ }+ let Some(binding) = crate::keymap::primary_binding(&self.keymap.app.open_transcript) else {+ return;+ };+ let notice = Line::from(format!(+ "Earlier messages are available — press {} to view the full transcript",+ binding.display_label()+ ))+ .dim();+ let notice_lines =+ crate::wrapping::word_wrap_lines([notice], usize::from(width.max(/*other*/ 1)));+ if let Some(max_rows) = self.resize_reflow_max_rows() {+ let available_history_rows = max_rows.saturating_sub(notice_lines.len());+ if available_history_rows == 0 {+ return;+ }+ if lines.len() > available_history_rows {+ lines.drain(..lines.len() - available_history_rows);+ }+ }+ lines.splice(0..0, notice_lines.into_iter().map(HyperlinkLine::new));+ }+/// Return whether current transcript state should be treated as stream-time resize state.////// The active stream controllers cover normal streaming. The trailing-cell checks cover thediff --git a/codex-rs/tui/src/app/resize_reflow_tests.rs b/codex-rs/tui/src/app/resize_reflow_tests.rsindex 8caa683033..b3e989bab9 100644--- a/codex-rs/tui/src/app/resize_reflow_tests.rs+++ b/codex-rs/tui/src/app/resize_reflow_tests.rs@@ -74,6 +74,11 @@ async fn initial_resume_replay_retains_scrollback_beyond_the_visible_viewport().retained_lines;assert_eq!(retained_lines.len(), 32);assert!(retained_lines.len() > usize::from(visible_history_rows));+ assert!(+ app.initial_history_replay_buffer+ .as_ref()+ .is_some_and(|buffer| buffer.was_truncated)+ );insta::assert_snapshot!(retained_lines.iter()@@ -142,3 +147,125 @@ async fn resize_reflow_preserves_explicitly_unlimited_history() {Some("cell 19".to_string()));}++#[tokio::test]+async fn capped_resize_reflow_prepends_transcript_notice_without_changing_transcript() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(8);+ app.transcript_cells = plain_history_cells(/*count*/ 12);++ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);++ assert_eq!(rendered.lines.len(), 8);+ assert_eq!(app.transcript_cells.len(), 12);+ insta::assert_snapshot!(+ rendered+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ @r"+ Earlier messages are available — press ctrl + t to view the full transcript+ cell 8++ cell 9++ cell 10++ cell 11+ "+ );+}++#[tokio::test]+async fn capped_resize_reflow_counts_wrapped_notice_rows() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(8);+ app.transcript_cells = plain_history_cells(/*count*/ 12);++ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 28);++ assert_eq!(rendered.lines.len(), 8);+ insta::assert_snapshot!(+ rendered+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ @r"+ Earlier messages are+ available — press ctrl + t+ to view the full transcript+ cell 9++ cell 10++ cell 11+ "+ );+}++#[tokio::test]+async fn one_row_history_cap_preserves_conversation_instead_of_notice() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(1);+ app.scrollback_has_older_history = true;+ app.transcript_cells = plain_history_cells(/*count*/ 2);++ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);++ assert_eq!(rendered.lines.len(), 1);+ insta::assert_snapshot!(+ rendered+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ @r"cell 1"+ );+}++#[tokio::test]+async fn paginated_resize_reflow_prepends_transcript_notice_for_unloaded_history() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);+ app.scrollback_has_older_history = true;+ app.transcript_cells = plain_history_cells(/*count*/ 2);++ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);++ insta::assert_snapshot!(+ rendered+ .lines+ .iter()+ .map(rendered_line_text)+ .collect::<Vec<_>>()+ .join("\n"),+ @r"+ Earlier messages are available — press ctrl + t to view the full transcript+ cell 0++ cell 1+ "+ );+}++#[tokio::test]+async fn scrollback_refill_only_loads_older_pages_for_an_underfilled_row_cap() {+ let mut app = make_test_app().await;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);+ app.scrollback_has_older_history = true;++ assert!(app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 32));++ app.scrollback_has_older_history = false;+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));++ app.scrollback_has_older_history = true;+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Disabled;+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));+}diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex ce2fb4d900..d9f8ab36b5 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -5124,7 +5124,8 @@ async fn capped_resize_reflow_renders_recent_suffix_only() {.map(rendered_line_text).collect::<Vec<_>>(),vec![- "cell 17".to_string(),+ "Earlier messages are available — press ctrl + t to view the full transcript"+ .to_string(),String::new(),"cell 18".to_string(),String::new(),diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex 307e1182a8..c560f72f86 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -11,6 +11,7 @@ use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::JSONRPCRequest;use codex_app_server_protocol::JSONRPCResponse;use codex_app_server_protocol::SortDirection;+use codex_app_server_protocol::ThreadHistoryMode;use codex_app_server_protocol::ThreadItemsListParams;use codex_app_server_protocol::ThreadItemsListResponse;use codex_app_server_protocol::ThreadStatus;@@ -43,6 +44,7 @@ enum HistoryCapabilities {Current,LegacyOnly,LegacyOnlyUnsupportedVariant,+ ForkHydrationFails,}/// Returns and resets `(thread/loaded/list, thread/read)` request counts.@@ -144,6 +146,14 @@ async fn start_recording_app_server_with_history("thread/turns/list" | "thread/items/list" => true,_ => false,};+ let reject_fork_hydration = history_capabilities+ == HistoryCapabilities::ForkHydrationFails+ && request.method == "thread/items/list"+ && request_sink+ .lock()+ .expect("request recorder lock")+ .iter()+ .any(|recorded| recorded.method == "thread/fork");let response = if matches!(history_capabilities,HistoryCapabilities::LegacyOnly@@ -166,6 +176,15 @@ async fn start_recording_app_server_with_history(message: message.to_string(),},})+ } else if reject_fork_hydration {+ JSONRPCMessage::Error(JSONRPCError {+ id: request_id,+ error: JSONRPCErrorError {+ code: -32603,+ data: None,+ message: "fork history hydration failed".to_string(),+ },+ })} else {let request = serde_json::from_value::<ClientRequest>(serde_json::to_value(request)?,@@ -240,12 +259,20 @@ async fn start_recording_app_server_with_history())}-fn create_legacy_history_rollout(config: &Config) -> Result<ThreadId> {- let thread_id = create_fake_rollout(+fn create_history_rollout(+ config: &Config,+ history_mode: ThreadHistoryMode,+ preview: &str,+) -> Result<ThreadId> {+ let create_rollout = match history_mode {+ ThreadHistoryMode::Legacy => create_fake_rollout,+ ThreadHistoryMode::Paginated => create_fake_paginated_rollout,+ };+ let thread_id = create_rollout(config.codex_home.as_path(),"2026-01-02T00-00-00","2026-01-02T00:00:00Z",- "legacy history",+ preview,Some(config.model_provider_id.as_str()),/*git_info*/ None,)@@ -606,7 +633,8 @@ async fn transcript_home_loads_every_older_history_page() -> Result<()> {#[tokio::test]async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> {let (app, _codex_home) = make_history_test_app().await?;- let legacy_thread_id = create_legacy_history_rollout(&app.config)?;+ let legacy_thread_id =+ create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;let (mut app_server, requests, proxy) = start_recording_app_server_with_history(&app.config,HistoryCapabilities::LegacyOnly,@@ -679,7 +707,8 @@ enum LegacyHistoryRequest {async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> {let (app, _codex_home) = make_history_test_app().await?;- let legacy_thread_id = create_legacy_history_rollout(&app.config)?;+ let legacy_thread_id =+ create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;let (mut app_server, requests, proxy) = start_recording_app_server_with_history(&app.config,HistoryCapabilities::LegacyOnly,@@ -736,6 +765,489 @@ async fn remote_legacy_history_resume_retries_generic_method_not_found() -> Resuasync fn remote_legacy_history_fork_avoids_unsupported_fields() -> Result<()> {assert_remote_legacy_history_retry(LegacyHistoryRequest::Fork).await}++#[tokio::test]+async fn paginated_fork_survives_post_response_hydration_failure() -> Result<()> {+ let (app, _codex_home) = make_history_test_app().await?;+ let parent_thread_id = create_history_rollout(+ &app.config,+ ThreadHistoryMode::Paginated,+ "paginated fork parent",+ )?;+ let (mut app_server, requests, proxy) = start_recording_app_server_with_history(+ &app.config,+ HistoryCapabilities::ForkHydrationFails,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;++ let started = app_server+ .resume_thread(+ app.config.clone(),+ parent_thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(started.session.thread_id, parent_thread_id);++ let forked = app_server+ .fork_thread(app.config.clone(), parent_thread_id)+ .await?;++ assert_ne!(forked.session.thread_id, parent_thread_id);+ assert_eq!(recorded_params(&requests, "thread/fork").len(), 1);++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn underfilled_scrollback_fetches_older_pages_without_opening_the_transcript() -> Result<()> {+ let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().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());+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(8);+ let thread_id = create_history_rollout(+ &app.config,+ ThreadHistoryMode::Paginated,+ "scrollback pagination",+ )?;+ let path = rollout_path(+ codex_home.path(),+ "2026-01-02T00-00-00",+ &thread_id.to_string(),+ );+ let mut records = std::fs::read_to_string(&path)?+ .lines()+ .map(serde_json::from_str::<serde_json::Value>)+ .collect::<Result<Vec<_>, _>>()?;+ let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: "scrollback-pagination-turn".to_string(),+ trace_id: None,+ started_at: None,+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ }))+ .chain((0..120).map(|index| {+ EventMsg::ItemCompleted(ItemCompletedEvent {+ thread_id,+ turn_id: "scrollback-pagination-turn".to_string(),+ item: TurnItem::AgentMessage(AgentMessageItem {+ id: format!("scrollback-item-{index}"),+ content: vec![AgentMessageContent::Text {+ text: format!("scrollback output {index}"),+ }],+ phase: None,+ memory_citation: None,+ }),+ started_at_ms: None,+ completed_at_ms: 0,+ })+ }));+ for event in events {+ records.push(serde_json::json!({+ "timestamp": "2026-01-02T00:00:00Z",+ "ordinal": records.len(),+ "type": "event_msg",+ "payload": serde_json::to_value(event)?,+ }));+ }+ let records = records+ .into_iter()+ .map(|record| record.to_string())+ .collect::<Vec<_>>()+ .join("\n");+ std::fs::write(path, format!("{records}\n"))?;++ 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.config.clone(),+ thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ let mut initial_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.codex_home.as_path()),+ );+ initial_cells.insert(+ /*index*/ 0,+ Arc::new(crate::history_cell::new_session_info(+ &app.config,+ started.session.model.as_str(),+ &started.session,+ /*is_first_event*/ false,+ Some("This is a test announcement".to_string()),+ /*auth_plan*/ None,+ /*show_fast_status*/ false,+ )),+ );+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ app.transcript_cells = initial_cells;+ app.scrollback_has_older_history = app_server.has_older_history(thread_id);+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);+ let initial_cell_count = app.transcript_cells.len();+ let initial_page_requests = recorded_params(&requests, "thread/items/list").len();+ let mut tui = crate::tui::test_support::make_test_tui()?;++ app.scrollback_has_older_history = false;+ app.handle_key_event(+ &mut tui,+ &mut app_server,+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),+ )+ .await;+ assert!(app.scrollback_has_older_history);+ if let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() {+ overlay.handle_event(+ &mut tui,+ TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),+ )?;+ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 100, /*height*/ 16,+ );+ let render_overlay = |overlay: &mut crate::pager_overlay::TranscriptOverlay| {+ let mut buffer = Buffer::empty(area);+ overlay.render(area, &mut buffer);+ (area.y..area.bottom())+ .map(|y| {+ (area.x..area.right())+ .map(|x| buffer[(x, y)].symbol())+ .collect::<String>()+ })+ .collect::<Vec<_>>()+ .join("\n")+ };+ let partial = render_overlay(overlay);+ assert!(partial.contains("Earlier messages are available — scroll up to load them"));+ assert!(!partial.contains("OpenAI Codex"));+ assert!(!partial.contains("This is a test announcement"));+ assert!(!partial.contains('%'));++ overlay.set_history_state(crate::pager_overlay::TranscriptHistoryState::LoadingOlder);+ let loading = render_overlay(overlay);+ assert!(loading.contains("Loading earlier messages..."));+ assert!(!loading.contains("OpenAI Codex"));+ assert!(!loading.contains('%'));+ } else {+ panic!("expected transcript overlay");+ }+ app.close_transcript_overlay(&mut tui);++ let terminal_width = tui.terminal.last_known_screen_size.into();+ app.reflow_transcript_now(&mut tui, terminal_width)?;+ let request = loop {+ match app_event_rx.recv().await {+ Some(event @ AppEvent::RequestOlderScrollbackHistory { .. }) => break event,+ Some(_) => {}+ None => panic!("scrollback refill request channel closed"),+ }+ };+ app.handle_event(&mut tui, &mut app_server, request).await?;+ let loaded = loop {+ match app_event_rx.recv().await {+ Some(event @ AppEvent::OlderThreadHistoryLoaded { .. }) => break event,+ Some(_) => {}+ None => panic!("older history page channel closed"),+ }+ };+ app.handle_event(&mut tui, &mut app_server, loaded).await?;++ assert!(app.overlay.is_none());+ assert!(app.transcript_cells.len() > initial_cell_count);+ assert_eq!(+ recorded_params(&requests, "thread/items/list").len(),+ initial_page_requests + 1+ );+ assert_eq!(+ app.render_transcript_lines_for_reflow(/*width*/ 80)+ .lines+ .len(),+ 32+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {+ let (app, _codex_home) = make_history_test_app().await?;+ let paginated_thread_id = create_history_rollout(+ &app.config,+ ThreadHistoryMode::Paginated,+ "paginated visible history",+ )?;+ let legacy_thread_id = create_history_rollout(+ &app.config,+ ThreadHistoryMode::Legacy,+ "legacy visible history",+ )?;+ let (mut app_server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;++ let resumed = app_server+ .resume_thread(+ app.config.clone(),+ paginated_thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ assert_eq!(resumed.session.thread_id, paginated_thread_id);+ let cells = crate::thread_transcript::load_session_transcript(+ &mut app_server,+ paginated_thread_id,+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ Some(app.config.codex_home.as_path()),+ )+ .await?;+ assert!(!cells.is_empty());+ app_server+ .fork_thread(app.config.clone(), paginated_thread_id)+ .await?;+ let mut side_config = app.config.clone();+ side_config.ephemeral = true;+ app_server+ .fork_side_thread(side_config, paginated_thread_id)+ .await?;++ let paginated_reads = recorded_params(&requests, "thread/read");+ assert!(!paginated_reads.is_empty());+ assert!(+ paginated_reads+ .iter()+ .all(|params| params["includeTurns"] != true),+ "paginated workflows requested full history: {paginated_reads:?}"+ );+ assert!(!recorded_params(&requests, "thread/turns/list").is_empty());+ assert!(!recorded_params(&requests, "thread/items/list").is_empty());++ let previous_read_count = paginated_reads.len();+ crate::thread_transcript::load_session_transcript(+ &mut app_server,+ legacy_thread_id,+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ Some(app.config.codex_home.as_path()),+ )+ .await?;+ let legacy_reads = recorded_params(&requests, "thread/read");+ let legacy_include_turns = legacy_reads[previous_read_count..]+ .iter()+ .map(|params| params["includeTurns"].as_bool().unwrap_or(false))+ .collect::<Vec<_>>();+ assert_eq!(legacy_include_turns, vec![false, true]);++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}++#[tokio::test]+async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history() -> Result<()> {+ let (app, codex_home) = make_history_test_app().await?;+ let parent_thread_id = create_history_rollout(+ &app.config,+ ThreadHistoryMode::Paginated,+ "parent-only paginated history",+ )?;+ let child_timestamp = "2026-01-02T00-00-01";+ let child_thread_id = ThreadId::from_string(+ &create_fake_parented_rollout_with_source(+ codex_home.path(),+ child_timestamp,+ "2026-01-02T00:00:01Z",+ "child-only paginated history",+ Some(app.config.model_provider_id.as_str()),+ /*git_info*/ None,+ RolloutSessionSource::SubAgent(SubAgentSource::ThreadSpawn {+ parent_thread_id,+ depth: 1,+ agent_path: Some(+ AgentPath::try_from("/root/worker").map_err(color_eyre::eyre::Report::msg)?,+ ),+ agent_nickname: Some("worker".to_string()),+ agent_role: Some("worker".to_string()),+ }),+ parent_thread_id.into(),+ parent_thread_id,+ )+ .map_err(|err| color_eyre::eyre::eyre!("failed to create subagent rollout: {err}"))?,+ )?;+ let child_rollout_path = rollout_path(+ codex_home.path(),+ child_timestamp,+ &child_thread_id.to_string(),+ );+ let mut child_lines = std::fs::read_to_string(&child_rollout_path)?+ .lines()+ .map(serde_json::from_str::<serde_json::Value>)+ .collect::<Result<Vec<_>, _>>()?;+ let mut meta = child_lines.remove(/*index*/ 0);+ meta["payload"]["history_mode"] = serde_json::json!("paginated");+ meta["payload"]["subagent_history_start_ordinal"] = serde_json::json!(3);+ meta["ordinal"] = serde_json::json!(0);+ for (index, line) in child_lines.iter_mut().enumerate() {+ line["ordinal"] = serde_json::json!(index + 3);+ }+ let rollout_record = |ordinal: usize, kind: &str, payload: serde_json::Value| {+ serde_json::json!({+ "timestamp": "2026-01-02T00:00:01Z",+ "ordinal": ordinal,+ "type": kind,+ "payload": payload,+ })+ };+ let inherited_response = rollout_record(+ /*ordinal*/ 1,+ "response_item",+ serde_json::json!({+ "type": "message",+ "role": "user",+ "content": [{+ "type": "input_text",+ "text": "parent-only paginated history",+ }],+ }),+ );+ let inherited_event = rollout_record(+ /*ordinal*/ 2,+ "event_msg",+ serde_json::json!({+ "type": "user_message",+ "message": "parent-only paginated history",+ "kind": "plain",+ }),+ );+ let lines = std::iter::once(meta)+ .chain([inherited_response, inherited_event])+ .chain(child_lines)+ .chain([+ rollout_record(+ /*ordinal*/ 5,+ "event_msg",+ serde_json::json!({+ "type": "task_started",+ "turn_id": "child-visible-turn",+ "model_context_window": null,+ }),+ ),+ rollout_record(+ /*ordinal*/ 6,+ "event_msg",+ serde_json::json!({+ "type": "item_completed",+ "thread_id": child_thread_id,+ "turn_id": "child-visible-turn",+ "item": {+ "type": "UserMessage",+ "id": "child-visible-user",+ "content": [{+ "type": "text",+ "text": "child-only paginated history",+ }],+ },+ }),+ ),+ ])+ .map(|line| line.to_string())+ .collect::<Vec<_>>()+ .join("\n");+ std::fs::write(child_rollout_path, format!("{lines}\n"))?;+ let (mut app_server, requests, proxy) = start_recording_app_server(+ &app.config,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ )+ .await?;++ let resumed = app_server+ .resume_thread(+ app.config.clone(),+ child_thread_id,+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ let child_turn_page = app_server+ .thread_turns_page(child_thread_id, /*cursor*/ None)+ .await?;+ let child_item_page = app_server+ .thread_items_page(+ child_thread_id,+ /*turn_id*/ None,+ /*cursor*/ None,+ /*limit*/ 16,+ )+ .await?;+ let [child_turn] = child_turn_page.data.as_slice() else {+ panic!("paginated subagent should expose exactly one child turn");+ };+ let [child_entry] = child_item_page.data.as_slice() else {+ panic!("paginated subagent should expose exactly one child message");+ };+ let ThreadItem::UserMessage { content, .. } = &child_entry.item else {+ panic!("paginated subagent should expose its child user message");+ };+ assert_eq!(resumed.session.thread_id, child_thread_id);+ assert_eq!(child_entry.turn_id, child_turn.id);+ assert_eq!(+ content,+ &[UserInput::Text {+ text: "child-only paginated history".to_string(),+ text_elements: Vec::new(),+ }],+ );+ assert_eq!(+ resumed+ .turns+ .iter()+ .flat_map(|turn| turn.items.iter())+ .collect::<Vec<_>>(),+ vec![&child_entry.item],+ );++ let cells = crate::thread_transcript::load_session_transcript(+ &mut app_server,+ child_thread_id,+ crate::thread_transcript::RawReasoningVisibility::Hidden,+ Some(app.config.codex_home.as_path()),+ )+ .await?;+ let visible_history = cells+ .iter()+ .map(|cell| lines_to_single_string(&cell.display_lines(/*width*/ 80)))+ .collect::<Vec<_>>()+ .join("\n");+ assert!(visible_history.contains("child-only paginated history"));+ assert!(!visible_history.contains("parent-only paginated history"));+ assert!(+ recorded_params(&requests, "thread/read")+ .iter()+ .all(|params| params["includeTurns"] != true)+ );++ app_server.shutdown().await?;+ proxy.await??;+ Ok(())+}+#[test]fn fresh_session_applies_requested_name() -> Result<()> {const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 21b2e61199..92169d193b 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -225,6 +225,11 @@ pub(crate) enum AppEvent {event: HistoryLookupResponse,},+ /// Refill terminal scrollback from older paginated history after its rows reflow.+ RequestOlderScrollbackHistory {+ thread_id: ThreadId,+ },+/// One background-loaded page of older Ctrl+T transcript history.OlderThreadHistoryLoaded {thread_id: ThreadId,diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 1a2a0833d7..c9d18d4bbb 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -801,15 +801,23 @@ impl AppServerSession {}};let mut response = response;- if presentation == ForkPresentation::Regular && !response.thread.ephemeral {- self.hydrate_initial_thread_history(- &mut response.thread,- /*turn_cursor*/ None,- /*item_cursor*/ None,- Some(&config),- HistoryHydrationScope::Initial,- )- .await?;+ if presentation == ForkPresentation::Regular+ && !response.thread.ephemeral+ && let Err(error) = self+ .hydrate_initial_thread_history(+ &mut response.thread,+ /*turn_cursor*/ None,+ /*item_cursor*/ None,+ Some(&config),+ HistoryHydrationScope::Initial,+ )+ .await+ {+ tracing::warn!(+ thread_id = %response.thread.id,+ error = %error,+ "preserving the created fork after bounded history hydration failed"+ );}let mut started =started_thread_from_fork_response(response, &config, self.thread_params_mode()).await?;@@ -2792,6 +2800,97 @@ mod tests {Ok(())}+ #[tokio::test]+ async fn side_fork_uses_one_request_for_long_paginated_history() -> Result<()> {+ let codex_home = tempfile::tempdir().expect("tempdir");+ let mut config = build_config(&codex_home).await;+ config.terminal_resize_reflow.max_rows =+ crate::legacy_core::config::TerminalResizeReflowMaxRows::Limit(100);+ let filename_ts = "2025-01-05T12-00-00";+ let source_id = create_fake_paginated_rollout(+ codex_home.path(),+ filename_ts,+ "2025-01-05T12:00:00Z",+ "Saved user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .expect("create long paginated source rollout");+ let source_path =+ app_test_support::rollout_path(codex_home.path(), filename_ts, source_id.as_str());+ let mut contents = std::fs::read_to_string(&source_path)?;+ 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,+ })+ };+ let started = rollout_line(+ /*ordinal*/ 3,+ serde_json::json!({+ "type": "task_started",+ "turn_id": "long-history-turn",+ "model_context_window": null,+ }),+ );+ contents.push_str(&format!("{started}\n"));+ for index in 0..256 {+ let item = rollout_line(+ index + 4,+ serde_json::json!({+ "type": "item_completed",+ "thread_id": source_id,+ "turn_id": "long-history-turn",+ "item": {+ "type": "UserMessage",+ "id": format!("long-history-user-{index}"),+ "content": [{+ "type": "text",+ "text": format!("long history message {index}"),+ }],+ },+ }),+ );+ contents.push_str(&format!("{item}\n"));+ }+ std::fs::write(source_path, contents)?;++ let source_thread_id = ThreadId::from_string(source_id.as_str())?;+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ let resumed = app_server+ .resume_thread(+ config.clone(),+ source_thread_id,+ ResumeModelSettings::RestoreFromThread,+ )+ .await?;+ let loaded_items: usize = resumed.turns.iter().map(|turn| turn.items.len()).sum();+ assert!(loaded_items <= HISTORY_ITEM_PAGE_LIMIT as usize);+ assert!(app_server.has_older_history(source_thread_id));++ let mut side_config = config;+ side_config.ephemeral = true;+ let next_request_id = app_server.next_request_id;+ let side = app_server+ .fork_side_thread(side_config, source_thread_id)+ .await?;++ assert_eq!(app_server.next_request_id, next_request_id + 1);+ assert_eq!(side.session.forked_from_id, Some(source_thread_id));+ assert_eq!(side.turns, Vec::<Turn>::new());+ assert!(app_server.has_older_history(source_thread_id));+ assert!(+ !app_server+ .history_pagination+ .contains_key(&side.session.thread_id)+ );++ app_server.shutdown().await?;+ Ok(())+ }+#[tokio::test]async fn config_request_overrides_preserve_implicit_personality_default() {let temp_dir = tempfile::tempdir().expect("tempdir");diff --git a/codex-rs/tui/src/app_server_session/history.rs b/codex-rs/tui/src/app_server_session/history.rsindex e42f5287c3..0e1f4b3d00 100644--- a/codex-rs/tui/src/app_server_session/history.rs+++ b/codex-rs/tui/src/app_server_session/history.rs@@ -191,6 +191,10 @@ impl AppServerSession {Ok(items)}+ /// Hydrates paginated threads through bounded turn and item pages.+ ///+ /// Legacy servers expose neither paging method, so only legacy threads may+ /// use `thread/read(includeTurns: true)` to preserve their existing history.pub(crate) async fn hydrate_initial_thread_history(&mut self,thread: &mut Thread,