Harden paginated history handling in the TUI (#36951)

## What changed

- Keep paginated resume, transcript, and fork workflows on bounded turn and item page requests, while preserving the legacy full-history fallback.
- Refill underfilled terminal scrollback from older pages and show a transcript shortcut when earlier history is unloaded or truncated by the row cap.
- Preserve a successfully created fork if its initial history hydration fails, keep side forks bounded, and retain the correct history boundary for nested forks and subagents.

## Testing

- Add coverage for scrollback refill and truncation notices, bounded paginated requests, fork hydration failures, nested forks, and inherited subagent history filtering.

GitOrigin-RevId: 10ba952ffb2f69717fbc71aa03cac7685f7dcf78
This commit is contained in:
Felipe Coury authored and copyberry committed 2026-08-04 19:18:03 +00:00
1 parent dbcd837c20
commit 449f099f1c
11 files changed
+894 -22

No files matched your search

@@ -1279,7 +1279,7 @@ async fn thread_fork_creates_reference_backed_paginated_thread() -> Result<()> {
let turn_id = mcp let turn_id = mcp
.send_turn_start_request(TurnStartParams { .send_turn_start_request(TurnStartParams {
thread_id: forked_thread_id, thread_id: forked_thread_id.clone(),
input: vec![UserInput::Text { input: vec![UserInput::Text {
text: "Continue from the fork".to_string(), text: "Continue from the fork".to_string(),
text_elements: Vec::new(), 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_path = excluded_turns_thread.path.expect("forked rollout path");
let excluded_turns_meta = read_session_meta_line(excluded_turns_path.as_path()).await?; 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)); 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(()) Ok(())
} }
+1
View File
@@ -506,6 +506,7 @@ struct SessionSummary {
struct InitialHistoryReplayBuffer { struct InitialHistoryReplayBuffer {
retained_lines: VecDeque<crate::terminal_hyperlinks::HyperlinkLine>, retained_lines: VecDeque<crate::terminal_hyperlinks::HyperlinkLine>,
render_from_transcript_tail: bool, render_from_transcript_tail: bool,
was_truncated: bool,
} }
pub(crate) struct App { pub(crate) struct App {
+8
View File
@@ -34,6 +34,14 @@ impl App {
self.handle_startup_thread_started(app_server, result) self.handle_startup_thread_started(app_server, result)
.await?; .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 { AppEvent::OlderThreadHistoryLoaded {
thread_id, thread_id,
cursor, cursor,
+21 -4
View File
@@ -5,6 +5,7 @@ use std::collections::HashSet;
use super::*; use super::*;
use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT; use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;
use crate::app_server_session::thread_items_page_params; use crate::app_server_session::thread_items_page_params;
use crate::history_cell::SessionInfoCell;
use crate::history_cell::UserHistoryCell; use crate::history_cell::UserHistoryCell;
use crate::pager_overlay::TranscriptHistoryState; use crate::pager_overlay::TranscriptHistoryState;
use crate::thread_transcript::RawReasoningVisibility; use crate::thread_transcript::RawReasoningVisibility;
@@ -13,7 +14,7 @@ use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::ThreadItemsListResponse; use codex_app_server_protocol::ThreadItemsListResponse;
impl App { 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( pub(crate) fn request_older_history_page(
&self, &self,
app_server: &mut AppServerSession, app_server: &mut AppServerSession,
@@ -61,9 +62,7 @@ impl App {
cursor: &str, cursor: &str,
result: Result<ThreadItemsListResponse, String>, result: Result<ThreadItemsListResponse, String>,
) -> Result<()> { ) -> Result<()> {
if self.chat_widget.thread_id() != Some(thread_id) if self.chat_widget.thread_id() != Some(thread_id) {
|| !matches!(self.overlay, Some(Overlay::Transcript(_)))
{
app_server.cancel_older_history_page(thread_id); app_server.cancel_older_history_page(thread_id);
return Ok(()); return Ok(());
} }
@@ -229,6 +228,24 @@ impl App {
}); });
continue_to_start = previous_state == TranscriptHistoryState::LoadingBeginning continue_to_start = previous_state == TranscriptHistoryState::LoadingBeginning
&& self.scrollback_has_older_history; && 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 if continue_to_start
&& self.request_older_history_page(app_server, thread_id) && self.request_older_history_page(app_server, thread_id)
+73 -2
View File
@@ -20,6 +20,7 @@ use std::time::Instant;
use color_eyre::eyre::Result; use color_eyre::eyre::Result;
use ratatui::layout::Size; use ratatui::layout::Size;
use ratatui::style::Stylize;
use ratatui::text::Line; use ratatui::text::Line;
use super::App; use super::App;
@@ -141,6 +142,7 @@ impl App {
self.initial_history_replay_buffer = Some(InitialHistoryReplayBuffer { self.initial_history_replay_buffer = Some(InitialHistoryReplayBuffer {
retained_lines: VecDeque::new(), retained_lines: VecDeque::new(),
render_from_transcript_tail: true, render_from_transcript_tail: true,
was_truncated: false,
}); });
} }
} }
@@ -163,14 +165,21 @@ impl App {
} }
if buffer.retained_lines.is_empty() { if buffer.retained_lines.is_empty() {
self.request_scrollback_history_top_up(/*rendered_rows*/ 0);
return; 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( tui.insert_history_hyperlink_lines_with_wrap_policy(
retained_lines, retained_lines,
self.history_line_wrap_policy(), self.history_line_wrap_policy(),
); );
self.request_scrollback_history_top_up(retained_rows);
} }
pub(super) fn insert_history_cell_lines_with_initial_replay_buffer( pub(super) fn insert_history_cell_lines_with_initial_replay_buffer(
@@ -230,6 +239,7 @@ impl App {
buffer.retained_lines.extend(display); buffer.retained_lines.extend(display);
while buffer.retained_lines.len() > max_rows { while buffer.retained_lines.len() > max_rows {
buffer.retained_lines.pop_front(); buffer.retained_lines.pop_front();
buffer.was_truncated = true;
} }
} }
@@ -286,7 +296,7 @@ impl App {
Ok(()) 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(); self.transcript_reflow.schedule_immediate();
tui.frame_requester().schedule_frame(); tui.frame_requester().schedule_frame();
} }
@@ -457,6 +467,7 @@ impl App {
let reflow_result = self.render_transcript_lines_for_reflow(width); let reflow_result = self.render_transcript_lines_for_reflow(width);
let reflowed_lines = reflow_result.lines; let reflowed_lines = reflow_result.lines;
let reflowed_rows = reflowed_lines.len();
// Drop any queued pre-resize/pre-consolidation inserts before rebuilding from cells. // Drop any queued pre-resize/pre-consolidation inserts before rebuilding from cells.
tui.clear_pending_history_lines(); tui.clear_pending_history_lines();
@@ -469,10 +480,35 @@ impl App {
self.history_line_wrap_policy(), self.history_line_wrap_policy(),
); );
} }
self.request_scrollback_history_top_up(reflowed_rows);
Ok(terminal_width) 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. /// Rebuild scrollback after rollback removes transcript cells.
/// ///
/// Unlike resize reflow, rollback must clear the terminal even when no cells remain. Otherwise /// 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 cell_displays = VecDeque::new();
let mut rendered_rows = 0usize; let mut rendered_rows = 0usize;
let mut start = self.transcript_cells.len(); let mut start = self.transcript_cells.len();
let mut history_was_truncated = false;
while start > 0 { while start > 0 {
start -= 1; start -= 1;
@@ -530,6 +567,7 @@ impl App {
}); });
if row_cap.is_some_and(|max_rows| rendered_rows > max_rows) { if row_cap.is_some_and(|max_rows| rendered_rows > max_rows) {
history_was_truncated = true;
break; break;
} }
} }
@@ -565,9 +603,11 @@ impl App {
if let Some(max_rows) = row_cap if let Some(max_rows) = row_cap
&& reflowed_lines.len() > max_rows && reflowed_lines.len() > max_rows
{ {
history_was_truncated = true;
let trimmed_line_count = reflowed_lines.len() - max_rows; let trimmed_line_count = reflowed_lines.len() - max_rows;
reflowed_lines = reflowed_lines.split_off(trimmed_line_count); 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(); self.has_emitted_history_lines = !reflowed_lines.is_empty();
ReflowRenderResult { 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. /// 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 /// The active stream controllers cover normal streaming. The trailing-cell checks cover the
+127
View File
@@ -74,6 +74,11 @@ async fn initial_resume_replay_retains_scrollback_beyond_the_visible_viewport()
.retained_lines; .retained_lines;
assert_eq!(retained_lines.len(), 32); assert_eq!(retained_lines.len(), 32);
assert!(retained_lines.len() > usize::from(visible_history_rows)); 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!( insta::assert_snapshot!(
retained_lines retained_lines
.iter() .iter()
@@ -142,3 +147,125 @@ async fn resize_reflow_preserves_explicitly_unlimited_history() {
Some("cell 19".to_string()) 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));
}
+2 -1
View File
@@ -5124,7 +5124,8 @@ async fn capped_resize_reflow_renders_recent_suffix_only() {
.map(rendered_line_text) .map(rendered_line_text)
.collect::<Vec<_>>(), .collect::<Vec<_>>(),
vec![ vec![
"cell 17".to_string(), "Earlier messages are available — press ctrl + t to view the full transcript"
.to_string(),
String::new(), String::new(),
"cell 18".to_string(), "cell 18".to_string(),
String::new(), String::new(),
@@ -11,6 +11,7 @@ use codex_app_server_protocol::JSONRPCMessage;
use codex_app_server_protocol::JSONRPCRequest; use codex_app_server_protocol::JSONRPCRequest;
use codex_app_server_protocol::JSONRPCResponse; use codex_app_server_protocol::JSONRPCResponse;
use codex_app_server_protocol::SortDirection; use codex_app_server_protocol::SortDirection;
use codex_app_server_protocol::ThreadHistoryMode;
use codex_app_server_protocol::ThreadItemsListParams; use codex_app_server_protocol::ThreadItemsListParams;
use codex_app_server_protocol::ThreadItemsListResponse; use codex_app_server_protocol::ThreadItemsListResponse;
use codex_app_server_protocol::ThreadStatus; use codex_app_server_protocol::ThreadStatus;
@@ -43,6 +44,7 @@ enum HistoryCapabilities {
Current, Current,
LegacyOnly, LegacyOnly,
LegacyOnlyUnsupportedVariant, LegacyOnlyUnsupportedVariant,
ForkHydrationFails,
} }
/// Returns and resets `(thread/loaded/list, thread/read)` request counts. /// 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, "thread/turns/list" | "thread/items/list" => true,
_ => false, _ => 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!( let response = if matches!(
history_capabilities, history_capabilities,
HistoryCapabilities::LegacyOnly HistoryCapabilities::LegacyOnly
@@ -166,6 +176,15 @@ async fn start_recording_app_server_with_history(
message: message.to_string(), 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 { } else {
let request = serde_json::from_value::<ClientRequest>( let request = serde_json::from_value::<ClientRequest>(
serde_json::to_value(request)?, 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> { fn create_history_rollout(
let thread_id = create_fake_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(), config.codex_home.as_path(),
"2026-01-02T00-00-00", "2026-01-02T00-00-00",
"2026-01-02T00:00:00Z", "2026-01-02T00:00:00Z",
"legacy history", preview,
Some(config.model_provider_id.as_str()), Some(config.model_provider_id.as_str()),
/*git_info*/ None, /*git_info*/ None,
) )
@@ -606,7 +633,8 @@ async fn transcript_home_loads_every_older_history_page() -> Result<()> {
#[tokio::test] #[tokio::test]
async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> { async fn remote_legacy_history_start_negotiates_once_for_resume_and_fork() -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?; 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( let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config, &app.config,
HistoryCapabilities::LegacyOnly, HistoryCapabilities::LegacyOnly,
@@ -679,7 +707,8 @@ enum LegacyHistoryRequest {
async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> { async fn assert_remote_legacy_history_retry(request: LegacyHistoryRequest) -> Result<()> {
let (app, _codex_home) = make_history_test_app().await?; 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( let (mut app_server, requests, proxy) = start_recording_app_server_with_history(
&app.config, &app.config,
HistoryCapabilities::LegacyOnly, 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<()> { async fn remote_legacy_history_fork_avoids_unsupported_fields() -> Result<()> {
assert_remote_legacy_history_retry(LegacyHistoryRequest::Fork).await 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] #[test]
fn fresh_session_applies_requested_name() -> Result<()> { fn fresh_session_applies_requested_name() -> Result<()> {
const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024; const TEST_STACK_SIZE_BYTES: usize = 8 * 1024 * 1024;
+5
View File
@@ -225,6 +225,11 @@ pub(crate) enum AppEvent {
event: HistoryLookupResponse, 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. /// One background-loaded page of older Ctrl+T transcript history.
OlderThreadHistoryLoaded { OlderThreadHistoryLoaded {
thread_id: ThreadId, thread_id: ThreadId,
+108 -9
View File
@@ -801,15 +801,23 @@ impl AppServerSession {
} }
}; };
let mut response = response; let mut response = response;
if presentation == ForkPresentation::Regular && !response.thread.ephemeral { if presentation == ForkPresentation::Regular
self.hydrate_initial_thread_history( && !response.thread.ephemeral
&mut response.thread, && let Err(error) = self
/*turn_cursor*/ None, .hydrate_initial_thread_history(
/*item_cursor*/ None, &mut response.thread,
Some(&config), /*turn_cursor*/ None,
HistoryHydrationScope::Initial, /*item_cursor*/ None,
) Some(&config),
.await?; HistoryHydrationScope::Initial,
)
.await
{
tracing::warn!(
thread_id = %response.thread.id,
error = %error,
"preserving the created fork after bounded history hydration failed"
);
} }
let mut started = let mut started =
started_thread_from_fork_response(response, &config, self.thread_params_mode()).await?; started_thread_from_fork_response(response, &config, self.thread_params_mode()).await?;
@@ -2792,6 +2800,97 @@ mod tests {
Ok(()) 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] #[tokio::test]
async fn config_request_overrides_preserve_implicit_personality_default() { async fn config_request_overrides_preserve_implicit_personality_default() {
let temp_dir = tempfile::tempdir().expect("tempdir"); let temp_dir = tempfile::tempdir().expect("tempdir");
@@ -191,6 +191,10 @@ impl AppServerSession {
Ok(items) 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( pub(crate) async fn hydrate_initial_thread_history(
&mut self, &mut self,
thread: &mut Thread, thread: &mut Thread,