Lightweight coding agent that runs in your terminal
Rust
Paginate transcript history in the TUI (#36948)
Felipe Coury8bfa49e350ed
diff --git a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs b/codex-rs/app-server/src/request_processors/thread_lifecycle.rsindex f661fdd312..1c9f1668da 100644--- a/codex-rs/app-server/src/request_processors/thread_lifecycle.rs+++ b/codex-rs/app-server/src/request_processors/thread_lifecycle.rs@@ -581,9 +581,6 @@ pub(super) async fn handle_pending_thread_resume_request(thread_status.clone(),has_live_in_progress_turn,);- let token_usage_turn_id = pending- .include_turns- .then(|| restored_token_usage_turn_id(&pending.history_items, thread.turns.as_slice()));let mut initial_turns_page = if let Some(mut page) = pending.paginated_initial_turns_page.take(){if let (Some(active_turn), Some(params)) =@@ -623,6 +620,12 @@ pub(super) async fn handle_pending_thread_resume_request(} else {None};+ let token_usage_turn_id = pending+ .include_turns+ .then(|| restored_token_usage_turn_id(&pending.history_items, thread.turns.as_slice()));+ if pending.initial_turns_page.is_none() {+ initial_turns_page = None;+ }if pending.redact_resume_payloads {redact_thread_resume_payloads(&mut thread.turns);if let Some(initial_turns_page) = initial_turns_page.as_mut() {diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex ed72571f40..b296a4e33d 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -3156,8 +3156,6 @@ impl ThreadRequestProcessor {matches!(thread.history_mode, ThreadHistoryMode::Paginated).then_some(thread.thread_id)});let paginated_resume = paginated_thread_id.is_some();- let needs_paginated_projection =- paginated_resume && (include_turns || initial_turns_page.is_some());let history_cwd = thread_history.session_cwd();let runtime_workspace_roots = runtime_workspace_roots.map(resolve_runtime_workspace_roots);@@ -3246,7 +3244,7 @@ impl ThreadRequestProcessor {// Paginated JSONL is canonical, but its SQLite projection can lag after a// previous write failure. Persist after reopening the live writer so legacy// response hydration reads the latest durable turns and items.- if needs_paginated_projection+ if paginated_resume&& let Err(error) = self.thread_store.persist_thread(thread_id)@@ -3342,12 +3340,6 @@ impl ThreadRequestProcessor {let active_permission_profile = thread_response_active_permission_profile(config_snapshot.active_permission_profile,);- let token_usage_turn_id = include_turns.then(|| {- restored_token_usage_turn_id(- response_history.get_rollout_items(),- thread.turns.as_slice(),- )- });let mut initial_turns_page = if let Some(params) = initial_turns_page.as_ref() {let initial_turns_page_result = if paginated_resume {self.paginated_resume_initial_turns_page(thread_id, params)@@ -3371,6 +3363,18 @@ impl ThreadRequestProcessor {} else {None};+ let token_usage_turn_id = (include_turns || paginated_resume)+ .then(|| {+ let turns = if thread.turns.is_empty() {+ initial_turns_page+ .as_ref()+ .map_or(&[][..], |page| page.data.as_slice())+ } else {+ thread.turns.as_slice()+ };+ restored_token_usage_turn_id(response_history.get_rollout_items(), turns)+ })+ .filter(|turn_id| !turn_id.is_empty());if redact_resume_payloads {redact_thread_resume_payloads(&mut thread.turns);if let Some(initial_turns_page) = initial_turns_page.as_mut() {@@ -3583,6 +3587,12 @@ impl ThreadRequestProcessor {).await?;}+ if paginated_resume && (include_turns || params.initial_turns_page.is_some()) {+ self.thread_store+ .persist_thread(existing_thread_id)+ .await+ .map_err(thread_store_resume_read_error)?;+ }let history_items = if needs_history {source_thread.history@@ -3641,15 +3651,6 @@ impl ThreadRequestProcessor {.thread_goal_processor.pending_resume_goal_state(existing_thread.as_ref()).await;- if paginated_resume && (include_turns || params.initial_turns_page.is_some()) {- // Paginated JSONL is canonical, but its SQLite projection can lag after a- // previous write failure. Persist before legacy response hydration reads the- // latest durable turns and items.- self.thread_store- .persist_thread(existing_thread_id)- .await- .map_err(thread_store_resume_read_error)?;- }let paginated_turns = if paginated_resume && include_turns {Some(self.paginated_thread_full_turns(existing_thread_id).await?)} else {@@ -4229,7 +4230,7 @@ impl ThreadRequestProcessor {};let ephemeral_token_usage_turn_id = (ephemeral && include_turns).then(|| restored_token_usage_turn_id(&history_items, ephemeral_turns.as_slice()));- let paginated_history_items = paginated_source.then(|| Arc::clone(&history_items));+ let token_usage_history_items = paginated_source.then(|| Arc::clone(&history_items));let new_thread = if let Some(prepared_fork) = prepared_fork {self.thread_manager@@ -4358,7 +4359,9 @@ impl ThreadRequestProcessor {restored_token_usage_turn_id(history.as_ref()- .map_or(&[], |history| history.items.as_slice()),+ .map(|history| history.items.as_slice())+ .or_else(|| token_usage_history_items.as_deref().map(Vec::as_slice))+ .unwrap_or(&[]),thread.turns.as_slice(),)});@@ -4379,7 +4382,7 @@ impl ThreadRequestProcessor {if paginated_source && include_turns {thread.turns = self.paginated_thread_full_turns(thread_id).await?;token_usage_turn_id = Some(restored_token_usage_turn_id(- paginated_history_items+ token_usage_history_items.as_deref().map_or(&[], Vec::as_slice),thread.turns.as_slice(),diff --git a/codex-rs/app-server/src/request_processors/token_usage_replay.rs b/codex-rs/app-server/src/request_processors/token_usage_replay.rsindex 8a44d886e8..50a59aa659 100644--- a/codex-rs/app-server/src/request_processors/token_usage_replay.rs+++ b/codex-rs/app-server/src/request_processors/token_usage_replay.rs@@ -79,6 +79,10 @@ fn latest_token_usage_turn_id_from_rollout_items(builder.handle_rollout_item(item);}+ if turns.is_empty() {+ return builder.active_turn_id_if_explicit();+ }+let active_turn_id = builder.active_turn_id()?;if turns.iter().any(|turn| turn.id == active_turn_id) {Some(active_turn_id.to_string())@@ -137,6 +141,16 @@ mod tests {);}+ #[test]+ fn replay_attribution_rejects_suffix_generated_turn_ids() {+ let rollout_items = token_usage_history();++ assert_eq!(+ latest_token_usage_turn_id_from_rollout_items(&rollout_items, /*turns*/ &[]),+ None+ );+ }+#[test]fn replay_attribution_uses_latest_token_count_and_ignores_tail_turn() {let mut rollout_items = token_usage_history();diff --git a/codex-rs/app-server/tests/suite/v2/thread_resume.rs b/codex-rs/app-server/tests/suite/v2/thread_resume.rsindex a4410da23b..341e367d00 100644--- a/codex-rs/app-server/tests/suite/v2/thread_resume.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_resume.rs@@ -57,6 +57,8 @@ use codex_app_server_protocol::ThreadStartParams;use codex_app_server_protocol::ThreadStartResponse;use codex_app_server_protocol::ThreadStatus;use codex_app_server_protocol::ThreadStatusChangedNotification;+use codex_app_server_protocol::ThreadTurnsListParams;+use codex_app_server_protocol::ThreadTurnsListResponse;use codex_app_server_protocol::ThreadUnsubscribeParams;use codex_app_server_protocol::TurnItemsView;use codex_app_server_protocol::TurnStartParams;@@ -105,6 +107,8 @@ use core_test_support::responses;use core_test_support::skip_if_no_network;use core_test_support::skip_if_remote;use core_test_support::skip_if_wine_exec;+use core_test_support::streaming_sse::StreamingSseChunk;+use core_test_support::streaming_sse::start_streaming_sse_server;use pretty_assertions::assert_eq;use serde_json::json;use std::fs::FileTimes;@@ -114,6 +118,7 @@ use std::path::PathBuf;use std::process::Command;use std::time::Duration;use tempfile::TempDir;+use tokio::sync::oneshot;use tokio::time::timeout;use uuid::Uuid;use wiremock::Mock;@@ -2392,6 +2397,183 @@ async fn thread_resume_emits_restored_token_usage_before_next_turn() -> Result<(Ok(())}+#[tokio::test]+async fn cold_paginated_resume_restores_usage_without_loading_turns() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let conversation_id = create_fake_paginated_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved user message",+ Some("mock_provider"),+ /*git_info*/ None,+ )?;+ let path = rollout_path(codex_home.path(), "2025-01-05T12-00-00", &conversation_id);+ let canonical_turn_id = "persisted-token-usage-turn";+ append_rollout_item_to_path(+ &path,+ &RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: canonical_turn_id.to_string(),+ trace_id: None,+ started_at: None,+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ })),+ )+ .await?;+ append_rollout_item_to_path(+ &path,+ &RolloutItem::EventMsg(EventMsg::TokenCount(TokenCountEvent {+ info: Some(TokenUsageInfo {+ total_token_usage: TokenUsage {+ input_tokens: 120,+ output_tokens: 30,+ total_tokens: 150,+ ..Default::default()+ },+ last_token_usage: TokenUsage {+ input_tokens: 70,+ output_tokens: 20,+ total_tokens: 90,+ ..Default::default()+ },+ model_context_window: Some(200_000),+ }),+ rate_limits: None,+ })),+ )+ .await?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build_initialized()+ .await?;++ let resume_id = app_server+ .send_thread_resume_request(ThreadResumeParams {+ thread_id: conversation_id,+ exclude_turns: true,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse { thread, .. } =+ timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(resume_id)).await??;+ assert!(thread.turns.is_empty());++ let notification = timeout(+ DEFAULT_READ_TIMEOUT,+ app_server.read_stream_until_notification_message("thread/tokenUsage/updated"),+ )+ .await??;+ let ServerNotification::ThreadTokenUsageUpdated(notification) = notification.try_into()? else {+ panic!("expected thread/tokenUsage/updated notification");+ };+ assert_eq!(notification.thread_id, thread.id);+ assert_eq!(notification.turn_id, canonical_turn_id);+ assert_eq!(notification.token_usage.total.total_tokens, 150);++ let turns_id = app_server+ .send_thread_turns_list_request(ThreadTurnsListParams {+ thread_id: thread.id,+ cursor: None,+ limit: Some(1),+ sort_direction: Some(SortDirection::Desc),+ items_view: Some(TurnItemsView::NotLoaded),+ })+ .await?;+ let turns: ThreadTurnsListResponse =+ timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(turns_id)).await??;+ assert_eq!(notification.turn_id, turns.data[0].id);++ Ok(())+}++#[tokio::test]+async fn cold_paginated_resume_omits_usage_when_its_turn_is_ambiguous() -> Result<()> {+ let server = create_mock_responses_server_repeating_assistant("Done").await;+ let codex_home = TempDir::new()?;+ mock_responses_config(&server.uri()).write(codex_home.path())?;+ let filename_ts = "2025-01-05T12-00-00";+ let conversation_id = create_fake_paginated_rollout(+ codex_home.path(),+ filename_ts,+ "2025-01-05T12:00:00Z",+ "Saved user message",+ Some("mock_provider"),+ /*git_info*/ None,+ )?;+ let path = rollout_path(codex_home.path(), filename_ts, &conversation_id);+ append_rollout_item_to_path(+ &path,+ &RolloutItem::EventMsg(EventMsg::TokenCount(TokenCountEvent {+ info: Some(TokenUsageInfo {+ total_token_usage: TokenUsage {+ total_tokens: 150,+ ..Default::default()+ },+ last_token_usage: TokenUsage {+ total_tokens: 90,+ ..Default::default()+ },+ model_context_window: Some(200_000),+ }),+ rate_limits: None,+ })),+ )+ .await?;+ let interrupted_turn_id = "interrupted-turn-after-token-usage";+ append_rollout_item_to_path(+ &path,+ &RolloutItem::EventMsg(EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: interrupted_turn_id.to_string(),+ trace_id: None,+ started_at: None,+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ })),+ )+ .await?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .build_initialized()+ .await?;++ let resume_id = app_server+ .send_thread_resume_request(ThreadResumeParams {+ thread_id: conversation_id,+ exclude_turns: true,+ ..Default::default()+ })+ .await?;+ let ThreadResumeResponse { thread, .. } =+ timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(resume_id)).await??;+ assert!(thread.turns.is_empty());+ let turns_id = app_server+ .send_thread_turns_list_request(ThreadTurnsListParams {+ thread_id: thread.id,+ cursor: None,+ limit: Some(1),+ sort_direction: Some(SortDirection::Desc),+ items_view: Some(TurnItemsView::NotLoaded),+ })+ .await?;+ let turns: ThreadTurnsListResponse =+ timeout(DEFAULT_READ_TIMEOUT, app_server.read_response(turns_id)).await??;+ assert_eq!(turns.data[0].id, interrupted_turn_id);+ assert!(+ timeout(+ Duration::from_millis(100),+ app_server.read_stream_until_notification_message("thread/tokenUsage/updated"),+ )+ .await+ .is_err(),+ "usage owned by an implicit turn must not be attributed to {interrupted_turn_id}"+ );++ Ok(())+}+#[tokio::test]async fn thread_resume_skips_restored_token_usage_when_turns_are_excluded() -> Result<()> {let server = create_mock_responses_server_repeating_assistant("Done").await;@@ -3437,22 +3619,28 @@ async fn thread_resume_rejects_mismatched_path_for_running_thread_id() -> Result#[tokio::test]async fn thread_resume_rejoins_running_paginated_thread_with_initial_page() -> Result<()> {- let server = responses::start_mock_server().await;- let first_response = responses::sse_response(responses::sse(vec![- responses::ev_response_created("resp-1"),- responses::ev_assistant_message("msg-1", "Done"),- responses::ev_completed("resp-1"),- ]));- let second_response = responses::sse_response(responses::sse(vec![- responses::ev_response_created("resp-2"),- responses::ev_assistant_message("msg-2", "Done"),- responses::ev_completed("resp-2"),- ]))- .set_delay(std::time::Duration::from_secs(2));- let _response_mock =- responses::mount_response_sequence(&server, vec![first_response, second_response]).await;+ let (release_running_turn, running_turn_gate) = oneshot::channel();+ let (server, _response_completions) = start_streaming_sse_server(vec![+ vec![StreamingSseChunk {+ gate: None,+ body: responses::sse(vec![+ responses::ev_response_created("resp-1"),+ responses::ev_assistant_message("msg-1", "Done"),+ responses::ev_completed("resp-1"),+ ]),+ }],+ vec![StreamingSseChunk {+ gate: Some(running_turn_gate),+ body: responses::sse(vec![+ responses::ev_response_created("resp-2"),+ responses::ev_assistant_message("msg-2", "Done"),+ responses::ev_completed("resp-2"),+ ]),+ }],+ ])+ .await;let codex_home = TempDir::new()?;- mock_responses_config(&server.uri()).write(codex_home.path())?;+ mock_responses_config(server.uri()).write(codex_home.path())?;let mut primary = TestAppServer::builder().with_codex_home(codex_home.path())@@ -3546,6 +3734,36 @@ async fn thread_resume_rejoins_running_paginated_thread_with_initial_page() -> Rassert!(initial_turns_page.backwards_cursor.is_some());assert!(initial_turns_page.next_cursor.is_some());+ timeout(+ DEFAULT_READ_TIMEOUT,+ primary.read_stream_until_notification_message("thread/tokenUsage/updated"),+ )+ .await??;++ let metadata_resume_id = primary+ .send_thread_resume_request(ThreadResumeParams {+ thread_id: thread.id.clone(),+ exclude_turns: true,+ ..Default::default()+ })+ .await?;+ let metadata_resume: ThreadResumeResponse = timeout(+ DEFAULT_READ_TIMEOUT,+ primary.read_response(metadata_resume_id),+ )+ .await??;+ assert!(metadata_resume.thread.turns.is_empty());+ assert!(metadata_resume.initial_turns_page.is_none());+ assert!(+ timeout(+ Duration::from_millis(100),+ primary.read_stream_until_notification_message("thread/tokenUsage/updated"),+ )+ .await+ .is_err(),+ "hot paginated resume should wait for a real token usage update"+ );+let asc_resume_id = primary.send_thread_resume_request(ThreadResumeParams {thread_id: thread.id.clone(),@@ -3573,11 +3791,15 @@ async fn thread_resume_rejoins_running_paginated_thread_with_initial_page() -> Rstatus => panic!("unexpected thread status after running resume: {status:?}"),}+ release_running_turn+ .send(())+ .expect("release the running model response");timeout(DEFAULT_READ_TIMEOUT,primary.read_stream_until_notification_message("turn/completed"),).await??;+ server.shutdown().await;Ok(())}diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 60649f0d16..047cdd1736 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -211,6 +211,7 @@ pub(crate) mod app_server_requests;mod background_requests;mod config_persistence;mod event_dispatch;+mod history_pagination;mod history_ui;mod input;mod loaded_threads;@@ -1308,7 +1309,9 @@ See the Codex keymap documentation for supported actions and examples."};if self.overlay.is_some() {- let _ = self.handle_backtrack_overlay_event(tui, event).await?;+ let _ = self+ .handle_backtrack_overlay_event(tui, app_server, event)+ .await?;} else {match event {TuiEvent::Key(key_event) => {diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 2e7d60e26b..26034a4d8e 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -33,6 +33,19 @@ impl App {self.handle_startup_thread_started(app_server, result).await?;}+ AppEvent::OlderThreadHistoryLoaded {+ thread_id,+ cursor,+ result,+ } => {+ if let Err(err) = self+ .handle_older_history_page(tui, app_server, thread_id, &cursor, result)+ .await+ {+ app_server.cancel_older_history_page(thread_id);+ tracing::warn!(%thread_id, error = %err, "failed to load older transcript history");+ }+ }AppEvent::ClearUi { name } => {self.clear_terminal_ui(tui, /*redraw_header*/ false)?;self.reset_app_ui_state_after_clear();@@ -278,18 +291,23 @@ impl App {nth_user_message,&mut prompt,) {- Ok(Some(before_turn_id)) => {+ Ok(before_turn_id)+ if before_turn_id.is_some()+ || app_server.has_older_history(thread_id) =>+ {+ let before_turn_id = before_turn_id+ .or_else(|| thread.turns.first().map(|turn| turn.id.clone()));app_server.fork_thread_at(config.clone(),thread_id,/*last_turn_id*/ None,- /*before_turn_id*/ Some(before_turn_id),+ before_turn_id,ForkGoalContinuation::StartIfIdle,).await}- Ok(None) => {+ Ok(_) => {app_server.start_thread_with_session_start_source(&config, /*session_start_source*/ None,diff --git a/codex-rs/tui/src/app/history_pagination.rs b/codex-rs/tui/src/app/history_pagination.rsnew file mode 100644index 0000000000..e83296d632--- /dev/null+++ b/codex-rs/tui/src/app/history_pagination.rs@@ -0,0 +1,186 @@+//! Load older transcript pages without rewriting terminal-native scrollback.++use std::collections::HashSet;++use super::*;+use crate::history_cell::UserHistoryCell;+use crate::thread_transcript::RawReasoningVisibility;+use crate::thread_transcript::thread_items_to_transcript_cells;+use codex_app_server_protocol::ThreadItemsListResponse;++impl App {+ pub(super) async fn handle_older_history_page(+ &mut self,+ tui: &mut tui::Tui,+ app_server: &mut AppServerSession,+ thread_id: ThreadId,+ cursor: &str,+ result: Result<ThreadItemsListResponse, String>,+ ) -> Result<()> {+ if self.chat_widget.thread_id() != Some(thread_id)+ || !matches!(self.overlay, Some(Overlay::Transcript(_)))+ {+ app_server.cancel_older_history_page(thread_id);+ return Ok(());+ }+ let page = result.map_err(|err| color_eyre::eyre::eyre!(err))?;+ let Some(store) = self+ .thread_event_channels+ .get(&thread_id)+ .map(|channel| Arc::clone(&channel.store))+ else {+ app_server.cancel_older_history_page(thread_id);+ return Ok(());+ };+ let (cwd, mut turns) = {+ let store = store.lock().await;+ (+ store+ .session+ .as_ref()+ .map_or_else(|| self.config.cwd.clone(), |session| session.cwd.clone()),+ store.turns.clone(),+ )+ };+ let mut items = app_server+ .apply_older_history_page(thread_id, cursor, page, &mut turns)+ .await?;+ let mut hidden_item_ids = HashSet::new();+ let mut review_mode = false;+ for (index, turn) in turns.iter().enumerate() {+ let hidden_nested_review_turn = index+ .checked_sub(/*rhs*/ 1)+ .and_then(|previous| turns.get(previous))+ .is_some_and(|previous| {+ crate::app_backtrack::is_hidden_nested_review_turn(previous, turn)+ });+ for item in &turn.items {+ match item {+ ThreadItem::EnteredReviewMode { .. } => review_mode = true,+ ThreadItem::ExitedReviewMode { .. } => review_mode = false,+ ThreadItem::UserMessage { .. } if review_mode || hidden_nested_review_turn => {+ hidden_item_ids.insert(item.id());+ }+ _ => {}+ }+ }+ }+ let visibility = if self.config.show_raw_agent_reasoning {+ RawReasoningVisibility::Visible+ } else {+ RawReasoningVisibility::Hidden+ };+ let width = tui.terminal.last_known_screen_size.width;+ if !hidden_item_ids.is_empty() {+ let user_items = turns+ .iter()+ .flat_map(|turn| turn.items.iter())+ .filter(|item| matches!(item, ThreadItem::UserMessage { .. }))+ .map(|item| (item.id().to_string(), item.clone()))+ .collect::<Vec<_>>();+ let projected_user_cells = thread_items_to_transcript_cells(+ Some(thread_id),+ &cwd,+ user_items.iter().map(|(_, item)| item.clone()),+ visibility,+ Some(self.config.codex_home.as_path()),+ );+ let mut persisted_user_cells = user_items+ .into_iter()+ .zip(projected_user_cells)+ .map(|((item_id, _), cell)| (item_id, cell))+ .collect::<Vec<_>>();+ let mut hidden_transcript_indices = Vec::new();+ for (index, cell) in self.transcript_cells.iter().enumerate().rev() {+ let Some(user_cell) = cell.as_any().downcast_ref::<UserHistoryCell>() else {+ continue;+ };+ let Some(position) = persisted_user_cells.iter().rposition(|(_, projected)| {+ projected+ .as_any()+ .downcast_ref::<UserHistoryCell>()+ .is_some_and(|projected| {+ projected.message == user_cell.message+ && projected.text_elements == user_cell.text_elements+ && projected.local_image_paths == user_cell.local_image_paths+ && projected.remote_image_urls == user_cell.remote_image_urls+ })+ }) else {+ continue;+ };+ if hidden_item_ids.contains(persisted_user_cells[position].0.as_str()) {+ hidden_transcript_indices.push(index);+ }+ persisted_user_cells.truncate(position);+ }+ if !hidden_transcript_indices.is_empty() {+ if self.backtrack.overlay_preview_active {+ let selected_index = crate::app_backtrack::nth_user_position(+ &self.transcript_cells,+ self.backtrack.nth_user_message,+ );+ let removed_visible_users = hidden_transcript_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);+ }+ for index in hidden_transcript_indices {+ self.transcript_cells.remove(index);+ }+ if let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut() {+ overlay.replace_cells(self.transcript_cells.clone());+ }+ }+ }+ items.retain(|item| !hidden_item_ids.contains(item.id()));+ {+ let mut store = store.lock().await;+ turns.retain_mut(|turn| {+ let Some(current) = store.turns.iter_mut().find(|current| current.id == turn.id)+ else {+ return true;+ };+ let items = std::mem::take(&mut turn.items)+ .into_iter()+ .filter(|item| !current.items.iter().any(|known| known.id() == item.id()))+ .collect::<Vec<_>>();+ current.items.splice(0..0, items);+ false+ });+ store.turns.splice(0..0, turns);+ }+ let cells = thread_items_to_transcript_cells(+ Some(thread_id),+ &cwd,+ items,+ visibility,+ Some(self.config.codex_home.as_path()),+ );+ 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(),+ );+ }+ if let Some(Overlay::Transcript(overlay)) = self.overlay.as_mut() {+ let index = overlay.prepend(cells.clone(), width);+ self.transcript_cells.splice(index..index, cells);+ }+ if self.backtrack.overlay_preview_active {+ self.apply_backtrack_selection_internal(self.backtrack.nth_user_message);+ }+ tui.frame_requester().schedule_frame();+ Ok(())+ }+}diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rsindex 6486679e3d..608febaa27 100644--- a/codex-rs/tui/src/app/session_lifecycle.rs+++ b/codex-rs/tui/src/app/session_lifecycle.rs@@ -235,6 +235,7 @@ impl App {err.chain().any(|cause| {let message = cause.to_string();message.contains("includeTurns is unavailable before first user message")+ || message.contains("thread/turns/list is unavailable before first user message")|| message.contains("ephemeral threads do not support includeTurns")})}diff --git a/codex-rs/tui/src/app/tests/safety_buffering.rs b/codex-rs/tui/src/app/tests/safety_buffering.rsindex 6e0e710f21..42fc6bce46 100644--- a/codex-rs/tui/src/app/tests/safety_buffering.rs+++ b/codex-rs/tui/src/app/tests/safety_buffering.rs@@ -314,8 +314,16 @@ fn user_message_count(thread: &Thread, prompt: &str) -> usize {ThreadItem::UserMessage { content, .. } => Some(content),_ => None,})- .flatten()- .filter(|item| matches!(item, AppServerUserInput::Text { text, .. } if text == prompt))+ .filter(|content| {+ content+ .iter()+ .filter_map(|item| match item {+ AppServerUserInput::Text { text, .. } => Some(text.as_str()),+ _ => None,+ })+ .collect::<String>()+ == prompt+ }).count()}diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex b3aa550b09..d8af260df4 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -1,4 +1,5 @@use super::*;+use app_test_support::create_fake_paginated_rollout;use app_test_support::create_fake_parented_rollout_with_source;use app_test_support::create_fake_rollout;use app_test_support::rollout_path;@@ -9,8 +10,19 @@ use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::JSONRPCMessage;use codex_app_server_protocol::JSONRPCResponse;use codex_app_server_protocol::SortDirection;+use codex_app_server_protocol::ThreadItemsListParams;+use codex_app_server_protocol::ThreadItemsListResponse;use codex_app_server_protocol::ThreadStatus;use codex_protocol::AgentPath;+use codex_protocol::items::AgentMessageContent;+use codex_protocol::items::AgentMessageItem;+use codex_protocol::items::EnteredReviewModeItem;+use codex_protocol::items::ExitedReviewModeItem;+use codex_protocol::items::TurnItem;+use codex_protocol::items::UserMessageItem;+use codex_protocol::protocol::ItemCompletedEvent;+use codex_protocol::protocol::ReviewTarget;+use codex_protocol::user_input::UserInput as CoreUserInput;use codex_state::SqliteConfig;use futures::SinkExt;use futures::StreamExt;@@ -168,6 +180,202 @@ async fn start_recording_app_server())}+#[tokio::test]+async fn older_pagination_reconciles_review_prompts_across_page_boundaries() -> Result<()> {+ 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 thread_id = create_fake_paginated_rollout(+ codex_home.path(),+ "2026-01-02T00-00-00",+ "2026-01-02T00:00:00Z",+ "older visible prompt",+ Some(app.config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .map_err(|error| color_eyre::eyre::eyre!("failed to create paginated rollout: {error}"))?;+ let thread_id = ThreadId::from_string(&thread_id)?;+ 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 user_item = |id: &str, text: &str| {+ TurnItem::UserMessage(UserMessageItem {+ id: id.to_string(),+ client_id: None,+ content: vec![CoreUserInput::Text {+ text: text.to_string(),+ text_elements: Vec::new(),+ }],+ })+ };+ let mut items = vec![+ user_item("older-visible-prompt", "older visible prompt"),+ TurnItem::EnteredReviewMode(EnteredReviewModeItem {+ id: "cross-page-review-start".to_string(),+ target: ReviewTarget::UncommittedChanges,+ user_facing_hint: "review started".to_string(),+ }),+ user_item("hidden-review-prompt", "hidden cross-page review prompt"),+ ];+ items.extend((0..97).map(|index| {+ TurnItem::AgentMessage(AgentMessageItem {+ id: format!("review-output-{index}"),+ content: vec![AgentMessageContent::Text {+ text: format!("review output {index}"),+ }],+ phase: None,+ memory_citation: None,+ })+ }));+ items.extend([+ TurnItem::ExitedReviewMode(ExitedReviewModeItem {+ id: "cross-page-review-end".to_string(),+ review_output: None,+ }),+ user_item("newer-visible-prompt", "newer visible prompt"),+ ]);+ let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {+ turn_id: "cross-page-review-turn".to_string(),+ trace_id: None,+ started_at: None,+ model_context_window: None,+ collaboration_mode_kind: Default::default(),+ }))+ .chain(items.into_iter().map(|item| {+ EventMsg::ItemCompleted(ItemCompletedEvent {+ thread_id,+ turn_id: "cross-page-review-turn".to_string(),+ item,+ 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 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()),+ );+ app.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ app.transcript_cells = initial_cells;+ assert_eq!(+ app.transcript_cells+ .iter()+ .filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())+ .map(|user| user.message.as_str())+ .collect::<Vec<_>>(),+ vec!["hidden cross-page review prompt", "newer visible prompt"]+ );+ app.backtrack.overlay_preview_active = true;+ app.backtrack.nth_user_message = 1;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.open_transcript_overlay(&mut tui);+ app.apply_backtrack_selection_internal(app.backtrack.nth_user_message);+ let cursor = app_server+ .begin_older_history_page(thread_id)+ .expect("review-mode marker should remain on an older page");+ let request_id = app_server.next_request_id();+ let page: ThreadItemsListResponse = app_server+ .request_handle()+ .request_typed(ClientRequest::ThreadItemsList {+ request_id,+ params: ThreadItemsListParams {+ thread_id: thread_id.to_string(),+ turn_id: None,+ cursor: Some(cursor.clone()),+ limit: Some(crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT),+ sort_direction: Some(SortDirection::Desc),+ },+ })+ .await?;+ app.handle_older_history_page(&mut tui, &mut app_server, thread_id, &cursor, Ok(page))+ .await?;++ let visible_user_messages = app+ .transcript_cells+ .iter()+ .filter_map(|cell| cell.as_any().downcast_ref::<UserHistoryCell>())+ .map(|user| user.message.clone())+ .collect::<Vec<_>>();+ assert_eq!(+ visible_user_messages,+ vec!["older visible prompt", "newer visible prompt"]+ );+ assert_eq!(app.backtrack.nth_user_message, 1);+ let area = ratatui::layout::Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 80, /*height*/ 12,+ );+ let mut buffer = Buffer::empty(area);+ let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() else {+ panic!("expected a transcript overlay");+ };+ overlay.render(area, &mut buffer);+ let highlighted_output = area+ .positions()+ .filter(|position| {+ buffer[*position]+ .style()+ .add_modifier+ .contains(ratatui::style::Modifier::REVERSED)+ })+ .map(|position| buffer[position].symbol())+ .collect::<String>();+ let highlighted_message = visible_user_messages+ .iter()+ .find(|message| highlighted_output.contains(message.as_str()))+ .expect("the selected user message should remain highlighted");+ insta::assert_snapshot!(+ format!(+ "{}\nhighlighted: {highlighted_message}",+ visible_user_messages.join("\n")+ ),+ @r"+ older visible prompt+ newer visible prompt+ highlighted: newer visible prompt+ ");++ 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/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rsindex f1765b8171..433f3fb371 100644--- a/codex-rs/tui/src/app/thread_routing.rs+++ b/codex-rs/tui/src/app/thread_routing.rs@@ -1246,6 +1246,9 @@ impl App {self.activate_thread_channel(thread_id).await;self.chat_widget.set_initial_user_message_submit_suppressed(/*suppressed*/ true);+ if !turns.is_empty() {+ self.chat_widget.set_token_info(/*info*/ None);+ }match presentation {ThreadAttachPresentation::SessionLineage => {self.chat_widget.handle_thread_session(session);diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rsindex 609e3e6b1e..b85769b45b 100644--- a/codex-rs/tui/src/app_backtrack.rs+++ b/codex-rs/tui/src/app_backtrack.rs@@ -26,6 +26,8 @@ use std::sync::Arc;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::bottom_pane::LocalImageAttachment;use crate::chatwidget::ChatWidget;use crate::chatwidget::UserMessage;@@ -37,7 +39,11 @@ use crate::history_cell::UserHistoryCell;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;use codex_protocol::ThreadId;@@ -88,8 +94,43 @@ impl App {pub(crate) async fn handle_backtrack_overlay_event(&mut self,tui: &mut tui::Tui,+ app_server: &mut AppServerSession,event: TuiEvent,) -> Result<bool> {+ if let TuiEvent::Key(key_event) = &event+ && let Some(Overlay::Transcript(overlay)) = self.overlay.as_ref()+ && (overlay.should_load_older(*key_event)+ || (self.backtrack.overlay_preview_active+ && self.backtrack.nth_user_message == 0+ && matches!(key_event.code, KeyCode::Esc | KeyCode::Left)+ && matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat)))+ && let Some(thread_id) = self.chat_widget.thread_id()+ && let Some(cursor) = app_server.begin_older_history_page(thread_id)+ {+ let request_id = app_server.next_request_id();+ let request_handle = app_server.request_handle();+ let app_event_tx = self.app_event_tx.clone();+ tokio::spawn(async move {+ 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),+ },+ })+ .await+ .map_err(|err| err.to_string());+ app_event_tx.send(AppEvent::OlderThreadHistoryLoaded {+ thread_id,+ cursor,+ result,+ });+ });+ }if self.backtrack.overlay_preview_active {match event {TuiEvent::Key(KeyEvent {@@ -313,7 +354,7 @@ impl App {}/// Apply a computed backtrack selection to the overlay and internal counter.- fn apply_backtrack_selection_internal(&mut self, nth_user_message: usize) {+ pub(crate) fn apply_backtrack_selection_internal(&mut self, nth_user_message: usize) {if let Some(cell_idx) = nth_user_position(&self.transcript_cells, nth_user_message) {self.backtrack.nth_user_message = nth_user_message;if let Some(Overlay::Transcript(t)) = &mut self.overlay {@@ -584,7 +625,7 @@ fn has_backtrack_target(cells: &[Arc<dyn crate::history_cell::HistoryCell>]) ->user_count(cells) > 0}-fn nth_user_position(+pub(crate) fn nth_user_position(cells: &[Arc<dyn crate::history_cell::HistoryCell>],nth: usize,) -> Option<usize> {diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 6037b7225b..21b2e61199 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -32,6 +32,7 @@ use codex_app_server_protocol::PluginUninstallResponse;use codex_app_server_protocol::SkillsListResponse;use codex_app_server_protocol::Thread;use codex_app_server_protocol::ThreadGoalStatus;+use codex_app_server_protocol::ThreadItemsListResponse;use codex_connectors::AppInfo;use codex_file_search::FileMatch;use codex_message_history::HistoryBatchCursor;@@ -224,6 +225,13 @@ pub(crate) enum AppEvent {event: HistoryLookupResponse,},+ /// One background-loaded page of older Ctrl+T transcript history.+ OlderThreadHistoryLoaded {+ thread_id: ThreadId,+ cursor: String,+ result: Result<ThreadItemsListResponse, String>,+ },+/// Persist a submitted prompt in the cross-session message history.AppendMessageHistoryEntry {thread_id: ThreadId,diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 75c5c16392..3c8db59e47 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -4,6 +4,9 @@//! request/response plumbing out of `App` and `ChatWidget`.mod fs;+mod history;++pub(crate) use history::HISTORY_ITEM_PAGE_LIMIT;use crate::bottom_pane::FeedbackAudience;use crate::legacy_core::config::Config;@@ -70,6 +73,7 @@ use codex_app_server_protocol::ThreadGoalGetResponse;use codex_app_server_protocol::ThreadGoalSetParams;use codex_app_server_protocol::ThreadGoalSetResponse;use codex_app_server_protocol::ThreadGoalStatus;+use codex_app_server_protocol::ThreadHistoryMode;use codex_app_server_protocol::ThreadInjectItemsParams;use codex_app_server_protocol::ThreadInjectItemsResponse;use codex_app_server_protocol::ThreadListParams;@@ -186,6 +190,7 @@ pub(crate) struct AppServerBootstrap {pub(crate) struct AppServerSession {client: AppServerClient,next_request_id: i64,+ history_pagination: HashMap<ThreadId, history::ThreadHistoryPagination>,remote_cwd_override: Option<PathBuf>,thread_params_mode: ThreadParamsMode,thread_settings_update_supported: bool,@@ -258,6 +263,7 @@ impl AppServerSession {Self {client,next_request_id: 1,+ history_pagination: HashMap::new(),remote_cwd_override: None,thread_params_mode,thread_settings_update_supported: true,@@ -544,22 +550,36 @@ impl AppServerSession {} else {self.session_config_with_effective_service_tier(&config)};- let response: ThreadResumeResponse = self+ let exclude_turns = self+ .history_pagination+ .get(&thread_id)+ .is_some_and(|state| state.history_mode == ThreadHistoryMode::Paginated);+ let mut response: ThreadResumeResponse = self.client.request_typed(ClientRequest::ThreadResume {request_id,- params: thread_resume_params_from_config(- session_config,- thread_id,- self.thread_params_mode(),- self.remote_cwd_override.as_deref(),- model_settings,- ),+ params: ThreadResumeParams {+ exclude_turns,+ ..thread_resume_params_from_config(+ session_config,+ thread_id,+ self.thread_params_mode(),+ self.remote_cwd_override.as_deref(),+ model_settings,+ )+ },}).await.map_err(|err| {bootstrap_request_error("thread/resume failed during TUI bootstrap", err)})?;+ self.hydrate_initial_thread_history(+ &mut response.thread,+ response.turns_backwards_cursor.clone(),+ response.items_backwards_cursor.clone(),+ Some(&config),+ )+ .await?;let fork_parent_title = self.fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref()).await;@@ -629,6 +649,17 @@ impl AppServerSession {goal_continuation: ForkGoalContinuation,presentation: ForkPresentation,) -> Result<AppServerStartedThread> {+ let fork_parent = match presentation {+ ForkPresentation::Regular => self+ .thread_read(thread_id, /*include_turns*/ false)+ .await+ .ok(),+ ForkPresentation::SideConversation => None,+ };+ let exclude_turns = fork_parent+ .as_ref()+ .is_some_and(|thread| thread.history_mode == ThreadHistoryMode::Paginated)+ || presentation == ForkPresentation::SideConversation;let request_id = self.next_request_id();let session_config = self.session_config_with_effective_service_tier(&config);let response: ThreadForkResponse = self@@ -640,7 +671,7 @@ impl AppServerSession {before_turn_id,defer_goal_continuation: goal_continuation== ForkGoalContinuation::DeferUntilNextTurn,- exclude_turns: presentation == ForkPresentation::SideConversation,+ exclude_turns,..thread_fork_params_from_config(session_config,thread_id,@@ -653,15 +684,19 @@ impl AppServerSession {.map_err(|err| {bootstrap_request_error("thread/fork failed during TUI bootstrap", err)})?;- let fork_parent_title = if presentation == ForkPresentation::SideConversation {- None- } else {- self.fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref())- .await- };+ 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),+ )+ .await?;+ }let mut started =started_thread_from_fork_response(response, &config, self.thread_params_mode()).await?;- started.session.fork_parent_title = fork_parent_title;+ started.session.fork_parent_title = fork_parent.and_then(|thread| thread.name);Ok(started)}@@ -753,17 +788,44 @@ impl AppServerSession {include_turns: bool,) -> Result<Thread> {let request_id = self.next_request_id();- let response: ThreadReadResponse = self+ let response = self.client- .request_typed(ClientRequest::ThreadRead {+ .request_typed::<ThreadReadResponse>(ClientRequest::ThreadRead {request_id,params: ThreadReadParams {thread_id: thread_id.to_string(),include_turns,},})- .await- .wrap_err("thread/read failed during TUI session lookup")?;+ .await;+ let mut response: ThreadReadResponse = match response {+ Ok(response) => return Ok(response.thread),+ Err(TypedRequestError::Server { source, .. })+ if include_turns+ && source.message+ == "paginated threads do not support thread/read(includeTurns=true)" =>+ {+ let request_id = self.next_request_id();+ self.client+ .request_typed(ClientRequest::ThreadRead {+ request_id,+ params: ThreadReadParams {+ thread_id: thread_id.to_string(),+ include_turns: false,+ },+ })+ .await+ .wrap_err("thread/read failed during TUI session lookup")?+ }+ Err(err) => return Err(err).wrap_err("thread/read failed during TUI session lookup"),+ };+ self.hydrate_initial_thread_history(+ &mut response.thread,+ /*turn_cursor*/ None,+ /*item_cursor*/ None,+ /*config*/ None,+ )+ .await?;Ok(response.thread)}@@ -1895,6 +1957,7 @@ mod tests {use super::*;use crate::legacy_core::config::ConfigBuilder;use crate::legacy_core::config::ConfigOverrides;+ use app_test_support::create_fake_paginated_rollout;use app_test_support::create_fake_rollout;use codex_app_server_protocol::ThreadStatus;use codex_app_server_protocol::Turn;@@ -2509,6 +2572,37 @@ mod tests {Ok(())}+ #[tokio::test]+ async fn ephemeral_paginated_fork_skips_unsupported_history_hydration() -> Result<()> {+ let codex_home = tempfile::tempdir()?;+ let config = build_config(&codex_home).await;+ let source_thread_id = ThreadId::from_string(+ &create_fake_paginated_rollout(+ codex_home.path(),+ "2025-01-05T12-00-00",+ "2025-01-05T12:00:00Z",+ "Saved user message",+ Some(config.model_provider_id.as_str()),+ /*git_info*/ None,+ )+ .map_err(|error| {+ color_eyre::eyre::eyre!("failed to create paginated rollout: {error}")+ })?,+ )?;+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ let mut ephemeral_config = config;+ ephemeral_config.ephemeral = true;++ let fork = app_server+ .fork_thread(ephemeral_config, source_thread_id)+ .await?;++ assert_eq!(fork.session.forked_from_id, Some(source_thread_id));+ assert!(fork.turns.is_empty());+ 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.rsnew file mode 100644index 0000000000..01cf943da3--- /dev/null+++ b/codex-rs/tui/src/app_server_session/history.rs@@ -0,0 +1,239 @@+//! Bounded app-server transcript loading for resume, fork, and transcript views.++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 codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::SortDirection;+use codex_app_server_protocol::Thread;+use codex_app_server_protocol::ThreadHistoryMode;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::ThreadItemsListParams;+use codex_app_server_protocol::ThreadItemsListResponse;+use codex_app_server_protocol::ThreadTurnsListParams;+use codex_app_server_protocol::ThreadTurnsListResponse;+use codex_app_server_protocol::Turn;+use codex_app_server_protocol::TurnItemsView;+use codex_protocol::ThreadId;+use color_eyre::eyre::Result;+use color_eyre::eyre::WrapErr;++pub(crate) const INITIAL_HISTORY_TURN_LIMIT: u32 = 5;+pub(crate) const HISTORY_ITEM_PAGE_LIMIT: u32 = 100;++#[derive(Clone, Debug, Default)]+pub(crate) struct ThreadHistoryPagination {+ pub(super) history_mode: ThreadHistoryMode,+ next_turn_cursor: Option<String>,+ next_item_cursor: Option<String>,+ loading_older: bool,+}++impl AppServerSession {+ pub(crate) fn has_older_history(&self, thread_id: ThreadId) -> bool {+ self.history_pagination+ .get(&thread_id)+ .is_some_and(|page| page.next_item_cursor.is_some())+ }++ pub(crate) fn begin_older_history_page(&mut self, thread_id: ThreadId) -> Option<String> {+ let page = self.history_pagination.get_mut(&thread_id)?;+ if page.loading_older {+ return None;+ }+ let cursor = page.next_item_cursor.clone()?;+ page.loading_older = true;+ Some(cursor)+ }++ pub(crate) fn cancel_older_history_page(&mut self, thread_id: ThreadId) {+ if let Some(page) = self.history_pagination.get_mut(&thread_id) {+ page.loading_older = false;+ }+ }++ pub(crate) async fn apply_older_history_page(+ &mut self,+ thread_id: ThreadId,+ cursor: &str,+ page: ThreadItemsListResponse,+ turns: &mut Vec<Turn>,+ ) -> Result<Vec<ThreadItem>> {+ let Some(mut state) = self.history_pagination.get(&thread_id).cloned() else {+ return Ok(Vec::new());+ };+ if !state.loading_older || state.next_item_cursor.as_deref() != Some(cursor) {+ return Ok(Vec::new());+ }+ let items = self+ .merge_thread_item_page(thread_id, page, &mut state, turns)+ .await?;+ state.loading_older = false;+ self.history_pagination.insert(thread_id, state);+ Ok(items)+ }++ async fn thread_turns_page(+ &mut self,+ thread_id: ThreadId,+ cursor: Option<String>,+ ) -> Result<ThreadTurnsListResponse> {+ let request_id = self.next_request_id();+ self.client+ .request_typed(ClientRequest::ThreadTurnsList {+ request_id,+ params: ThreadTurnsListParams {+ thread_id: thread_id.to_string(),+ cursor,+ limit: Some(INITIAL_HISTORY_TURN_LIMIT),+ sort_direction: Some(SortDirection::Desc),+ items_view: Some(TurnItemsView::NotLoaded),+ },+ })+ .await+ .wrap_err("failed to load a bounded thread history page")+ }++ async fn merge_thread_item_page(+ &mut self,+ thread_id: ThreadId,+ page: ThreadItemsListResponse,+ state: &mut ThreadHistoryPagination,+ turns: &mut Vec<Turn>,+ ) -> Result<Vec<ThreadItem>> {+ state.next_item_cursor = page.next_cursor;+ 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;+ turns.splice(0..0, page.data.into_iter().rev());+ }+ if let Some(turn) = turns.iter_mut().find(|turn| turn.id == entry.turn_id)+ && !turn.items.iter().any(|item| item.id() == entry.item.id())+ {+ items.push(entry.item.clone());+ turn.items.insert(/*index*/ 0, entry.item);+ turn.items_view = TurnItemsView::Summary;+ }+ }+ items.reverse();+ Ok(items)+ }++ pub(crate) async fn hydrate_initial_thread_history(+ &mut self,+ thread: &mut Thread,+ turn_cursor: Option<String>,+ item_cursor: Option<String>,+ config: Option<&Config>,+ ) -> Result<()> {+ let thread_id = ThreadId::from_string(&thread.id)+ .wrap_err("invalid thread id in bounded history response")?;+ if thread.history_mode == ThreadHistoryMode::Legacy {+ if thread.turns.is_empty() {+ thread.turns = Box::pin(self.thread_read(thread_id, /*include_turns*/ true))+ .await?+ .turns;+ }+ self.history_pagination.entry(thread_id).or_default();+ return Ok(());+ }++ let page = self.thread_turns_page(thread_id, turn_cursor).await?;+ thread.turns = page.data.into_iter().rev().collect();+ let mut state = ThreadHistoryPagination {+ history_mode: ThreadHistoryMode::Paginated,+ next_turn_cursor: page.next_cursor,+ 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 mut scanned_items = 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_items = item_budget.map(|budget| budget.saturating_sub(scanned_items));+ if remaining_rows == Some(0) || remaining_items == Some(0) {+ break;+ }+ let limit = remaining_rows+ .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")?;+ 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)+ .await?;+ if state.next_item_cursor.is_none() {+ break;+ }+ }+ if config.is_some() {+ self.history_pagination.insert(thread_id, state);+ }+ Ok(())+ }+}++fn rendered_history_rows(thread: &Thread, config: &Config, width: u16) -> usize {+ if thread.turns.iter().all(|turn| turn.items.is_empty()) {+ return 0;+ }+ let visibility = if config.show_raw_agent_reasoning {+ RawReasoningVisibility::Visible+ } else {+ RawReasoningVisibility::Hidden+ };+ let mode = if config.tui_raw_output_mode {+ HistoryRenderMode::Raw+ } else {+ HistoryRenderMode::Rich+ };+ thread_to_transcript_cells(+ thread.clone(),+ visibility,+ Some(config.codex_home.as_path()),+ )+ .into_iter()+ .fold(/*init*/ 0, |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())+ })+}diff --git a/codex-rs/tui/src/bottom_pane/chat_composer.rs b/codex-rs/tui/src/bottom_pane/chat_composer.rsindex af5ec97452..fe3cd178c5 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs@@ -620,6 +620,7 @@ impl ChatComposer {flash: None,context_window_percent: None,context_window_used_tokens: None,+ context_window_pending: false,collaboration_mode_indicator: None,goal_status_indicator: None,ide_context_active: false,@@ -1353,10 +1354,14 @@ impl ChatComposer {}fn right_footer_line_with_context(&self) -> Line<'static> {- let mut line = context_window_line(- self.footer.context_window_percent,- self.footer.context_window_used_tokens,- );+ let mut line = if self.footer.context_window_pending {+ Line::default()+ } else {+ context_window_line(+ self.footer.context_window_percent,+ self.footer.context_window_used_tokens,+ )+ };if let Some(vim_mode) = self.vim_mode_indicator_span() {line.spans.push(" | ".dim());line.spans.push(vim_mode);@@ -4218,6 +4223,10 @@ impl ChatComposer {self.footer.context_window_used_tokens = used_tokens;}+ pub(crate) fn set_context_window_pending(&mut self, pending: bool) {+ self.footer.context_window_pending = pending;+ }+pub(crate) fn set_esc_backtrack_hint(&mut self, show: bool) {self.footer.esc_backtrack_hint = show;if show {diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs b/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rsindex 3ad87a1462..fd63d2d000 100644--- a/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs+++ b/codex-rs/tui/src/bottom_pane/chat_composer/footer_state.rs@@ -23,6 +23,7 @@ pub(super) struct FooterState {pub(super) flash: Option<FooterFlash>,pub(super) context_window_percent: Option<i64>,pub(super) context_window_used_tokens: Option<i64>,+ pub(super) context_window_pending: bool,pub(super) collaboration_mode_indicator: Option<CollaborationModeIndicator>,pub(super) goal_status_indicator: Option<GoalStatusIndicator>,pub(super) ide_context_active: bool,diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rsindex e6455e2eb3..527e510aa7 100644--- a/codex-rs/tui/src/bottom_pane/mod.rs+++ b/codex-rs/tui/src/bottom_pane/mod.rs@@ -1123,6 +1123,11 @@ impl BottomPane {self.request_redraw();}+ pub(crate) fn set_context_window_pending(&mut self, pending: bool) {+ self.composer.set_context_window_pending(pending);+ self.request_redraw();+ }+/// Show a generic list selection view with the provided items.pub(crate) fn show_selection_view(&mut self,diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 92eae23843..7151ed0d50 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -564,6 +564,7 @@ pub(crate) struct ChatWidget {runtime_model_provider_base_url: Option<String>,pub(crate) remote_connection: Option<RemoteConnectionStatus>,token_info: Option<TokenUsageInfo>,+ token_usage_pending: bool,rate_limit_snapshots_by_limit_id: BTreeMap<String, RateLimitSnapshotDisplay>,refreshing_status_outputs: Vec<(u64, StatusHistoryHandle)>,next_status_refresh_request_id: u64,@@ -1144,6 +1145,9 @@ impl ChatWidget {match info {Some(info) => self.apply_token_info(info),None => {+ self.token_usage_pending = true;+ self.bottom_pane+ .set_context_window_pending(/*pending*/ true);self.bottom_pane.set_context_window(/*percent*/ None, /*used_tokens*/ None);self.token_info = None;@@ -1152,6 +1156,9 @@ impl ChatWidget {}fn apply_token_info(&mut self, info: TokenUsageInfo) {+ self.token_usage_pending = false;+ self.bottom_pane+ .set_context_window_pending(/*pending*/ false);let percent = self.context_remaining_percent(&info);let used_tokens = self.context_used_tokens(&info, percent.is_some());self.bottom_pane.set_context_window(percent, used_tokens);diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rsindex 99430339bc..06ccca7313 100644--- a/codex-rs/tui/src/chatwidget/constructor.rs+++ b/codex-rs/tui/src/chatwidget/constructor.rs@@ -128,6 +128,7 @@ impl ChatWidget {runtime_model_provider_base_url,remote_connection: None,token_info: None,+ token_usage_pending: false,rate_limit_snapshots_by_limit_id: BTreeMap::new(),refreshing_status_outputs: Vec::new(),next_status_refresh_request_id: 0,diff --git a/codex-rs/tui/src/chatwidget/status_controls.rs b/codex-rs/tui/src/chatwidget/status_controls.rsindex 8bae8b64fb..8a78601ea7 100644--- a/codex-rs/tui/src/chatwidget/status_controls.rs+++ b/codex-rs/tui/src/chatwidget/status_controls.rs@@ -358,6 +358,9 @@ impl ChatWidget {}pub(super) fn status_line_context_remaining_percent(&self) -> Option<i64> {+ if self.token_usage_pending {+ return None;+ }let Some(context_window) = self.status_line_context_window_size() else {return Some(100);};@@ -375,8 +378,8 @@ impl ChatWidget {}pub(super) fn status_line_context_used_percent(&self) -> Option<i64> {- let remaining = self.status_line_context_remaining_percent().unwrap_or(100);- Some((100 - remaining).clamp(0, 100))+ self.status_line_context_remaining_percent()+ .map(|remaining| (100 - remaining).clamp(0, 100))}pub(super) fn status_line_total_usage(&self) -> TokenUsage {diff --git a/codex-rs/tui/src/chatwidget/status_surfaces.rs b/codex-rs/tui/src/chatwidget/status_surfaces.rsindex fa17bb385b..5c9343c697 100644--- a/codex-rs/tui/src/chatwidget/status_surfaces.rs+++ b/codex-rs/tui/src/chatwidget/status_surfaces.rs@@ -715,14 +715,18 @@ impl ChatWidget {StatusLineItem::ContextWindowSize => self.status_line_context_window_size().map(|cws| format!("{} window", format_tokens_compact(cws))),- StatusLineItem::TotalInputTokens => Some(format!(- "{} in",- format_tokens_compact(self.status_line_total_usage().input_tokens)- )),- StatusLineItem::TotalOutputTokens => Some(format!(- "{} out",- format_tokens_compact(self.status_line_total_usage().output_tokens)- )),+ StatusLineItem::TotalInputTokens => (!self.token_usage_pending).then(|| {+ format!(+ "{} in",+ format_tokens_compact(self.status_line_total_usage().input_tokens)+ )+ }),+ StatusLineItem::TotalOutputTokens => (!self.token_usage_pending).then(|| {+ format!(+ "{} out",+ format_tokens_compact(self.status_line_total_usage().output_tokens)+ )+ }),StatusLineItem::SessionId => self.thread_id.map(|id| id.to_string()),StatusLineItem::FastMode => Some(if self.current_service_tier() == Some(ServiceTier::Fast.request_value()) {diff --git a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rsindex 1fe5065eeb..7532551d55 100644--- a/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs+++ b/codex-rs/tui/src/chatwidget/tests/status_and_layout.rs@@ -41,6 +41,52 @@ async fn token_count_none_resets_context_indicator() {assert_eq!(chat.bottom_pane.context_window_percent(), None);}+#[tokio::test]+async fn resumed_session_hides_unknown_token_usage_until_an_update_arrives() {+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;+ chat.thread_id = Some(ThreadId::new());+ chat.set_token_info(/*info*/ None);++ let width = 80;+ let height = chat.desired_height(width);+ let mut terminal =+ ratatui::Terminal::new(TestBackend::new(width, height)).expect("create terminal");+ terminal+ .draw(|frame| chat.render(frame.area(), frame.buffer_mut()))+ .expect("render resumed session");+ let rendered = normalized_backend_snapshot(terminal.backend());+ assert!(!rendered.contains("100% context left"));+ insta::assert_snapshot!(+ rendered+ .lines()+ .find(|line| line.contains("context left"))+ .map(str::trim)+ .unwrap_or("(hidden)"),+ @"(hidden)"+ );++ chat.config.tui_status_line = Some(vec![+ "context-remaining".to_string(),+ "context-used".to_string(),+ "total-input-tokens".to_string(),+ "total-output-tokens".to_string(),+ ]);+ chat.refresh_status_line();+ assert_eq!(status_line_text(&chat), None);++ handle_token_count(+ &mut chat,+ Some(make_token_info(+ /*total_tokens*/ 12_700, /*context_window*/ 13_000,+ )),+ );+ chat.refresh_status_line();+ assert_eq!(+ status_line_text(&chat),+ Some("Context 30% left · Context 70% used · 0 in · 0 out".to_string())+ );+}+#[tokio::test]async fn app_server_cyber_policy_error_renders_dedicated_notice() {let (mut chat, mut rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/pager_overlay.rs b/codex-rs/tui/src/pager_overlay.rsindex f149bd0744..c32c1b4ced 100644--- a/codex-rs/tui/src/pager_overlay.rs+++ b/codex-rs/tui/src/pager_overlay.rs@@ -20,6 +20,7 @@ use std::sync::Arc;use crate::chatwidget::ActiveCellTranscriptKey;use crate::history_cell::HistoryCell;+use crate::history_cell::SessionInfoCell;use crate::history_cell::UserHistoryCell;use crate::key_hint;use crate::key_hint::KeyBinding;@@ -597,6 +598,57 @@ impl TranscriptOverlay {}}+ /// Returns whether an upward navigation is close enough to request older history.+ pub(crate) fn should_load_older(&self, key_event: KeyEvent) -> bool {+ self.view.keymap.jump_top.is_pressed(key_event)+ || (self.view.scroll_offset+ <= self.view.last_content_height.unwrap_or(/*default*/ 0)+ && (self.view.keymap.scroll_up.is_pressed(key_event)+ || self.view.keymap.page_up.is_pressed(key_event)+ || self.view.keymap.half_page_up.is_pressed(key_event)))+ }++ /// Prepends history without moving visible content and returns its insertion index.+ pub(crate) fn prepend(&mut self, cells: Vec<Arc<dyn HistoryCell>>, width: u16) -> usize {+ if cells.is_empty() {+ return 0;+ }+ let follow_bottom = self.view.is_scrolled_to_bottom();+ let previous_height = self.view.content_height(width);+ let live_tail = self.take_live_tail_renderable();+ let added_cells = cells.len();+ let insert_at = self+ .cells+ .iter()+ .rposition(|cell| cell.as_any().is::<SessionInfoCell>())+ .map_or(/*default*/ 0, |index| index.saturating_add(/*rhs*/ 1));+ self.cells.splice(insert_at..insert_at, cells);+ for index in [+ &mut self.highlight_cell,+ &mut self.view.pending_scroll_chunk,+ ] {+ if let Some(index) = index.as_mut()+ && *index >= insert_at+ {+ *index = index.saturating_add(added_cells);+ }+ }+ self.rebuild_renderables();+ if let Some(live_tail) = live_tail {+ self.view.renderables.push(live_tail);+ }+ self.view.scroll_offset = if follow_bottom {+ usize::MAX+ } else {+ self.view.scroll_offset.saturating_add(+ self.view+ .content_height(width)+ .saturating_sub(previous_height),+ )+ };+ insert_at+ }+/// Replace committed transcript cells while keeping any cached in-progress output that is/// currently shown at the end of the overlay.///@@ -1059,6 +1111,18 @@ mod tests {);}+ #[test]+ fn jump_top_requests_older_history_from_the_bottom() {+ let overlay = transcript_overlay(vec![Arc::new(TestCell {+ lines: vec![Line::from("recent")],+ })]);++ assert!(overlay.should_load_older(KeyEvent::new(+ KeyCode::Home,+ crossterm::event::KeyModifiers::NONE,+ )));+ }+#[test]fn edit_next_hint_is_visible_when_highlighted() {let mut overlay = transcript_overlay(vec![Arc::new(TestCell {@@ -1140,6 +1204,38 @@ mod tests {assert_snapshot!(term.backend());}+ #[test]+ fn transcript_overlay_preserves_live_tail_when_prepending_history() {+ let mut overlay = transcript_overlay(vec![Arc::new(TestCell {+ lines: vec![Line::from("recent")],+ })]);+ overlay.sync_live_tail(+ /*width*/ 40,+ Some(ActiveCellTranscriptKey {+ revision: 1,+ is_stream_continuation: false,+ animation_tick: None,+ }),+ |_| Some(vec![HyperlinkLine::from("live tail")]),+ );+ overlay.prepend(+ vec![Arc::new(TestCell {+ lines: vec![Line::from("older")],+ })],+ /*width*/ 40,+ );++ let area = Rect::new(+ /*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 10,+ );+ let mut buffer = Buffer::empty(area);+ overlay.render(area, &mut buffer);+ let rendered = buffer_to_text(&buffer, area);+ assert!(rendered.contains("older"));+ assert!(rendered.contains("recent"));+ assert!(rendered.contains("live tail"));+ }+#[test]fn transcript_overlay_live_tail_preserves_semantic_web_links() {let destination = "https://example.com/a/streamed/path";@@ -1326,6 +1422,29 @@ mod tests {}));assert_eq!(overlay.view.scroll_offset, 0);+ overlay.view.scroll_offset = 3;+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))+ .expect("draw");+ let content_area = Rect::new(+ /*x*/ 0, /*y*/ 1, /*width*/ 40, /*height*/ 4,+ );+ let visible_before = buffer_to_text(term.backend().buffer(), content_area);+ overlay.prepend(+ vec![Arc::new(TestCell {+ lines: vec!["older first".into(), "older second".into()],+ })],+ /*width*/ 40,+ );+ term.draw(|frame| overlay.render(frame.area(), frame.buffer_mut()))+ .expect("draw");+ assert_eq!(+ buffer_to_text(term.backend().buffer(), content_area),+ visible_before+ );+ assert_snapshot!(+ "transcript_overlay_prepended_history",+ visible_before.trim()+ );}#[test]diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_prepended_history.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_prepended_history.snapnew file mode 100644index 0000000000..e7602f1517--- /dev/null+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_prepended_history.snap@@ -0,0 +1,7 @@+---+source: tui/src/pager_overlay.rs+expression: visible_before.trim()+---+line2++line3diff --git a/codex-rs/tui/src/thread_transcript.rs b/codex-rs/tui/src/thread_transcript.rsindex c7b7a2bb8a..a2f74e7933 100644--- a/codex-rs/tui/src/thread_transcript.rs+++ b/codex-rs/tui/src/thread_transcript.rs@@ -17,6 +17,7 @@ use codex_app_server_protocol::ThreadItem;use codex_app_server_protocol::UserInput;use codex_protocol::ThreadId;use codex_protocol::items::UserMessageItem;+use codex_utils_absolute_path::AbsolutePathBuf;use ratatui::style::Stylize as _;use ratatui::text::Line;@@ -51,13 +52,34 @@ pub(crate) fn thread_to_transcript_cells(codex_home: Option<&std::path::Path>,) -> TranscriptCells {let cwd = thread.cwd;+ let thread_id = ThreadId::from_string(&thread.id).ok();+ let mut cells = thread_items_to_transcript_cells(+ thread_id,+ &cwd,+ thread.turns.into_iter().flat_map(|turn| turn.items),+ raw_reasoning_visibility,+ codex_home,+ );+ if cells.is_empty() {+ cells.push(Arc::new(PlainHistoryCell::new(vec![+ "No transcript content available".italic().dim().into(),+ ])));+ }+ cells+}++pub(crate) fn thread_items_to_transcript_cells(+ thread_id: Option<ThreadId>,+ cwd: &AbsolutePathBuf,+ items: impl IntoIterator<Item = ThreadItem>,+ raw_reasoning_visibility: RawReasoningVisibility,+ codex_home: Option<&std::path::Path>,+) -> TranscriptCells {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))+ thread_id.and_then(|thread_id| InlineVisualizationContext::new(codex_home, thread_id))});let mut cells: TranscriptCells = Vec::new();- for item in thread.turns.into_iter().flat_map(|turn| turn.items) {+ for item in items {match item {ThreadItem::UserMessage {id,@@ -135,11 +157,6 @@ pub(crate) fn thread_to_transcript_cells(}}}- if cells.is_empty() {- cells.push(Arc::new(PlainHistoryCell::new(vec![- "No transcript content available".italic().dim().into(),- ])));- }cells}