Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Harden paginated history handling in the TUI (#36951)

Felipe Coury449f099f1cad
diff --git a/codex-rs/app-server/tests/suite/v2/thread_fork.rs b/codex-rs/app-server/tests/suite/v2/thread_fork.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<crate::terminal_hyperlinks::HyperlinkLine>,
render_from_transcript_tail: bool,
+ was_truncated: bool,
}
pub(crate) struct App {
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.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<ThreadItemsListResponse, String>,
) -> Result<()> {
- if self.chat_widget.thread_id() != Some(thread_id)
- || !matches!(self.overlay, Some(Overlay::Transcript(_)))
- {
+ if self.chat_widget.thread_id() != Some(thread_id) {
app_server.cancel_older_history_page(thread_id);
return Ok(());
}
@@ -229,6 +228,24 @@ impl App {
});
continue_to_start = previous_state == TranscriptHistoryState::LoadingBeginning
&& self.scrollback_has_older_history;
+ } else {
+ let index = self
+ .transcript_cells
+ .iter()
+ .rposition(|cell| cell.as_any().is::<SessionInfoCell>())
+ .map_or(/*default*/ 0, |index| index.saturating_add(/*rhs*/ 1));
+ self.transcript_cells.splice(index..index, cells);
+ let wrap_width = self.chat_widget.history_wrap_width(width);
+ let rendered_rows = self
+ .render_transcript_lines_for_reflow(wrap_width)
+ .lines
+ .len();
+ self.schedule_immediate_resize_reflow(tui);
+ if self.scrollback_history_needs_top_up(rendered_rows)
+ && self.request_older_history_page(app_server, thread_id)
+ {
+ return Ok(());
+ }
}
if continue_to_start
&& self.request_older_history_page(app_server, thread_id)
diff --git a/codex-rs/tui/src/app/resize_reflow.rs b/codex-rs/tui/src/app/resize_reflow.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::<Vec<_>>();
+ let mut retained_lines = buffer.retained_lines.into_iter().collect::<Vec<_>>();
+ let width = self
+ .chat_widget
+ .history_wrap_width(tui.terminal.last_known_screen_size.width);
+ self.prepend_scrollback_history_notice(&mut retained_lines, buffer.was_truncated, width);
+ let retained_rows = retained_lines.len();
tui.insert_history_hyperlink_lines_with_wrap_policy(
retained_lines,
self.history_line_wrap_policy(),
);
+ self.request_scrollback_history_top_up(retained_rows);
}
pub(super) fn insert_history_cell_lines_with_initial_replay_buffer(
@@ -230,6 +239,7 @@ impl App {
buffer.retained_lines.extend(display);
while buffer.retained_lines.len() > max_rows {
buffer.retained_lines.pop_front();
+ buffer.was_truncated = true;
}
}
@@ -286,7 +296,7 @@ impl App {
Ok(())
}
- fn schedule_immediate_resize_reflow(&mut self, tui: &mut tui::Tui) {
+ pub(super) fn schedule_immediate_resize_reflow(&mut self, tui: &mut tui::Tui) {
self.transcript_reflow.schedule_immediate();
tui.frame_requester().schedule_frame();
}
@@ -457,6 +467,7 @@ impl App {
let reflow_result = self.render_transcript_lines_for_reflow(width);
let reflowed_lines = reflow_result.lines;
+ let reflowed_rows = reflowed_lines.len();
// Drop any queued pre-resize/pre-consolidation inserts before rebuilding from cells.
tui.clear_pending_history_lines();
@@ -469,10 +480,35 @@ impl App {
self.history_line_wrap_policy(),
);
}
+ self.request_scrollback_history_top_up(reflowed_rows);
Ok(terminal_width)
}
+ /// Return whether older paginated source can fill unused configured scrollback rows.
+ pub(super) fn scrollback_history_needs_top_up(&self, rendered_rows: usize) -> bool {
+ self.overlay.is_none()
+ && self.scrollback_has_older_history
+ && self
+ .resize_reflow_max_rows()
+ .is_some_and(|max_rows| rendered_rows < max_rows)
+ }
+
+ fn request_scrollback_history_top_up(&self, rendered_rows: usize) {
+ if self.scrollback_history_needs_top_up(rendered_rows)
+ && let Some(thread_id) = self.chat_widget.thread_id()
+ {
+ tracing::debug!(
+ %thread_id,
+ rendered_rows,
+ max_rows = self.resize_reflow_max_rows(),
+ "refilling underfilled terminal scrollback from paginated history"
+ );
+ self.app_event_tx
+ .send(crate::app_event::AppEvent::RequestOlderScrollbackHistory { thread_id });
+ }
+ }
+
/// Rebuild scrollback after rollback removes transcript cells.
///
/// Unlike resize reflow, rollback must clear the terminal even when no cells remain. Otherwise
@@ -517,6 +553,7 @@ impl App {
let mut cell_displays = VecDeque::new();
let mut rendered_rows = 0usize;
let mut start = self.transcript_cells.len();
+ let mut history_was_truncated = false;
while start > 0 {
start -= 1;
@@ -530,6 +567,7 @@ impl App {
});
if row_cap.is_some_and(|max_rows| rendered_rows > max_rows) {
+ history_was_truncated = true;
break;
}
}
@@ -565,9 +603,11 @@ impl App {
if let Some(max_rows) = row_cap
&& reflowed_lines.len() > max_rows
{
+ history_was_truncated = true;
let trimmed_line_count = reflowed_lines.len() - max_rows;
reflowed_lines = reflowed_lines.split_off(trimmed_line_count);
}
+ self.prepend_scrollback_history_notice(&mut reflowed_lines, history_was_truncated, width);
self.has_emitted_history_lines = !reflowed_lines.is_empty();
ReflowRenderResult {
@@ -575,6 +615,37 @@ impl App {
}
}
+ fn prepend_scrollback_history_notice(
+ &self,
+ lines: &mut Vec<HyperlinkLine>,
+ history_was_truncated: bool,
+ width: u16,
+ ) {
+ if lines.is_empty() || (!history_was_truncated && !self.scrollback_has_older_history) {
+ return;
+ }
+ let Some(binding) = crate::keymap::primary_binding(&self.keymap.app.open_transcript) else {
+ return;
+ };
+ let notice = Line::from(format!(
+ "Earlier messages are available — press {} to view the full transcript",
+ binding.display_label()
+ ))
+ .dim();
+ let notice_lines =
+ crate::wrapping::word_wrap_lines([notice], usize::from(width.max(/*other*/ 1)));
+ if let Some(max_rows) = self.resize_reflow_max_rows() {
+ let available_history_rows = max_rows.saturating_sub(notice_lines.len());
+ if available_history_rows == 0 {
+ return;
+ }
+ if lines.len() > available_history_rows {
+ lines.drain(..lines.len() - available_history_rows);
+ }
+ }
+ lines.splice(0..0, notice_lines.into_iter().map(HyperlinkLine::new));
+ }
+
/// Return whether current transcript state should be treated as stream-time resize state.
///
/// The active stream controllers cover normal streaming. The trailing-cell checks cover 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::<Vec<_>>()
+ .join("\n"),
+ @r"
+ Earlier messages are available — press ctrl + t to view the full transcript
+ cell 8
+
+ cell 9
+
+ cell 10
+
+ cell 11
+ "
+ );
+}
+
+#[tokio::test]
+async fn capped_resize_reflow_counts_wrapped_notice_rows() {
+ let mut app = make_test_app().await;
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(8);
+ app.transcript_cells = plain_history_cells(/*count*/ 12);
+
+ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 28);
+
+ assert_eq!(rendered.lines.len(), 8);
+ insta::assert_snapshot!(
+ rendered
+ .lines
+ .iter()
+ .map(rendered_line_text)
+ .collect::<Vec<_>>()
+ .join("\n"),
+ @r"
+ Earlier messages are
+ available — press ctrl + t
+ to view the full transcript
+ cell 9
+
+ cell 10
+
+ cell 11
+ "
+ );
+}
+
+#[tokio::test]
+async fn one_row_history_cap_preserves_conversation_instead_of_notice() {
+ let mut app = make_test_app().await;
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(1);
+ app.scrollback_has_older_history = true;
+ app.transcript_cells = plain_history_cells(/*count*/ 2);
+
+ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);
+
+ assert_eq!(rendered.lines.len(), 1);
+ insta::assert_snapshot!(
+ rendered
+ .lines
+ .iter()
+ .map(rendered_line_text)
+ .collect::<Vec<_>>()
+ .join("\n"),
+ @r"cell 1"
+ );
+}
+
+#[tokio::test]
+async fn paginated_resize_reflow_prepends_transcript_notice_for_unloaded_history() {
+ let mut app = make_test_app().await;
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);
+ app.scrollback_has_older_history = true;
+ app.transcript_cells = plain_history_cells(/*count*/ 2);
+
+ let rendered = app.render_transcript_lines_for_reflow(/*width*/ 80);
+
+ insta::assert_snapshot!(
+ rendered
+ .lines
+ .iter()
+ .map(rendered_line_text)
+ .collect::<Vec<_>>()
+ .join("\n"),
+ @r"
+ Earlier messages are available — press ctrl + t to view the full transcript
+ cell 0
+
+ cell 1
+ "
+ );
+}
+
+#[tokio::test]
+async fn scrollback_refill_only_loads_older_pages_for_an_underfilled_row_cap() {
+ let mut app = make_test_app().await;
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);
+ app.scrollback_has_older_history = true;
+
+ assert!(app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));
+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 32));
+
+ app.scrollback_has_older_history = false;
+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));
+
+ app.scrollback_has_older_history = true;
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Disabled;
+ assert!(!app.scrollback_history_needs_top_up(/*rendered_rows*/ 31));
+}
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.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<_>>(),
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::<ClientRequest>(
serde_json::to_value(request)?,
@@ -240,12 +259,20 @@ async fn start_recording_app_server_with_history(
))
}
-fn create_legacy_history_rollout(config: &Config) -> Result<ThreadId> {
- let thread_id = create_fake_rollout(
+fn create_history_rollout(
+ config: &Config,
+ history_mode: ThreadHistoryMode,
+ preview: &str,
+) -> Result<ThreadId> {
+ let create_rollout = match history_mode {
+ ThreadHistoryMode::Legacy => create_fake_rollout,
+ ThreadHistoryMode::Paginated => create_fake_paginated_rollout,
+ };
+ let thread_id = create_rollout(
config.codex_home.as_path(),
"2026-01-02T00-00-00",
"2026-01-02T00:00:00Z",
- "legacy history",
+ preview,
Some(config.model_provider_id.as_str()),
/*git_info*/ None,
)
@@ -606,7 +633,8 @@ async fn transcript_home_loads_every_older_history_page() -> Result<()> {
#[tokio::test]
async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
- let legacy_thread_id = create_legacy_history_rollout(&app.config)?;
+ let legacy_thread_id =
+ create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnly,
@@ -679,7 +707,8 @@ enum LegacyHistoryRequest {
async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?;
- let legacy_thread_id = create_legacy_history_rollout(&app.config)?;
+ let legacy_thread_id =
+ create_history_rollout(&app.config, ThreadHistoryMode::Legacy, "legacy history")?;
let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config,
HistoryCapabilities::LegacyOnly,
@@ -736,6 +765,489 @@ async fn remote_legacy_history_resume_retries_generic_method_not_found() -> 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::<serde_json::Value>)
+ .collect::<Result<Vec<_>, _>>()?;
+ let events = std::iter::once(EventMsg::TurnStarted(TurnStartedEvent {
+ turn_id: "scrollback-pagination-turn".to_string(),
+ trace_id: None,
+ started_at: None,
+ model_context_window: None,
+ collaboration_mode_kind: Default::default(),
+ }))
+ .chain((0..120).map(|index| {
+ EventMsg::ItemCompleted(ItemCompletedEvent {
+ thread_id,
+ turn_id: "scrollback-pagination-turn".to_string(),
+ item: TurnItem::AgentMessage(AgentMessageItem {
+ id: format!("scrollback-item-{index}"),
+ content: vec![AgentMessageContent::Text {
+ text: format!("scrollback output {index}"),
+ }],
+ phase: None,
+ memory_citation: None,
+ }),
+ started_at_ms: None,
+ completed_at_ms: 0,
+ })
+ }));
+ for event in events {
+ records.push(serde_json::json!({
+ "timestamp": "2026-01-02T00:00:00Z",
+ "ordinal": records.len(),
+ "type": "event_msg",
+ "payload": serde_json::to_value(event)?,
+ }));
+ }
+ let records = records
+ .into_iter()
+ .map(|record| record.to_string())
+ .collect::<Vec<_>>()
+ .join("\n");
+ std::fs::write(path, format!("{records}\n"))?;
+
+ let (mut app_server, requests, proxy) = start_recording_app_server(
+ &app.config,
+ /*blocked_thread_list*/ None,
+ /*failed_thread_name*/ None,
+ )
+ .await?;
+ let started = app_server
+ .resume_thread(
+ app.config.clone(),
+ thread_id,
+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,
+ )
+ .await?;
+ let mut initial_cells = crate::thread_transcript::thread_items_to_transcript_cells(
+ Some(thread_id),
+ &app.config.cwd,
+ started.turns.iter().flat_map(|turn| turn.items.clone()),
+ crate::thread_transcript::RawReasoningVisibility::Hidden,
+ Some(app.config.codex_home.as_path()),
+ );
+ initial_cells.insert(
+ /*index*/ 0,
+ Arc::new(crate::history_cell::new_session_info(
+ &app.config,
+ started.session.model.as_str(),
+ &started.session,
+ /*is_first_event*/ false,
+ Some("This is a test announcement".to_string()),
+ /*auth_plan*/ None,
+ /*show_fast_status*/ false,
+ )),
+ );
+ app.enqueue_primary_thread_session(started.session, started.turns)
+ .await?;
+ app.transcript_cells = initial_cells;
+ app.scrollback_has_older_history = app_server.has_older_history(thread_id);
+ app.config.terminal_resize_reflow.max_rows = TerminalResizeReflowMaxRows::Limit(32);
+ let initial_cell_count = app.transcript_cells.len();
+ let initial_page_requests = recorded_params(&requests, "thread/items/list").len();
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+
+ app.scrollback_has_older_history = false;
+ app.handle_key_event(
+ &mut tui,
+ &mut app_server,
+ KeyEvent::new(KeyCode::Char('t'), KeyModifiers::CONTROL),
+ )
+ .await;
+ assert!(app.scrollback_has_older_history);
+ if let Some(Overlay::Transcript(overlay)) = app.overlay.as_mut() {
+ overlay.handle_event(
+ &mut tui,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE)),
+ )?;
+ let area = Rect::new(
+ /*x*/ 0, /*y*/ 0, /*width*/ 100, /*height*/ 16,
+ );
+ let render_overlay = |overlay: &mut crate::pager_overlay::TranscriptOverlay| {
+ let mut buffer = Buffer::empty(area);
+ overlay.render(area, &mut buffer);
+ (area.y..area.bottom())
+ .map(|y| {
+ (area.x..area.right())
+ .map(|x| buffer[(x, y)].symbol())
+ .collect::<String>()
+ })
+ .collect::<Vec<_>>()
+ .join("\n")
+ };
+ let partial = render_overlay(overlay);
+ assert!(partial.contains("Earlier messages are available — scroll up to load them"));
+ assert!(!partial.contains("OpenAI Codex"));
+ assert!(!partial.contains("This is a test announcement"));
+ assert!(!partial.contains('%'));
+
+ overlay.set_history_state(crate::pager_overlay::TranscriptHistoryState::LoadingOlder);
+ let loading = render_overlay(overlay);
+ assert!(loading.contains("Loading earlier messages..."));
+ assert!(!loading.contains("OpenAI Codex"));
+ assert!(!loading.contains('%'));
+ } else {
+ panic!("expected transcript overlay");
+ }
+ app.close_transcript_overlay(&mut tui);
+
+ let terminal_width = tui.terminal.last_known_screen_size.into();
+ app.reflow_transcript_now(&mut tui, terminal_width)?;
+ let request = loop {
+ match app_event_rx.recv().await {
+ Some(event @ AppEvent::RequestOlderScrollbackHistory { .. }) => break event,
+ Some(_) => {}
+ None => panic!("scrollback refill request channel closed"),
+ }
+ };
+ app.handle_event(&mut tui, &mut app_server, request).await?;
+ let loaded = loop {
+ match app_event_rx.recv().await {
+ Some(event @ AppEvent::OlderThreadHistoryLoaded { .. }) => break event,
+ Some(_) => {}
+ None => panic!("older history page channel closed"),
+ }
+ };
+ app.handle_event(&mut tui, &mut app_server, loaded).await?;
+
+ assert!(app.overlay.is_none());
+ assert!(app.transcript_cells.len() > initial_cell_count);
+ assert_eq!(
+ recorded_params(&requests, "thread/items/list").len(),
+ initial_page_requests + 1
+ );
+ assert_eq!(
+ app.render_transcript_lines_for_reflow(/*width*/ 80)
+ .lines
+ .len(),
+ 32
+ );
+
+ app_server.shutdown().await?;
+ proxy.await??;
+ Ok(())
+}
+
+#[tokio::test]
+async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {
+ let (app, _codex_home) = make_history_test_app().await?;
+ let paginated_thread_id = create_history_rollout(
+ &app.config,
+ ThreadHistoryMode::Paginated,
+ "paginated visible history",
+ )?;
+ let legacy_thread_id = create_history_rollout(
+ &app.config,
+ ThreadHistoryMode::Legacy,
+ "legacy visible history",
+ )?;
+ let (mut app_server, requests, proxy) = start_recording_app_server(
+ &app.config,
+ /*blocked_thread_list*/ None,
+ /*failed_thread_name*/ None,
+ )
+ .await?;
+
+ let resumed = app_server
+ .resume_thread(
+ app.config.clone(),
+ paginated_thread_id,
+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,
+ )
+ .await?;
+ assert_eq!(resumed.session.thread_id, paginated_thread_id);
+ let cells = crate::thread_transcript::load_session_transcript(
+ &mut app_server,
+ paginated_thread_id,
+ crate::thread_transcript::RawReasoningVisibility::Hidden,
+ Some(app.config.codex_home.as_path()),
+ )
+ .await?;
+ assert!(!cells.is_empty());
+ app_server
+ .fork_thread(app.config.clone(), paginated_thread_id)
+ .await?;
+ let mut side_config = app.config.clone();
+ side_config.ephemeral = true;
+ app_server
+ .fork_side_thread(side_config, paginated_thread_id)
+ .await?;
+
+ let paginated_reads = recorded_params(&requests, "thread/read");
+ assert!(!paginated_reads.is_empty());
+ assert!(
+ paginated_reads
+ .iter()
+ .all(|params| params["includeTurns"] != true),
+ "paginated workflows requested full history: {paginated_reads:?}"
+ );
+ assert!(!recorded_params(&requests, "thread/turns/list").is_empty());
+ assert!(!recorded_params(&requests, "thread/items/list").is_empty());
+
+ let previous_read_count = paginated_reads.len();
+ crate::thread_transcript::load_session_transcript(
+ &mut app_server,
+ legacy_thread_id,
+ crate::thread_transcript::RawReasoningVisibility::Hidden,
+ Some(app.config.codex_home.as_path()),
+ )
+ .await?;
+ let legacy_reads = recorded_params(&requests, "thread/read");
+ let legacy_include_turns = legacy_reads[previous_read_count..]
+ .iter()
+ .map(|params| params["includeTurns"].as_bool().unwrap_or(false))
+ .collect::<Vec<_>>();
+ assert_eq!(legacy_include_turns, vec![false, true]);
+
+ app_server.shutdown().await?;
+ proxy.await??;
+ Ok(())
+}
+
+#[tokio::test]
+async fn cold_paginated_subagent_transcript_excludes_inherited_parent_history() -> Result<()> {
+ let (app, codex_home) = make_history_test_app().await?;
+ let parent_thread_id = create_history_rollout(
+ &app.config,
+ ThreadHistoryMode::Paginated,
+ "parent-only paginated history",
+ )?;
+ let child_timestamp = "2026-01-02T00-00-01";
+ let child_thread_id = ThreadId::from_string(
+ &create_fake_parented_rollout_with_source(
+ codex_home.path(),
+ child_timestamp,
+ "2026-01-02T00:00:01Z",
+ "child-only paginated history",
+ Some(app.config.model_provider_id.as_str()),
+ /*git_info*/ None,
+ RolloutSessionSource::SubAgent(SubAgentSource::ThreadSpawn {
+ parent_thread_id,
+ depth: 1,
+ agent_path: Some(
+ AgentPath::try_from("/root/worker").map_err(color_eyre::eyre::Report::msg)?,
+ ),
+ agent_nickname: Some("worker".to_string()),
+ agent_role: Some("worker".to_string()),
+ }),
+ parent_thread_id.into(),
+ parent_thread_id,
+ )
+ .map_err(|err| color_eyre::eyre::eyre!("failed to create subagent rollout: {err}"))?,
+ )?;
+ let child_rollout_path = rollout_path(
+ codex_home.path(),
+ child_timestamp,
+ &child_thread_id.to_string(),
+ );
+ let mut child_lines = std::fs::read_to_string(&child_rollout_path)?
+ .lines()
+ .map(serde_json::from_str::<serde_json::Value>)
+ .collect::<Result<Vec<_>, _>>()?;
+ let mut meta = child_lines.remove(/*index*/ 0);
+ meta["payload"]["history_mode"] = serde_json::json!("paginated");
+ meta["payload"]["subagent_history_start_ordinal"] = serde_json::json!(3);
+ meta["ordinal"] = serde_json::json!(0);
+ for (index, line) in child_lines.iter_mut().enumerate() {
+ line["ordinal"] = serde_json::json!(index + 3);
+ }
+ let rollout_record = |ordinal: usize, kind: &str, payload: serde_json::Value| {
+ serde_json::json!({
+ "timestamp": "2026-01-02T00:00:01Z",
+ "ordinal": ordinal,
+ "type": kind,
+ "payload": payload,
+ })
+ };
+ let inherited_response = rollout_record(
+ /*ordinal*/ 1,
+ "response_item",
+ serde_json::json!({
+ "type": "message",
+ "role": "user",
+ "content": [{
+ "type": "input_text",
+ "text": "parent-only paginated history",
+ }],
+ }),
+ );
+ let inherited_event = rollout_record(
+ /*ordinal*/ 2,
+ "event_msg",
+ serde_json::json!({
+ "type": "user_message",
+ "message": "parent-only paginated history",
+ "kind": "plain",
+ }),
+ );
+ let lines = std::iter::once(meta)
+ .chain([inherited_response, inherited_event])
+ .chain(child_lines)
+ .chain([
+ rollout_record(
+ /*ordinal*/ 5,
+ "event_msg",
+ serde_json::json!({
+ "type": "task_started",
+ "turn_id": "child-visible-turn",
+ "model_context_window": null,
+ }),
+ ),
+ rollout_record(
+ /*ordinal*/ 6,
+ "event_msg",
+ serde_json::json!({
+ "type": "item_completed",
+ "thread_id": child_thread_id,
+ "turn_id": "child-visible-turn",
+ "item": {
+ "type": "UserMessage",
+ "id": "child-visible-user",
+ "content": [{
+ "type": "text",
+ "text": "child-only paginated history",
+ }],
+ },
+ }),
+ ),
+ ])
+ .map(|line| line.to_string())
+ .collect::<Vec<_>>()
+ .join("\n");
+ std::fs::write(child_rollout_path, format!("{lines}\n"))?;
+ let (mut app_server, requests, proxy) = start_recording_app_server(
+ &app.config,
+ /*blocked_thread_list*/ None,
+ /*failed_thread_name*/ None,
+ )
+ .await?;
+
+ let resumed = app_server
+ .resume_thread(
+ app.config.clone(),
+ child_thread_id,
+ crate::app_server_session::ResumeModelSettings::RestoreFromThread,
+ )
+ .await?;
+ let child_turn_page = app_server
+ .thread_turns_page(child_thread_id, /*cursor*/ None)
+ .await?;
+ let child_item_page = app_server
+ .thread_items_page(
+ child_thread_id,
+ /*turn_id*/ None,
+ /*cursor*/ None,
+ /*limit*/ 16,
+ )
+ .await?;
+ let [child_turn] = child_turn_page.data.as_slice() else {
+ panic!("paginated subagent should expose exactly one child turn");
+ };
+ let [child_entry] = child_item_page.data.as_slice() else {
+ panic!("paginated subagent should expose exactly one child message");
+ };
+ let ThreadItem::UserMessage { content, .. } = &child_entry.item else {
+ panic!("paginated subagent should expose its child user message");
+ };
+ assert_eq!(resumed.session.thread_id, child_thread_id);
+ assert_eq!(child_entry.turn_id, child_turn.id);
+ assert_eq!(
+ content,
+ &[UserInput::Text {
+ text: "child-only paginated history".to_string(),
+ text_elements: Vec::new(),
+ }],
+ );
+ assert_eq!(
+ resumed
+ .turns
+ .iter()
+ .flat_map(|turn| turn.items.iter())
+ .collect::<Vec<_>>(),
+ vec![&child_entry.item],
+ );
+
+ let cells = crate::thread_transcript::load_session_transcript(
+ &mut app_server,
+ child_thread_id,
+ crate::thread_transcript::RawReasoningVisibility::Hidden,
+ Some(app.config.codex_home.as_path()),
+ )
+ .await?;
+ let visible_history = cells
+ .iter()
+ .map(|cell| lines_to_single_string(&cell.display_lines(/*width*/ 80)))
+ .collect::<Vec<_>>()
+ .join("\n");
+ assert!(visible_history.contains("child-only paginated history"));
+ assert!(!visible_history.contains("parent-only paginated history"));
+ assert!(
+ recorded_params(&requests, "thread/read")
+ .iter()
+ .all(|params| params["includeTurns"] != true)
+ );
+
+ app_server.shutdown().await?;
+ proxy.await??;
+ Ok(())
+}
+
#[test]
fn fresh_session_applies_requested_name() -> Result<()> {
const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.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::<Turn>::new());
+ assert!(app_server.has_older_history(source_thread_id));
+ assert!(
+ !app_server
+ .history_pagination
+ .contains_key(&side.session.thread_id)
+ );
+
+ app_server.shutdown().await?;
+ Ok(())
+ }
+
#[tokio::test]
async fn config_request_overrides_preserve_implicit_personality_default() {
let temp_dir = tempfile::tempdir().expect("tempdir");
diff --git a/codex-rs/tui/src/app_server_session/history.rs b/codex-rs/tui/src/app_server_session/history.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,