Lightweight coding agent that runs in your terminal
Rust
Avoid querying terminal size on every TUI redraw (#36482)
Felipe Coury7dc1856685d5
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex b201d8f020..5c1a6f9a73 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -174,6 +174,7 @@ use crossterm::event::KeyEventKind;use crossterm::event::KeyModifiers;use ratatui::backend::Backend;use ratatui::layout::Rect;+use ratatui::layout::Size;use ratatui::style::Stylize;use ratatui::text::Line;use ratatui::widgets::Paragraph;@@ -1135,7 +1136,7 @@ See the Codex keymap documentation for supported actions and examples."let tui_events = tui.event_stream();tokio::pin!(tui_events);- tui.frame_requester().schedule_frame();+ tui.schedule_screen_size_recheck(Duration::ZERO);tracing::info!(duration_ms = %(startup_elapsed_before_app + startup_started_at.elapsed()).as_millis(),bootstrap_ms = %bootstrap_ms,@@ -1289,8 +1290,9 @@ See the Codex keymap documentation for supported actions and examples."app_server: &mut AppServerSession,event: TuiEvent,) -> Result<AppRunControl> {- if matches!(event, TuiEvent::Draw | TuiEvent::Resize) {- self.handle_draw_pre_render(tui)?;+ let screen_size = tui.screen_size_for_event(&event)?;+ if !matches!(&event, TuiEvent::Key(_) | TuiEvent::Paste(_)) {+ self.handle_draw_pre_render(tui, screen_size)?;}if self.overlay.is_some() {@@ -1308,9 +1310,9 @@ See the Codex keymap documentation for supported actions and examples."let pasted = pasted.replace("\r", "\n");self.chat_widget.handle_paste(pasted);}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {if self.backtrack_render_pending {- self.rebuild_transcript_after_backtrack(tui)?;+ self.rebuild_transcript_after_backtrack(tui, screen_size.into())?;self.backtrack_render_pending = false;}self.chat_widget.maybe_post_pending_notification(tui);@@ -1318,18 +1320,18 @@ See the Codex keymap documentation for supported actions and examples.".chat_widget.handle_paste_burst_tick(tui.frame_requester()){+ tui.defer_screen_size(screen_size);return Ok(AppRunControl::Continue);}// Allow widgets to process any pending timers before rendering.self.chat_widget.pre_draw_tick();- let rendered_area = self.render_chat_widget_frame(tui)?;+ let rendered_area = self.render_chat_widget_frame(tui, screen_size)?;if self.chat_widget.ambient_pet_image_enabled() {- let terminal_size = tui.terminal.size()?;let ambient_pet_area = Rect::new(/*x*/ 0,/*y*/ 0,- terminal_size.width,- terminal_size.height,+ screen_size.width,+ screen_size.height,);if let Err(err) = tui.draw_ambient_pet_image(self.chat_widget@@ -1361,17 +1363,17 @@ See the Codex keymap documentation for supported actions and examples."pub(super) fn show_shutdown_feedback(&mut self, tui: &mut tui::Tui) -> Result<()> {self.disable_ambient_pet_before_shutdown(tui)?;self.chat_widget.show_shutdown_in_progress();- self.handle_draw_pre_render(tui)?;+ let screen_size = tui.terminal.last_known_screen_size;+ self.handle_draw_pre_render(tui, screen_size)?;self.chat_widget.pre_draw_tick();- self.render_chat_widget_frame(tui)?;+ self.render_chat_widget_frame(tui, screen_size)?;Ok(())}- fn render_chat_widget_frame(&mut self, tui: &mut tui::Tui) -> Result<Rect> {- let width = tui.terminal.size()?.width;- self.with_chat_widget_frame(width, |desired_height, chat_widget| {+ fn render_chat_widget_frame(&mut self, tui: &mut tui::Tui, screen_size: Size) -> Result<Rect> {+ self.with_chat_widget_frame(screen_size.width, |desired_height, chat_widget| {let mut rendered_area = Rect::default();- tui.draw_with_resize_reflow(desired_height, |frame| {+ tui.draw_with_resize_reflow(desired_height, screen_size, |frame| {let area = frame.area();rendered_area = area;chat_widget.render(area, frame.buffer);diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 626b2001d9..fa6bf71862 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -437,13 +437,14 @@ impl App {AppEvent::CodexOp(op) => {let is_user_turn = matches!(&op, AppCommand::UserTurn { .. });if is_user_turn {- self.handle_draw_pre_render(tui)?;+ let screen_size = tui.terminal.last_known_screen_size;+ self.handle_draw_pre_render(tui, screen_size)?;if self.transcript_reflow.has_pending_reflow() {self.transcript_reflow.schedule_immediate();- self.maybe_run_resize_reflow(tui)?;+ self.maybe_run_resize_reflow(tui, screen_size)?;}self.chat_widget.pre_draw_tick();- self.render_chat_widget_frame(tui)?;+ self.render_chat_widget_frame(tui, screen_size)?;}self.chat_widget.prepare_local_op_submission(&op);if let Err(err) = self.submit_active_thread_op(app_server, op).await {diff --git a/codex-rs/tui/src/app/input.rs b/codex-rs/tui/src/app/input.rsindex dcd88dfb82..b81b479f3d 100644--- a/codex-rs/tui/src/app/input.rs+++ b/codex-rs/tui/src/app/input.rs@@ -79,7 +79,8 @@ impl App {} else {self.chat_widget.set_raw_output_mode(enabled);}- if let Err(err) = self.reflow_transcript_now(tui) {+ let terminal_width = tui.terminal.last_known_screen_size.into();+ if let Err(err) = self.reflow_transcript_now(tui, terminal_width) {tracing::warn!(error = %err, "failed to reflow transcript after raw output mode toggle");self.chat_widget.add_error_message(format!("Failed to redraw transcript: {err}"));diff --git a/codex-rs/tui/src/app/resize_reflow.rs b/codex-rs/tui/src/app/resize_reflow.rsindex 7d00f7f5ff..266d3aa602 100644--- a/codex-rs/tui/src/app/resize_reflow.rs+++ b/codex-rs/tui/src/app/resize_reflow.rs@@ -30,6 +30,16 @@ use crate::terminal_hyperlinks::HyperlinkLine;use crate::transcript_reflow::TRANSCRIPT_REFLOW_DEBOUNCE;use crate::tui;+/// Full terminal width before transcript-specific layout reservations.+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(super) struct TerminalWidth(u16);++impl From<ratatui::layout::Size> for TerminalWidth {+ fn from(size: ratatui::layout::Size) -> Self {+ Self(size.width)+ }+}+struct ReflowCellDisplay {lines: Vec<HyperlinkLine>,is_stream_continuation: bool,@@ -253,7 +263,8 @@ impl App {pub(super) fn maybe_finish_stream_reflow(&mut self, tui: &mut tui::Tui) -> Result<()> {if self.transcript_reflow.take_stream_finish_reflow_needed() {self.schedule_immediate_resize_reflow(tui);- self.maybe_run_resize_reflow(tui)?;+ let screen_size = tui.terminal.last_known_screen_size;+ self.maybe_run_resize_reflow(tui, screen_size)?;} else if self.transcript_reflow.pending_is_due(Instant::now()) {tui.frame_requester().schedule_frame();}@@ -285,7 +296,8 @@ impl App {}self.schedule_immediate_resize_reflow(tui);- self.maybe_run_resize_reflow(tui)?;+ let screen_size = tui.terminal.last_known_screen_size;+ self.maybe_run_resize_reflow(tui, screen_size)?;if !self.transcript_reflow.has_pending_reflow() {self.transcript_reflow.clear_stream_flags();}@@ -342,8 +354,11 @@ impl App {self.reset_history_emission_state();}- pub(super) fn handle_draw_pre_render(&mut self, tui: &mut tui::Tui) -> Result<()> {- let size = tui.terminal.size()?;+ pub(super) fn handle_draw_pre_render(+ &mut self,+ tui: &mut tui::Tui,+ size: ratatui::layout::Size,+ ) -> Result<()> {let should_rebuild_transcript = self.handle_draw_size_change(size,tui.terminal.last_known_screen_size,@@ -355,7 +370,7 @@ impl App {// rebuild from transcript cells.tui.clear_pending_history_lines();}- self.maybe_run_resize_reflow(tui)?;+ self.maybe_run_resize_reflow(tui, size)?;Ok(())}@@ -365,7 +380,11 @@ impl App {/// surface. Callers must keep using `HistoryCell` source as the rebuild input; attempting to/// reuse terminal-wrapped output here would preserve exactly the stale wrapping this feature is/// meant to remove.- pub(super) fn maybe_run_resize_reflow(&mut self, tui: &mut tui::Tui) -> Result<()> {+ pub(super) fn maybe_run_resize_reflow(+ &mut self,+ tui: &mut tui::Tui,+ screen_size: ratatui::layout::Size,+ ) -> Result<()> {let Some(deadline) = self.transcript_reflow.pending_until() else {return Ok(());};@@ -390,8 +409,8 @@ impl App {let reflow_ran_during_stream =!self.transcript_cells.is_empty() && self.should_mark_reflow_as_stream_time();- let width = self.reflow_transcript_now(tui)?;- self.transcript_reflow.mark_reflowed_width(width);+ let width = self.reflow_transcript_now(tui, screen_size.into())?;+ self.transcript_reflow.mark_reflowed_width(width.0);if reflow_ran_during_stream {self.transcript_reflow.mark_ran_during_stream();@@ -399,15 +418,17 @@ impl App {// Some terminals settle their final reported width after the repaint that handled the// last resize event. Request one cheap follow-up draw so `handle_draw_pre_render` can// sample that width and schedule a final reflow if needed.- tui.frame_requester()- .schedule_frame_in(TRANSCRIPT_REFLOW_DEBOUNCE);+ tui.schedule_screen_size_recheck(TRANSCRIPT_REFLOW_DEBOUNCE);Ok(())}- pub(super) fn reflow_transcript_now(&mut self, tui: &mut tui::Tui) -> Result<u16> {- let terminal_width = tui.terminal.size()?.width;- let width = self.chat_widget.history_wrap_width(terminal_width);+ pub(super) fn reflow_transcript_now(+ &mut self,+ tui: &mut tui::Tui,+ terminal_width: TerminalWidth,+ ) -> Result<TerminalWidth> {+ let width = self.chat_widget.history_wrap_width(terminal_width.0);if self.transcript_cells.is_empty() {// Drop any queued pre-resize/pre-consolidation inserts before rebuilding from cells.tui.clear_pending_history_lines();@@ -438,9 +459,12 @@ impl App {/// Unlike resize reflow, rollback must clear the terminal even when no cells remain. Otherwise/// the cancelled user prompt stays visible in scrollback despite being removed from the source/// transcript.- pub(super) fn rebuild_transcript_after_backtrack(&mut self, tui: &mut tui::Tui) -> Result<()> {- let terminal_width = tui.terminal.size()?.width;- let width = self.chat_widget.history_wrap_width(terminal_width);+ pub(super) fn rebuild_transcript_after_backtrack(+ &mut self,+ tui: &mut tui::Tui,+ terminal_width: TerminalWidth,+ ) -> Result<()> {+ let width = self.chat_widget.history_wrap_width(terminal_width.0);let reflowed_lines = if self.transcript_cells.is_empty() {self.reset_history_emission_state();Vec::new()diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex c319cc35de..1ef8c4bc2c 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -5357,7 +5357,8 @@ async fn required_stream_reflow_during_capped_initial_replay_survives_transcriptassert!(app.initial_history_replay_buffer.is_none());assert!(app.transcript_reflow.has_pending_reflow());- app.maybe_run_resize_reflow(&mut tui)?;+ let screen_size = tui.terminal.last_known_screen_size;+ app.maybe_run_resize_reflow(&mut tui, screen_size)?;assert!(app.transcript_reflow.has_pending_reflow());app.close_transcript_overlay(&mut tui);@@ -5422,6 +5423,27 @@ async fn height_shrink_schedules_resize_reflow() {assert!(app.transcript_reflow.has_pending_reflow());}+#[tokio::test]+async fn resizing_empty_transcript_schedules_settled_size_recheck() {+ let (mut app, _rx, _op_rx) = make_test_app_with_channels().await;+ let mut tui = crate::tui::test_support::make_test_tui().expect("test tui");+ let frame_requester = crate::tui::FrameRequester::test_dummy();+ let initial_size = ratatui::layout::Size::new(/*width*/ 80, /*height*/ 24);+ let resized_size = ratatui::layout::Size::new(/*width*/ 100, /*height*/ 24);++ assert!(!app.handle_draw_size_change(initial_size, initial_size, &frame_requester));+ tui.screen_size_for_event(&TuiEvent::Resize(resized_size))+ .expect("resolve resize event");+ tui.terminal.resize(resized_size).expect("apply event size");+ assert!(app.handle_draw_size_change(resized_size, initial_size, &frame_requester));+ tokio::time::sleep(crate::transcript_reflow::TRANSCRIPT_REFLOW_DEBOUNCE).await;+ assert_eq!(+ tui.screen_size_for_event(&TuiEvent::Draw)+ .expect("resolve settled size"),+ initial_size+ );+}+fn test_turn(turn_id: &str, status: TurnStatus, items: Vec<ThreadItem>) -> Turn {Turn {id: turn_id.to_string(),diff --git a/codex-rs/tui/src/app_backtrack.rs b/codex-rs/tui/src/app_backtrack.rsindex f4114a3f90..609e3e6b1e 100644--- a/codex-rs/tui/src/app_backtrack.rs+++ b/codex-rs/tui/src/app_backtrack.rs@@ -341,8 +341,10 @@ impl App {/// source of truth for the active cell and its cache invalidation key, and because `App` owns/// overlay lifecycle and frame scheduling for animations.fn overlay_forward_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {- if matches!(&event, TuiEvent::Draw | TuiEvent::Resize)- && let Some(Overlay::Transcript(t)) = &mut self.overlay+ if matches!(+ &event,+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_)+ ) && let Some(Overlay::Transcript(t)) = &mut self.overlay{let active_key = self.chat_widget.active_cell_transcript_key();let chat_widget = &self.chat_widget;diff --git a/codex-rs/tui/src/custom_terminal.rs b/codex-rs/tui/src/custom_terminal.rsindex d7d0cf36e5..480d1a8635 100644--- a/codex-rs/tui/src/custom_terminal.rs+++ b/codex-rs/tui/src/custom_terminal.rs@@ -345,8 +345,17 @@ wherewhereF: FnOnce(&mut Frame),{- self.try_draw(|frame| {- render_callback(frame);+ let screen_size = self.size()?;+ self.draw_with_size(screen_size, render_callback)+ }++ /// Draws a single frame using a screen size already obtained by the caller.+ pub(crate) fn draw_with_size<F>(&mut self, screen_size: Size, render: F) -> io::Result<()>+ where+ F: FnOnce(&mut Frame),+ {+ self.try_draw_with_size(screen_size, |frame| {+ render(frame);io::Result::Ok(())})}@@ -391,10 +400,18 @@ whereF: FnOnce(&mut Frame) -> Result<(), E>,E: Into<io::Error>,{- // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets- // and the terminal (if growing), which may OOB.- self.autoresize()?;+ let screen_size = self.size()?;+ self.try_draw_with_size(screen_size, render_callback)+ }+ fn try_draw_with_size<F, E>(&mut self, screen_size: Size, render_callback: F) -> io::Result<()>+ where+ F: FnOnce(&mut Frame) -> Result<(), E>,+ E: Into<io::Error>,+ {+ if screen_size != self.last_known_screen_size {+ self.resize(screen_size)?;+ }let mut frame = self.get_frame();render_callback(&mut frame).map_err(Into::into)?;@@ -792,6 +809,7 @@ mod tests {use super::*;use std::num::NonZeroU16;+ use insta::assert_snapshot;use pretty_assertions::assert_eq;use ratatui::backend::WindowSize;use ratatui::layout::Rect;@@ -806,6 +824,7 @@ mod tests {output: Vec<u8>,size: Size,cursor: Position,+ size_call_count: std::cell::Cell<usize>,}impl CaptureBackend {@@ -814,6 +833,7 @@ mod tests {output: Vec::new(),size: Size { width, height },cursor: Position { x: 0, y: 0 },+ size_call_count: std::cell::Cell::new(/*value*/ 0),}}@@ -889,6 +909,8 @@ mod tests {}fn size(&self) -> io::Result<Size> {+ self.size_call_count+ .set(self.size_call_count.get().saturating_add(/*rhs*/ 1));Ok(self.size)}@@ -904,6 +926,65 @@ mod tests {}}+ #[test]+ fn ordinary_redraws_with_known_size_do_not_query_backend_size() {+ let mut terminal =+ Terminal::with_options(CaptureBackend::new(/*width*/ 80, /*height*/ 24))+ .expect("terminal");+ let screen_size = terminal.last_known_screen_size;++ for _ in 0..3 {+ terminal.draw_with_size(screen_size, |_| {}).expect("draw");+ }++ assert_eq!(terminal.backend().size_call_count.get(), 1);+ }++ #[test]+ fn resize_draw_applies_event_dimensions_without_querying_backend_size() {+ let mut terminal =+ Terminal::with_options(CaptureBackend::new(/*width*/ 12, /*height*/ 4))+ .expect("terminal");+ let mut snapshots = Vec::new();++ for width in [12, 8] {+ let size = Size::new(width, /*height*/ 4);+ let area = Rect::new(/*x*/ 0, /*y*/ 0, size.width, size.height);+ terminal.set_viewport_area(area);+ terminal+ .draw_with_size(size, |frame| {+ Paragraph::new("alpha beta")+ .wrap(Wrap { trim: false })+ .render(area, frame.buffer_mut());+ })+ .expect("draw resized frame");++ let rendered = (0..size.height)+ .map(|y| {+ (0..size.width)+ .map(|x| terminal.previous_buffer()[(x, y)].symbol())+ .collect::<String>()+ .trim_end()+ .to_string()+ })+ .collect::<Vec<_>>()+ .join("\n");+ snapshots.push(rendered.trim_end().to_string());+ }++ assert_eq!(terminal.backend().size_call_count.get(), 1);+ assert_eq!(+ terminal.last_known_screen_size,+ Size::new(/*width*/ 8, /*height*/ 4)+ );+ assert_snapshot!(snapshots.join("\n\n"), @r"+ alpha beta++ alpha+ beta+ ");+ }+#[test]fn diff_buffers_does_not_emit_clear_to_end_for_full_width_row() {let area = Rect::new(0, 0, 3, 2);diff --git a/codex-rs/tui/src/cwd_prompt.rs b/codex-rs/tui/src/cwd_prompt.rsindex 3af493a14e..1083a99ae1 100644--- a/codex-rs/tui/src/cwd_prompt.rs+++ b/codex-rs/tui/src/cwd_prompt.rs@@ -129,10 +129,11 @@ pub(crate) async fn run_cwd_selection_prompt(while !screen.is_done() {if let Some(event) = events.next().await {+ tui.screen_size_for_event(&event)?;match event {TuiEvent::Key(key_event) => screen.handle_key(key_event),TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {tui.draw(u16::MAX, |frame| {frame.render_widget_ref(&screen, frame.area());})?;diff --git a/codex-rs/tui/src/external_agent_config_migration/mod.rs b/codex-rs/tui/src/external_agent_config_migration/mod.rsindex ff6c344b8d..41d1f1de5f 100644--- a/codex-rs/tui/src/external_agent_config_migration/mod.rs+++ b/codex-rs/tui/src/external_agent_config_migration/mod.rs@@ -101,10 +101,11 @@ pub(crate) async fn run_external_agent_config_migration_prompt(while !screen.is_done() {if let Some(event) = events.next().await {+ let _ = tui.screen_size_for_event(&event);match event {TuiEvent::Key(key_event) => screen.handle_key(key_event),TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {let _ = tui.draw(u16::MAX, |frame| {frame.render_widget_ref(&screen, frame.area());});diff --git a/codex-rs/tui/src/external_agent_config_migration/source.rs b/codex-rs/tui/src/external_agent_config_migration/source.rsindex 92e64a2bf3..12197c8fbc 100644--- a/codex-rs/tui/src/external_agent_config_migration/source.rs+++ b/codex-rs/tui/src/external_agent_config_migration/source.rs@@ -58,10 +58,11 @@ pub(crate) async fn run_external_agent_config_source_prompt(while !screen.is_done() {if let Some(event) = events.next().await {+ let _ = tui.screen_size_for_event(&event);match event {TuiEvent::Key(key_event) => screen.handle_key(key_event),TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {let _ = tui.draw(u16::MAX, |frame| {frame.render_widget_ref(&screen, frame.area());});diff --git a/codex-rs/tui/src/model_migration.rs b/codex-rs/tui/src/model_migration.rsindex c307abb78f..afaa2245f5 100644--- a/codex-rs/tui/src/model_migration.rs+++ b/codex-rs/tui/src/model_migration.rs@@ -150,10 +150,11 @@ pub(crate) async fn run_model_migration_prompt(while !screen.is_done() {if let Some(event) = events.next().await {+ let _ = alt.tui.screen_size_for_event(&event);match event {TuiEvent::Key(key_event) => screen.handle_key(key_event),TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {let _ = alt.tui.draw(u16::MAX, |frame| {frame.render_widget_ref(&screen, frame.area());});diff --git a/codex-rs/tui/src/onboarding/onboarding_screen.rs b/codex-rs/tui/src/onboarding/onboarding_screen.rsindex 0236d06894..af151409b6 100644--- a/codex-rs/tui/src/onboarding/onboarding_screen.rs+++ b/codex-rs/tui/src/onboarding/onboarding_screen.rs@@ -495,6 +495,7 @@ pub(crate) async fn run_onboarding_app(tokio::select! {event = tui_events.next() => {if let Some(event) = event {+ tui.screen_size_for_event(&event)?;match event {TuiEvent::Key(key_event) => {onboarding_screen.handle_key_event(key_event);@@ -509,7 +510,7 @@ pub(crate) async fn run_onboarding_app(TuiEvent::Paste(text) => {onboarding_screen.handle_paste(text);}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {if !did_full_clear_after_success&& onboarding_screen.steps.iter().any(|step| {if let Step::Auth(w) = step {diff --git a/codex-rs/tui/src/pager_overlay.rs b/codex-rs/tui/src/pager_overlay.rsindex 8920bc2715..b29fe1e760 100644--- a/codex-rs/tui/src/pager_overlay.rs+++ b/codex-rs/tui/src/pager_overlay.rs@@ -799,7 +799,7 @@ impl TranscriptOverlay {}other => self.view.handle_key_event(tui, other),},- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {tui.draw(u16::MAX, |frame| {self.render(frame.area(), frame.buffer);})?;@@ -897,7 +897,7 @@ impl StaticOverlay {}other => self.view.handle_key_event(tui, other),},- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {tui.draw(u16::MAX, |frame| {self.render(frame.area(), frame.buffer);})?;diff --git a/codex-rs/tui/src/resume_picker.rs b/codex-rs/tui/src/resume_picker.rsindex 1131ce9509..2203929988 100644--- a/codex-rs/tui/src/resume_picker.rs+++ b/codex-rs/tui/src/resume_picker.rs@@ -50,6 +50,7 @@ use crossterm::event::KeyModifiers;use ratatui::layout::Constraint;use ratatui::layout::Layout;use ratatui::layout::Rect;+use ratatui::layout::Size;use ratatui::style::Color;use ratatui::style::Style;use ratatui::style::Styled as _;@@ -480,6 +481,7 @@ async fn run_session_picker_with_loader(loop {tokio::select! {Some(ev) = tui_events.next() => {+ let screen_size = alt.tui.screen_size_for_event(&ev)?;if state.overlay.is_some() {state.handle_overlay_event(alt.tui, ev)?;continue;@@ -496,14 +498,13 @@ async fn run_session_picker_with_loader(TuiEvent::Paste(pasted) => {state.handle_paste(pasted);}- TuiEvent::Draw | TuiEvent::Resize => {- if let Ok(size) = alt.tui.terminal.size() {- let list_height =- size.height.saturating_sub(PICKER_CHROME_HEIGHT) as usize;- state.update_viewport(list_height, list_viewport_width(size.width));- state.ensure_minimum_rows_for_view(list_height);- }- draw_picker(alt.tui, &state)?;+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {+ let list_width = list_viewport_width(screen_size.width);+ let list_height =+ usize::from(screen_size.height.saturating_sub(PICKER_CHROME_HEIGHT));+ state.update_viewport(list_height, list_width);+ state.ensure_minimum_rows_for_view(list_height);+ draw_picker(alt.tui, &state, screen_size)?;if state.note_transcript_loading_frame_drawn() {state.open_pending_transcript_if_ready();}@@ -1876,10 +1877,9 @@ fn parse_timestamp_str(ts: &str) -> Option<DateTime<Utc>> {.ok()}-fn draw_picker(tui: &mut Tui, state: &PickerState) -> std::io::Result<()> {+fn draw_picker(tui: &mut Tui, state: &PickerState, screen_size: Size) -> std::io::Result<()> {// Render full-screen overlay- let height = tui.terminal.size()?.height;- tui.draw(height, |frame| {+ tui.draw(screen_size.height, |frame| {let area = frame.area();let [header, _header_gap, search, _search_gap, list, footer] = Layout::vertical([Constraint::Length(1),diff --git a/codex-rs/tui/src/startup_hooks_review.rs b/codex-rs/tui/src/startup_hooks_review.rsindex f53947e15f..3cec4d0cb9 100644--- a/codex-rs/tui/src/startup_hooks_review.rs+++ b/codex-rs/tui/src/startup_hooks_review.rs@@ -107,6 +107,7 @@ async fn run_startup_hooks_review_app(let Some(event) = tui_events.next().await else {return Ok(StartupHooksReviewOutcome::Continue);};+ tui.screen_size_for_event(&event)?;match event {TuiEvent::Key(key_event) => {if matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat) {@@ -167,7 +168,7 @@ async fn run_startup_hooks_review_app(}}TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => draw_view(tui, &view)?,+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => draw_view(tui, &view)?,}}}diff --git a/codex-rs/tui/src/tui.rs b/codex-rs/tui/src/tui.rsindex fb0e10dd25..51a8b17a5a 100644--- a/codex-rs/tui/src/tui.rs+++ b/codex-rs/tui/src/tui.rs@@ -35,6 +35,7 @@ use ratatui::crossterm::terminal::enable_raw_mode;use ratatui::layout::Offset;use ratatui::layout::Position;use ratatui::layout::Rect;+use ratatui::layout::Size;use ratatui::text::Line;use tokio::sync::broadcast;use tokio_stream::Stream;@@ -52,6 +53,7 @@ use crate::tui::event_stream::EventBroker;use crate::tui::event_stream::TuiEventStream;#[cfg(unix)]use crate::tui::job_control::SuspendContext;+use crate::tui::screen_size::ScreenSizePolicy;use codex_config::types::NotificationCondition;use codex_config::types::NotificationMethod;@@ -61,6 +63,7 @@ mod frame_requester;#[cfg(unix)]mod job_control;mod keyboard_modes;+mod screen_size;mod terminal_stderr;#[cfg(test)]pub(crate) mod test_support;@@ -548,13 +551,18 @@ pub enum TuiEvent {Key(KeyEvent),/// A bracketed paste payload normalized by the app layer before it reaches the composer.Paste(String),- /// A terminal size notification that should be handled as resize-sensitive draw work.+ /// A terminal size notification and its reported dimensions.////// Resize is separate from `Draw` so the app can run feature-gated pre-render logic without/// changing the default draw path for scheduled frames.- Resize,+ Resize(Size),/// A scheduled repaint that does not necessarily correspond to a terminal size change.Draw,+ /// The first repaint after returning from process suspension.+ ///+ /// The app refreshes terminal geometry for this draw because resize events are not delivered+ /// while the process is suspended.+ Resume,}pub struct Tui {@@ -563,6 +571,7 @@ pub struct Tui {event_broker: Arc<EventBroker>,pub(crate) terminal: Terminal,pending_history_lines: Vec<PendingHistoryLines>,+ screen_size: ScreenSizePolicy,ambient_pet_image_state: crate::pets::PetImageRenderState,pet_picker_preview_image_state: crate::pets::PetImageRenderState,alt_saved_viewport: Option<ratatui::layout::Rect>,@@ -620,6 +629,7 @@ impl Tui {event_broker: Arc::new(EventBroker::new()),terminal,pending_history_lines: vec![],+ screen_size: ScreenSizePolicy::default(),ambient_pet_image_state: crate::pets::PetImageRenderState::default(),pet_picker_preview_image_state: crate::pets::PetImageRenderState::default(),alt_saved_viewport: None,@@ -715,6 +725,7 @@ impl Tui {}self.resume_events();+ self.schedule_screen_size_recheck(Duration::ZERO);output}@@ -775,6 +786,7 @@ impl Tui {let _ = execute!(self.terminal.backend_mut(), EnableAlternateScroll);if let Ok(size) = self.terminal.size() {self.alt_saved_viewport = Some(self.terminal.viewport_area);+ self.terminal.resize(size)?;self.terminal.set_viewport_area(ratatui::layout::Rect::new(0,0,@@ -848,29 +860,29 @@ impl Tui {fn update_inline_viewport_for_resize_reflow(terminal: &mut Terminal,height: u16,+ screen_size: Size,) -> Result<bool> {- let size = terminal.size()?;- let terminal_height_shrank = size.height < terminal.last_known_screen_size.height;- let terminal_height_grew = size.height > terminal.last_known_screen_size.height;+ let terminal_height_shrank = screen_size.height < terminal.last_known_screen_size.height;+ let terminal_height_grew = screen_size.height > terminal.last_known_screen_size.height;let viewport_was_bottom_aligned =terminal.viewport_area.bottom() == terminal.last_known_screen_size.height;let previous_area = terminal.viewport_area;let mut area = terminal.viewport_area;- area.height = height.min(size.height);- area.width = size.width;+ area.height = height.min(screen_size.height);+ area.width = screen_size.width;let mut needs_full_repaint = false;- if area.bottom() > size.height {- let scroll_by = area.bottom() - size.height;+ if area.bottom() > screen_size.height {+ let scroll_by = area.bottom() - screen_size.height;if !terminal_height_shrank {terminal.backend_mut().scroll_region_up(0..area.top(), scroll_by)?;}- area.y = size.height - area.height;+ area.y = screen_size.height - area.height;} else if terminal_height_grew && viewport_was_bottom_aligned {- area.y = size.height - area.height;+ area.y = screen_size.height - area.height;}if area != terminal.viewport_area {@@ -915,6 +927,7 @@ impl Tui {height: u16,draw_fn: impl FnOnce(&mut custom_terminal::Frame),) -> Result<()> {+ let screen_size = self.take_event_screen_size()?;// If we are resuming from ^Z, we need to prepare the resume action now so we can apply it// in the synchronized update.#[cfg(unix)]@@ -924,14 +937,14 @@ impl Tui {// Precompute any viewport updates that need a cursor-position query before entering// the synchronized update, to avoid racing with the event reader.- let mut pending_viewport_area = self.pending_viewport_area()?;+ let mut pending_viewport_area = self.pending_viewport_area(screen_size)?;ensure_virtual_terminal_processing()?;stdout().sync_update(|_| {#[cfg(unix)]if let Some(prepared) = prepared_resume.take() {- prepared.apply(&mut self.terminal)?;+ prepared.apply(&mut self.terminal, screen_size)?;}let terminal = &mut self.terminal;@@ -940,17 +953,15 @@ impl Tui {terminal.clear()?;}- let size = terminal.size()?;-let mut area = terminal.viewport_area;- area.height = height.min(size.height);- area.width = size.width;+ area.height = height.min(screen_size.height);+ area.width = screen_size.width;// If the viewport has expanded, scroll everything else up to make room.- if area.bottom() > size.height {+ if area.bottom() > screen_size.height {terminal.backend_mut()- .scroll_region_up(0..area.top(), area.bottom() - size.height)?;- area.y = size.height - area.height;+ .scroll_region_up(0..area.top(), area.bottom() - screen_size.height)?;+ area.y = screen_size.height - area.height;}if area != terminal.viewport_area {// On startup, the old viewport can still be empty. Clear from the@@ -979,7 +990,7 @@ impl Tui {self.suspend_context.set_cursor_y(inline_area_bottom);}- terminal.draw(|frame| {+ terminal.draw_with_size(screen_size, |frame| {draw_fn(frame);})})?@@ -1049,6 +1060,7 @@ impl Tui {pub fn draw_with_resize_reflow(&mut self,height: u16,+ screen_size: Size,draw_fn: impl FnOnce(&mut custom_terminal::Frame),) -> Result<()> {// If we are resuming from ^Z, we need to prepare the resume action now so we can apply it@@ -1063,12 +1075,12 @@ impl Tui {stdout().sync_update(|_| {#[cfg(unix)]if let Some(prepared) = prepared_resume.take() {- prepared.apply(&mut self.terminal)?;+ prepared.apply(&mut self.terminal, screen_size)?;}let terminal = &mut self.terminal;let needs_full_repaint =- Self::update_inline_viewport_for_resize_reflow(terminal, height)?;+ Self::update_inline_viewport_for_resize_reflow(terminal, height, screen_size)?;Self::flush_pending_history_lines(terminal,&mut self.pending_history_lines,@@ -1093,15 +1105,14 @@ impl Tui {self.suspend_context.set_cursor_y(inline_area_bottom);}- terminal.draw(|frame| {+ terminal.draw_with_size(screen_size, |frame| {draw_fn(frame);})})?}- fn pending_viewport_area(&mut self) -> Result<Option<Rect>> {+ fn pending_viewport_area(&mut self, screen_size: Size) -> Result<Option<Rect>> {let terminal = &mut self.terminal;- let screen_size = terminal.size()?;let last_known_screen_size = terminal.last_known_screen_size;if screen_size != last_known_screen_size&& let Ok(cursor_pos) = terminal.get_cursor_position()diff --git a/codex-rs/tui/src/tui/event_stream.rs b/codex-rs/tui/src/tui/event_stream.rsindex da719463f3..da972c87e7 100644--- a/codex-rs/tui/src/tui/event_stream.rs+++ b/codex-rs/tui/src/tui/event_stream.rs@@ -263,11 +263,13 @@ impl<S: EventSource + Default + Unpin> TuiEventStream<S> {"failed to suspend TUI process");}- return Some(TuiEvent::Draw);+ return Some(TuiEvent::Resume);}Some(TuiEvent::Key(key_event))}- Event::Resize(_, _) => Some(TuiEvent::Resize),+ Event::Resize(width, height) => {+ Some(TuiEvent::Resize(ratatui::layout::Size { width, height }))+ }Event::Paste(pasted) => Some(TuiEvent::Paste(pasted)),Event::FocusGained => {self.terminal_focused.store(true, Ordering::Relaxed);@@ -513,7 +515,13 @@ mod tests {handle.send(Ok(Event::Resize(80, 24)));let next = stream.next().await;- assert!(matches!(next, Some(TuiEvent::Resize)));+ assert!(matches!(+ next,+ Some(TuiEvent::Resize(ratatui::layout::Size {+ width: 80,+ height: 24+ }))+ ));}#[tokio::test(flavor = "current_thread")]diff --git a/codex-rs/tui/src/tui/job_control.rs b/codex-rs/tui/src/tui/job_control.rsindex bc46a0a895..2db1fc04f5 100644--- a/codex-rs/tui/src/tui/job_control.rs+++ b/codex-rs/tui/src/tui/job_control.rs@@ -14,6 +14,7 @@ use crossterm::terminal::EnterAlternateScreen;use crossterm::terminal::LeaveAlternateScreen;use ratatui::crossterm::execute;use ratatui::layout::Rect;+use ratatui::layout::Size;use crate::key_hint;@@ -178,7 +179,7 @@ pub(crate) enum PreparedResumeAction {}impl PreparedResumeAction {- pub(crate) fn apply(self, terminal: &mut Terminal) -> Result<()> {+ pub(crate) fn apply(self, terminal: &mut Terminal, screen_size: Size) -> Result<()> {match self {PreparedResumeAction::RealignViewport(area) => {terminal.set_viewport_area(area);@@ -187,10 +188,8 @@ impl PreparedResumeAction {execute!(terminal.backend_mut(), EnterAlternateScreen)?;// Enable "alternate scroll" so terminals may translate wheel to arrowsexecute!(terminal.backend_mut(), EnableAlternateScroll)?;- if let Ok(size) = terminal.size() {- terminal.set_viewport_area(Rect::new(0, 0, size.width, size.height));- terminal.clear()?;- }+ terminal.set_viewport_area(Rect::from(screen_size));+ terminal.clear()?;}}Ok(())diff --git a/codex-rs/tui/src/tui/screen_size.rs b/codex-rs/tui/src/tui/screen_size.rsnew file mode 100644index 0000000000..c08709cc77--- /dev/null+++ b/codex-rs/tui/src/tui/screen_size.rs@@ -0,0 +1,78 @@+//! Terminal geometry policy shared by the main app and standalone screens.++use std::io;+use std::time::Duration;+use std::time::Instant;++use ratatui::layout::Size;++use super::Tui;+use super::TuiEvent;+use crate::transcript_reflow::TRANSCRIPT_REFLOW_DEBOUNCE;++#[derive(Default)]+pub(super) struct ScreenSizePolicy {+ pending_recheck_at: Option<Instant>,+ pending_draw_size: Option<Size>,+ deferred_size: Option<Size>,+}++impl Tui {+ /// Resolve event geometry while avoiding backend queries on ordinary repaint frames.+ pub(crate) fn screen_size_for_event(&mut self, event: &TuiEvent) -> io::Result<Size> {+ if matches!(event, TuiEvent::Resize(_)) {+ self.schedule_screen_size_recheck(TRANSCRIPT_REFLOW_DEBOUNCE);+ } else if matches!(event, TuiEvent::Draw)+ && let Some(deadline) = self.screen_size.pending_recheck_at+ {+ let now = Instant::now();+ if now < deadline {+ self.frame_requester.schedule_frame_in(deadline - now);+ } else {+ return self.screen_size_for_event(&TuiEvent::Resume);+ }+ }++ let cached = self.terminal.last_known_screen_size;+ let size = match event {+ TuiEvent::Resize(size) => {+ self.screen_size.deferred_size = None;+ *size+ }+ TuiEvent::Resume => {+ self.screen_size.pending_recheck_at = None;+ self.screen_size.deferred_size = None;+ self.terminal.size()?+ }+ TuiEvent::Draw => self.screen_size.deferred_size.take().unwrap_or(cached),+ TuiEvent::Key(_) | TuiEvent::Paste(_) => cached,+ };+ self.screen_size.pending_draw_size =+ (!matches!(event, TuiEvent::Key(_) | TuiEvent::Paste(_))).then_some(size);+ Ok(size)+ }++ /// Schedule one backend sample after a resize, reflow, or external program.+ pub(crate) fn schedule_screen_size_recheck(&mut self, delay: Duration) {+ self.screen_size.pending_recheck_at = Some(Instant::now() + delay);+ self.frame_requester.schedule_frame_in(delay);+ }++ pub(crate) fn defer_screen_size(&mut self, size: Size) {+ self.screen_size.deferred_size = Some(size);+ }++ pub(super) fn take_event_screen_size(&mut self) -> io::Result<Size> {+ if let Some(size) = self.screen_size.pending_draw_size.take() {+ return Ok(size);+ }+ let size = self.terminal.size()?;+ self.screen_size.pending_recheck_at = None;+ self.screen_size.deferred_size = None;+ Ok(size)+ }+}++#[cfg(test)]+#[path = "screen_size_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/tui/screen_size_tests.rs b/codex-rs/tui/src/tui/screen_size_tests.rsnew file mode 100644index 0000000000..248f69b0d1--- /dev/null+++ b/codex-rs/tui/src/tui/screen_size_tests.rs@@ -0,0 +1,65 @@+use std::time::Duration;++use pretty_assertions::assert_eq;+use ratatui::layout::Size;++use crate::tui::TuiEvent;++#[tokio::test]+async fn draw_size_policy_refreshes_only_after_resume() {+ let mut tui = crate::tui::test_support::make_test_tui().expect("test tui");+ let cached = Size::new(/*width*/ 120, /*height*/ 40);+ let resumed = tui.terminal.size().expect("backend size");+ tui.terminal.last_known_screen_size = cached;+ let resized = Size::new(/*width*/ 100, /*height*/ 30);+ for (event, expected) in [+ (TuiEvent::Draw, cached),+ (TuiEvent::Resume, resumed),+ (TuiEvent::Resize(resized), resized),+ (TuiEvent::Paste(String::new()), cached),+ (TuiEvent::Draw, resized),+ (TuiEvent::Paste(String::new()), cached),+ ] {+ assert_eq!(tui.screen_size_for_event(&event).expect("size"), expected);+ if matches!(event, TuiEvent::Resize(_)) {+ tui.defer_screen_size(resized);+ }+ }+ assert_eq!(tui.take_event_screen_size().expect("size"), resumed);+ assert!(tui.screen_size.pending_recheck_at.is_none());+}++#[tokio::test]+async fn standalone_resize_draw_rechecks_settled_screen_size_once() {+ let mut tui = crate::tui::test_support::make_test_tui().expect("test tui");+ let resize_size = Size::new(/*width*/ 120, /*height*/ 40);++ tui.screen_size_for_event(&TuiEvent::Resize(resize_size))+ .expect("resolve resize");+ tui.terminal.resize(resize_size).expect("apply resize");+ assert_eq!(+ tui.screen_size_for_event(&TuiEvent::Draw)+ .expect("resolve early draw"),+ resize_size+ );++ tui.schedule_screen_size_recheck(Duration::ZERO);+ assert_eq!(+ tui.screen_size_for_event(&TuiEvent::Draw)+ .expect("resolve settled draw"),+ tui.terminal.size().expect("terminal size")+ );+ assert!(tui.screen_size.pending_recheck_at.is_none());+}++#[tokio::test]+async fn entering_alternate_screen_updates_cached_screen_size() {+ let mut tui = crate::tui::test_support::make_test_tui().expect("test tui");+ let screen_size = tui.terminal.size().expect("terminal size");+ tui.terminal.last_known_screen_size = Size::new(/*width*/ 120, /*height*/ 40);++ tui.enter_alt_screen().expect("enter alternate screen");++ assert_eq!(tui.terminal.last_known_screen_size, screen_size);+ tui.leave_alt_screen().expect("leave alternate screen");+}diff --git a/codex-rs/tui/src/update_prompt.rs b/codex-rs/tui/src/update_prompt.rsindex a4e0f38ffe..de8bfb0dca 100644--- a/codex-rs/tui/src/update_prompt.rs+++ b/codex-rs/tui/src/update_prompt.rs@@ -55,10 +55,11 @@ pub(crate) async fn run_update_prompt_if_needed(while !screen.is_done() {if let Some(event) = events.next().await {+ tui.screen_size_for_event(&event)?;match event {TuiEvent::Key(key_event) => screen.handle_key(key_event),TuiEvent::Paste(_) => {}- TuiEvent::Draw | TuiEvent::Resize => {+ TuiEvent::Draw | TuiEvent::Resume | TuiEvent::Resize(_) => {tui.draw(u16::MAX, |frame| {frame.render_widget_ref(&screen, frame.area());})?;