From 5396defe86be9f8a191ce37bad8c6f5e04832821 Mon Sep 17 00:00:00 2001
From: Tuan-Lung Wang <tlwang@openai.com>
Date: Mon, 16 Mar 2026 21:54:18 -0700
Subject: [PATCH] Add transcript search navigation

---
 codex-rs/tui/src/app_backtrack.rs             |    8 +-
 codex-rs/tui/src/pager_overlay.rs             | 1179 +++++++++++++++--
 ..._tests__static_overlay_snapshot_basic.snap |    4 +-
 ...ests__static_overlay_wraps_long_lines.snap |    5 +-
 ...ript_overlay_apply_patch_scroll_vt100.snap |   23 +-
 ..._transcript_overlay_renders_live_tail.snap |    6 +-
 ...s__transcript_overlay_search_snapshot.snap |   20 +
 ...ts__transcript_overlay_snapshot_basic.snap |    6 +-
 8 files changed, 1134 insertions(+), 117 deletions(-)
 create mode 100644 codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_search_snapshot.snap

diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rs
index 1bb2c29569..4ff75b1564 100644
--- a/codex-rs/tui/src/app_backtrack.rs
+++ b/codex-rs/tui/src/app_backtrack.rs
@@ -156,8 +156,12 @@ impl App {
             ..
         }) = event
         {
-            // First Esc in transcript overlay: begin backtrack preview at latest user message.
-            self.begin_overlay_backtrack_preview(tui);
+            if self.overlay.as_ref().is_some_and(Overlay::consumes_escape) {
+                self.overlay_forward_event(tui, event)?;
+            } else {
+                // First Esc in transcript overlay: begin backtrack preview at latest user message.
+                self.begin_overlay_backtrack_preview(tui);
+            }
             Ok(true)
         } else {
             // Not in backtrack mode: forward events to the overlay widget.
diff --git a/codex-rs/tui/src/pager_overlay.rs b/codex-rs/tui/src/pager_overlay.rs
index 901f51c7fe..eb3590798b 100644
--- a/codex-rs/tui/src/pager_overlay.rs
+++ b/codex-rs/tui/src/pager_overlay.rs
@@ -32,8 +32,10 @@ use crate::style::user_message_style;
 use crate::text_formatting::truncate_text;
 use crate::tui;
 use crate::tui::TuiEvent;
+use crate::wrapping::word_wrap_lines;
 use crossterm::event::KeyCode;
 use crossterm::event::KeyEvent;
+use crossterm::event::KeyEventKind;
 use ratatui::buffer::Buffer;
 use ratatui::buffer::Cell;
 use ratatui::layout::Constraint;
@@ -51,6 +53,7 @@ use ratatui::widgets::Paragraph;
 use ratatui::widgets::Widget;
 use ratatui::widgets::WidgetRef;
 use ratatui::widgets::Wrap;
+use unicode_segmentation::UnicodeSegmentation;
 
 pub(crate) enum Overlay {
     Transcript(TranscriptOverlay),
@@ -86,6 +89,13 @@ impl Overlay {
             Overlay::Static(o) => o.is_done(),
         }
     }
+
+    pub(crate) fn consumes_escape(&self) -> bool {
+        match self {
+            Overlay::Transcript(o) => o.consumes_escape(),
+            Overlay::Static(_) => false,
+        }
+    }
 }
 
 const KEY_UP: KeyBinding = key_hint::plain(KeyCode::Up);
@@ -113,8 +123,14 @@ const KEY_TAB: KeyBinding = key_hint::plain(KeyCode::Tab);
 const KEY_A: KeyBinding = key_hint::plain(KeyCode::Char('a'));
 const KEY_E: KeyBinding = key_hint::plain(KeyCode::Char('e'));
 const KEY_D: KeyBinding = key_hint::plain(KeyCode::Char('d'));
+const KEY_SLASH: KeyBinding = key_hint::plain(KeyCode::Char('/'));
+const KEY_QUESTION: KeyBinding = key_hint::plain(KeyCode::Char('?'));
+const KEY_N: KeyBinding = key_hint::plain(KeyCode::Char('n'));
+const KEY_CAPITAL_N: KeyBinding = key_hint::plain(KeyCode::Char('N'));
+const KEY_BACKSPACE: KeyBinding = key_hint::plain(KeyCode::Backspace);
 const MAX_ANCHOR_LINES: usize = 2;
 const DETAILS_PLACEHOLDER_LABEL: &str = "Details...";
+const SEARCH_MATCH_CONTEXT_GRAPHEMES: usize = 48;
 
 // Common pager navigation hints rendered on the first line
 const PAGER_KEY_HINTS: &[(&[KeyBinding], &str)] = &[
@@ -146,6 +162,12 @@ fn render_key_hints(area: Rect, buf: &mut Buffer, pairs: &[(&[KeyBinding], &str)
     Paragraph::new(vec![Line::from(spans).dim()]).render_ref(area, buf);
 }
 
+fn is_shift_char_press(event: KeyEvent, ch: char) -> bool {
+    matches!(event.kind, KeyEventKind::Press | KeyEventKind::Repeat)
+        && event.code == KeyCode::Char(ch)
+        && event.modifiers == crossterm::event::KeyModifiers::SHIFT
+}
+
 /// Generic widget for rendering a pager view.
 struct PagerView {
     renderables: Vec<Box<dyn Renderable>>,
@@ -416,6 +438,19 @@ impl PagerView {
             .map(|r| r.desired_height(area.width) as usize)
             .sum::<usize>();
     }
+
+    fn scroll_chunk_offset_to_top(&mut self, idx: usize, line_offset: usize, area: Rect) {
+        if idx >= self.renderables.len() {
+            return;
+        }
+        self.scroll_offset = self
+            .renderables
+            .iter()
+            .take(idx)
+            .map(|r| r.desired_height(area.width) as usize)
+            .sum::<usize>()
+            .saturating_add(line_offset);
+    }
 }
 
 /// A renderable that caches its desired height.
@@ -452,6 +487,8 @@ impl Renderable for CachedRenderable {
 struct CellRenderable {
     cell: Arc<dyn HistoryCell>,
     highlight_style: Option<Style>,
+    search_query: Option<String>,
+    active_search_match_index: Option<usize>,
 }
 
 impl Renderable for CellRenderable {
@@ -471,6 +508,11 @@ impl Renderable for CellRenderable {
                 .map(|span| span.patch_style(style))
                 .collect();
         }
+        if let (Some(query), Some(active_search_match_index)) =
+            (self.search_query.as_ref(), self.active_search_match_index)
+        {
+            highlight_search_match_in_lines(&mut lines, query, active_search_match_index);
+        }
         let p = Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false });
         p.render(area, buf);
     }
@@ -480,6 +522,95 @@ impl Renderable for CellRenderable {
     }
 }
 
