Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Bound legacy resume preview scans (#39033)

Charlie Marsha8525b139c35
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 9c5b0659ea..5b03b9f050 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -1123,6 +1123,21 @@ async fn paginated_workflows_never_request_full_thread_history() -> Result<()> {
assert!(!recorded_params(&requests, "thread/items/list").is_empty());
let previous_read_count = paginated_reads.len();
+ let preview = crate::resume_picker::load_transcript_preview(
+ &mut app_server,
+ legacy_thread_id,
+ Some(&app.config),
+ )
+ .await?;
+ assert!(!preview.is_empty());
+ let preview_reads = recorded_params(&requests, "thread/read");
+ let preview_include_turns = preview_reads[previous_read_count..]
+ .iter()
+ .map(|params| params["includeTurns"].as_bool().unwrap_or(false))
+ .collect::<Vec<_>>();
+ assert_eq!(preview_include_turns, vec![false]);
+
+ let previous_read_count = preview_reads.len();
crate::thread_transcript::load_session_transcript(
&mut app_server,
legacy_thread_id,
diff --git a/codex-rs/tui/src/resume_picker_transcript_preview.rs b/codex-rs/tui/src/resume_picker_transcript_preview.rs
index 5caf471a5e..a1044f02fb 100644
--- a/codex-rs/tui/src/resume_picker_transcript_preview.rs
+++ b/codex-rs/tui/src/resume_picker_transcript_preview.rs
@@ -1,5 +1,9 @@
use std::borrow::Cow;
use std::collections::HashSet;
+use std::fs::File;
+use std::io::Read;
+use std::io::Seek;
+use std::io::SeekFrom;
use std::path::Path;
use super::TranscriptPreviewLine;
@@ -8,17 +12,24 @@ use crate::app_server_session::AppServerSession;
use crate::app_server_session::HISTORY_ITEM_PAGE_LIMIT;
use crate::app_server_session::HISTORY_ITEM_SCAN_LIMIT;
use crate::app_server_session::HistoryHydrationScope;
+use crate::app_server_session::ThreadParamsMode;
use crate::git_action_directives::parse_assistant_markdown;
use crate::inline_visualization::InlineVisualizationContext;
use crate::legacy_core::config::Config;
use codex_app_server_protocol::ThreadHistoryMode;
use codex_app_server_protocol::ThreadItem;
use codex_protocol::ThreadId;
+use codex_protocol::protocol::EventMsg;
+use codex_rollout::ReverseJsonlScanner;
+use codex_rollout::RolloutItem;
+use codex_rollout::RolloutLine;
+use codex_rollout::ScanOutcome;
const MAX_TRANSCRIPT_PREVIEW_LINES: usize = 6;
const TRANSCRIPT_PREVIEW_ITEMS_PAGE_SIZE: u32 = 6;
+const MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES: usize = 1024 * 1024;
-/// Loads the newest nonblank transcript lines within a bounded paginated-item scan.
+/// Loads the newest transcript lines from bounded paginated items or a local legacy rollout tail.
pub(crate) async fn load_transcript_preview(
app_server: &mut AppServerSession,
thread_id: ThreadId,
@@ -28,19 +39,6 @@ pub(crate) async fn load_transcript_preview(
.thread_read(thread_id, /*include_turns*/ false)
.await
.map_err(std::io::Error::other)?;
- if thread.history_mode == ThreadHistoryMode::Legacy {
- app_server
- .hydrate_initial_thread_history(
- &mut thread,
- /*turn_cursor*/ None,
- /*item_cursor*/ None,
- /*config*/ None,
- HistoryHydrationScope::Initial,
- )
- .await
- .map_err(std::io::Error::other)?;
- }
- let cwd = thread.cwd.as_path();
let inline_visualization_context = config.and_then(|config| {
ThreadId::from_string(&thread.id)
.ok()
@@ -49,6 +47,40 @@ pub(crate) async fn load_transcript_preview(
let mut lines = Vec::with_capacity(MAX_TRANSCRIPT_PREVIEW_LINES);
match thread.history_mode {
ThreadHistoryMode::Legacy => {
+ if matches!(app_server.thread_params_mode(), ThreadParamsMode::Embedded)
+ && let Some(path) = thread.path.as_ref()
+ && path
+ .file_name()
+ .and_then(|name| name.to_str())
+ .is_some_and(|name| name.ends_with(".jsonl"))
+ {
+ let path = path.clone();
+ let cwd = thread.cwd.clone();
+ let inline_visualization_context = inline_visualization_context.clone();
+ let scanned = tokio::task::spawn_blocking(move || {
+ scan_legacy_transcript_preview(
+ path.as_path(),
+ cwd.as_path(),
+ inline_visualization_context.as_ref(),
+ )
+ })
+ .await;
+ if let Ok(Ok(Some(mut scanned_lines))) = scanned {
+ scanned_lines.reverse();
+ return Ok(scanned_lines);
+ }
+ }
+
+ app_server
+ .hydrate_initial_thread_history(
+ &mut thread,
+ /*turn_cursor*/ None,
+ /*item_cursor*/ None,
+ /*config*/ None,
+ HistoryHydrationScope::Initial,
+ )
+ .await
+ .map_err(std::io::Error::other)?;
append_transcript_preview_lines(
&mut lines,
thread
@@ -56,11 +88,12 @@ pub(crate) async fn load_transcript_preview(
.iter()
.rev()
.flat_map(|turn| turn.items.iter().rev()),
- cwd,
+ thread.cwd.as_path(),
inline_visualization_context.as_ref(),
);
}
ThreadHistoryMode::Paginated => {
+ let cwd = thread.cwd.as_path();
let mut cursor = None;
let mut seen_cursors = HashSet::new();
let mut scanned_items = 0_usize;
@@ -109,6 +142,89 @@ pub(crate) async fn load_transcript_preview(
Ok(lines)
}
+/// Scans a bounded legacy rollout tail, falling back when its history cannot be proven complete.
+fn scan_legacy_transcript_preview(
+ path: &Path,
+ cwd: &Path,
+ inline_visualization_context: Option<&InlineVisualizationContext>,
+) -> std::io::Result<Option<Vec<TranscriptPreviewLine>>> {
+ let mut lines = Vec::with_capacity(MAX_TRANSCRIPT_PREVIEW_LINES);
+ let file = File::open(path)?;
+ let end_offset = file.metadata()?.len();
+ let minimum_offset = end_offset.saturating_sub(MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES as u64);
+ let mut scanner = ReverseJsonlScanner::new_at(
+ BoundedRolloutTailReader {
+ file,
+ minimum_offset,
+ },
+ end_offset,
+ )?
+ .with_max_record_bytes(MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES);
+ loop {
+ let outcome = match scanner.scan_next::<RolloutLine>() {
+ Ok(Some(outcome)) => outcome,
+ Ok(None) => break,
+ Err(error) if error.kind() == std::io::ErrorKind::UnexpectedEof => return Ok(None),
+ Err(error) => return Err(error),
+ };
+ let ScanOutcome::Parsed(line) = outcome else {
+ continue;
+ };
+ match line.item {
+ RolloutItem::EventMsg(EventMsg::ThreadRolledBack(_)) => return Ok(None),
+ RolloutItem::EventMsg(EventMsg::UserMessage(message)) => {
+ append_transcript_preview_text(
+ &mut lines,
+ TranscriptPreviewSpeaker::User,
+ &message.message,
+ cwd,
+ inline_visualization_context,
+ );
+ }
+ RolloutItem::EventMsg(EventMsg::AgentMessage(message)) => {
+ append_transcript_preview_text(
+ &mut lines,
+ TranscriptPreviewSpeaker::Assistant,
+ &message.message,
+ cwd,
+ inline_visualization_context,
+ );
+ }
+ _ => {}
+ }
+ if lines.len() == MAX_TRANSCRIPT_PREVIEW_LINES {
+ break;
+ }
+ }
+
+ Ok(Some(lines))
+}
+
+/// Prevents reverse scans from reading past the bounded suffix of a rollout.
+struct BoundedRolloutTailReader {
+ file: File,
+ minimum_offset: u64,
+}
+
+impl Read for BoundedRolloutTailReader {
+ fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
+ self.file.read(buffer)
+ }
+}
+
+impl Seek for BoundedRolloutTailReader {
+ fn seek(&mut self, position: SeekFrom) -> std::io::Result<u64> {
+ let offset = self.file.seek(position)?;
+ if offset < self.minimum_offset {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::UnexpectedEof,
+ "legacy transcript preview exceeded its scan budget",
+ ));
+ }
+ Ok(offset)
+ }
+}
+
/// Appends the newest preview lines from items already ordered newest-first.
fn append_transcript_preview_lines<'a>(
lines: &mut Vec<TranscriptPreviewLine>,
diff --git a/codex-rs/tui/src/resume_picker_transcript_preview_tests.rs b/codex-rs/tui/src/resume_picker_transcript_preview_tests.rs
index a817ebde25..d3246a14e4 100644
--- a/codex-rs/tui/src/resume_picker_transcript_preview_tests.rs
+++ b/codex-rs/tui/src/resume_picker_transcript_preview_tests.rs
@@ -14,6 +14,10 @@ use codex_app_server_protocol::ThreadStartResponse;
use codex_app_server_protocol::TurnStartParams;
use codex_app_server_protocol::TurnStartResponse;
use codex_app_server_protocol::UserInput;
+use codex_protocol::protocol::AgentMessageEvent;
+use codex_protocol::protocol::ThreadRolledBackEvent;
+use codex_protocol::protocol::UserMessageEvent;
+use codex_rollout::CompactedItem;
use core_test_support::responses;
use pretty_assertions::assert_eq;
use tempfile::tempdir;
@@ -25,6 +29,225 @@ fn preview_line(speaker: TranscriptPreviewSpeaker, text: &str) -> TranscriptPrev
}
}
+fn rollout_user_message(text: &str) -> RolloutItem {
+ RolloutItem::EventMsg(EventMsg::UserMessage(UserMessageEvent {
+ message: text.to_string(),
+ ..Default::default()
+ }))
+}
+
+fn rollout_agent_message(text: &str) -> RolloutItem {
+ RolloutItem::EventMsg(EventMsg::AgentMessage(AgentMessageEvent {
+ message: text.to_string(),
+ phase: None,
+ memory_citation: None,
+ }))
+}
+
+fn write_preview_rollout(path: &Path, items: Vec<RolloutItem>) {
+ let contents = items
+ .into_iter()
+ .map(|item| {
+ serde_json::to_string(&RolloutLine {
+ timestamp: String::from("2026-07-19T12:00:00Z"),
+ ordinal: None,
+ item,
+ })
+ .expect("serialize rollout line")
+ })
+ .collect::<Vec<_>>()
+ .join("\n");
+ std::fs::write(path, format!("{contents}\n")).expect("write rollout");
+}
+
+#[test]
+fn legacy_transcript_preview_scans_tail_across_compaction() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ write_preview_rollout(
+ &path,
+ vec![
+ rollout_user_message("older user"),
+ rollout_agent_message("older assistant"),
+ RolloutItem::Compacted(CompactedItem {
+ message: String::from("summary that is not transcript text"),
+ replacement_history: None,
+ window_number: None,
+ first_window_id: None,
+ previous_window_id: None,
+ window_id: None,
+ }),
+ rollout_user_message("recent user"),
+ rollout_agent_message("commentary one\ncommentary two"),
+ rollout_agent_message("final one\n\n final two "),
+ ],
+ );
+
+ let mut lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout")
+ .expect("bounded tail");
+ lines.reverse();
+
+ assert_eq!(
+ lines,
+ vec![
+ preview_line(TranscriptPreviewSpeaker::Assistant, "older assistant"),
+ preview_line(TranscriptPreviewSpeaker::User, "recent user"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "commentary one"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "commentary two"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "final one"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "final two"),
+ ]
+ );
+}
+
+#[test]
+fn legacy_transcript_preview_falls_back_when_rollback_is_in_the_tail() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ write_preview_rollout(
+ &path,
+ vec![
+ rollout_user_message("rolled back user"),
+ rollout_agent_message("rolled back assistant"),
+ RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
+ num_turns: 1,
+ })),
+ rollout_user_message("recent user"),
+ rollout_agent_message("recent assistant"),
+ ],
+ );
+
+ let lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout");
+
+ assert_eq!(lines, None);
+}
+
+#[test]
+fn legacy_transcript_preview_stops_before_rollback_outside_the_tail() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ write_preview_rollout(
+ &path,
+ vec![
+ rollout_user_message("rolled back user"),
+ RolloutItem::EventMsg(EventMsg::ThreadRolledBack(ThreadRolledBackEvent {
+ num_turns: 1,
+ })),
+ rollout_user_message("recent user"),
+ rollout_agent_message("one\ntwo\nthree\nfour\nfive\nsix"),
+ ],
+ );
+
+ let mut lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout")
+ .expect("bounded tail");
+ lines.reverse();
+
+ assert_eq!(
+ lines,
+ vec![
+ preview_line(TranscriptPreviewSpeaker::Assistant, "one"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "two"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "three"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "four"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "five"),
+ preview_line(TranscriptPreviewSpeaker::Assistant, "six"),
+ ]
+ );
+}
+
+#[test]
+fn legacy_transcript_preview_falls_back_for_oversized_visible_record() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ write_preview_rollout(
+ &path,
+ vec![rollout_agent_message(
+ &"x".repeat(MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES),
+ )],
+ );
+
+ let lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout");
+
+ assert_eq!(lines, None);
+}
+
+#[test]
+fn legacy_transcript_preview_falls_back_for_oversized_hidden_record() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ write_preview_rollout(
+ &path,
+ vec![
+ rollout_user_message("older user"),
+ RolloutItem::Compacted(CompactedItem {
+ message: "x".repeat(MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES),
+ replacement_history: None,
+ window_number: None,
+ first_window_id: None,
+ previous_window_id: None,
+ window_id: None,
+ }),
+ rollout_agent_message("recent assistant"),
+ ],
+ );
+
+ let lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout");
+
+ assert_eq!(lines, None);
+}
+
+#[test]
+fn legacy_transcript_preview_falls_back_when_scan_budget_is_exhausted() {
+ let temp_dir = tempdir().expect("tempdir");
+ let path = temp_dir.path().join("rollout.jsonl");
+ let compacted = RolloutItem::Compacted(CompactedItem {
+ message: "x".repeat(MAX_LEGACY_TRANSCRIPT_PREVIEW_SCAN_BYTES / 8),
+ replacement_history: None,
+ window_number: None,
+ first_window_id: None,
+ previous_window_id: None,
+ window_id: None,
+ });
+ let mut items = vec![rollout_user_message("older user")];
+ items.extend(std::iter::repeat_n(compacted, 9));
+ items.push(rollout_agent_message("recent assistant"));
+ write_preview_rollout(&path, items);
+
+ let lines = scan_legacy_transcript_preview(
+ &path,
+ temp_dir.path(),
+ /*inline_visualization_context*/ None,
+ )
+ .expect("scan rollout");
+
+ assert_eq!(lines, None);
+}
+
#[test]
fn transcript_preview_reverse_scan_stops_before_older_items() {
let newest = ThreadItem::AgentMessage {