diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork.rs b/codex-rs/app-server/tests/suite/v2/thread_fork.rs index 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.rs index 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, 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.rs index 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.rs index 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, ) -> 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::()) + .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.rs index 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::>(); + let mut retained_lines = buffer.retained_lines.into_iter().collect::>(); + 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, + 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 the diff --git a/codex-rs/tui/src/app/resize_reflow_tests.rs b/codex-rs/tui/src/app/resize_reflow_tests.rs index 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::>() + .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::>() + .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::>() + .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::>() + .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.rs index 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![ - "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.rs index 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::( 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 { - let thread_id = create_fake_rollout( +fn create_history_rollout( + config: &Config, + history_mode: ThreadHistoryMode, + preview: &str, +) -> Result { + 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() -> Resu async 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::) + .collect::, _>>()?; + 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::>() + .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::() + }) + .collect::>() + .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::>(); + 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::) + .collect::, _>>()?; + 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::>() + .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![&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::>() + .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.rs index 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.rs index 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::::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.rs index 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,