+fn highlight_search_match_in_lines(
+    lines: &mut [Line<'static>],
+    query: &str,
+    active_search_match_index: usize,
+) {
+    if query.is_empty() {
+        return;
+    }
+    let mut occurrence_idx = 0;
+    for line in lines {
+        let mut spans = Vec::new();
+        for span in line.spans.clone() {
+            spans.extend(highlight_search_match_in_span(
+                span,
+                query,
+                &mut occurrence_idx,
+                active_search_match_index,
+            ));
+        }
+        line.spans = spans;
+    }
+}
+
+fn highlight_search_match_in_span(
+    span: Span<'static>,
+    query: &str,
+    occurrence_idx: &mut usize,
+    active_search_match_index: usize,
+) -> Vec<Span<'static>> {
+    let content = span.content.to_string();
+    let ranges = match_ranges(&content, query);
+    if ranges.is_empty() {
+        return vec![span];
+    }
+
+    let highlight_style = Style::default().yellow().bold().underlined();
+    let mut spans = Vec::new();
+    let mut start = 0;
+    for (match_start, match_end) in ranges {
+        if start < match_start {
+            let mut prefix = span.clone();
+            prefix.content = content[start..match_start].to_string().into();
+            spans.push(prefix);
+        }
+
+        let mut matched = span.clone();
+        matched.content = content[match_start..match_end].to_string().into();
+        if *occurrence_idx == active_search_match_index {
+            matched.style = matched.style.patch(highlight_style);
+        }
+        spans.push(matched);
+        *occurrence_idx += 1;
+        start = match_end;
+    }
+
+    if start < content.len() {
+        let mut suffix = span;
+        suffix.content = content[start..].to_string().into();
+        spans.push(suffix);
+    }
+
+    spans
+}
+
+fn match_ranges(content: &str, query: &str) -> Vec<(usize, usize)> {
+    let query_graphemes = query.graphemes(true).count();
+    if query_graphemes == 0 || content.is_empty() {
+        return Vec::new();
+    }
+
+    let grapheme_indices: Vec<(usize, &str)> = content.grapheme_indices(true).collect();
+    let mut ranges = Vec::new();
+    let mut idx = 0;
+    while idx + query_graphemes <= grapheme_indices.len() {
+        let start = grapheme_indices[idx].0;
+        let end = grapheme_indices
+            .get(idx + query_graphemes)
+            .map(|(offset, _)| *offset)
+            .unwrap_or(content.len());
+        if content[start..end].to_lowercase() == query {
+            ranges.push((start, end));
+            idx += query_graphemes;
+        } else {
+            idx += 1;
+        }
+    }
+    ranges
+}
+
 struct CollapsedTurnRenderable {
     prompt: String,
     show_details_placeholder: bool,
@@ -489,12 +620,13 @@ struct CollapsedTurnRenderable {
 impl CollapsedTurnRenderable {
     fn lines(&self, width: u16) -> Vec<Line<'static>> {
         let budget = width.saturating_sub(4).max(8) as usize;
-        let mut lines = vec![
-            Line::from(vec![
-                Span::styled("› ".to_string(), user_message_style().bold().dim()),
-                Span::styled(truncate_preview_text(&self.prompt, budget), user_message_style()),
-            ]),
-        ];
+        let mut lines = vec![Line::from(vec![
+            Span::styled("› ".to_string(), user_message_style().bold().dim()),
+            Span::styled(
+                truncate_preview_text(&self.prompt, budget),
+                user_message_style(),
+            ),
+        ])];
         if self.show_details_placeholder {
             lines.push(details_line(budget));
         }
@@ -609,6 +741,9 @@ pub(crate) struct TranscriptOverlay {
     expand_all: bool,
     show_details: bool,
     mode: TranscriptBrowseMode,
+    search: Option<TranscriptSearch>,
+    search_input: Option<TranscriptSearchInput>,
+    pending_search_scroll: Option<(usize, usize)>,
     is_done: bool,
 }
 
@@ -618,6 +753,54 @@ enum TranscriptBrowseMode {
     ByPrompt,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum SearchDirection {
+    Forward,
+    Backward,
+}
+
+impl SearchDirection {
+    fn prompt_prefix(self) -> char {
+        match self {
+            SearchDirection::Forward => '/',
+            SearchDirection::Backward => '?',
+        }
+    }
+
+    fn is_forward(self) -> bool {
+        matches!(self, SearchDirection::Forward)
+    }
+
+    fn reverse(self) -> Self {
+        match self {
+            SearchDirection::Forward => SearchDirection::Backward,
+            SearchDirection::Backward => SearchDirection::Forward,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct TranscriptSearchMatch {
+    anchor_idx: usize,
+    cell_idx: usize,
+    match_index_in_cell: usize,
+    preview: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct TranscriptSearch {
+    query: String,
+    direction: SearchDirection,
+    matches: Vec<TranscriptSearchMatch>,
+    selected_match: Option<usize>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct TranscriptSearchInput {
+    direction: SearchDirection,
+    query: String,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct TranscriptAnchor {
     cell_idx: usize,
@@ -661,6 +844,9 @@ impl TranscriptOverlay {
                     false,
                     false,
                     selected_anchor.and_then(|idx| anchors.get(idx).map(|anchor| anchor.cell_idx)),
+                    None,
+                    None,
+                    None,
                 ),
                 "T R A N S C R I P T".to_string(),
                 usize::MAX,
@@ -675,6 +861,9 @@ impl TranscriptOverlay {
             expand_all: false,
             show_details: false,
             mode,
+            search: None,
+            search_input: None,
+            pending_search_scroll: None,
             is_done: false,
         };
         if let Some(anchor_idx) = overlay.selected_anchor {
@@ -701,7 +890,10 @@ impl TranscriptOverlay {
             let message_preview = Self::summarize_user_prompt(user_cell);
             anchors.push(TranscriptAnchor {
                 cell_idx,
-                label: format!("{turn_number}. {}", truncate_preview_text(&message_preview, 48)),
+                label: format!(
+                    "{turn_number}. {}",
+                    truncate_preview_text(&message_preview, 48)
+                ),
             });
         }
         anchors
@@ -738,6 +930,23 @@ impl TranscriptOverlay {
         })
     }
 
+    fn active_search_cell(&self) -> Option<usize> {
+        self.active_search_match_descriptor()
+            .map(|(cell_idx, _)| cell_idx)
+    }
+
+    fn active_search_match_descriptor(&self) -> Option<(usize, usize)> {
+        self.search
+            .as_ref()
+            .and_then(|search| search.selected_match)
+            .and_then(|idx| {
+                self.search
+                    .as_ref()
+                    .and_then(|search| search.matches.get(idx))
+                    .map(|search_match| (search_match.cell_idx, search_match.match_index_in_cell))
+            })
+    }
+
     fn refresh_anchors(&mut self) {
         let previously_selected_cell = self
             .selected_anchor
@@ -773,6 +982,188 @@ impl TranscriptOverlay {
             .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
     }
 
+    fn begin_search_input(&mut self, direction: SearchDirection) {
+        let existing_query = self
+            .search
+            .as_ref()
+            .map(|search| search.query.clone())
+            .unwrap_or_default();
+        self.search_input = Some(TranscriptSearchInput {
+            direction,
+            query: existing_query,
+        });
+    }
+
+    fn clear_search(&mut self) {
+        self.search = None;
+        self.search_input = None;
+        self.pending_search_scroll = None;
+        self.rebuild_renderables();
+    }
+
+    fn consumes_escape(&self) -> bool {
+        self.search.is_some() || self.search_input.is_some()
+    }
+
+    fn handle_search_input_key_event(
+        &mut self,
+        tui: &mut tui::Tui,
+        key_event: KeyEvent,
+    ) -> Result<()> {
+        let Some(input) = self.search_input.as_ref() else {
+            return Ok(());
+        };
+        if !matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat) {
+            return Ok(());
+        }
+
+        match key_event {
+            e if KEY_ESC.is_press(e) => {
+                self.clear_search();
+            }
+            e if KEY_ENTER.is_press(e) => {
+                let direction = input.direction;
+                let query = input.query.trim().to_string();
+                self.search_input = None;
+                if query.is_empty() {
+                    self.clear_search();
+                } else {
+                    self.commit_search(query, direction);
+                }
+            }
+            e if KEY_BACKSPACE.is_press(e) => {
+                if let Some(input) = self.search_input.as_mut() {
+                    input.query.pop();
+                }
+            }
+            KeyEvent {
+                code: KeyCode::Char(c),
+                modifiers,
+                ..
+            } if modifiers.is_empty() || modifiers == crossterm::event::KeyModifiers::SHIFT => {
+                if let Some(input) = self.search_input.as_mut() {
+                    input.query.push(c);
+                }
+            }
+            _ => return Ok(()),
+        }
+
+        tui.frame_requester()
+            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+        Ok(())
+    }
+
+    fn commit_search(&mut self, query: String, direction: SearchDirection) {
+        let matches = Self::build_search_matches(&self.cells, &self.anchors, &query);
+        let current_cell = self
+            .active_search_cell()
+            .or_else(|| self.selected_transcript_cell());
+        let selected_match = Self::initial_search_match_index(&matches, direction, current_cell);
+        self.search = Some(TranscriptSearch {
+            query,
+            direction,
+            matches,
+            selected_match,
+        });
+        self.sync_to_selected_search_match();
+    }
+
+    fn advance_search(&mut self, reverse: bool) {
+        let Some(search) = self.search.as_mut() else {
+            return;
+        };
+        if search.matches.is_empty() {
+            return;
+        }
+
+        let direction = if reverse {
+            search.direction.reverse()
+        } else {
+            search.direction
+        };
+        let current = search.selected_match.unwrap_or(0);
+        let len = search.matches.len();
+        let next = if direction.is_forward() {
+            (current + 1) % len
+        } else if current == 0 {
+            len - 1
+        } else {
+            current - 1
+        };
+        search.selected_match = Some(next);
+        self.sync_to_selected_search_match();
+    }
+
+    fn sync_to_selected_search_match(&mut self) {
+        let Some((anchor_idx, cell_idx, match_index_in_cell)) =
+            self.search.as_ref().and_then(|search| {
+                search
+                    .selected_match
+                    .and_then(|match_idx| search.matches.get(match_idx))
+                    .map(|search_match| {
+                        (
+                            search_match.anchor_idx,
+                            search_match.cell_idx,
+                            search_match.match_index_in_cell,
+                        )
+                    })
+            })
+        else {
+            self.rebuild_renderables();
+            return;
+        };
+
+        if self.anchors.get(anchor_idx).is_none() {
+            self.selected_anchor = Some(anchor_idx);
+            self.rebuild_renderables();
+            return;
+        }
+
+        self.selected_anchor = Some(anchor_idx);
+        self.rebuild_renderables();
+        self.pending_search_scroll = Some((cell_idx, match_index_in_cell));
+    }
+
+    fn refresh_search_matches(&mut self) {
+        let Some(existing_search) = self.search.as_ref() else {
+            return;
+        };
+
+        let previous_match = existing_search
+            .selected_match
+            .and_then(|idx| existing_search.matches.get(idx))
+            .map(|search_match| (search_match.cell_idx, search_match.match_index_in_cell));
+        let query = existing_search.query.clone();
+        let direction = existing_search.direction;
+        let matches = Self::build_search_matches(&self.cells, &self.anchors, &query);
+        let selected_match = previous_match
+            .and_then(|(cell_idx, match_index_in_cell)| {
+                matches.iter().position(|search_match| {
+                    search_match.cell_idx == cell_idx
+                        && search_match.match_index_in_cell == match_index_in_cell
+                })
+            })
+            .or_else(|| {
+                Self::initial_search_match_index(
+                    &matches,
+                    direction,
+                    self.selected_transcript_cell(),
+                )
+            });
+        self.search = Some(TranscriptSearch {
+            query,
+            direction,
+            matches,
+            selected_match,
+        });
+        if let Some(search) = self.search.as_ref()
+            && let Some(selected_match) = search.selected_match
+            && let Some(search_match) = search.matches.get(selected_match)
+        {
+            self.selected_anchor = Some(search_match.anchor_idx);
+        }
+    }
+
     fn handle_anchor_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) -> Result<()> {
         if self.anchors.is_empty() {
             return Ok(());
@@ -782,7 +1173,9 @@ impl TranscriptOverlay {
         let current = self.selected_anchor.unwrap_or(last_anchor).min(last_anchor);
         let next = match key_event {
             e if KEY_UP.is_press(e) || KEY_K.is_press(e) => current.saturating_sub(1),
-            e if KEY_DOWN.is_press(e) || KEY_J.is_press(e) => current.saturating_add(1).min(last_anchor),
+            e if KEY_DOWN.is_press(e) || KEY_J.is_press(e) => {
+                current.saturating_add(1).min(last_anchor)
+            }
             e if KEY_HOME.is_press(e) => 0,
             e if KEY_END.is_press(e) => last_anchor,
             _ => return Ok(()),
@@ -791,6 +1184,70 @@ impl TranscriptOverlay {
         Ok(())
     }
 
+    fn build_search_matches(
+        cells: &[Arc<dyn HistoryCell>],
+        anchors: &[TranscriptAnchor],
+        query: &str,
+    ) -> Vec<TranscriptSearchMatch> {
+        if query.is_empty() {
+            return Vec::new();
+        }
+
+        let query_lower = query.to_lowercase();
+        Self::turn_ranges(cells, anchors)
+            .into_iter()
+            .enumerate()
+            .flat_map(|(anchor_idx, turn_range)| {
+                let query_lower = query_lower.clone();
+                turn_range
+                    .flat_map(move |cell_idx| {
+                        let transcript_text = searchable_cell_text(cells[cell_idx].as_ref());
+                        match_ranges(&transcript_text, &query_lower)
+                            .into_iter()
+                            .enumerate()
+                            .map(move |(match_index_in_cell, (match_start, _))| {
+                                TranscriptSearchMatch {
+                                    anchor_idx,
+                                    cell_idx,
+                                    match_index_in_cell,
+                                    preview: search_preview(&transcript_text, match_start),
+                                }
+                            })
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect()
+    }
+
+    fn initial_search_match_index(
+        matches: &[TranscriptSearchMatch],
+        direction: SearchDirection,
+        current_cell: Option<usize>,
+    ) -> Option<usize> {
+        if matches.is_empty() {
+            return None;
+        }
+        let Some(current_cell) = current_cell else {
+            return Some(if direction.is_forward() {
+                0
+            } else {
+                matches.len().saturating_sub(1)
+            });
+        };
+
+        if direction.is_forward() {
+            matches
+                .iter()
+                .position(|search_match| search_match.cell_idx >= current_cell)
+                .or(Some(0))
+        } else {
+            matches
+                .iter()
+                .rposition(|search_match| search_match.cell_idx <= current_cell)
+                .or_else(|| matches.len().checked_sub(1))
+        }
+    }
+
     fn render_cells(
         cells: &[Arc<dyn HistoryCell>],
         anchors: &[TranscriptAnchor],
@@ -798,16 +1255,33 @@ impl TranscriptOverlay {
         expand_all: bool,
         show_details: bool,
         highlight_cell: Option<usize>,
+        active_search_cell: Option<usize>,
+        active_search_match: Option<(usize, usize)>,
+        active_search_query: Option<&str>,
     ) -> Vec<Box<dyn Renderable>> {
         let mut renderables: Vec<Box<dyn Renderable>> = Vec::new();
         let turn_ranges = Self::turn_ranges(cells, anchors);
         let selected_anchor = selected_anchor.unwrap_or_else(|| anchors.len().saturating_sub(1));
-        let first_anchor_idx = anchors.first().map(|anchor| anchor.cell_idx).unwrap_or(cells.len());
+        let first_anchor_idx = anchors
+            .first()
+            .map(|anchor| anchor.cell_idx)
+            .unwrap_or(cells.len());
 
         for cell_idx in 0..first_anchor_idx {
             let cell = &cells[cell_idx];
-            let renderable = Self::cell_renderable(cell.clone(), cell_idx, highlight_cell);
-            renderables.push(Self::with_spacing(renderable, !cell.is_stream_continuation(), renderables.len()));
+            let renderable = Self::cell_renderable(
+                cell.clone(),
+                cell_idx,
+                highlight_cell,
+                active_search_cell,
+                active_search_match,
+                active_search_query,
+            );
+            renderables.push(Self::with_spacing(
+                renderable,
+                !cell.is_stream_continuation(),
+                renderables.len(),
+            ));
         }
 
         for (anchor_idx, turn_range) in turn_ranges.iter().enumerate() {
@@ -819,6 +1293,9 @@ impl TranscriptOverlay {
                     &turn_display,
                     show_details,
                     highlight_cell,
+                    active_search_cell,
+                    active_search_match,
+                    active_search_query,
                 );
             } else if let Some(anchor) = anchors.get(anchor_idx) {
                 let collapsed = Box::new(CachedRenderable::new(CollapsedTurnRenderable {
@@ -839,12 +1316,18 @@ impl TranscriptOverlay {
         turn_display: &TurnDisplay,
         show_details: bool,
         highlight_cell: Option<usize>,
+        active_search_cell: Option<usize>,
+        active_search_match: Option<(usize, usize)>,
+        active_search_query: Option<&str>,
     ) {
         let prompt_cell = &cells[turn_display.prompt_idx];
         let prompt_renderable = Self::cell_renderable(
             prompt_cell.clone(),
             turn_display.prompt_idx,
             highlight_cell,
+            active_search_cell,
+            active_search_match,
+            active_search_query,
         );
         renderables.push(Self::with_spacing(
             prompt_renderable,
@@ -852,10 +1335,19 @@ impl TranscriptOverlay {
             renderables.len(),
         ));
 
-        if show_details {
+        let reveal_search_details = active_search_cell
+            .is_some_and(|cell_idx| turn_display.details_indices.contains(&cell_idx));
+        if show_details || reveal_search_details {
             for &cell_idx in &turn_display.details_indices {
                 let cell = &cells[cell_idx];
-                let renderable = Self::cell_renderable(cell.clone(), cell_idx, highlight_cell);
+                let renderable = Self::cell_renderable(
+                    cell.clone(),
+                    cell_idx,
+                    highlight_cell,
+                    active_search_cell,
+                    active_search_match,
+                    active_search_query,
+                );
                 renderables.push(Self::with_spacing(
                     renderable,
                     !cell.is_stream_continuation(),
@@ -870,7 +1362,14 @@ impl TranscriptOverlay {
 
         for &cell_idx in &turn_display.final_answer_indices {
             let cell = &cells[cell_idx];
-            let renderable = Self::cell_renderable(cell.clone(), cell_idx, highlight_cell);
+            let renderable = Self::cell_renderable(
+                cell.clone(),
+                cell_idx,
+                highlight_cell,
+                active_search_cell,
+                active_search_match,
+                active_search_query,
+            );
             renderables.push(Self::with_spacing(
                 renderable,
                 !cell.is_stream_continuation(),
@@ -883,17 +1382,31 @@ impl TranscriptOverlay {
         cell: Arc<dyn HistoryCell>,
         cell_idx: usize,
         highlight_cell: Option<usize>,
+        active_search_cell: Option<usize>,
+        active_search_match: Option<(usize, usize)>,
+        active_search_query: Option<&str>,
     ) -> Box<dyn Renderable> {
+        let search_query = (active_search_cell == Some(cell_idx))
+            .then(|| active_search_query.map(str::to_lowercase))
+            .flatten();
+        let active_search_match_index =
+            active_search_match.and_then(|(active_cell_idx, match_index_in_cell)| {
+                (active_cell_idx == cell_idx).then_some(match_index_in_cell)
+            });
         if cell.as_any().is::<UserHistoryCell>() {
             Box::new(CachedRenderable::new(CellRenderable {
                 cell,
                 highlight_style: (highlight_cell == Some(cell_idx))
                     .then(|| user_message_style().reversed()),
+                search_query,
+                active_search_match_index,
             })) as Box<dyn Renderable>
         } else {
             Box::new(CachedRenderable::new(CellRenderable {
                 cell,
                 highlight_style: None,
+                search_query,
+                active_search_match_index,
             })) as Box<dyn Renderable>
         }
     }
@@ -910,7 +1423,10 @@ impl TranscriptOverlay {
         }
     }
 
-    fn turn_ranges(cells: &[Arc<dyn HistoryCell>], anchors: &[TranscriptAnchor]) -> Vec<Range<usize>> {
+    fn turn_ranges(
+        cells: &[Arc<dyn HistoryCell>],
+        anchors: &[TranscriptAnchor],
+    ) -> Vec<Range<usize>> {
         anchors
             .iter()
             .enumerate()
@@ -946,7 +1462,10 @@ impl TranscriptOverlay {
         cell.as_any().is::<AgentMessageCell>()
     }
 
-    fn final_answer_indices(cells: &[Arc<dyn HistoryCell>], turn_range: Range<usize>) -> Vec<usize> {
+    fn final_answer_indices(
+        cells: &[Arc<dyn HistoryCell>],
+        turn_range: Range<usize>,
+    ) -> Vec<usize> {
         if let Some(range) = Self::latest_agent_message_range(cells, turn_range.clone()) {
             return range.collect();
         }
@@ -995,9 +1514,11 @@ impl TranscriptOverlay {
     }
 
     fn has_meaningful_transcript(cell: &dyn HistoryCell) -> bool {
-        cell.transcript_lines(200)
-            .iter()
-            .any(|line| line.spans.iter().any(|span| !span.content.trim().is_empty()))
+        cell.transcript_lines(200).iter().any(|line| {
+            line.spans
+                .iter()
+                .any(|span| !span.content.trim().is_empty())
+        })
     }
 
     fn collapsed_response_summary(
@@ -1031,7 +1552,10 @@ impl TranscriptOverlay {
         "(no response yet)".to_string()
     }
 
-    fn collapsed_final_answer_summary(cells: &[Arc<dyn HistoryCell>], turn_display: &TurnDisplay) -> String {
+    fn collapsed_final_answer_summary(
+        cells: &[Arc<dyn HistoryCell>],
+        turn_display: &TurnDisplay,
+    ) -> String {
         if turn_display.has_final_answer() {
             let start = *turn_display
                 .final_answer_indices
@@ -1067,30 +1591,29 @@ impl TranscriptOverlay {
         for (anchor_idx, turn_range) in turn_ranges.iter().enumerate() {
             let turn_display = Self::turn_display(&self.cells, turn_range.clone());
             if self.expand_all || anchor_idx == selected_anchor {
-                let mut visible_indices = vec![turn_display.prompt_idx];
-                if self.show_details {
-                    visible_indices.extend(turn_display.details_indices.iter().copied());
+                let visible_details = self.show_details
+                    || self
+                        .active_search_cell()
+                        .is_some_and(|idx| turn_display.details_indices.contains(&idx));
+                let mut visible_indices = vec![Some(turn_display.prompt_idx)];
+                if visible_details {
+                    visible_indices.extend(turn_display.details_indices.iter().copied().map(Some));
+                } else if turn_display.has_details() {
+                    visible_indices.push(None);
                 }
-                visible_indices.extend(turn_display.final_answer_indices.iter().copied());
-                if let Some(offset) = visible_indices.iter().position(|idx| *idx == cell_idx) {
+                visible_indices.extend(turn_display.final_answer_indices.iter().copied().map(Some));
+                if let Some(offset) = visible_indices
+                    .iter()
+                    .position(|idx| *idx == Some(cell_idx))
+                {
                     return Some(chunk_idx + offset);
                 }
-                if !self.show_details && turn_display.has_details() && cell_idx == turn_display.prompt_idx {
-                    return Some(chunk_idx);
-                }
-                chunk_idx += 1
-                    + usize::from(turn_display.has_details() || self.show_details && !turn_display.details_indices.is_empty())
-                    + turn_display.final_answer_indices.len()
-                    + if self.show_details {
-                        turn_display.details_indices.len()
-                    } else {
-                        0
-                    };
+                chunk_idx += visible_indices.len();
             } else {
-                if turn_range.start == cell_idx {
+                if turn_range.contains(&cell_idx) {
                     return Some(chunk_idx);
                 }
-                chunk_idx += 2 + usize::from(turn_display.has_details());
+                chunk_idx += 1;
             }
         }
         None
@@ -1112,6 +1635,7 @@ impl TranscriptOverlay {
         let tail_renderable = self.take_live_tail_renderable();
         self.cells.push(cell);
         self.refresh_anchors();
+        self.refresh_search_matches();
         self.view.renderables = Self::render_cells(
             &self.cells,
             &self.anchors,
@@ -1119,6 +1643,9 @@ impl TranscriptOverlay {
             self.expand_all,
             self.show_details,
             self.selected_transcript_cell(),
+            self.active_search_cell(),
+            self.active_search_match_descriptor(),
+            self.search.as_ref().map(|search| search.query.as_str()),
         );
         if let Some(tail) = tail_renderable {
             let tail = if !had_prior_cells
@@ -1156,6 +1683,7 @@ impl TranscriptOverlay {
             self.highlight_cell = None;
         }
         self.refresh_anchors();
+        self.refresh_search_matches();
         self.rebuild_renderables();
         if follow_bottom {
             self.view.scroll_offset = usize::MAX;
@@ -1245,6 +1773,9 @@ impl TranscriptOverlay {
             self.expand_all,
             self.show_details,
             self.selected_transcript_cell(),
+            self.active_search_cell(),
+            self.active_search_match_descriptor(),
+            self.search.as_ref().map(|search| search.query.as_str()),
         );
         if let Some(tail) = tail_renderable {
             self.view.renderables.push(tail);
@@ -1282,6 +1813,7 @@ impl TranscriptOverlay {
     fn render_hints(&self, area: Rect, buf: &mut Buffer) {
         let line1 = Rect::new(area.x, area.y, area.width, 1);
         let line2 = Rect::new(area.x, area.y.saturating_add(1), area.width, 1);
+        let line3 = Rect::new(area.x, area.y.saturating_add(2), area.width, 1);
         render_key_hints(line1, buf, PAGER_KEY_HINTS);
 
         let mut pairs: Vec<(&[KeyBinding], &str)> = vec![
@@ -1294,7 +1826,14 @@ impl TranscriptOverlay {
                     "show side panel"
                 },
             ),
-            (&[KEY_E], if self.expand_all { "collapse all" } else { "expand all" }),
+            (
+                &[KEY_E],
+                if self.expand_all {
+                    "collapse all"
+                } else {
+                    "expand all"
+                },
+            ),
             (
                 &[KEY_D],
                 if self.show_details {
@@ -1322,6 +1861,87 @@ impl TranscriptOverlay {
             pairs.push((&[KEY_ESC], "to edit prev"));
         }
         render_key_hints(line2, buf, &pairs);
+        self.render_search_status(line3, buf);
+    }
+
+    fn render_search_status(&self, area: Rect, buf: &mut Buffer) {
+        let Some(line) = self.search_status_line() else {
+            return;
+        };
+        Paragraph::new(vec![line]).render_ref(area, buf);
+    }
+
+    fn search_status_line(&self) -> Option<Line<'static>> {
+        if let Some(input) = self.search_input.as_ref() {
+            let mut spans: Vec<Span<'static>> = vec![
+                "Search ".dim(),
+                format!("{}{}", input.direction.prompt_prefix(), input.query).cyan(),
+            ];
+            if input.query.is_empty() {
+                spans.push(" (type to search)".dim());
+            }
+            spans.push("  ".into());
+            spans.push("<".into());
+            spans.push(Span::from(KEY_ENTER));
+            spans.push(">".into());
+            spans.push(" search".dim());
+            spans.push("  ".into());
+            spans.push("<".into());
+            spans.push(Span::from(KEY_ESC));
+            spans.push(">".into());
+            spans.push(" cancel".dim());
+            return Some(Line::from(spans));
+        }
+
+        let Some(search) = self.search.as_ref() else {
+            return Some(Line::from(vec![
+                "<".into(),
+                Span::from(KEY_SLASH),
+                ">".into(),
+                "/".into(),
+                "<".into(),
+                Span::from(KEY_QUESTION),
+                ">".into(),
+                " to search".dim(),
+            ]));
+        };
+        let prefix = search.direction.prompt_prefix();
+        let mut spans: Vec<Span<'static>> = vec![
+            "Search ".dim(),
+            format!("{prefix}{}", search.query).cyan(),
+            "  ".into(),
+        ];
+        match search.selected_match {
+            Some(selected_match) if !search.matches.is_empty() => {
+                spans.push(
+                    format!(
+                        "{}/{}",
+                        selected_match.saturating_add(1),
+                        search.matches.len()
+                    )
+                    .bold(),
+                );
+                if let Some(search_match) = search.matches.get(selected_match) {
+                    spans.push("  ".into());
+                    spans.push(search_match.preview.clone().dim());
+                }
+                spans.push("  ".into());
+                spans.push("<".into());
+                spans.push("n".into());
+                spans.push(">".into());
+                spans.push("/".into());
+                spans.push("<".into());
+                spans.push("N".into());
+                spans.push(">".into());
+                spans.push("  ".into());
+                spans.push("<".into());
+                spans.push(Span::from(KEY_ESC));
+                spans.push(">".into());
+                spans.push(" clear".dim());
+            }
+            _ => spans.push("no matches".italic().dim()),
+        }
+        Some(Line::from(spans))
     }
 
     fn render_anchor_shell(&self, area: Rect, buf: &mut Buffer) {
@@ -1361,13 +1981,9 @@ impl TranscriptOverlay {
             .iter()
             .enumerate()
             .map(|(idx, anchor)| {
-                self.anchor_paragraph(
-                    anchor,
-                    inner.width,
-                    Some(idx) == self.selected_anchor,
-                )
-                .line_count(inner.width)
-                .min(MAX_ANCHOR_LINES)
+                self.anchor_paragraph(anchor, inner.width, Some(idx) == self.selected_anchor)
+                    .line_count(inner.width)
+                    .min(MAX_ANCHOR_LINES)
             })
             .collect();
 
@@ -1402,8 +2018,12 @@ impl TranscriptOverlay {
         for idx in start..end {
             let height = heights[idx] as u16;
             let row_area = Rect::new(inner.x, y, inner.width, height);
-            self.anchor_paragraph(&self.anchors[idx], inner.width, Some(idx) == self.selected_anchor)
-                .render(row_area, buf);
+            self.anchor_paragraph(
+                &self.anchors[idx],
+                inner.width,
+                Some(idx) == self.selected_anchor,
+            )
+            .render(row_area, buf);
             y = y.saturating_add(height);
             if y >= inner.bottom() {
                 break;
@@ -1435,6 +2055,40 @@ impl TranscriptOverlay {
         .wrap(Wrap { trim: false })
     }
 
+    fn apply_pending_search_scroll(&mut self, transcript_area: Rect) {
+        let Some((cell_idx, match_index_in_cell)) = self.pending_search_scroll.take() else {
+            return;
+        };
+        let Some(chunk_idx) = self.chunk_index_for_cell(cell_idx) else {
+            return;
+        };
+
+        let content_area = self.view.content_area(transcript_area);
+        let Some(query) = self
+            .search
+            .as_ref()
+            .map(|search| search.query.to_lowercase())
+        else {
+            self.view.scroll_chunk_to_top(chunk_idx, content_area);
+            return;
+        };
+        let Some(cell) = self.cells.get(cell_idx) else {
+            return;
+        };
+
+        if let Some(line_offset) = search_match_wrapped_line_offset(
+            cell.as_ref(),
+            content_area.width,
+            &query,
+            match_index_in_cell,
+        ) {
+            self.view
+                .scroll_chunk_offset_to_top(chunk_idx, line_offset, content_area);
+        } else {
+            self.view.scroll_chunk_to_top(chunk_idx, content_area);
+        }
+    }
+
     pub(crate) fn render(&mut self, area: Rect, buf: &mut Buffer) {
         let top_h = area.height.saturating_sub(3);
         let top = Rect::new(area.x, area.y, area.width, top_h);
@@ -1446,9 +2100,11 @@ impl TranscriptOverlay {
                 Constraint::Length(anchor_width),
             ])
             .areas(top);
+            self.apply_pending_search_scroll(transcript_area);
             self.view.render(transcript_area, buf);
             self.render_anchor_shell(anchors_area, buf);
         } else {
+            self.apply_pending_search_scroll(top);
             self.view.render(top, buf);
         }
         self.render_hints(bottom, buf);
@@ -1458,53 +2114,88 @@ impl TranscriptOverlay {
 impl TranscriptOverlay {
     pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
         match event {
-            TuiEvent::Key(key_event) => match key_event {
-                e if KEY_Q.is_press(e) || KEY_CTRL_C.is_press(e) || KEY_CTRL_T.is_press(e) => {
-                    self.is_done = true;
-                    Ok(())
+            TuiEvent::Key(key_event) => {
+                if self.search_input.is_some() {
+                    return self.handle_search_input_key_event(tui, key_event);
                 }
-                e if KEY_A.is_press(e) => {
-                    self.anchors_visible = !self.anchors_visible;
-                    if !self.anchors_visible {
-                        self.mode = TranscriptBrowseMode::FreeForm;
+                match key_event {
+                    e if KEY_Q.is_press(e) || KEY_CTRL_C.is_press(e) || KEY_CTRL_T.is_press(e) => {
+                        self.is_done = true;
+                        Ok(())
                     }
-                    tui.frame_requester()
-                        .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
-                    Ok(())
-                }
-                e if KEY_TAB.is_press(e) && self.anchors_visible => {
-                    self.mode = match self.mode {
-                        TranscriptBrowseMode::FreeForm => {
-                            if let Some(anchor_idx) = self.selected_anchor {
-                                self.select_anchor(anchor_idx);
-                            }
-                            TranscriptBrowseMode::ByPrompt
+                    e if KEY_ESC.is_press(e) && self.search.is_some() => {
+                        self.clear_search();
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_SLASH.is_press(e) => {
+                        self.begin_search_input(SearchDirection::Forward);
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_QUESTION.is_press(e) || is_shift_char_press(e, '?') => {
+                        self.begin_search_input(SearchDirection::Backward);
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_N.is_press(e) => {
+                        self.advance_search(/*reverse*/ false);
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_CAPITAL_N.is_press(e) || is_shift_char_press(e, 'N') => {
+                        self.advance_search(/*reverse*/ true);
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_A.is_press(e) => {
+                        self.anchors_visible = !self.anchors_visible;
+                        if !self.anchors_visible {
+                            self.mode = TranscriptBrowseMode::FreeForm;
                         }
-                        TranscriptBrowseMode::ByPrompt => TranscriptBrowseMode::FreeForm,
-                    };
-                    tui.frame_requester()
-                        .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
-                    Ok(())
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_TAB.is_press(e) && self.anchors_visible => {
+                        self.mode = match self.mode {
+                            TranscriptBrowseMode::FreeForm => {
+                                if let Some(anchor_idx) = self.selected_anchor {
+                                    self.select_anchor(anchor_idx);
+                                }
+                                TranscriptBrowseMode::ByPrompt
+                            }
+                            TranscriptBrowseMode::ByPrompt => TranscriptBrowseMode::FreeForm,
+                        };
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_E.is_press(e) => {
+                        self.expand_all = !self.expand_all;
+                        self.rebuild_renderables();
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    e if KEY_D.is_press(e) => {
+                        self.show_details = !self.show_details;
+                        self.rebuild_renderables();
+                        tui.frame_requester()
+                            .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
+                        Ok(())
+                    }
+                    other => match self.mode {
+                        TranscriptBrowseMode::FreeForm => self.view.handle_key_event(tui, other),
+                        TranscriptBrowseMode::ByPrompt => self.handle_anchor_key_event(tui, other),
+                    },
                 }
-                e if KEY_E.is_press(e) => {
-                    self.expand_all = !self.expand_all;
-                    self.rebuild_renderables();
-                    tui.frame_requester()
-                        .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
-                    Ok(())
-                }
-                e if KEY_D.is_press(e) => {
-                    self.show_details = !self.show_details;
-                    self.rebuild_renderables();
-                    tui.frame_requester()
-                        .schedule_frame_in(crate::tui::TARGET_FRAME_INTERVAL);
-                    Ok(())
-                }
-                other => match self.mode {
-                    TranscriptBrowseMode::FreeForm => self.view.handle_key_event(tui, other),
-                    TranscriptBrowseMode::ByPrompt => self.handle_anchor_key_event(tui, other),
-                },
-            },
+            }
             TuiEvent::Draw => {
                 tui.draw(u16::MAX, |frame| {
                     self.render(frame.area(), frame.buffer);
@@ -1583,6 +2274,64 @@ impl StaticOverlay {
     }
 }
 
+fn searchable_cell_text(cell: &dyn HistoryCell) -> String {
+    cell.transcript_lines(2000)
+        .into_iter()
+        .map(|line| {
+            line.spans
+                .into_iter()
+                .map(|span| span.content.into_owned())
+                .collect::<String>()
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn search_preview(text: &str, match_start: usize) -> String {
+    let mut line_start = 0;
+    for line in text.lines() {
+        let line_end = line_start + line.len();
+        if (line_start..=line_end).contains(&match_start) {
+            let trimmed = line.trim();
+            if trimmed.is_empty() {
+                break;
+            }
+            return truncate_preview_text(trimmed, SEARCH_MATCH_CONTEXT_GRAPHEMES);
+        }
+        line_start = line_end.saturating_add(1);
+    }
+    truncate_preview_text(text.trim(), SEARCH_MATCH_CONTEXT_GRAPHEMES)
+}
+
+fn search_match_wrapped_line_offset(
+    cell: &dyn HistoryCell,
+    width: u16,
+    query: &str,
+    match_index_in_cell: usize,
+) -> Option<usize> {
+    if width == 0 {
+        return None;
+    }
+
+    let wrapped_lines = word_wrap_lines(cell.transcript_lines(width), width as usize);
+    let mut occurrence_idx = 0;
+    for (line_idx, line) in wrapped_lines.iter().enumerate() {
+        let line_text = line
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+        for _ in match_ranges(&line_text, query) {
+            if occurrence_idx == match_index_in_cell {
+                return Some(line_idx);
+            }
+            occurrence_idx += 1;
+        }
+    }
+
+    None
+}
+
 fn render_offset_content(
     area: Rect,
     buf: &mut Buffer,
@@ -1615,6 +2364,7 @@ mod tests {
     use super::*;
     use codex_protocol::protocol::ExecCommandSource;
     use codex_protocol::protocol::ReviewDecision;
+    use crossterm::event::KeyModifiers;
     use insta::assert_snapshot;
     use pretty_assertions::assert_eq;
     use std::collections::HashMap;
@@ -1656,6 +2406,22 @@ mod tests {
         Box::new(Paragraph::new(text)) as Box<dyn Renderable>
     }
 
+    fn user_prompt_cell(message: &str) -> Arc<dyn HistoryCell> {
+        Arc::new(history_cell::new_user_prompt(
+            message.to_string(),
+            Vec::new(),
+            Vec::new(),
+            Vec::new(),
+        ))
+    }
+
+    fn agent_message_cell(message: &str, is_first_line: bool) -> Arc<dyn HistoryCell> {
+        Arc::new(history_cell::AgentMessageCell::new(
+            vec![Line::from(message.to_string())],
+            is_first_line,
+        ))
+    }
+
     #[test]
     fn edit_prev_hint_is_visible() {
         let mut overlay = TranscriptOverlay::new(vec![Arc::new(TestCell {
@@ -1663,7 +2429,7 @@ mod tests {
         })]);
 
         // Render into a wide buffer so the footer hints aren't truncated.
-        let area = Rect::new(0, 0, 120, 10);
+        let area = Rect::new(0, 0, 180, 10);
         let mut buf = Buffer::empty(area);
         overlay.render(area, &mut buf);
 
@@ -1682,7 +2448,7 @@ mod tests {
         overlay.set_highlight_cell(Some(0));
 
         // Render into a wide buffer so the footer hints aren't truncated.
-        let area = Rect::new(0, 0, 120, 10);
+        let area = Rect::new(0, 0, 180, 10);
         let mut buf = Buffer::empty(area);
         overlay.render(area, &mut buf);
 
@@ -1779,6 +2545,19 @@ mod tests {
         out
     }
 
+    fn buffer_row_text(buf: &Buffer, area: Rect, y: u16) -> String {
+        let mut row = String::new();
+        for x in area.x..area.right() {
+            let symbol = buf[(x, y)].symbol();
+            if symbol.is_empty() {
+                row.push(' ');
+            } else {
+                row.push(symbol.chars().next().unwrap_or(' '));
+            }
+        }
+        row
+    }
+
     #[test]
     fn transcript_overlay_apply_patch_scroll_vt100_clears_previous_page() {
         let cwd = PathBuf::from("/repo");
@@ -2014,6 +2793,220 @@ mod tests {
         assert_snapshot!(term.backend());
     }
 
+    #[test]
+    fn transcript_overlay_search_snapshot() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("Find the foo item"),
+            Arc::new(TestCell {
+                lines: vec![Line::from("detail output with foo inside details")],
+            }),
+            agent_message_cell("Final answer that also mentions foo.", true),
+            user_prompt_cell("Other prompt"),
+            agent_message_cell("Another final answer.", true),
+        ]);
+        overlay.commit_search("foo".to_string(), SearchDirection::Forward);
+
+        let mut term = Terminal::new(TestBackend::new(72, 16)).expect("term");
+        term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
+            .expect("draw");
+        assert_snapshot!(term.backend());
+    }
+
+    #[test]
+    fn transcript_overlay_search_reveals_details_for_selected_match() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("First prompt"),
+            Arc::new(TestCell {
+                lines: vec![Line::from("detail output with needle hidden inside")],
+            }),
+            agent_message_cell("Final answer", true),
+        ]);
+
+        overlay.commit_search("needle".to_string(), SearchDirection::Forward);
+
+        let area = Rect::new(0, 0, 80, 14);
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+        let rendered = buffer_to_text(&buf, area);
+
+        assert!(
+            rendered.contains("detail output with needle hidden inside"),
+            "expected active search to reveal matching details, got {rendered:?}"
+        );
+    }
+
+    #[test]
+    fn transcript_overlay_search_navigation_updates_prompt_selection() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("First prompt"),
+            agent_message_cell("No match here", true),
+            user_prompt_cell("Second prompt"),
+            Arc::new(TestCell {
+                lines: vec![Line::from("details include needle here")],
+            }),
+            agent_message_cell("Final answer", true),
+        ]);
+
+        overlay.commit_search("needle".to_string(), SearchDirection::Forward);
+
+        let search = overlay.search.as_ref().expect("search should exist");
+        assert_eq!(search.matches.len(), 1);
+        assert_eq!(overlay.selected_anchor, Some(1));
+        assert_eq!(overlay.active_search_cell(), Some(3));
+    }
+
+    #[test]
+    fn transcript_overlay_search_scrolls_to_matching_chunk() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("First prompt"),
+            agent_message_cell("First final answer", true),
+            user_prompt_cell("Second prompt"),
+            Arc::new(TestCell {
+                lines: vec![Line::from("details include needle here")],
+            }),
+            agent_message_cell("Second final answer", true),
+            user_prompt_cell("Third prompt"),
+            agent_message_cell("Third final answer", true),
+        ]);
+
+        overlay.commit_search("needle".to_string(), SearchDirection::Forward);
+
+        assert_eq!(overlay.selected_anchor, Some(1));
+        assert_eq!(overlay.active_search_cell(), Some(3));
+        assert_eq!(
+            overlay.view.pending_scroll_chunk,
+            Some(PendingChunkScroll {
+                chunk_index: 2,
+                align_top: true,
+            })
+        );
+    }
+
+    #[test]
+    fn transcript_overlay_search_scrolls_to_matching_line_within_long_cell() {
+        let detail_lines = (0..20)
+            .map(|idx| {
+                if idx == 16 {
+                    Line::from("line 16 with needle")
+                } else {
+                    Line::from(format!("line {idx}"))
+                }
+            })
+            .collect::<Vec<_>>();
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("Prompt"),
+            Arc::new(TestCell {
+                lines: detail_lines,
+            }),
+            agent_message_cell("Final answer", true),
+        ]);
+        overlay.anchors_visible = false;
+        overlay.commit_search("needle".to_string(), SearchDirection::Forward);
+
+        let area = Rect::new(0, 0, 40, 10);
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+
+        let rendered = buffer_to_text(&buf, area);
+        assert!(
+            rendered.contains("needle"),
+            "expected search navigation to scroll the match into view, got {rendered:?}"
+        );
+    }
+
+    #[test]
+    fn transcript_overlay_search_highlights_one_occurrence_at_a_time() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("Prompt"),
+            Arc::new(TestCell {
+                lines: vec![Line::from("match foo rest foo")],
+            }),
+            agent_message_cell("Final answer", true),
+        ]);
+        overlay.anchors_visible = false;
+        overlay.commit_search("foo".to_string(), SearchDirection::Forward);
+
+        let search = overlay.search.as_ref().expect("search should exist");
+        assert_eq!(search.matches.len(), 2);
+
+        let area = Rect::new(0, 0, 60, 12);
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+
+        let match_row = (area.y..area.bottom())
+            .find(|y| buffer_row_text(&buf, area, *y).contains("match foo rest foo"))
+            .expect("expected rendered row containing the search match");
+        let row_text = buffer_row_text(&buf, area, match_row);
+        let first_match_start = row_text
+            .find("foo")
+            .expect("expected highlighted query in rendered row")
+            as u16;
+        let second_match_start = row_text
+            .rfind("foo")
+            .expect("expected second highlighted query in rendered row")
+            as u16;
+        let line_start = row_text
+            .find("match")
+            .expect("expected detail line prefix in rendered row") as u16;
+
+        assert_eq!(
+            buf[(area.x + first_match_start, match_row)].fg,
+            ratatui::style::Color::Yellow,
+        );
+        assert_ne!(
+            buf[(area.x + second_match_start, match_row)].fg,
+            ratatui::style::Color::Yellow,
+        );
+        assert_ne!(
+            buf[(area.x + line_start, match_row)].fg,
+            ratatui::style::Color::Yellow,
+        );
+
+        overlay.advance_search(/*reverse*/ false);
+
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+        assert_ne!(
+            buf[(area.x + first_match_start, match_row)].fg,
+            ratatui::style::Color::Yellow,
+        );
+        assert_eq!(
+            buf[(area.x + second_match_start, match_row)].fg,
+            ratatui::style::Color::Yellow,
+        );
+    }
+
+    #[test]
+    fn shifted_search_bindings_match_shifted_key_events() {
+        assert!(is_shift_char_press(
+            KeyEvent::new(KeyCode::Char('?'), KeyModifiers::SHIFT),
+            '?',
+        ));
+        assert!(is_shift_char_press(
+            KeyEvent::new(KeyCode::Char('N'), KeyModifiers::SHIFT),
+            'N',
+        ));
+    }
+
+    #[test]
+    fn transcript_overlay_escape_is_consumed_by_active_search() {
+        let mut overlay = TranscriptOverlay::new(vec![
+            user_prompt_cell("Find the foo item"),
+            agent_message_cell("Final answer that also mentions foo.", true),
+        ]);
+
+        assert!(!overlay.consumes_escape());
+
+        overlay.begin_search_input(SearchDirection::Forward);
+        assert!(overlay.consumes_escape());
+
+        overlay.commit_search("foo".to_string(), SearchDirection::Forward);
+        assert!(overlay.consumes_escape());
+
+        overlay.clear_search();
+        assert!(!overlay.consumes_escape());
+    }
+
     #[test]
     fn pager_view_content_height_counts_renderables() {
         let pv = PagerView::new(
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_snapshot_basic.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_snapshot_basic.snap
index bc7818aff9..451e29c1d0 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_snapshot_basic.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_snapshot_basic.snap
@@ -9,6 +9,6 @@ expression: term.backend()
 "~                                       "
 "~                                       "
 "───────────────────────────────── 100% ─"
-" ↑/↓ to scroll   pgup/pgdn to page   hom"
-" q to quit                              "
+" <↑>/<↓> to scroll   <pgup>/<pgdn> to pa"
+" <q> to quit                            "
 "                                        "
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_wraps_long_lines.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_wraps_long_lines.snap
index 2dfab2aa7d..40c536ade0 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_wraps_long_lines.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_wraps_long_lines.snap
@@ -1,6 +1,5 @@
 ---
 source: tui/src/pager_overlay.rs
-assertion_line: 798
 expression: term.backend()
 ---
 "/ S T A T I C / / / / / "
@@ -8,6 +7,6 @@ expression: term.backend()
 "should wrap when        "
 "rendered within a narrow"
 "─────────────────── 0% ─"
-" ↑/↓ to scroll   pgup/pg"
-" q to quit              "
+" <↑>/<↓> to scroll   <pg"
+" <q> to quit            "
 "                        "
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_apply_patch_scroll_vt100.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_apply_patch_scroll_vt100.snap
index 1f086e81e4..515a1b326c 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_apply_patch_scroll_vt100.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_apply_patch_scroll_vt100.snap
@@ -2,14 +2,15 @@
 source: tui/src/pager_overlay.rs
 expression: snapshot
 ---
-/ T R A N S C R I P T / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
-• Added foo.txt (+2 -0)
-    1 +hello
-    2 +world
-
-• Added foo.txt (+2 -0)
-    1 +hello
-    2 +world
-─────────────────────────────────────────────────────────────────────────── 0% ─
- ↑/↓ to scroll   pgup/pgdn to page   home/end to jump
- q to quit   esc to edit prev
+/ T R A N S C R I P T / / / / / / / / / / / ┌User Prompts──────────────────────┐
+• Added foo.txt (+2 -0)                     │No user prompts yet.              │
+    1 +hello                                │                                  │
+    2 +world                                │Add another turn                  │
+                                            │and reopen Ctrl+T.                │
+• Added foo.txt (+2 -0)                     │                                  │
+    1 +hello                                │                                  │
+    2 +world                                │                                  │
+─────────────────────────────────────── 0% ─└──────────────────────────────────┘
+ <↑>/<↓> to scroll   <pgup>/<pgdn> to page   <home>/<end> to jump
+ <q> to quit   <a> hide side panel   <e> expand all   <d> show details   <tab> s
+</>/<?> to search
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_renders_live_tail.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_renders_live_tail.snap
index 05ea902460..d463acfd98 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_renders_live_tail.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_renders_live_tail.snap
@@ -9,6 +9,6 @@ expression: term.backend()
 "~                                       "
 "~                                       "
 "───────────────────────────────── 100% ─"
-" ↑/↓ to scroll   pgup/pgdn to page   hom"
-" q to quit   esc to edit prev           "
-"                                        "
+" <↑>/<↓> to scroll   <pgup>/<pgdn> to pa"
+" <q> to quit   <a> hide side panel   <e>"
+"</>/<?> to search                       "
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_search_snapshot.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_search_snapshot.snap
new file mode 100644
index 0000000000..3c756b2165
--- /dev/null
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_search_snapshot.snap
@@ -0,0 +1,20 @@
+---
+source: tui/src/pager_overlay.rs
+expression: term.backend()
+---
+"/ T R A N S C R I P T / / / / / / / / / / / / / / / / / / / / / / / / / "
+"                                                                        "
+"› Find the foo item                                                     "
+"                                                                        "
+"                                                                        "
+"  Details...                                                            "
+"                                                                        "
+"• Final answer that also mentions foo.                                  "
+"                                                                        "
+"› 2. Other prompt                                                       "
+"• (no response yet)                                                     "
+"~                                                                       "
+"───────────────────────────────────────────────────────────────── 100% ─"
+" <↑>/<↓> to scroll   <pgup>/<pgdn> to page   <home>/<end> to jump       "
+" <q> to quit   <a> hide side panel   <e> expand all   <d> show details  "
+"Search /foo  1/3  › Find the foo item  <n>/<N>  <esc> clear             "
diff --git a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_snapshot_basic.snap b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_snapshot_basic.snap
index 61fcf7d2ea..97c942aa92 100644
--- a/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_snapshot_basic.snap
+++ b/codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_snapshot_basic.snap
@@ -9,6 +9,6 @@ expression: term.backend()
 "                                        "
 "gamma                                   "
 "───────────────────────────────── 100% ─"
-" ↑/↓ to scroll   pgup/pgdn to page   hom"
-" q to quit   esc to edit prev           "
-"                                        "
+" <↑>/<↓> to scroll   <pgup>/<pgdn> to pa"
+" <q> to quit   <a> hide side panel   <e>"
+"</>/<?> to search                       "