Scope TUI history item lookups to their owning turns (#61595)

## Why

Item IDs are unique only within a turn. Reusing an ID across turns can misplace completion boundaries or hide unrelated items when loading older history.

## What changed

Carry turn IDs with paginated history items and key completion grouping and hidden review prompt lookups by both turn ID and item ID. Skip completion boundaries that would move backward through the page.

## Testing

Extend regression coverage to reuse item IDs across turns, checking completion ordering, visibility of unrelated tool items, and pagination without overlapping completion footers.

GitOrigin-RevId: 6cc8e16a1731d5aad4cbfb1c27e51c4665b0a655
This commit is contained in:
Eric Traut
2026-11-15 01:46:01 +00:00
committed by copyberry
parent 3b8bd2ee7e
commit e8e5108c97
7 changed files with 82 additions and 68 deletions
+10 -9
View File
@@ -1,4 +1,5 @@
//! Split older items at turn boundaries so each terminal row is rendered on the page that owns it.
//! Split older items at turn boundaries so each terminal row is rendered on its owning page.
//! Item IDs are unique only within their turn.
use codex_app_server_protocol::ThreadItemPayload;
use codex_app_server_protocol::Turn;
@@ -7,30 +8,30 @@ use codex_app_server_protocol::TurnStatus;
use std::collections::HashMap;
pub(super) fn group_turn_items<'a>(
items: &[ThreadItemPayload],
items: &[(String, ThreadItemPayload)],
turns: &'a [Turn],
) -> Vec<(std::ops::Range<usize>, Option<&'a Turn>)> {
let offsets: HashMap<_, _> = items
.iter()
.enumerate()
.map(|(i, item)| (item.id(), i + 1))
.map(|(i, (turn_id, item))| ((turn_id.as_str(), item.id()), i + 1))
.collect();
let first = turns.iter().find_map(|turn| turn.items.first());
let first = turns
.iter()
.find_map(|turn| turn.items.first().map(|item| (turn.id.as_str(), item.id())));
// Itemless interruptions follow the preceding turn, or precede the first item in history.
let mut end = first
.filter(|item| offsets.get(item.id()) == Some(&1))
.map(|_| 0);
let mut end = first.filter(|key| offsets.get(key) == Some(&1)).map(|_| 0);
let mut start = 0;
let mut groups = Vec::new();
for turn in turns {
if let Some(last) = turn.items.last() {
end = offsets.get(last.id()).copied();
end = offsets.get(&(turn.id.as_str(), last.id())).copied();
} else if turn.status != TurnStatus::Interrupted
|| turn.items_view == TurnItemsView::NotLoaded
{
continue;
}
if let Some(end) = end {
if let Some(end) = end.filter(|end| *end >= start) {
groups.push((start..end, Some(turn)));
start = end;
}
@@ -1,13 +1,18 @@
//! Pagination boundaries preserve grouped item rendering and attach completion metadata once.
#![cfg(test)]
use super::*;
use codex_app_server_protocol::ThreadItem;
use codex_app_server_protocol::TurnItemsView;
use codex_app_server_protocol::TurnStatus;
use pretty_assertions::assert_eq;
fn payloads(items: &[codex_app_server_protocol::ThreadItem]) -> Vec<ThreadItemPayload> {
items.iter().map(|entry| entry.payload.clone()).collect()
fn payloads(turn: &Turn, items: &[ThreadItem]) -> Vec<(String, ThreadItemPayload)> {
items
.iter()
.map(|entry| (turn.id.clone(), entry.payload.clone()))
.collect()
}
fn turn(id: &str, status: TurnStatus, item_ids: &[&str]) -> Turn {
@@ -40,11 +45,11 @@ fn split_turn_only_completes_on_the_page_with_its_last_item() {
&["first", "second", "last"],
)];
assert_eq!(
group_turn_items(&payloads(&turns[0].items[1..]), &turns),
group_turn_items(&payloads(&turns[0], &turns[0].items[1..]), &turns),
vec![(0..2, Some(&turns[0]))],
);
assert_eq!(
group_turn_items(&payloads(&turns[0].items[..1]), &turns),
group_turn_items(&payloads(&turns[0], &turns[0].items[..1]), &turns),
vec![(0..1, None)],
);
}
@@ -52,17 +57,21 @@ fn split_turn_only_completes_on_the_page_with_its_last_item() {
#[test]
fn multiple_turns_keep_item_groups_and_completion_order() {
let turns = vec![
turn("first", TurnStatus::Completed, &["a", "b"]),
turn("second", TurnStatus::Completed, &["c", "d"]),
turn("first", TurnStatus::Completed, &["a", "shared"]),
turn("second", TurnStatus::Completed, &["middle"]),
turn("last", TurnStatus::Completed, &["shared"]),
];
let items = turns
.iter()
.flat_map(Turn::item_payloads)
.cloned()
.flat_map(|turn| payloads(turn, &turn.items))
.collect::<Vec<_>>();
assert_eq!(
group_turn_items(&items, &turns),
vec![(0..2, Some(&turns[0])), (2..4, Some(&turns[1])),],
vec![
(0..2, Some(&turns[0])),
(2..3, Some(&turns[1])),
(3..4, Some(&turns[2]))
],
);
}
@@ -75,7 +84,7 @@ fn itemless_interruptions_keep_their_position_on_the_owning_page() {
turn("running", TurnStatus::InProgress, &["b"]),
];
assert_eq!(
group_turn_items(&payloads(&turns[1].items), &turns),
group_turn_items(&payloads(&turns[1], &turns[1].items), &turns),
vec![
(0..0, Some(&turns[0])),
(0..1, Some(&turns[1])),
@@ -83,7 +92,7 @@ fn itemless_interruptions_keep_their_position_on_the_owning_page() {
],
);
assert_eq!(
group_turn_items(&payloads(&turns[3].items), &turns),
group_turn_items(&payloads(&turns[3], &turns[3].items), &turns),
vec![(0..1, Some(&turns[3]))],
);
}
+21 -23
View File
@@ -162,7 +162,7 @@ impl App {
&mut self,
tui: &mut tui::Tui,
turns: &[Turn],
hidden_item_ids: &HashSet<&str>,
hidden_item_ids: &HashSet<(&str, &str)>,
thread_id: ThreadId,
cwd: &AbsolutePathBuf,
visibility: RawReasoningVisibility,
@@ -172,38 +172,35 @@ impl App {
}
let user_items = turns
.iter()
.flat_map(Turn::item_payloads)
.filter(|item| matches!(item, ThreadItemPayload::UserMessage { .. }))
.map(|item| (item.id().to_string(), item.clone()))
.flat_map(|turn| {
turn.item_payloads()
.map(move |item| (turn.id.as_str(), item))
})
.filter(|(_, item)| matches!(item, ThreadItemPayload::UserMessage { .. }))
.map(|(turn_id, item)| (hidden_item_ids.contains(&(turn_id, item.id())), item))
.collect::<Vec<_>>();
let projected_user_cells = thread_items_to_transcript_cells(
Some(thread_id),
cwd,
user_items.iter().map(|(_, item)| item.clone()),
user_items.iter().map(|(_, item)| (*item).clone()),
visibility,
Some(&self.config),
);
let persisted_user_cells = user_items
.into_iter()
.zip(projected_user_cells)
.map(|((item_id, _), cell)| (item_id, cell))
.map(|((hidden, _), cell)| (hidden, cell))
.collect();
if self.chat_widget.thread_id() != Some(thread_id)
&& let Some(pane) = self.side_companions.get_mut(&thread_id)
{
for index in
hidden_transcript_indices(&pane.cells, persisted_user_cells, hidden_item_ids)
{
for index in hidden_transcript_indices(&pane.cells, persisted_user_cells) {
pane.splice_older_cells(index..index + 1, Vec::new());
pane.view.restart_search();
}
return;
}
let indices = hidden_transcript_indices(
&self.transcript_cells,
persisted_user_cells,
hidden_item_ids,
);
let indices = hidden_transcript_indices(&self.transcript_cells, persisted_user_cells);
if indices.is_empty() {
return;
}
@@ -245,9 +242,9 @@ impl App {
/// Project each terminal row on the page containing the end of its turn.
fn project_older_history_cells(
&mut self,
items: Vec<ThreadItemPayload>,
items: Vec<(String, ThreadItemPayload)>,
turns: &[Turn],
hidden_item_ids: &HashSet<&str>,
hidden_item_ids: &HashSet<(&str, &str)>,
thread_id: ThreadId,
cwd: &AbsolutePathBuf,
visibility: RawReasoningVisibility,
@@ -255,11 +252,13 @@ impl App {
let mut cells = Vec::new();
for (range, turn_end) in completion::group_turn_items(&items, turns) {
// Internal prompts stay invisible, but still separate adjacent tool groups.
for visible in items[range].split(|item| hidden_item_ids.contains(item.id())) {
for visible in items[range]
.split(|(turn_id, item)| hidden_item_ids.contains(&(turn_id.as_str(), item.id())))
{
cells.extend(thread_items_to_transcript_cells(
Some(thread_id),
cwd,
visible.iter().cloned(),
visible.iter().map(|(_, item)| item.clone()),
visibility,
Some(&self.config),
));
@@ -401,7 +400,7 @@ impl App {
}
/// Classify internal review prompts across page boundaries before rendering any older items.
fn hidden_review_item_ids(turns: &[Turn]) -> HashSet<&str> {
fn hidden_review_item_ids(turns: &[Turn]) -> HashSet<(&str, &str)> {
let mut hidden = HashSet::new();
let mut review_mode = false;
for (index, turn) in turns.iter().enumerate() {
@@ -418,7 +417,7 @@ fn hidden_review_item_ids(turns: &[Turn]) -> HashSet<&str> {
ThreadItemPayload::UserMessage { .. }
if review_mode || hidden_nested_review_turn =>
{
hidden.insert(item.id());
hidden.insert((turn.id.as_str(), item.id()));
}
_ => {}
}
@@ -437,8 +436,7 @@ fn history_prefix_len(cells: &[Arc<dyn HistoryCell>]) -> usize {
/// Match repeated user messages from newest to oldest so identical visible prompts stay distinct.
fn hidden_transcript_indices(
cells: &[Arc<dyn HistoryCell>],
mut persisted_user_cells: Vec<(String, Arc<dyn HistoryCell>)>,
hidden_item_ids: &HashSet<&str>,
mut persisted_user_cells: Vec<(bool, Arc<dyn HistoryCell>)>,
) -> Vec<usize> {
let mut indices = Vec::new();
for (index, cell) in cells.iter().enumerate().rev() {
@@ -458,7 +456,7 @@ fn hidden_transcript_indices(
}) else {
continue;
};
if hidden_item_ids.contains(persisted_user_cells[position].0.as_str()) {
if persisted_user_cells[position].0 {
indices.push(index);
}
persisted_user_cells.truncate(position);
@@ -106,15 +106,12 @@ async fn fork_lineage_stays_before_repeated_older_history_pages() {
fn repeated_prompt_matching_removes_only_the_hidden_occurrence() {
let cells = vec![user_cell("repeat"), user_cell("other"), user_cell("repeat")];
let persisted = vec![
("unloaded".to_string(), user_cell("repeat")),
("hidden".to_string(), user_cell("repeat")),
("middle".to_string(), user_cell("other")),
("visible".to_string(), user_cell("repeat")),
(true, user_cell("repeat")),
(true, user_cell("repeat")),
(false, user_cell("other")),
(false, user_cell("repeat")),
];
assert_eq!(
hidden_transcript_indices(&cells, persisted, &HashSet::from(["hidden", "unloaded"])),
vec![0],
);
assert_eq!(hidden_transcript_indices(&cells, persisted), vec![0],);
}
#[tokio::test]
@@ -144,8 +141,8 @@ async fn resume_places_interruption_before_searches_split_across_pages() {
canceled.items.push(search("canceled"));
audit.items.insert(/*index*/ 0, search("older"));
let page = vec![
canceled.items[0].payload.clone(),
audit.items[0].payload.clone(),
(canceled.id.clone(), canceled.items[0].payload.clone()),
(audit.id.clone(), audit.items[0].payload.clone()),
];
let cwd = app.config.cwd.clone();
let older = app.project_older_history_cells(
@@ -213,14 +210,16 @@ async fn hidden_last_item_keeps_turn_groups_and_completion_boundaries() {
first.completed_at = Some(1_700_000_000);
first.duration_ms = Some(125_000);
let mut second = turn("second", TurnStatus::InProgress, &[]);
second.items = vec![computer("newer-call")];
second.items = vec![computer("hidden")];
let turns = vec![first, second];
let hidden = hidden_review_item_ids(&turns);
assert_eq!(hidden, HashSet::from(["hidden"]));
assert_eq!(hidden, HashSet::from([("first", "hidden")]));
let items = turns
.iter()
.flat_map(Turn::item_payloads)
.cloned()
.flat_map(|turn| {
turn.item_payloads()
.map(|item| (turn.id.clone(), item.clone()))
})
.collect::<Vec<_>>();
let cells = app.project_older_history_cells(
@@ -247,10 +246,7 @@ async fn hidden_last_item_keeps_turn_groups_and_completion_boundaries() {
assert_eq!(
(groups, completions, visible_users),
(
vec![
vec!["older-call".to_string()],
vec!["newer-call".to_string()]
],
vec![vec!["older-call".to_string()], vec!["hidden".to_string()]],
expected_completions,
0,
),
@@ -176,7 +176,7 @@ async fn history_hydration_metadata_tracks_missing_turns_and_stale_completions_k
.apply_older_history_page(target.thread_id, &old_cursor, page, &mut thread.turns)
.await?;
assert_eq!(
items.iter().map(ThreadItemPayload::id).collect::<Vec<_>>(),
items.iter().map(|(_, item)| item.id()).collect::<Vec<_>>(),
vec!["item-3-0", "item-5-0"]
);
assert_eq!(
@@ -201,8 +201,18 @@ async fn older_page_updates_the_parked_parent_without_moving_focus() -> Result<(
#[tokio::test]
async fn older_pagination_completion_footers_follow_answers_without_overlap_duplicates()
-> Result<()> {
let (mut app, _codex_home, thread_id) =
let (mut app, codex_home, thread_id) =
completed_history_app(&["Oldest", "Middle", "Newest"]).await?;
// Reuse an item ID across turns without changing the expected transcript.
let path = rollout_path(
codex_home.path(),
"2000-09-06T14-32-00",
&thread_id.to_string(),
);
std::fs::write(
&path,
std::fs::read_to_string(&path)?.replace("answer-0", "prompt-1"),
)?;
let (mut app_server, _requests, proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
@@ -243,7 +243,7 @@ impl AppServerSession {
cursor: &str,
page: ThreadItemsListResponse,
turns: &mut Vec<Turn>,
) -> Result<Vec<ThreadItemPayload>> {
) -> Result<Vec<(String, ThreadItemPayload)>> {
if !self.is_older_history_page_pending(thread_id, cursor) {
return Ok(Vec::new());
}
@@ -304,7 +304,7 @@ impl AppServerSession {
page: ThreadItemsListResponse,
state: &mut ThreadHistoryPagination,
turns: &mut Vec<Turn>,
) -> Result<Vec<ThreadItemPayload>> {
) -> Result<Vec<(String, ThreadItemPayload)>> {
state.next_item_cursor = advancing_cursor(
state.next_item_cursor.as_deref(),
page.next_cursor,
@@ -342,7 +342,7 @@ impl AppServerSession {
&& !turn.items.iter().any(|item| item.id() == entry.item.id())
{
let item = ThreadItem::try_from(entry)?;
items.push(item.payload.clone());
items.push((turn.id.clone(), item.payload.clone()));
turn.items.insert(/*index*/ 0, item);
turn.items_view = TurnItemsView::Summary;
}
@@ -490,7 +490,7 @@ impl AppServerSession {
fn rendered_history_rows(
thread_id: ThreadId,
thread: &Thread,
items: Vec<ThreadItemPayload>,
items: Vec<(String, ThreadItemPayload)>,
config: &Config,
local_settings: &crate::local_settings::LocalSettings,
width: u16,
@@ -509,7 +509,7 @@ fn rendered_history_rows(
thread_items_to_transcript_cells(
Some(thread_id),
&thread.cwd,
items,
items.into_iter().map(|(_, item)| item),
visibility,
Some(config),
)