Merge remote-tracking branch 'origin/main' into easong/mcp-CLI-interface

codex-rs/Cargo.lock

@@ -1005,6 +1005,7 @@ dependencies = [
  "tui-markdown",
  "unicode-segmentation",
  "unicode-width 0.1.14",
+ "url",
  "uuid",
  "vt100",
 ]

codex-rs/core/prompt.md

@@ -134,14 +134,6 @@ If completing the user's task requires writing or modifying files, your code and
 - Do not use one-letter variable names unless explicitly requested.
 - NEVER output inline citations like "【F:README.md†L5-L14】" in your outputs. The CLI is not able to render these so they will just be broken in the UI. Instead, if you output valid filepaths, users will be able to click on them to open the files in their editor.
 
-## Testing your work
-
-If the codebase has tests or the ability to build or run, you should use them to verify that your work is complete. Generally, your testing philosophy should be to start as specific as possible to the code you changed so that you can catch issues efficiently, then make your way to broader tests as you build confidence. If there's no test for the code you changed, and if the adjacent patterns in the codebases show that there's a logical place for you to add a test, you may do so. However, do not add tests to codebases with no tests, or where the patterns don't indicate so.
-
-Once you're confident in correctness, use formatting commands to ensure that your code is well formatted. These commands can take time so you should run them on as precise a target as possible. If there are issues you can iterate up to 3 times to get formatting right, but if you still can't manage it's better to save the user time and present them a correct solution where you call out the formatting in your final message. If the codebase does not have a formatter configured, do not add one.
-
-For all of testing, running, building, and formatting, do not attempt to fix unrelated bugs. It is not your responsibility to fix them. (You may mention them to the user in your final message though.)
-
 ## Sandbox and approvals
 
 The Codex CLI harness supports several different sandboxing, and approval configurations that the user can choose from.
@@ -177,6 +169,22 @@ Note that when sandboxing is set to read-only, you'll need to request approval f
 
 You will be told what filesystem sandboxing, network sandboxing, and approval mode are active in a developer or user message. If you are not told about this, assume that you are running with workspace-write, network sandboxing ON, and approval on-failure.
 
+## Validating your work
+
+If the codebase has tests or the ability to build or run, consider using them to verify that your work is complete. 
+
+When testing, your philosophy should be to start as specific as possible to the code you changed so that you can catch issues efficiently, then make your way to broader tests as you build confidence. If there's no test for the code you changed, and if the adjacent patterns in the codebases show that there's a logical place for you to add a test, you may do so. However, do not add tests to codebases with no tests.
+
+Similarly, once you're confident in correctness, you can suggest or use formatting commands to ensure that your code is well formatted. If there are issues you can iterate up to 3 times to get formatting right, but if you still can't manage it's better to save the user time and present them a correct solution where you call out the formatting in your final message. If the codebase does not have a formatter configured, do not add one.
+
+For all of testing, running, building, and formatting, do not attempt to fix unrelated bugs. It is not your responsibility to fix them. (You may mention them to the user in your final message though.)
+
+Be mindful of whether to run validation commands proactively. In the absence of behavioral guidance:
+
+- When running in non-interactive approval modes like **never** or **on-failure**, proactively run tests, lint and do whatever you need to ensure you've completed the task.
+- When working in interactive approval modes like **untrusted**, or **on-request**, hold off on running tests or lint commands until the user is ready for you to finalize your output, because these commands take time to run and slow down iteration. Instead suggest what you want to do next, and let the user confirm first.
+- When working on test-related tasks, such as adding tests, fixing tests, or reproducing a bug to verify behavior, you may proactively run tests regardless of approval mode. Use your judgement to decide whether this is a test-related task.
+
 ## Ambition vs. precision
 
 For tasks that have no prior context (i.e. the user is starting something brand new), you should feel free to be ambitious and demonstrate creativity with your implementation.

codex-rs/core/src/client.rs

@@ -1,6 +1,5 @@
 use std::io::BufRead;
 use std::path::Path;
-use std::sync::OnceLock;
 use std::time::Duration;
 
 use bytes::Bytes;
@@ -8,7 +7,6 @@ use codex_login::AuthManager;
 use codex_login::AuthMode;
 use eventsource_stream::Eventsource;
 use futures::prelude::*;
-use regex_lite::Regex;
 use reqwest::StatusCode;
 use serde::Deserialize;
 use serde::Serialize;
@@ -37,6 +35,7 @@ use crate::flags::CODEX_RS_SSE_FIXTURE;
 use crate::model_family::ModelFamily;
 use crate::model_provider_info::ModelProviderInfo;
 use crate::model_provider_info::WireApi;
+use crate::openai_model_info::get_model_info;
 use crate::openai_tools::create_tools_json_for_responses_api;
 use crate::protocol::TokenUsage;
 use crate::user_agent::get_codex_user_agent;
@@ -54,8 +53,11 @@ struct ErrorResponse {
 #[derive(Debug, Deserialize)]
 struct Error {
     r#type: Option<String>,
-    code: Option<String>,
     message: Option<String>,
+
+    // Optional fields available on "usage_limit_reached" and "usage_not_included" errors
+    plan_type: Option<String>,
+    resets_in_seconds: Option<u64>,
 }
 
 #[derive(Debug, Clone)]
@@ -89,6 +91,12 @@ impl ModelClient {
         }
     }
 
+    pub fn get_model_context_window(&self) -> Option<u64> {
+        self.config
+            .model_context_window
+            .or_else(|| get_model_info(&self.config.model_family).map(|info| info.context_window))
+    }
+
     /// Dispatches to either the Responses or Chat implementation depending on
     /// the provider config.  Public callers always invoke `stream()` – the
     /// specialised helpers are private to avoid accidental misuse.
@@ -142,9 +150,12 @@ impl ModelClient {
         }
 
         let auth_manager = self.auth_manager.clone();
-        let auth = auth_manager.as_ref().and_then(|m| m.auth());
 
-        let auth_mode = auth.as_ref().map(|a| a.mode);
+        let auth_mode = auth_manager
+            .as_ref()
+            .and_then(|m| m.auth())
+            .as_ref()
+            .map(|a| a.mode);
 
         let store = prompt.store && auth_mode != Some(AuthMode::ChatGPT);
 
@@ -211,15 +222,18 @@ impl ModelClient {
         let mut attempt = 0;
         let max_retries = self.provider.request_max_retries();
 
-        trace!(
-            "POST to {}: {}",
-            self.provider.get_full_url(&auth),
-            serde_json::to_string(&payload)?
-        );
-
         loop {
             attempt += 1;
 
+            // Always fetch the latest auth in case a prior attempt refreshed the token.
+            let auth = auth_manager.as_ref().and_then(|m| m.auth());
+
+            trace!(
+                "POST to {}: {}",
+                self.provider.get_full_url(&auth),
+                serde_json::to_string(&payload)?
+            );
+
             let mut req_builder = self
                 .provider
                 .create_request_builder(&self.client, &auth)
@@ -303,19 +317,20 @@ impl ModelClient {
 
                     if status == StatusCode::TOO_MANY_REQUESTS {
                         let body = res.json::<ErrorResponse>().await.ok();
-                        if let Some(ErrorResponse {
-                            error:
-                                Error {
-                                    r#type: Some(error_type),
-                                    ..
-                                },
-                        }) = body
-                        {
-                            if error_type == "usage_limit_reached" {
+                        if let Some(ErrorResponse { error }) = body {
+                            if error.r#type.as_deref() == Some("usage_limit_reached") {
+                                // Prefer the plan_type provided in the error message if present
+                                // because it's more up to date than the one encoded in the auth
+                                // token.
+                                let plan_type = error
+                                    .plan_type
+                                    .or_else(|| auth.and_then(|a| a.get_plan_type()));
+                                let resets_in_seconds = error.resets_in_seconds;
                                 return Err(CodexErr::UsageLimitReached(UsageLimitReachedError {
-                                    plan_type: auth.and_then(|a| a.get_plan_type()),
+                                    plan_type,
+                                    resets_in_seconds,
                                 }));
-                            } else if error_type == "usage_not_included" {
+                            } else if error.r#type.as_deref() == Some("usage_not_included") {
                                 return Err(CodexErr::UsageNotIncluded);
                             }
                         }
@@ -563,9 +578,8 @@ async fn process_sse<S>(
                     if let Some(error) = error {
                         match serde_json::from_value::<Error>(error.clone()) {
                             Ok(error) => {
-                                let delay = try_parse_retry_after(&error);
                                 let message = error.message.unwrap_or_default();
-                                response_error = Some(CodexErr::Stream(message, delay));
+                                response_error = Some(CodexErr::Stream(message, None));
                             }
                             Err(e) => {
                                 debug!("failed to parse ErrorResponse: {e}");
@@ -653,40 +667,6 @@ async fn stream_from_fixture(
     Ok(ResponseStream { rx_event })
 }
 
-fn rate_limit_regex() -> &'static Regex {
-    static RE: OnceLock<Regex> = OnceLock::new();
-
-    #[expect(clippy::unwrap_used)]
-    RE.get_or_init(|| Regex::new(r"Please try again in (\d+(?:\.\d+)?)(s|ms)").unwrap())
-}
-
-fn try_parse_retry_after(err: &Error) -> Option<Duration> {
-    if err.code != Some("rate_limit_exceeded".to_string()) {
-        return None;
-    }
-
-    // parse the Please try again in 1.898s format using regex
-    let re = rate_limit_regex();
-    if let Some(message) = &err.message
-        && let Some(captures) = re.captures(message)
-    {
-        let seconds = captures.get(1);
-        let unit = captures.get(2);
-
-        if let (Some(value), Some(unit)) = (seconds, unit) {
-            let value = value.as_str().parse::<f64>().ok()?;
-            let unit = unit.as_str();
-
-            if unit == "s" {
-                return Some(Duration::from_secs_f64(value));
-            } else if unit == "ms" {
-                return Some(Duration::from_millis(value as u64));
-            }
-        }
-    }
-    None
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -907,7 +887,7 @@ mod tests {
                     msg,
                     "Rate limit reached for gpt-5 in organization org-AAA on tokens per min (TPM): Limit 30000, Used 22999, Requested 12528. Please try again in 11.054s. Visit https://platform.openai.com/account/rate-limits to learn more."
                 );
-                assert_eq!(*delay, Some(Duration::from_secs_f64(11.054)));
+                assert_eq!(*delay, None);
             }
             other => panic!("unexpected second event: {other:?}"),
         }
@@ -1011,27 +991,4 @@ mod tests {
             );
         }
     }
-
-    #[test]
-    fn test_try_parse_retry_after() {
-        let err = Error {
-            r#type: None,
-            message: Some("Rate limit reached for gpt-5 in organization org- on tokens per min (TPM): Limit 1, Used 1, Requested 19304. Please try again in 28ms. Visit https://platform.openai.com/account/rate-limits to learn more.".to_string()),
-            code: Some("rate_limit_exceeded".to_string()),
-        };
-
-        let delay = try_parse_retry_after(&err);
-        assert_eq!(delay, Some(Duration::from_millis(28)));
-    }
-
-    #[test]
-    fn test_try_parse_retry_after_no_delay() {
-        let err = Error {
-            r#type: None,
-            message: Some("Rate limit reached for gpt-5 in organization <ORG> on tokens per min (TPM): Limit 30000, Used 6899, Requested 24050. Please try again in 1.898s. Visit https://platform.openai.com/account/rate-limits to learn more.".to_string()),
-            code: Some("rate_limit_exceeded".to_string()),
-        };
-        let delay = try_parse_retry_after(&err);
-        assert_eq!(delay, Some(Duration::from_secs_f64(1.898)));
-    }
 }

codex-rs/core/src/codex.rs

@@ -15,6 +15,7 @@ use codex_apply_patch::MaybeApplyPatchVerified;
 use codex_apply_patch::maybe_parse_apply_patch_verified;
 use codex_login::AuthManager;
 use codex_protocol::protocol::ConversationHistoryResponseEvent;
+use codex_protocol::protocol::TaskStartedEvent;
 use codex_protocol::protocol::TurnAbortReason;
 use codex_protocol::protocol::TurnAbortedEvent;
 use futures::prelude::*;
@@ -62,6 +63,7 @@ use crate::exec_env::create_env;
 use crate::mcp_connection_manager::McpConnectionManager;
 use crate::mcp_tool_call::handle_mcp_tool_call;
 use crate::model_family::find_family_for_model;
+use crate::openai_model_info::get_model_info;
 use crate::openai_tools::ApplyPatchToolArgs;
 use crate::openai_tools::ToolsConfig;
 use crate::openai_tools::ToolsConfigParams;
@@ -1079,6 +1081,9 @@ async fn submission_loop(
                 let mut updated_config = (*config).clone();
                 updated_config.model = effective_model.clone();
                 updated_config.model_family = effective_family.clone();
+                if let Some(model_info) = get_model_info(&effective_family) {
+                    updated_config.model_context_window = Some(model_info.context_window);
+                }
 
                 let client = ModelClient::new(
                     Arc::new(updated_config),
@@ -1152,6 +1157,7 @@ async fn submission_loop(
                 if let Err(items) = sess.inject_input(items) {
                     // Derive a fresh TurnContext for this turn using the provided overrides.
                     let provider = turn_context.client.get_provider();
+                    let auth_manager = turn_context.client.get_auth_manager();
 
                     // Derive a model family for the requested model; fall back to the session's.
                     let model_family = find_family_for_model(&model)
@@ -1161,12 +1167,15 @@ async fn submission_loop(
                     let mut per_turn_config = (*config).clone();
                     per_turn_config.model = model.clone();
                     per_turn_config.model_family = model_family.clone();
+                    if let Some(model_info) = get_model_info(&model_family) {
+                        per_turn_config.model_context_window = Some(model_info.context_window);
+                    }
 
                     // Build a new client with per‑turn reasoning settings.
                     // Reuse the same provider and session id; auth defaults to env/API key.
                     let client = ModelClient::new(
                         Arc::new(per_turn_config),
-                        None,
+                        auth_manager,
                         provider,
                         effort,
                         summary,
@@ -1369,7 +1378,9 @@ async fn run_task(
     }
     let event = Event {
         id: sub_id.clone(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window: turn_context.client.get_model_context_window(),
+        }),
     };
     if sess.tx_event.send(event).await.is_err() {
         return;
@@ -1769,11 +1780,6 @@ async fn try_run_turn(
                 return Ok(output);
             }
             ResponseEvent::OutputTextDelta(delta) => {
-                {
-                    let mut st = sess.state.lock_unchecked();
-                    st.history.append_assistant_text(&delta);
-                }
-
                 let event = Event {
                     id: sub_id.to_string(),
                     msg: EventMsg::AgentMessageDelta(AgentMessageDeltaEvent { delta }),
@@ -1816,9 +1822,12 @@ async fn run_compact_task(
     input: Vec<InputItem>,
     compact_instructions: String,
 ) {
+    let model_context_window = turn_context.client.get_model_context_window();
     let start_event = Event {
         id: sub_id.clone(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window,
+        }),
     };
     if sess.tx_event.send(start_event).await.is_err() {
         return;
@@ -2454,11 +2463,15 @@ async fn handle_container_exec_with_params(
                 sandbox_type,
                 sandbox_policy: &turn_context.sandbox_policy,
                 codex_linux_sandbox_exe: &sess.codex_linux_sandbox_exe,
-                stdout_stream: Some(StdoutStream {
-                    sub_id: sub_id.clone(),
-                    call_id: call_id.clone(),
-                    tx_event: sess.tx_event.clone(),
-                }),
+                stdout_stream: if exec_command_context.apply_patch.is_some() {
+                    None
+                } else {
+                    Some(StdoutStream {
+                        sub_id: sub_id.clone(),
+                        call_id: call_id.clone(),
+                        tx_event: sess.tx_event.clone(),
+                    })
+                },
             },
         )
         .await;
@@ -2587,11 +2600,15 @@ async fn handle_sandbox_error(
                         sandbox_type: SandboxType::None,
                         sandbox_policy: &turn_context.sandbox_policy,
                         codex_linux_sandbox_exe: &sess.codex_linux_sandbox_exe,
-                        stdout_stream: Some(StdoutStream {
-                            sub_id: sub_id.clone(),
-                            call_id: call_id.clone(),
-                            tx_event: sess.tx_event.clone(),
-                        }),
+                        stdout_stream: if exec_command_context.apply_patch.is_some() {
+                            None
+                        } else {
+                            Some(StdoutStream {
+                                sub_id: sub_id.clone(),
+                                call_id: call_id.clone(),
+                                tx_event: sess.tx_event.clone(),
+                            })
+                        },
                     },
                 )
                 .await;

codex-rs/core/src/conversation_history.rs

@@ -28,49 +28,7 @@ impl ConversationHistory {
                 continue;
             }
 
-            // Merge adjacent assistant messages into a single history entry.
-            // This prevents duplicates when a partial assistant message was
-            // streamed into history earlier in the turn and the final full
-            // message is recorded at turn end.
-            match (&*item, self.items.last_mut()) {
-                (
-                    ResponseItem::Message {
-                        role: new_role,
-                        content: new_content,
-                        ..
-                    },
-                    Some(ResponseItem::Message {
-                        role: last_role,
-                        content: last_content,
-                        ..
-                    }),
-                ) if new_role == "assistant" && last_role == "assistant" => {
-                    append_text_content(last_content, new_content);
-                }
-                _ => {
-                    self.items.push(item.clone());
-                }
-            }
-        }
-    }
-
-    /// Append a text `delta` to the latest assistant message, creating a new
-    /// assistant entry if none exists yet (e.g. first delta for this turn).
-    pub(crate) fn append_assistant_text(&mut self, delta: &str) {
-        match self.items.last_mut() {
-            Some(ResponseItem::Message { role, content, .. }) if role == "assistant" => {
-                append_text_delta(content, delta);
-            }
-            _ => {
-                // Start a new assistant message with the delta.
-                self.items.push(ResponseItem::Message {
-                    id: None,
-                    role: "assistant".to_string(),
-                    content: vec![codex_protocol::models::ContentItem::OutputText {
-                        text: delta.to_string(),
-                    }],
-                });
-            }
+            self.items.push(item.clone());
         }
     }
 
@@ -118,34 +76,6 @@ fn is_api_message(message: &ResponseItem) -> bool {
     }
 }
 
-/// Helper to append the textual content from `src` into `dst` in place.
-fn append_text_content(
-    dst: &mut Vec<codex_protocol::models::ContentItem>,
-    src: &Vec<codex_protocol::models::ContentItem>,
-) {
-    for c in src {
-        if let codex_protocol::models::ContentItem::OutputText { text } = c {
-            append_text_delta(dst, text);
-        }
-    }
-}
-
-/// Append a single text delta to the last OutputText item in `content`, or
-/// push a new OutputText item if none exists.
-fn append_text_delta(content: &mut Vec<codex_protocol::models::ContentItem>, delta: &str) {
-    if let Some(codex_protocol::models::ContentItem::OutputText { text }) = content
-        .iter_mut()
-        .rev()
-        .find(|c| matches!(c, codex_protocol::models::ContentItem::OutputText { .. }))
-    {
-        text.push_str(delta);
-    } else {
-        content.push(codex_protocol::models::ContentItem::OutputText {
-            text: delta.to_string(),
-        });
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -171,49 +101,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn merges_adjacent_assistant_messages() {
-        let mut h = ConversationHistory::default();
-        let a1 = assistant_msg("Hello");
-        let a2 = assistant_msg(", world!");
-        h.record_items([&a1, &a2]);
-
-        let items = h.contents();
-        assert_eq!(
-            items,
-            vec![ResponseItem::Message {
-                id: None,
-                role: "assistant".to_string(),
-                content: vec![ContentItem::OutputText {
-                    text: "Hello, world!".to_string()
-                }]
-            }]
-        );
-    }
-
-    #[test]
-    fn append_assistant_text_creates_and_appends() {
-        let mut h = ConversationHistory::default();
-        h.append_assistant_text("Hello");
-        h.append_assistant_text(", world");
-
-        // Now record a final full assistant message and verify it merges.
-        let final_msg = assistant_msg("!");
-        h.record_items([&final_msg]);
-
-        let items = h.contents();
-        assert_eq!(
-            items,
-            vec![ResponseItem::Message {
-                id: None,
-                role: "assistant".to_string(),
-                content: vec![ContentItem::OutputText {
-                    text: "Hello, world!".to_string()
-                }]
-            }]
-        );
-    }
-
     #[test]
     fn filters_non_api_messages() {
         let mut h = ConversationHistory::default();

codex-rs/core/src/conversation_manager.rs

@@ -110,6 +110,10 @@ impl ConversationManager {
             .ok_or_else(|| CodexErr::ConversationNotFound(conversation_id))
     }
 
+    pub async fn remove_conversation(&self, conversation_id: Uuid) {
+        self.conversations.write().await.remove(&conversation_id);
+    }
+
     /// Fork an existing conversation by dropping the last `drop_last_messages`
     /// user/assistant messages from its transcript and starting a new
     /// conversation with identical configuration (unless overridden by the

codex-rs/core/src/error.rs

@@ -128,27 +128,70 @@ pub enum CodexErr {
 #[derive(Debug)]
 pub struct UsageLimitReachedError {
     pub plan_type: Option<String>,
+    pub resets_in_seconds: Option<u64>,
 }
 
 impl std::fmt::Display for UsageLimitReachedError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Base message differs slightly for legacy ChatGPT Plus plan users.
         if let Some(plan_type) = &self.plan_type
             && plan_type == "plus"
         {
             write!(
                 f,
-                "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing), or wait for limits to reset (every 5h and every week.)."
+                "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing) or try again"
             )?;
+            if let Some(secs) = self.resets_in_seconds {
+                let reset_duration = format_reset_duration(secs);
+                write!(f, " in {reset_duration}.")?;
+            } else {
+                write!(f, " later.")?;
+            }
         } else {
-            write!(
-                f,
-                "You've hit your usage limit. Limits reset every 5h and every week."
-            )?;
+            write!(f, "You've hit your usage limit.")?;
+
+            if let Some(secs) = self.resets_in_seconds {
+                let reset_duration = format_reset_duration(secs);
+                write!(f, " Try again in {reset_duration}.")?;
+            } else {
+                write!(f, " Try again later.")?;
+            }
         }
+
         Ok(())
     }
 }
 
+fn format_reset_duration(total_secs: u64) -> String {
+    let days = total_secs / 86_400;
+    let hours = (total_secs % 86_400) / 3_600;
+    let minutes = (total_secs % 3_600) / 60;
+
+    let mut parts: Vec<String> = Vec::new();
+    if days > 0 {
+        let unit = if days == 1 { "day" } else { "days" };
+        parts.push(format!("{} {}", days, unit));
+    }
+    if hours > 0 {
+        let unit = if hours == 1 { "hour" } else { "hours" };
+        parts.push(format!("{} {}", hours, unit));
+    }
+    if minutes > 0 {
+        let unit = if minutes == 1 { "minute" } else { "minutes" };
+        parts.push(format!("{} {}", minutes, unit));
+    }
+
+    if parts.is_empty() {
+        return "less than a minute".to_string();
+    }
+
+    match parts.len() {
+        1 => parts[0].clone(),
+        2 => format!("{} {}", parts[0], parts[1]),
+        _ => format!("{} {} {}", parts[0], parts[1], parts[2]),
+    }
+}
+
 #[derive(Debug)]
 pub struct EnvVarError {
     /// Name of the environment variable that is missing.
@@ -181,6 +224,8 @@ impl CodexErr {
 pub fn get_error_message_ui(e: &CodexErr) -> String {
     match e {
         CodexErr::Sandbox(SandboxErr::Denied(_, _, stderr)) => stderr.to_string(),
+        // Timeouts are not sandbox errors from a UX perspective; present them plainly
+        CodexErr::Sandbox(SandboxErr::Timeout) => "error: command timed out".to_string(),
         _ => e.to_string(),
     }
 }
@@ -193,19 +238,23 @@ mod tests {
     fn usage_limit_reached_error_formats_plus_plan() {
         let err = UsageLimitReachedError {
             plan_type: Some("plus".to_string()),
+            resets_in_seconds: None,
         };
         assert_eq!(
             err.to_string(),
-            "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing), or wait for limits to reset (every 5h and every week.)."
+            "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing) or try again later."
         );
     }
 
     #[test]
     fn usage_limit_reached_error_formats_default_when_none() {
-        let err = UsageLimitReachedError { plan_type: None };
+        let err = UsageLimitReachedError {
+            plan_type: None,
+            resets_in_seconds: None,
+        };
         assert_eq!(
             err.to_string(),
-            "You've hit your usage limit. Limits reset every 5h and every week."
+            "You've hit your usage limit. Try again later."
         );
     }
 
@@ -213,10 +262,59 @@ mod tests {
     fn usage_limit_reached_error_formats_default_for_other_plans() {
         let err = UsageLimitReachedError {
             plan_type: Some("pro".to_string()),
+            resets_in_seconds: None,
         };
         assert_eq!(
             err.to_string(),
-            "You've hit your usage limit. Limits reset every 5h and every week."
+            "You've hit your usage limit. Try again later."
+        );
+    }
+
+    #[test]
+    fn usage_limit_reached_includes_minutes_when_available() {
+        let err = UsageLimitReachedError {
+            plan_type: None,
+            resets_in_seconds: Some(5 * 60),
+        };
+        assert_eq!(
+            err.to_string(),
+            "You've hit your usage limit. Try again in 5 minutes."
+        );
+    }
+
+    #[test]
+    fn usage_limit_reached_includes_hours_and_minutes() {
+        let err = UsageLimitReachedError {
+            plan_type: Some("plus".to_string()),
+            resets_in_seconds: Some(3 * 3600 + 32 * 60),
+        };
+        assert_eq!(
+            err.to_string(),
+            "You've hit your usage limit. Upgrade to Pro (https://openai.com/chatgpt/pricing) or try again in 3 hours 32 minutes."
+        );
+    }
+
+    #[test]
+    fn usage_limit_reached_includes_days_hours_minutes() {
+        let err = UsageLimitReachedError {
+            plan_type: None,
+            resets_in_seconds: Some(2 * 86_400 + 3 * 3600 + 5 * 60),
+        };
+        assert_eq!(
+            err.to_string(),
+            "You've hit your usage limit. Try again in 2 days 3 hours 5 minutes."
+        );
+    }
+
+    #[test]
+    fn usage_limit_reached_less_than_minute() {
+        let err = UsageLimitReachedError {
+            plan_type: None,
+            resets_in_seconds: Some(30),
+        };
+        assert_eq!(
+            err.to_string(),
+            "You've hit your usage limit. Try again in less than a minute."
         );
     }
 }

codex-rs/core/src/git_info.rs

@@ -385,7 +385,9 @@ async fn find_closest_sha(cwd: &Path, branches: &[String], remotes: &[String]) -
 }
 
 async fn diff_against_sha(cwd: &Path, sha: &GitSha) -> Option<String> {
-    let output = run_git_command_with_timeout(&["diff", &sha.0], cwd).await?;
+    let output =
+        run_git_command_with_timeout(&["diff", "--no-textconv", "--no-ext-diff", &sha.0], cwd)
+            .await?;
     // 0 is success and no diff.
     // 1 is success but there is a diff.
     let exit_ok = output.status.code().is_some_and(|c| c == 0 || c == 1);
@@ -406,10 +408,21 @@ async fn diff_against_sha(cwd: &Path, sha: &GitSha) -> Option<String> {
             .collect();
 
         if !untracked.is_empty() {
+            // Use platform-appropriate null device and guard paths with `--`.
+            let null_device: &str = if cfg!(windows) { "NUL" } else { "/dev/null" };
             let futures_iter = untracked.into_iter().map(|file| async move {
                 let file_owned = file;
-                let args_vec: Vec<&str> =
-                    vec!["diff", "--binary", "--no-index", "/dev/null", &file_owned];
+                let args_vec: Vec<&str> = vec![
+                    "diff",
+                    "--no-textconv",
+                    "--no-ext-diff",
+                    "--binary",
+                    "--no-index",
+                    // -- ensures that filenames that start with - are not treated as options.
+                    "--",
+                    null_device,
+                    &file_owned,
+                ];
                 run_git_command_with_timeout(&args_vec, cwd).await
             });
             let results = join_all(futures_iter).await;

codex-rs/core/src/model_provider_info.rs

@@ -17,6 +17,10 @@ use crate::error::EnvVarError;
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS: u64 = 300_000;
 const DEFAULT_STREAM_MAX_RETRIES: u64 = 5;
 const DEFAULT_REQUEST_MAX_RETRIES: u64 = 4;
+/// Hard cap for user-configured `stream_max_retries`.
+const MAX_STREAM_MAX_RETRIES: u64 = 100;
+/// Hard cap for user-configured `request_max_retries`.
+const MAX_REQUEST_MAX_RETRIES: u64 = 100;
 
 /// Wire protocol that the provider speaks. Most third-party services only
 /// implement the classic OpenAI Chat Completions JSON schema, whereas OpenAI
@@ -207,12 +211,14 @@ impl ModelProviderInfo {
     pub fn request_max_retries(&self) -> u64 {
         self.request_max_retries
             .unwrap_or(DEFAULT_REQUEST_MAX_RETRIES)
+            .min(MAX_REQUEST_MAX_RETRIES)
     }
 
     /// Effective maximum number of stream reconnection attempts for this provider.
     pub fn stream_max_retries(&self) -> u64 {
         self.stream_max_retries
             .unwrap_or(DEFAULT_STREAM_MAX_RETRIES)
+            .min(MAX_STREAM_MAX_RETRIES)
     }
 
     /// Effective idle timeout for streaming responses.

codex-rs/core/tests/suite/client.rs

@@ -12,6 +12,7 @@ use codex_login::CodexAuth;
 use core_test_support::load_default_config_for_test;
 use core_test_support::load_sse_fixture_with_id;
 use core_test_support::wait_for_event;
+use serde_json::json;
 use tempfile::TempDir;
 use wiremock::Mock;
 use wiremock::MockServer;
@@ -66,7 +67,6 @@ fn write_auth_json(
     account_id: Option<&str>,
 ) -> String {
     use base64::Engine as _;
-    use serde_json::json;
 
     let header = json!({ "alg": "none", "typ": "JWT" });
     let payload = json!({
@@ -746,3 +746,151 @@ async fn env_var_overrides_loaded_auth() {
 fn create_dummy_codex_auth() -> CodexAuth {
     CodexAuth::create_dummy_chatgpt_auth_for_testing()
 }
+
+/// Scenario:
+/// - Turn 1: user sends U1; model streams deltas then a final assistant message A.
+/// - Turn 2: user sends U2; model streams a delta then the same final assistant message A.
+/// - Turn 3: user sends U3; model responds (same SSE again, not important).
+///
+/// We assert that the `input` sent on each turn contains the expected conversation history
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn history_dedupes_streamed_and_final_messages_across_turns() {
+    // Skip under Codex sandbox network restrictions (mirrors other tests).
+    if std::env::var(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
+        println!(
+            "Skipping test because it cannot execute when network is disabled in a Codex sandbox."
+        );
+        return;
+    }
+
+    // Mock server that will receive three sequential requests and return the same SSE stream
+    // each time: a few deltas, then a final assistant message, then completed.
+    let server = MockServer::start().await;
+
+    // Build a small SSE stream with deltas and a final assistant message.
+    // We emit the same body for all 3 turns; ids vary but are unused by assertions.
+    let sse_raw = r##"[
+        {"type":"response.output_text.delta", "delta":"Hey "},
+        {"type":"response.output_text.delta", "delta":"there"},
+        {"type":"response.output_text.delta", "delta":"!\n"},
+        {"type":"response.output_item.done", "item":{
+            "type":"message", "role":"assistant",
+            "content":[{"type":"output_text","text":"Hey there!\n"}]
+        }},
+        {"type":"response.completed", "response": {"id": "__ID__"}}
+    ]"##;
+    let sse1 = core_test_support::load_sse_fixture_with_id_from_str(sse_raw, "resp1");
+
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .respond_with(
+            ResponseTemplate::new(200)
+                .insert_header("content-type", "text/event-stream")
+                .set_body_raw(sse1.clone(), "text/event-stream"),
+        )
+        .expect(3) // respond identically to the three sequential turns
+        .mount(&server)
+        .await;
+
+    // Configure provider to point to mock server (Responses API) and use API key auth.
+    let model_provider = ModelProviderInfo {
+        base_url: Some(format!("{}/v1", server.uri())),
+        ..built_in_model_providers()["openai"].clone()
+    };
+
+    // Init session with isolated codex home.
+    let codex_home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+
+    let conversation_manager =
+        ConversationManager::with_auth(CodexAuth::from_api_key("Test API Key"));
+    let NewConversation {
+        conversation: codex,
+        ..
+    } = conversation_manager
+        .new_conversation(config)
+        .await
+        .expect("create new conversation");
+
+    // Turn 1: user sends U1; wait for completion.
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text { text: "U1".into() }],
+        })
+        .await
+        .unwrap();
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+
+    // Turn 2: user sends U2; wait for completion.
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text { text: "U2".into() }],
+        })
+        .await
+        .unwrap();
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+
+    // Turn 3: user sends U3; wait for completion.
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text { text: "U3".into() }],
+        })
+        .await
+        .unwrap();
+    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+
+    // Inspect the three captured requests.
+    let requests = server.received_requests().await.unwrap();
+    assert_eq!(requests.len(), 3, "expected 3 requests (one per turn)");
+
+    // Replace full-array compare with tail-only raw JSON compare using a single hard-coded value.
+    let r3_tail_expected = serde_json::json!([
+        {
+            "type": "message",
+            "id": null,
+            "role": "user",
+            "content": [{"type":"input_text","text":"U1"}]
+        },
+        {
+            "type": "message",
+            "id": null,
+            "role": "assistant",
+            "content": [{"type":"output_text","text":"Hey there!\n"}]
+        },
+        {
+            "type": "message",
+            "id": null,
+            "role": "user",
+            "content": [{"type":"input_text","text":"U2"}]
+        },
+        {
+            "type": "message",
+            "id": null,
+            "role": "assistant",
+            "content": [{"type":"output_text","text":"Hey there!\n"}]
+        },
+        {
+            "type": "message",
+            "id": null,
+            "role": "user",
+            "content": [{"type":"input_text","text":"U3"}]
+        }
+    ]);
+
+    let r3_input_array = requests[2]
+        .body_json::<serde_json::Value>()
+        .unwrap()
+        .get("input")
+        .and_then(|v| v.as_array())
+        .cloned()
+        .expect("r3 missing input array");
+    // skipping earlier context and developer messages
+    let tail_len = r3_tail_expected.as_array().unwrap().len();
+    let actual_tail = &r3_input_array[r3_input_array.len() - tail_len..];
+    assert_eq!(
+        serde_json::Value::Array(actual_tail.to_vec()),
+        r3_tail_expected,
+        "request 3 tail mismatch",
+    );
+}

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -179,7 +179,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             EventMsg::StreamError(StreamErrorEvent { message }) => {
                 ts_println!(self, "{}", message.style(self.dimmed));
             }
-            EventMsg::TaskStarted => {
+            EventMsg::TaskStarted(_) => {
                 // Ignore.
             }
             EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {

codex-rs/mcp-server/src/codex_tool_runner.rs

@@ -257,7 +257,7 @@ async fn run_codex_tool_session_inner(
                     }
                     EventMsg::AgentReasoningRawContent(_)
                     | EventMsg::AgentReasoningRawContentDelta(_)
-                    | EventMsg::TaskStarted
+                    | EventMsg::TaskStarted(_)
                     | EventMsg::TokenCount(_)
                     | EventMsg::AgentReasoning(_)
                     | EventMsg::AgentReasoningSectionBreak(_)

codex-rs/protocol/src/protocol.rs

@@ -401,7 +401,7 @@ pub enum EventMsg {
     Error(ErrorEvent),
 
     /// Agent has started a task
-    TaskStarted,
+    TaskStarted(TaskStartedEvent),
 
     /// Agent has completed all actions
     TaskComplete(TaskCompleteEvent),
@@ -494,6 +494,11 @@ pub struct TaskCompleteEvent {
     pub last_agent_message: Option<String>,
 }
 
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TaskStartedEvent {
+    pub model_context_window: Option<u64>,
+}
+
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
 pub struct TokenUsage {
     pub input_tokens: u64,

codex-rs/tui/Cargo.toml

@@ -40,7 +40,10 @@ codex-login = { path = "../login" }
 codex-ollama = { path = "../ollama" }
 codex-protocol = { path = "../protocol" }
 color-eyre = "0.6.3"
-crossterm = { version = "0.28.1", features = ["bracketed-paste", "event-stream"] }
+crossterm = { version = "0.28.1", features = [
+    "bracketed-paste",
+    "event-stream",
+] }
 diffy = "0.4.2"
 image = { version = "^0.25.6", default-features = false, features = [
     "jpeg",
@@ -82,6 +85,7 @@ tui-input = "0.14.0"
 tui-markdown = "0.3.3"
 unicode-segmentation = "1.12.0"
 unicode-width = "0.1"
+url = "2"
 uuid = "1"
 
 [target.'cfg(unix)'.dependencies]

codex-rs/tui/src/app.rs

@@ -3,7 +3,7 @@ use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 use crate::chatwidget::ChatWidget;
 use crate::file_search::FileSearchManager;
-use crate::transcript_app::TranscriptApp;
+use crate::pager_overlay::Overlay;
 use crate::tui;
 use crate::tui::TuiEvent;
 use codex_ansi_escape::ansi_escape_line;
@@ -40,8 +40,8 @@ pub(crate) struct App {
 
     pub(crate) transcript_lines: Vec<Line<'static>>,
 
-    // Transcript overlay state
-    pub(crate) transcript_overlay: Option<TranscriptApp>,
+    // Pager overlay state (Transcript or Static like Diff)
+    pub(crate) overlay: Option<Overlay>,
     pub(crate) deferred_history_lines: Vec<Line<'static>>,
 
     pub(crate) enhanced_keys_supported: bool,
@@ -89,7 +89,7 @@ impl App {
             file_search,
             enhanced_keys_supported,
             transcript_lines: Vec::new(),
-            transcript_overlay: None,
+            overlay: None,
             deferred_history_lines: Vec::new(),
             commit_anim_running: Arc::new(AtomicBool::new(false)),
             backtrack: BacktrackState::default(),
@@ -117,7 +117,7 @@ impl App {
         tui: &mut tui::Tui,
         event: TuiEvent,
     ) -> Result<bool> {
-        if self.transcript_overlay.is_some() {
+        if self.overlay.is_some() {
             let _ = self.handle_backtrack_overlay_event(tui, event).await?;
         } else {
             match event {
@@ -172,26 +172,27 @@ impl App {
                 tui.frame_requester().schedule_frame();
             }
             AppEvent::InsertHistoryLines(lines) => {
-                if let Some(overlay) = &mut self.transcript_overlay {
-                    overlay.insert_lines(lines.clone());
+                if let Some(Overlay::Transcript(t)) = &mut self.overlay {
+                    t.insert_lines(lines.clone());
                     tui.frame_requester().schedule_frame();
                 }
                 self.transcript_lines.extend(lines.clone());
-                if self.transcript_overlay.is_some() {
+                if self.overlay.is_some() {
                     self.deferred_history_lines.extend(lines);
                 } else {
                     tui.insert_history_lines(lines);
                 }
             }
             AppEvent::InsertHistoryCell(cell) => {
-                if let Some(overlay) = &mut self.transcript_overlay {
-                    overlay.insert_lines(cell.transcript_lines());
+                let cell_transcript = cell.transcript_lines();
+                if let Some(Overlay::Transcript(t)) = &mut self.overlay {
+                    t.insert_lines(cell_transcript.clone());
                     tui.frame_requester().schedule_frame();
                 }
-                self.transcript_lines.extend(cell.transcript_lines());
+                self.transcript_lines.extend(cell_transcript.clone());
                 let display = cell.display_lines();
                 if !display.is_empty() {
-                    if self.transcript_overlay.is_some() {
+                    if self.overlay.is_some() {
                         self.deferred_history_lines.extend(display);
                     } else {
                         tui.insert_history_lines(display);
@@ -240,7 +241,7 @@ impl App {
                 } else {
                     text.lines().map(ansi_escape_line).collect()
                 };
-                self.transcript_overlay = Some(TranscriptApp::with_title(
+                self.overlay = Some(Overlay::new_static_with_title(
                     pager_lines,
                     "D I F F".to_string(),
                 ));
@@ -276,22 +277,6 @@ impl App {
 
     async fn handle_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) {
         match key_event {
-            KeyEvent {
-                code: KeyCode::Char('c'),
-                modifiers: crossterm::event::KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } => {
-                self.chat_widget.on_ctrl_c();
-            }
-            KeyEvent {
-                code: KeyCode::Char('d'),
-                modifiers: crossterm::event::KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } if self.chat_widget.composer_is_empty() => {
-                self.app_event_tx.send(AppEvent::ExitRequest);
-            }
             KeyEvent {
                 code: KeyCode::Char('t'),
                 modifiers: crossterm::event::KeyModifiers::CONTROL,
@@ -300,7 +285,7 @@ impl App {
             } => {
                 // Enter alternate screen and set viewport to full size.
                 let _ = tui.enter_alt_screen();
-                self.transcript_overlay = Some(TranscriptApp::new(self.transcript_lines.clone()));
+                self.overlay = Some(Overlay::new_transcript(self.transcript_lines.clone()));
                 tui.frame_requester().schedule_frame();
             }
             // Esc primes/advances backtracking only in normal (not working) mode

codex-rs/tui/src/app_backtrack.rs

@@ -1,6 +1,6 @@
 use crate::app::App;
 use crate::backtrack_helpers;
-use crate::transcript_app::TranscriptApp;
+use crate::pager_overlay::Overlay;
 use crate::tui;
 use crate::tui::TuiEvent;
 use codex_core::protocol::ConversationHistoryResponseEvent;
@@ -79,7 +79,7 @@ impl App {
         if self.chat_widget.composer_is_empty() {
             if !self.backtrack.primed {
                 self.prime_backtrack();
-            } else if self.transcript_overlay.is_none() {
+            } else if self.overlay.is_none() {
                 self.open_backtrack_preview(tui);
             } else if self.backtrack.overlay_preview_active {
                 self.step_backtrack_and_highlight(tui);
@@ -103,7 +103,7 @@ impl App {
     /// Open transcript overlay (enters alternate screen and shows full transcript).
     pub(crate) fn open_transcript_overlay(&mut self, tui: &mut tui::Tui) {
         let _ = tui.enter_alt_screen();
-        self.transcript_overlay = Some(TranscriptApp::new(self.transcript_lines.clone()));
+        self.overlay = Some(Overlay::new_transcript(self.transcript_lines.clone()));
         tui.frame_requester().schedule_frame();
     }
 
@@ -115,7 +115,7 @@ impl App {
             let lines = std::mem::take(&mut self.deferred_history_lines);
             tui.insert_history_lines(lines);
         }
-        self.transcript_overlay = None;
+        self.overlay = None;
         self.backtrack.overlay_preview_active = false;
         if was_backtrack {
             // Ensure backtrack state is fully reset when overlay closes (e.g. via 'q').
@@ -193,23 +193,23 @@ impl App {
     ) {
         let (nth, offset, hl) = selection;
         self.backtrack.count = nth;
-        if let Some(overlay) = &mut self.transcript_overlay {
+        if let Some(Overlay::Transcript(t)) = &mut self.overlay {
             if let Some(off) = offset {
-                overlay.scroll_offset = off;
+                t.set_scroll_offset(off);
             }
-            overlay.set_highlight_range(hl);
+            t.set_highlight_range(hl);
         }
     }
 
     /// Forward any event to the overlay and close it if done.
     fn overlay_forward_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
-        if let Some(overlay) = &mut self.transcript_overlay {
+        if let Some(overlay) = &mut self.overlay {
             overlay.handle_event(tui, event)?;
-            if overlay.is_done {
+            if overlay.is_done() {
                 self.close_transcript_overlay(tui);
+                tui.frame_requester().schedule_frame();
             }
         }
-        tui.frame_requester().schedule_frame();
         Ok(())
     }
 

codex-rs/tui/src/bottom_pane/chat_composer.rs

@@ -1,6 +1,7 @@
 use codex_core::protocol::TokenUsage;
 use crossterm::event::KeyCode;
 use crossterm::event::KeyEvent;
+use crossterm::event::KeyEventKind;
 use crossterm::event::KeyModifiers;
 use ratatui::buffer::Buffer;
 use ratatui::layout::Constraint;
@@ -29,6 +30,8 @@ use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 use crate::bottom_pane::textarea::TextArea;
 use crate::bottom_pane::textarea::TextAreaState;
+use crate::clipboard_paste::normalize_pasted_path;
+use crate::clipboard_paste::pasted_image_format;
 use codex_file_search::FileMatch;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -220,6 +223,8 @@ impl ChatComposer {
             let placeholder = format!("[Pasted Content {char_count} chars]");
             self.textarea.insert_element(&placeholder);
             self.pending_pastes.push((placeholder, pasted));
+        } else if self.handle_paste_image_path(pasted.clone()) {
+            self.textarea.insert_str(" ");
         } else {
             self.textarea.insert_str(&pasted);
         }
@@ -232,6 +237,25 @@ impl ChatComposer {
         true
     }
 
+    pub fn handle_paste_image_path(&mut self, pasted: String) -> bool {
+        let Some(path_buf) = normalize_pasted_path(&pasted) else {
+            return false;
+        };
+
+        match image::image_dimensions(&path_buf) {
+            Ok((w, h)) => {
+                tracing::info!("OK: {pasted}");
+                let format_label = pasted_image_format(&path_buf).label();
+                self.attach_image(path_buf, w, h, format_label);
+                true
+            }
+            Err(err) => {
+                tracing::info!("ERR: {err}");
+                false
+            }
+        }
+    }
+
     /// Replace the entire composer content with `text` and reset cursor.
     pub(crate) fn set_text_content(&mut self, text: String) {
         self.textarea.set_text(&text);
@@ -383,6 +407,33 @@ impl ChatComposer {
             input => self.handle_input_basic(input),
         }
     }
+    #[inline]
+    fn clamp_to_char_boundary(text: &str, pos: usize) -> usize {
+        let mut p = pos.min(text.len());
+        if p < text.len() && !text.is_char_boundary(p) {
+            p = text
+                .char_indices()
+                .map(|(i, _)| i)
+                .take_while(|&i| i <= p)
+                .last()
+                .unwrap_or(0);
+        }
+        p
+    }
+
+    #[inline]
+    fn handle_non_ascii_char(&mut self, input: KeyEvent) -> (InputResult, bool) {
+        if !self.paste_burst_buffer.is_empty() || self.in_paste_burst_mode {
+            let pasted = std::mem::take(&mut self.paste_burst_buffer);
+            self.in_paste_burst_mode = false;
+            self.handle_paste(pasted);
+        }
+        self.textarea.input(input);
+        let text_after = self.textarea.text();
+        self.pending_pastes
+            .retain(|(placeholder, _)| text_after.contains(placeholder));
+        (InputResult::None, true)
+    }
 
     /// Handle key events when file search popup is visible.
     fn handle_key_event_with_file_popup(&mut self, key_event: KeyEvent) -> (InputResult, bool) {
@@ -438,8 +489,10 @@ impl ChatComposer {
                         // using the flat text and byte-offset cursor API.
                         let cursor_offset = self.textarea.cursor();
                         let text = self.textarea.text();
-                        let before_cursor = &text[..cursor_offset];
-                        let after_cursor = &text[cursor_offset..];
+                        // Clamp to a valid char boundary to avoid panics when slicing.
+                        let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
+                        let before_cursor = &text[..safe_cursor];
+                        let after_cursor = &text[safe_cursor..];
 
                         // Determine token boundaries in the full text.
                         let start_idx = before_cursor
@@ -452,7 +505,7 @@ impl ChatComposer {
                             .find(|(_, c)| c.is_whitespace())
                             .map(|(idx, _)| idx)
                             .unwrap_or(after_cursor.len());
-                        let end_idx = cursor_offset + end_rel_idx;
+                        let end_idx = safe_cursor + end_rel_idx;
 
                         self.textarea.replace_range(start_idx..end_idx, "");
                         self.textarea.set_cursor(start_idx);
@@ -600,9 +653,11 @@ impl ChatComposer {
     fn insert_selected_path(&mut self, path: &str) {
         let cursor_offset = self.textarea.cursor();
         let text = self.textarea.text();
+        // Clamp to a valid char boundary to avoid panics when slicing.
+        let safe_cursor = Self::clamp_to_char_boundary(text, cursor_offset);
 
-        let before_cursor = &text[..cursor_offset];
-        let after_cursor = &text[cursor_offset..];
+        let before_cursor = &text[..safe_cursor];
+        let after_cursor = &text[safe_cursor..];
 
         // Determine token boundaries.
         let start_idx = before_cursor
@@ -616,7 +671,7 @@ impl ChatComposer {
             .find(|(_, c)| c.is_whitespace())
             .map(|(idx, _)| idx)
             .unwrap_or(after_cursor.len());
-        let end_idx = cursor_offset + end_rel_idx;
+        let end_idx = safe_cursor + end_rel_idx;
 
         // Replace the slice `[start_idx, end_idx)` with the chosen path and a trailing space.
         let mut new_text =
@@ -634,6 +689,15 @@ impl ChatComposer {
     /// Handle key event when no popup is visible.
     fn handle_key_event_without_popup(&mut self, key_event: KeyEvent) -> (InputResult, bool) {
         match key_event {
+            KeyEvent {
+                code: KeyCode::Char('d'),
+                modifiers: crossterm::event::KeyModifiers::CONTROL,
+                kind: KeyEventKind::Press,
+                ..
+            } if self.is_empty() => {
+                self.app_event_tx.send(AppEvent::ExitRequest);
+                (InputResult::None, true)
+            }
             // -------------------------------------------------------------
             // History navigation (Up / Down) – only when the composer is not
             // empty or when the cursor is at the correct position, to avoid
@@ -730,13 +794,6 @@ impl ChatComposer {
                 }
                 self.pending_pastes.clear();
 
-                // Strip image placeholders from the submitted text; images are retrieved via take_recent_submission_images()
-                for img in &self.attached_images {
-                    if text.contains(&img.placeholder) {
-                        text = text.replace(&img.placeholder, "");
-                    }
-                }
-
                 text = text.trim().to_string();
                 if !text.is_empty() {
                     self.history.record_local_submission(&text);
@@ -782,6 +839,13 @@ impl ChatComposer {
             let has_ctrl_or_alt =
                 modifiers.contains(KeyModifiers::CONTROL) || modifiers.contains(KeyModifiers::ALT);
             if !has_ctrl_or_alt {
+                // Non-ASCII characters (e.g., from IMEs) can arrive in quick bursts and be
+                // misclassified by our non-bracketed paste heuristic. To avoid leaving
+                // residual buffered content or misdetecting a paste, flush any burst buffer
+                // and insert non-ASCII characters directly.
+                if !ch.is_ascii() {
+                    return self.handle_non_ascii_char(input);
+                }
                 // Update burst heuristics.
                 match self.last_plain_char_time {
                     Some(prev) if now.duration_since(prev) <= PASTE_BURST_CHAR_INTERVAL => {
@@ -916,8 +980,9 @@ impl ChatComposer {
     /// Attempts to remove an image or paste placeholder if the cursor is at the end of one.
     /// Returns true if a placeholder was removed.
     fn try_remove_any_placeholder_at_cursor(&mut self) -> bool {
-        let p = self.textarea.cursor();
+        // Clamp the cursor to a valid char boundary to avoid panics when slicing.
         let text = self.textarea.text();
+        let p = Self::clamp_to_char_boundary(text, self.textarea.cursor());
 
         // Try image placeholders first
         let mut out: Option<(usize, String)> = None;
@@ -929,7 +994,7 @@ impl ChatComposer {
                 continue;
             }
             let start = p - ph.len();
-            if text[start..p] != *ph {
+            if text.get(start..p) != Some(ph.as_str()) {
                 continue;
             }
 
@@ -937,7 +1002,11 @@ impl ChatComposer {
             let mut occ_before = 0usize;
             let mut search_pos = 0usize;
             while search_pos < start {
-                if let Some(found) = text[search_pos..start].find(ph) {
+                let segment = match text.get(search_pos..start) {
+                    Some(s) => s,
+                    None => break,
+                };
+                if let Some(found) = segment.find(ph) {
                     occ_before += 1;
                     search_pos += found + ph.len();
                 } else {
@@ -973,7 +1042,7 @@ impl ChatComposer {
                 if p + ph.len() > text.len() {
                     continue;
                 }
-                if &text[p..p + ph.len()] != ph {
+                if text.get(p..p + ph.len()) != Some(ph.as_str()) {
                     continue;
                 }
 
@@ -981,7 +1050,11 @@ impl ChatComposer {
                 let mut occ_before = 0usize;
                 let mut search_pos = 0usize;
                 while search_pos < p {
-                    if let Some(found) = text[search_pos..p].find(ph) {
+                    let segment = match text.get(search_pos..p) {
+                        Some(s) => s,
+                        None => break 'out None,
+                    };
+                    if let Some(found) = segment.find(ph) {
                         occ_before += 1;
                         search_pos += found + ph.len();
                     } else {
@@ -1016,7 +1089,7 @@ impl ChatComposer {
                 return None;
             }
             let start = p - ph.len();
-            if text[start..p] == *ph {
+            if text.get(start..p) == Some(ph.as_str()) {
                 Some(ph.clone())
             } else {
                 None
@@ -1032,7 +1105,7 @@ impl ChatComposer {
             if p + ph.len() > text.len() {
                 return None;
             }
-            if &text[p..p + ph.len()] == ph {
+            if text.get(p..p + ph.len()) == Some(ph.as_str()) {
                 Some(ph.clone())
             } else {
                 None
@@ -1236,7 +1309,10 @@ impl WidgetRef for ChatComposer {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use image::ImageBuffer;
+    use image::Rgba;
     use std::path::PathBuf;
+    use tempfile::tempdir;
 
     use crate::app_event::AppEvent;
     use crate::bottom_pane::AppEventSender;
@@ -1819,7 +1895,7 @@ mod tests {
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert_eq!(text, "hi"),
+            InputResult::Submitted(text) => assert_eq!(text, "[image 32x16 PNG] hi"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -1837,7 +1913,7 @@ mod tests {
         let (result, _) =
             composer.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
         match result {
-            InputResult::Submitted(text) => assert!(text.is_empty()),
+            InputResult::Submitted(text) => assert_eq!(text, "[image 10x5 PNG]"),
             _ => panic!("expected Submitted"),
         }
         let imgs = composer.take_recent_submission_images();
@@ -1878,6 +1954,31 @@ mod tests {
         }
     }
 
+    #[test]
+    fn backspace_with_multibyte_text_before_placeholder_does_not_panic() {
+        use crossterm::event::KeyCode;
+        use crossterm::event::KeyEvent;
+        use crossterm::event::KeyModifiers;
+
+        let (tx, _rx) = unbounded_channel::<AppEvent>();
+        let sender = AppEventSender::new(tx);
+        let mut composer =
+            ChatComposer::new(true, sender, false, "Ask Codex to do anything".to_string());
+
+        // Insert an image placeholder at the start
+        let path = PathBuf::from("/tmp/image_multibyte.png");
+        composer.attach_image(path, 10, 5, "PNG");
+        // Add multibyte text after the placeholder
+        composer.textarea.insert_str("日本語");
+
+        // Cursor is at end; pressing backspace should delete the last character
+        // without panicking and leave the placeholder intact.
+        composer.handle_key_event(KeyEvent::new(KeyCode::Backspace, KeyModifiers::NONE));
+
+        assert_eq!(composer.attached_images.len(), 1);
+        assert!(composer.textarea.text().starts_with("[image 10x5 PNG]"));
+    }
+
     #[test]
     fn deleting_one_of_duplicate_image_placeholders_removes_matching_entry() {
         let (tx, _rx) = unbounded_channel::<AppEvent>();
@@ -1913,4 +2014,25 @@ mod tests {
             "one image mapping remains"
         );
     }
+
+    #[test]
+    fn pasting_filepath_attaches_image() {
+        let tmp = tempdir().expect("create TempDir");
+        let tmp_path: PathBuf = tmp.path().join("codex_tui_test_paste_image.png");
+        let img: ImageBuffer<Rgba<u8>, Vec<u8>> =
+            ImageBuffer::from_fn(3, 2, |_x, _y| Rgba([1, 2, 3, 255]));
+        img.save(&tmp_path).expect("failed to write temp png");
+
+        let (tx, _rx) = unbounded_channel::<AppEvent>();
+        let sender = AppEventSender::new(tx);
+        let mut composer =
+            ChatComposer::new(true, sender, false, "Ask Codex to do anything".to_string());
+
+        let needs_redraw = composer.handle_paste(tmp_path.to_string_lossy().to_string());
+        assert!(needs_redraw);
+        assert!(composer.textarea.text().starts_with("[image 3x2 PNG] "));
+
+        let imgs = composer.take_recent_submission_images();
+        assert_eq!(imgs, vec![tmp_path.clone()]);
+    }
 }

codex-rs/tui/src/bottom_pane/mod.rs

@@ -72,7 +72,7 @@ pub(crate) struct BottomPaneParams {
 }
 
 impl BottomPane {
-    const BOTTOM_PAD_LINES: u16 = 2;
+    const BOTTOM_PAD_LINES: u16 = 1;
     pub fn new(params: BottomPaneParams) -> Self {
         let enhanced_keys_supported = params.enhanced_keys_supported;
         Self {
@@ -530,7 +530,7 @@ mod tests {
         // Push an approval modal (e.g., command approval) which should hide the status view.
         pane.push_approval_request(exec_request());
 
-        // Simulate pressing 'n' (deny) on the modal.
+        // Simulate pressing 'n' (No) on the modal.
         use crossterm::event::KeyCode;
         use crossterm::event::KeyEvent;
         use crossterm::event::KeyModifiers;
@@ -648,28 +648,15 @@ mod tests {
             "expected Working header on top row: {top:?}"
         );
 
-        // Next row (spacer) is blank, and bottom two rows are blank padding
-        let mut spacer = String::new();
+        // Last row should be blank padding; the row above should generally contain composer content.
         let mut r_last = String::new();
-        let mut r_last2 = String::new();
         for x in 0..area.width {
-            // Spacer row immediately below the status header lives at y=2.
-            spacer.push(buf[(x, 2)].symbol().chars().next().unwrap_or(' '));
             r_last.push(buf[(x, height - 1)].symbol().chars().next().unwrap_or(' '));
-            r_last2.push(buf[(x, height - 2)].symbol().chars().next().unwrap_or(' '));
         }
-        assert!(
-            spacer.trim().is_empty(),
-            "expected spacer line blank: {spacer:?}"
-        );
         assert!(
             r_last.trim().is_empty(),
             "expected last row blank: {r_last:?}"
         );
-        assert!(
-            r_last2.trim().is_empty(),
-            "expected second-to-last row blank: {r_last2:?}"
-        );
     }
 
     #[test]

codex-rs/tui/src/bottom_pane/textarea.rs

@@ -231,6 +231,13 @@ impl TextArea {
                 code: KeyCode::Enter,
                 ..
             } => self.insert_str("\n"),
+            KeyEvent {
+                code: KeyCode::Char('h'),
+                modifiers,
+                ..
+            } if modifiers == (KeyModifiers::CONTROL | KeyModifiers::ALT) => {
+                self.delete_backward_word()
+            },
             KeyEvent {
                 code: KeyCode::Backspace,
                 modifiers: KeyModifiers::ALT,
@@ -1138,10 +1145,6 @@ mod tests {
 
     #[test]
     fn control_b_and_f_move_cursor() {
-        use crossterm::event::KeyCode;
-        use crossterm::event::KeyEvent;
-        use crossterm::event::KeyModifiers;
-
         let mut t = ta_with("abcd");
         t.set_cursor(1);
 
@@ -1154,10 +1157,6 @@ mod tests {
 
     #[test]
     fn control_b_f_fallback_control_chars_move_cursor() {
-        use crossterm::event::KeyCode;
-        use crossterm::event::KeyEvent;
-        use crossterm::event::KeyModifiers;
-
         let mut t = ta_with("abcd");
         t.set_cursor(2);
 
@@ -1171,6 +1170,48 @@ mod tests {
         assert_eq!(t.cursor(), 2);
     }
 
+    #[test]
+    fn delete_backward_word_alt_keys() {
+        // Test the custom Alt+Ctrl+h binding
+        let mut t = ta_with("hello world");
+        t.set_cursor(t.text().len()); // cursor at the end
+        t.input(KeyEvent::new(
+            KeyCode::Char('h'),
+            KeyModifiers::CONTROL | KeyModifiers::ALT,
+        ));
+        assert_eq!(t.text(), "hello ");
+        assert_eq!(t.cursor(), 6);
+
+        // Test the standard Alt+Backspace binding
+        let mut t = ta_with("hello world");
+        t.set_cursor(t.text().len()); // cursor at the end
+        t.input(KeyEvent::new(KeyCode::Backspace, KeyModifiers::ALT));
+        assert_eq!(t.text(), "hello ");
+        assert_eq!(t.cursor(), 6);
+    }
+
+    #[test]
+    fn control_h_backspace() {
+        // Test Ctrl+H as backspace
+        let mut t = ta_with("12345");
+        t.set_cursor(3); // cursor after '3'
+        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
+        assert_eq!(t.text(), "1245");
+        assert_eq!(t.cursor(), 2);
+
+        // Test Ctrl+H at beginning (should be no-op)
+        t.set_cursor(0);
+        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
+        assert_eq!(t.text(), "1245");
+        assert_eq!(t.cursor(), 0);
+
+        // Test Ctrl+H at end
+        t.set_cursor(t.text().len());
+        t.input(KeyEvent::new(KeyCode::Char('h'), KeyModifiers::CONTROL));
+        assert_eq!(t.text(), "124");
+        assert_eq!(t.cursor(), 3);
+    }
+
     #[test]
     fn cursor_vertical_movement_across_lines_and_bounds() {
         let mut t = ta_with("short\nloooooooooong\nmid");

codex-rs/tui/src/chatwidget.rs

@@ -243,17 +243,51 @@ impl ChatWidget {
         );
     }
 
-    fn on_error(&mut self, message: String) {
+    /// Finalize any active exec as failed, push an error message into history,
+    /// and stop/clear running UI state.
+    fn finalize_turn_with_error_message(&mut self, message: String) {
+        // Ensure any spinner is replaced by a red ✗ and flushed into history.
+        self.finalize_active_exec_cell_as_failed();
+        // Emit the provided error message/history cell.
         self.add_to_history(history_cell::new_error_event(message));
+        // Reset running state and clear streaming buffers.
         self.bottom_pane.set_task_running(false);
         self.running_commands.clear();
         self.stream.clear_all();
+    }
+
+    fn on_error(&mut self, message: String) {
+        self.finalize_turn_with_error_message(message);
         self.request_redraw();
 
         // After an error ends the turn, try sending the next queued input.
         self.maybe_send_next_queued_input();
     }
 
+    /// Handle a turn aborted due to user interrupt (Esc).
+    /// When there are queued user messages, restore them into the composer
+    /// separated by newlines rather than auto‑submitting the next one.
+    fn on_interrupted_turn(&mut self) {
+        // Finalize, log a gentle prompt, and clear running state.
+        self.finalize_turn_with_error_message("Tell the model what to do differently".to_owned());
+
+        // If any messages were queued during the task, restore them into the composer.
+        if !self.queued_user_messages.is_empty() {
+            let combined = self
+                .queued_user_messages
+                .iter()
+                .map(|m| m.text.clone())
+                .collect::<Vec<_>>()
+                .join("\n");
+            self.bottom_pane.set_composer_text(combined);
+            // Clear the queue and update the status indicator list.
+            self.queued_user_messages.clear();
+            self.refresh_queued_user_messages();
+        }
+
+        self.request_redraw();
+    }
+
     fn on_plan_update(&mut self, update: codex_core::plan_tool::UpdatePlanArgs) {
         self.add_to_history(history_cell::new_plan_update(update));
     }
@@ -534,17 +568,7 @@ impl ChatWidget {
             ev.result,
         ));
     }
-    fn interrupt_running_task(&mut self) {
-        if self.bottom_pane.is_task_running() {
-            self.active_exec_cell = None;
-            self.running_commands.clear();
-            self.bottom_pane.clear_ctrl_c_quit_hint();
-            self.submit_op(Op::Interrupt);
-            self.bottom_pane.set_task_running(false);
-            self.stream.clear_all();
-            self.request_redraw();
-        }
-    }
+
     fn layout_areas(&self, area: Rect) -> [Rect; 2] {
         Layout::vertical([
             Constraint::Max(
@@ -657,48 +681,57 @@ impl ChatWidget {
     }
 
     pub(crate) fn handle_key_event(&mut self, key_event: KeyEvent) {
-        if key_event.kind == KeyEventKind::Press {
-            self.bottom_pane.clear_ctrl_c_quit_hint();
+        match key_event {
+            KeyEvent {
+                code: KeyCode::Char('c'),
+                modifiers: crossterm::event::KeyModifiers::CONTROL,
+                kind: KeyEventKind::Press,
+                ..
+            } => {
+                self.on_ctrl_c();
+                return;
+            }
+            other if other.kind == KeyEventKind::Press => {
+                self.bottom_pane.clear_ctrl_c_quit_hint();
+            }
+            _ => {}
         }
 
-        // Alt+Up: Edit the most recent queued user message (if any).
-        if matches!(
-            key_event,
+        match key_event {
             KeyEvent {
                 code: KeyCode::Up,
                 modifiers: KeyModifiers::ALT,
                 kind: KeyEventKind::Press,
                 ..
-            }
-        ) && !self.queued_user_messages.is_empty()
-        {
-            // Prefer the most recently queued item.
-            if let Some(user_message) = self.queued_user_messages.pop_back() {
-                self.bottom_pane.set_composer_text(user_message.text);
-                self.refresh_queued_user_messages();
-                self.request_redraw();
-            }
-            return;
-        }
-
-        match self.bottom_pane.handle_key_event(key_event) {
-            InputResult::Submitted(text) => {
-                // If a task is running, queue the user input to be sent after the turn completes.
-                let user_message = UserMessage {
-                    text,
-                    image_paths: self.bottom_pane.take_recent_submission_images(),
-                };
-                if self.bottom_pane.is_task_running() {
-                    self.queued_user_messages.push_back(user_message);
+            } if !self.queued_user_messages.is_empty() => {
+                // Prefer the most recently queued item.
+                if let Some(user_message) = self.queued_user_messages.pop_back() {
+                    self.bottom_pane.set_composer_text(user_message.text);
                     self.refresh_queued_user_messages();
-                } else {
-                    self.submit_user_message(user_message);
+                    self.request_redraw();
                 }
             }
-            InputResult::Command(cmd) => {
-                self.dispatch_command(cmd);
+            _ => {
+                match self.bottom_pane.handle_key_event(key_event) {
+                    InputResult::Submitted(text) => {
+                        // If a task is running, queue the user input to be sent after the turn completes.
+                        let user_message = UserMessage {
+                            text,
+                            image_paths: self.bottom_pane.take_recent_submission_images(),
+                        };
+                        if self.bottom_pane.is_task_running() {
+                            self.queued_user_messages.push_back(user_message);
+                            self.refresh_queued_user_messages();
+                        } else {
+                            self.submit_user_message(user_message);
+                        }
+                    }
+                    InputResult::Command(cmd) => {
+                        self.dispatch_command(cmd);
+                    }
+                    InputResult::None => {}
+                }
             }
-            InputResult::None => {}
         }
     }
 
@@ -905,13 +938,13 @@ impl ChatWidget {
                 self.on_agent_reasoning_final()
             }
             EventMsg::AgentReasoningSectionBreak(_) => self.on_reasoning_section_break(),
-            EventMsg::TaskStarted => self.on_task_started(),
+            EventMsg::TaskStarted(_) => self.on_task_started(),
             EventMsg::TaskComplete(TaskCompleteEvent { .. }) => self.on_task_complete(),
             EventMsg::TokenCount(token_usage) => self.on_token_count(token_usage),
             EventMsg::Error(ErrorEvent { message }) => self.on_error(message),
             EventMsg::TurnAborted(ev) => match ev.reason {
                 TurnAbortReason::Interrupted => {
-                    self.on_error("Tell the model what to do differently".to_owned())
+                    self.on_interrupted_turn();
                 }
                 TurnAbortReason::Replaced => {
                     self.on_error("Turn aborted: replaced by a new task".to_owned())
@@ -948,6 +981,16 @@ impl ChatWidget {
         self.frame_requester.schedule_frame();
     }
 
+    /// Mark the active exec cell as failed (✗) and flush it into history.
+    fn finalize_active_exec_cell_as_failed(&mut self) {
+        if let Some(cell) = self.active_exec_cell.take() {
+            let cell = cell.into_failed();
+            // Insert finalized exec into history and keep grouping consistent.
+            self.add_to_history(cell);
+            self.last_history_was_exec = true;
+        }
+    }
+
     // If idle and there are queued inputs, submit exactly one to start the next turn.
     fn maybe_send_next_queued_input(&mut self) {
         if self.bottom_pane.is_task_running() {
@@ -1102,22 +1145,15 @@ impl ChatWidget {
     }
 
     /// Handle Ctrl-C key press.
-    /// Returns CancellationEvent::Handled if the event was consumed by the UI, or
-    /// CancellationEvent::Ignored if the caller should handle it (e.g. exit).
-    pub(crate) fn on_ctrl_c(&mut self) -> CancellationEvent {
-        match self.bottom_pane.on_ctrl_c() {
-            CancellationEvent::Handled => return CancellationEvent::Handled,
-            CancellationEvent::Ignored => {}
-        }
-        if self.bottom_pane.is_task_running() {
-            self.interrupt_running_task();
-            CancellationEvent::Ignored
-        } else if self.bottom_pane.ctrl_c_quit_hint_visible() {
-            self.submit_op(Op::Shutdown);
-            CancellationEvent::Handled
-        } else {
-            self.bottom_pane.show_ctrl_c_quit_hint();
-            CancellationEvent::Ignored
+    fn on_ctrl_c(&mut self) {
+        if self.bottom_pane.on_ctrl_c() == CancellationEvent::Ignored {
+            if self.bottom_pane.is_task_running() {
+                self.submit_op(Op::Interrupt);
+            } else if self.bottom_pane.ctrl_c_quit_hint_visible() {
+                self.submit_op(Op::Shutdown);
+            } else {
+                self.bottom_pane.show_ctrl_c_quit_hint();
+            }
         }
     }
 

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__approval_modal_exec.snap

@@ -1,5 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 728
 expression: terminal.backend()
 ---
 "? Codex wants to run echo hello world                                           "
@@ -7,7 +8,6 @@ expression: terminal.backend()
 "Model wants to run a command                                                    "
 "                                                                                "
 "▌Allow command?                                                                 "
-"▌ Yes   Always   No   No, provide feedback                                      "
+"▌ Yes   Always   No, provide feedback                                           "
 "▌ Approve and run the command                                                   "
 "                                                                                "
-"                                                                                "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__approval_modal_patch.snap

@@ -1,6 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
-assertion_line: 690
+assertion_line: 763
 expression: terminal.backend()
 ---
 "The model wants to apply changes                                                "
@@ -8,7 +8,6 @@ expression: terminal.backend()
 "This will grant write access to /tmp for the remainder of this session.         "
 "                                                                                "
 "▌Apply changes?                                                                 "
-"▌ Yes   No   No, provide feedback                                               "
+"▌ Yes   No, provide feedback                                                    "
 "▌ Approve and apply the changes                                                 "
 "                                                                                "
-"                                                                                "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chat_small_idle_h2.snap

@@ -1,5 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 779
 expression: terminal.backend()
 ---
 "▌ Ask Codex to do anything              "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chat_small_idle_h3.snap

@@ -1,7 +1,8 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 779
 expression: terminal.backend()
 ---
+"                                        "
 "▌ Ask Codex to do anything              "
 "                                        "
-"                                        "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chat_small_running_h2.snap

@@ -1,5 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 807
 expression: terminal.backend()
 ---
 "▌ Ask Codex to do anything              "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__chat_small_running_h3.snap

@@ -1,5 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 807
 expression: terminal.backend()
 ---
 "                                        "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__interrupt_exec_marks_failed.snap

@@ -0,0 +1,6 @@
+---
+source: tui/src/chatwidget/tests.rs
+expression: exec_blob
+---
+>_
+  ✗ ⌨️ sleep 1

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_widget_active.snap

@@ -1,6 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
-assertion_line: 806
+assertion_line: 878
 expression: terminal.backend()
 ---
 "                                                                                "
@@ -9,4 +9,3 @@ expression: terminal.backend()
 "▌ Ask Codex to do anything                                                      "
 " ⏎ send   Ctrl+J newline   Ctrl+T transcript   Ctrl+C quit                      "
 "                                                                                "
-"                                                                                "

codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__status_widget_and_approval_modal.snap

@@ -1,5 +1,6 @@
 ---
 source: tui/src/chatwidget/tests.rs
+assertion_line: 851
 expression: terminal.backend()
 ---
 "? Codex wants to run echo 'hello world'                                         "
@@ -7,7 +8,6 @@ expression: terminal.backend()
 "Codex wants to run a command                                                    "
 "                                                                                "
 "▌Allow command?                                                                 "
-"▌ Yes   Always   No   No, provide feedback                                      "
+"▌ Yes   Always   No, provide feedback                                           "
 "▌ Approve and run the command                                                   "
 "                                                                                "
-"                                                                                "

codex-rs/tui/src/chatwidget/tests.rs

@@ -22,6 +22,7 @@ use codex_core::protocol::PatchApplyBeginEvent;
 use codex_core::protocol::PatchApplyEndEvent;
 use codex_core::protocol::StreamErrorEvent;
 use codex_core::protocol::TaskCompleteEvent;
+use codex_core::protocol::TaskStartedEvent;
 use codex_login::CodexAuth;
 use crossterm::event::KeyCode;
 use crossterm::event::KeyEvent;
@@ -370,6 +371,48 @@ fn exec_history_cell_shows_working_then_failed() {
     );
 }
 
+// Snapshot test: interrupting a running exec finalizes the active cell with a red ✗
+// marker (replacing the spinner) and flushes it into history.
+#[test]
+fn interrupt_exec_marks_failed_snapshot() {
+    let (mut chat, mut rx, _op_rx) = make_chatwidget_manual();
+
+    // Begin a long-running command so we have an active exec cell with a spinner.
+    chat.handle_codex_event(Event {
+        id: "call-int".into(),
+        msg: EventMsg::ExecCommandBegin(ExecCommandBeginEvent {
+            call_id: "call-int".into(),
+            command: vec!["bash".into(), "-lc".into(), "sleep 1".into()],
+            cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
+            parsed_cmd: vec![
+                codex_core::parse_command::ParsedCommand::Unknown {
+                    cmd: "sleep 1".into(),
+                }
+                .into(),
+            ],
+        }),
+    });
+
+    // Simulate the task being aborted (as if ESC was pressed), which should
+    // cause the active exec cell to be finalized as failed and flushed.
+    chat.handle_codex_event(Event {
+        id: "call-int".into(),
+        msg: EventMsg::TurnAborted(codex_core::protocol::TurnAbortedEvent {
+            reason: TurnAbortReason::Interrupted,
+        }),
+    });
+
+    let cells = drain_insert_history(&mut rx);
+    assert!(
+        !cells.is_empty(),
+        "expected finalized exec cell to be inserted into history"
+    );
+
+    // The first inserted cell should be the finalized exec; snapshot its text.
+    let exec_blob = lines_to_single_string(&cells[0]);
+    assert_snapshot!("interrupt_exec_marks_failed", exec_blob);
+}
+
 #[test]
 fn exec_history_extends_previous_when_consecutive() {
     let (mut chat, mut rx, _op_rx) = make_chatwidget_manual();
@@ -721,6 +764,45 @@ fn approval_modal_patch_snapshot() {
     assert_snapshot!("approval_modal_patch", terminal.backend());
 }
 
+#[test]
+fn interrupt_restores_queued_messages_into_composer() {
+    let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual();
+
+    // Simulate a running task to enable queuing of user inputs.
+    chat.bottom_pane.set_task_running(true);
+
+    // Queue two user messages while the task is running.
+    chat.queued_user_messages
+        .push_back(UserMessage::from("first queued".to_string()));
+    chat.queued_user_messages
+        .push_back(UserMessage::from("second queued".to_string()));
+    chat.refresh_queued_user_messages();
+
+    // Deliver a TurnAborted event with Interrupted reason (as if Esc was pressed).
+    chat.handle_codex_event(Event {
+        id: "turn-1".into(),
+        msg: EventMsg::TurnAborted(codex_core::protocol::TurnAbortedEvent {
+            reason: codex_core::protocol::TurnAbortReason::Interrupted,
+        }),
+    });
+
+    // Composer should now contain the queued messages joined by newlines, in order.
+    assert_eq!(
+        chat.bottom_pane.composer_text(),
+        "first queued\nsecond queued"
+    );
+
+    // Queue should be cleared and no new user input should have been auto-submitted.
+    assert!(chat.queued_user_messages.is_empty());
+    assert!(
+        op_rx.try_recv().is_err(),
+        "unexpected outbound op after interrupt"
+    );
+
+    // Drain rx to avoid unused warnings.
+    let _ = drain_insert_history(&mut rx);
+}
+
 // Snapshot test: ChatWidget at very small heights (idle)
 // Ensures overall layout behaves when terminal height is extremely constrained.
 #[test]
@@ -748,7 +830,9 @@ fn ui_snapshots_small_heights_task_running() {
     // Activate status line
     chat.handle_codex_event(Event {
         id: "task-1".into(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window: None,
+        }),
     });
     chat.handle_codex_event(Event {
         id: "task-1".into(),
@@ -777,7 +861,9 @@ fn status_widget_and_approval_modal_snapshot() {
     // Begin a running task so the status indicator would be active.
     chat.handle_codex_event(Event {
         id: "task-1".into(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window: None,
+        }),
     });
     // Provide a deterministic header for the status line.
     chat.handle_codex_event(Event {
@@ -817,7 +903,9 @@ fn status_widget_active_snapshot() {
     // Activate the status indicator by simulating a task start.
     chat.handle_codex_event(Event {
         id: "task-1".into(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window: None,
+        }),
     });
     // Provide a deterministic header via a bold reasoning chunk.
     chat.handle_codex_event(Event {
@@ -1165,7 +1253,7 @@ fn stream_error_is_rendered_to_history() {
     let cells = drain_insert_history(&mut rx);
     assert!(!cells.is_empty(), "expected a history cell for StreamError");
     let blob = lines_to_single_string(cells.last().unwrap());
-    assert!(blob.contains("⚠ "));
+    assert!(blob.contains("⚠\u{200A} "));
     assert!(blob.contains("stream error:"));
     assert!(blob.contains("idle timeout waiting for SSE"));
 }
@@ -1265,7 +1353,9 @@ fn multiple_agent_messages_in_single_turn_emit_multiple_headers() {
     // Begin turn
     chat.handle_codex_event(Event {
         id: "s1".into(),
-        msg: EventMsg::TaskStarted,
+        msg: EventMsg::TaskStarted(TaskStartedEvent {
+            model_context_window: None,
+        }),
     });
 
     // First finalized assistant message

codex-rs/tui/src/clipboard_paste.rs

@@ -1,3 +1,4 @@
+use std::path::Path;
 use std::path::PathBuf;
 use tempfile::Builder;
 
@@ -24,12 +25,16 @@ impl std::error::Error for PasteImageError {}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum EncodedImageFormat {
     Png,
+    Jpeg,
+    Other,
 }
 
 impl EncodedImageFormat {
     pub fn label(self) -> &'static str {
         match self {
             EncodedImageFormat::Png => "PNG",
+            EncodedImageFormat::Jpeg => "JPEG",
+            EncodedImageFormat::Other => "IMG",
         }
     }
 }
@@ -95,3 +100,185 @@ pub fn paste_image_to_temp_png() -> Result<(PathBuf, PastedImageInfo), PasteImag
         .map_err(|e| PasteImageError::IoError(e.error.to_string()))?;
     Ok((path, info))
 }
+
+/// Normalize pasted text that may represent a filesystem path.
+///
+/// Supports:
+/// - `file://` URLs (converted to local paths)
+/// - Windows/UNC paths
+/// - shell-escaped single paths (via `shlex`)
+pub fn normalize_pasted_path(pasted: &str) -> Option<PathBuf> {
+    let pasted = pasted.trim();
+
+    // file:// URL → filesystem path
+    if let Ok(url) = url::Url::parse(pasted)
+        && url.scheme() == "file"
+    {
+        return url.to_file_path().ok();
+    }
+
+    // TODO: We'll improve the implementation/unit tests over time, as appropriate.
+    // Possibly use typed-path: https://github.com/openai/codex/pull/2567/commits/3cc92b78e0a1f94e857cf4674d3a9db918ed352e
+    //
+    // Detect unquoted Windows paths and bypass POSIX shlex which
+    // treats backslashes as escapes (e.g., C:\Users\Alice\file.png).
+    // Also handles UNC paths (\\server\share\path).
+    let looks_like_windows_path = {
+        // Drive letter path: C:\ or C:/
+        let drive = pasted
+            .chars()
+            .next()
+            .map(|c| c.is_ascii_alphabetic())
+            .unwrap_or(false)
+            && pasted.get(1..2) == Some(":")
+            && pasted
+                .get(2..3)
+                .map(|s| s == "\\" || s == "/")
+                .unwrap_or(false);
+        // UNC path: \\server\share
+        let unc = pasted.starts_with("\\\\");
+        drive || unc
+    };
+    if looks_like_windows_path {
+        return Some(PathBuf::from(pasted));
+    }
+
+    // shell-escaped single path → unescaped
+    let parts: Vec<String> = shlex::Shlex::new(pasted).collect();
+    if parts.len() == 1 {
+        return parts.into_iter().next().map(PathBuf::from);
+    }
+
+    None
+}
+
+/// Infer an image format for the provided path based on its extension.
+pub fn pasted_image_format(path: &Path) -> EncodedImageFormat {
+    match path
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|s| s.to_ascii_lowercase())
+        .as_deref()
+    {
+        Some("png") => EncodedImageFormat::Png,
+        Some("jpg") | Some("jpeg") => EncodedImageFormat::Jpeg,
+        _ => EncodedImageFormat::Other,
+    }
+}
+
+#[cfg(test)]
+mod pasted_paths_tests {
+    use super::*;
+
+    #[cfg(not(windows))]
+    #[test]
+    fn normalize_file_url() {
+        let input = "file:///tmp/example.png";
+        let result = normalize_pasted_path(input).expect("should parse file URL");
+        assert_eq!(result, PathBuf::from("/tmp/example.png"));
+    }
+
+    #[test]
+    fn normalize_file_url_windows() {
+        let input = r"C:\Temp\example.png";
+        let result = normalize_pasted_path(input).expect("should parse file URL");
+        assert_eq!(result, PathBuf::from(r"C:\Temp\example.png"));
+    }
+
+    #[test]
+    fn normalize_shell_escaped_single_path() {
+        let input = "/home/user/My\\ File.png";
+        let result = normalize_pasted_path(input).expect("should unescape shell-escaped path");
+        assert_eq!(result, PathBuf::from("/home/user/My File.png"));
+    }
+
+    #[test]
+    fn normalize_simple_quoted_path_fallback() {
+        let input = "\"/home/user/My File.png\"";
+        let result = normalize_pasted_path(input).expect("should trim simple quotes");
+        assert_eq!(result, PathBuf::from("/home/user/My File.png"));
+    }
+
+    #[test]
+    fn normalize_single_quoted_unix_path() {
+        let input = "'/home/user/My File.png'";
+        let result = normalize_pasted_path(input).expect("should trim single quotes via shlex");
+        assert_eq!(result, PathBuf::from("/home/user/My File.png"));
+    }
+
+    #[test]
+    fn normalize_multiple_tokens_returns_none() {
+        // Two tokens after shell splitting → not a single path
+        let input = "/home/user/a\\ b.png /home/user/c.png";
+        let result = normalize_pasted_path(input);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn pasted_image_format_png_jpeg_unknown() {
+        assert_eq!(
+            pasted_image_format(Path::new("/a/b/c.PNG")),
+            EncodedImageFormat::Png
+        );
+        assert_eq!(
+            pasted_image_format(Path::new("/a/b/c.jpg")),
+            EncodedImageFormat::Jpeg
+        );
+        assert_eq!(
+            pasted_image_format(Path::new("/a/b/c.JPEG")),
+            EncodedImageFormat::Jpeg
+        );
+        assert_eq!(
+            pasted_image_format(Path::new("/a/b/c")),
+            EncodedImageFormat::Other
+        );
+        assert_eq!(
+            pasted_image_format(Path::new("/a/b/c.webp")),
+            EncodedImageFormat::Other
+        );
+    }
+
+    #[test]
+    fn normalize_single_quoted_windows_path() {
+        let input = r"'C:\\Users\\Alice\\My File.jpeg'";
+        let result =
+            normalize_pasted_path(input).expect("should trim single quotes on windows path");
+        assert_eq!(result, PathBuf::from(r"C:\\Users\\Alice\\My File.jpeg"));
+    }
+
+    #[test]
+    fn normalize_unquoted_windows_path_with_spaces() {
+        let input = r"C:\\Users\\Alice\\My Pictures\\example image.png";
+        let result = normalize_pasted_path(input).expect("should accept unquoted windows path");
+        assert_eq!(
+            result,
+            PathBuf::from(r"C:\\Users\\Alice\\My Pictures\\example image.png")
+        );
+    }
+
+    #[test]
+    fn normalize_unc_windows_path() {
+        let input = r"\\\\server\\share\\folder\\file.jpg";
+        let result = normalize_pasted_path(input).expect("should accept UNC windows path");
+        assert_eq!(
+            result,
+            PathBuf::from(r"\\\\server\\share\\folder\\file.jpg")
+        );
+    }
+
+    #[test]
+    fn pasted_image_format_with_windows_style_paths() {
+        assert_eq!(
+            pasted_image_format(Path::new(r"C:\\a\\b\\c.PNG")),
+            EncodedImageFormat::Png
+        );
+        assert_eq!(
+            pasted_image_format(Path::new(r"C:\\a\\b\\c.jpeg")),
+            EncodedImageFormat::Jpeg
+        );
+        assert_eq!(
+            pasted_image_format(Path::new(r"C:\\a\\b\\noext")),
+            EncodedImageFormat::Other
+        );
+    }
+}

codex-rs/tui/src/history_cell.rs

@@ -175,6 +175,26 @@ impl WidgetRef for &ExecCell {
     }
 }
 
+impl ExecCell {
+    /// Convert an active exec cell into a failed, completed exec cell.
+    /// Replaces the spinner with a red ✗ and sets a zero/elapsed duration.
+    pub(crate) fn into_failed(mut self) -> ExecCell {
+        let elapsed = self
+            .start_time
+            .map(|st| st.elapsed())
+            .unwrap_or_else(|| Duration::from_millis(0));
+        self.start_time = None;
+        self.duration = Some(elapsed);
+        self.output = Some(CommandOutput {
+            exit_code: 1,
+            stdout: String::new(),
+            stderr: String::new(),
+            formatted_output: String::new(),
+        });
+        self
+    }
+}
+
 #[derive(Debug)]
 struct CompletedMcpToolCallWithImageOutput {
     _image: DynamicImage,
@@ -210,6 +230,17 @@ fn pretty_provider_name(id: &str) -> String {
         title_case(id)
     }
 }
+/// Return the emoji followed by a hair space (U+200A).
+/// Using only the hair space avoids excessive padding after the emoji while
+/// still providing a small visual gap across terminals.
+fn padded_emoji(emoji: &str) -> String {
+    format!("{emoji}\u{200A}")
+}
+
+/// Convenience function over `padded_emoji()`.
+fn padded_emoji_with(emoji: &str, text: impl AsRef<str>) -> String {
+    format!("{}{}", padded_emoji(emoji), text.as_ref())
+}
 
 pub(crate) fn new_session_info(
     config: &Config,
@@ -348,22 +379,22 @@ fn new_parsed_command(
 
     for parsed in parsed_commands.iter() {
         let text = match parsed {
-            ParsedCommand::Read { name, .. } => format!("📖 {name}"),
+            ParsedCommand::Read { name, .. } => padded_emoji_with("📖", name),
             ParsedCommand::ListFiles { cmd, path } => match path {
-                Some(p) => format!("📂 {p}"),
-                None => format!("📂 {cmd}"),
+                Some(p) => padded_emoji_with("📂", p),
+                None => padded_emoji_with("📂", cmd),
             },
             ParsedCommand::Search { query, path, cmd } => match (query, path) {
-                (Some(q), Some(p)) => format!("🔎 {q} in {p}"),
-                (Some(q), None) => format!("🔎 {q}"),
-                (None, Some(p)) => format!("🔎 {p}"),
-                (None, None) => format!("🔎 {cmd}"),
+                (Some(q), Some(p)) => padded_emoji_with("🔎", format!("{q} in {p}")),
+                (Some(q), None) => padded_emoji_with("🔎", q),
+                (None, Some(p)) => padded_emoji_with("🔎", p),
+                (None, None) => padded_emoji_with("🔎", cmd),
             },
-            ParsedCommand::Format { .. } => "✨ Formatting".to_string(),
-            ParsedCommand::Test { cmd } => format!("🧪 {cmd}"),
-            ParsedCommand::Lint { cmd, .. } => format!("🧹 {cmd}"),
-            ParsedCommand::Unknown { cmd } => format!("⌨️ {cmd}"),
-            ParsedCommand::Noop { cmd } => format!("🔄 {cmd}"),
+            ParsedCommand::Format { .. } => padded_emoji_with("✨", "Formatting"),
+            ParsedCommand::Test { cmd } => padded_emoji_with("🧪", cmd),
+            ParsedCommand::Lint { cmd, .. } => padded_emoji_with("🧹", cmd),
+            ParsedCommand::Unknown { cmd } => padded_emoji_with("⌨️", cmd),
+            ParsedCommand::Noop { cmd } => padded_emoji_with("🔄", cmd),
         };
         // Prefix: two spaces, marker, space. Continuations align under the text block.
         for (j, line_text) in text.lines().enumerate() {
@@ -449,8 +480,10 @@ pub(crate) fn new_active_mcp_tool_call(invocation: McpInvocation) -> PlainHistor
 }
 
 pub(crate) fn new_web_search_call(query: String) -> PlainHistoryCell {
-    let lines: Vec<Line<'static>> =
-        vec![Line::from(""), Line::from(vec!["🌐 ".into(), query.into()])];
+    let lines: Vec<Line<'static>> = vec![
+        Line::from(""),
+        Line::from(vec![padded_emoji("🌐").into(), query.into()]),
+    ];
     PlainHistoryCell { lines }
 }
 
@@ -594,7 +627,10 @@ pub(crate) fn new_status_output(
     };
 
     // 📂 Workspace
-    lines.push(Line::from(vec!["📂 ".into(), "Workspace".bold()]));
+    lines.push(Line::from(vec![
+        padded_emoji("📂").into(),
+        "Workspace".bold(),
+    ]));
     // Path (home-relative, e.g., ~/code/project)
     let cwd_str = match relativize_to_home(&config.cwd) {
         Some(rel) if !rel.as_os_str().is_empty() => {
@@ -675,7 +711,10 @@ pub(crate) fn new_status_output(
     if let Ok(auth) = try_read_auth_json(&auth_file)
         && let Some(tokens) = auth.tokens.clone()
     {
-        lines.push(Line::from(vec!["👤 ".into(), "Account".bold()]));
+        lines.push(Line::from(vec![
+            padded_emoji("👤").into(),
+            "Account".bold(),
+        ]));
         lines.push(Line::from("  • Signed in with ChatGPT"));
 
         let info = tokens.id_token;
@@ -702,7 +741,7 @@ pub(crate) fn new_status_output(
     }
 
     // 🧠 Model
-    lines.push(Line::from(vec!["🧠 ".into(), "Model".bold()]));
+    lines.push(Line::from(vec![padded_emoji("🧠").into(), "Model".bold()]));
     lines.push(Line::from(vec![
         "  • Name: ".into(),
         config.model.clone().into(),
@@ -853,13 +892,26 @@ pub(crate) fn new_mcp_tools_output(
 }
 
 pub(crate) fn new_error_event(message: String) -> PlainHistoryCell {
-    let lines: Vec<Line<'static>> = vec!["".into(), vec!["🖐 ".red().bold(), message.into()].into()];
+    // Use a hair space (U+200A) to create a subtle, near-invisible separation
+    // before the text. VS16 is intentionally omitted to keep spacing tighter
+    // in terminals like Ghostty.
+    let lines: Vec<Line<'static>> = vec![
+        "".into(),
+        vec![padded_emoji("🖐").red().bold(), " ".into(), message.into()].into(),
+    ];
     PlainHistoryCell { lines }
 }
 
 pub(crate) fn new_stream_error_event(message: String) -> PlainHistoryCell {
-    let lines: Vec<Line<'static>> =
-        vec![vec!["⚠ ".magenta().bold(), message.dim()].into(), "".into()];
+    let lines: Vec<Line<'static>> = vec![
+        vec![
+            padded_emoji("⚠").magenta().bold(),
+            " ".into(),
+            message.dim(),
+        ]
+        .into(),
+        "".into(),
+    ];
     PlainHistoryCell { lines }
 }
 

codex-rs/tui/src/lib.rs

@@ -46,6 +46,7 @@ pub mod live_wrap;
 mod markdown;
 mod markdown_stream;
 pub mod onboarding;
+mod pager_overlay;
 mod render;
 mod session_log;
 mod shimmer;
@@ -53,7 +54,6 @@ mod slash_command;
 mod status_indicator_widget;
 mod streaming;
 mod text_formatting;
-mod transcript_app;
 mod tui;
 mod user_approval_widget;
 

codex-rs/tui/src/pager_overlay.rs

@@ -0,0 +1,603 @@
+use std::io::Result;
+use std::time::Duration;
+
+use crate::insert_history;
+use crate::tui;
+use crate::tui::TuiEvent;
+use crossterm::event::KeyCode;
+use crossterm::event::KeyEvent;
+use crossterm::event::KeyEventKind;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Color;
+use ratatui::style::Style;
+use ratatui::style::Styled;
+use ratatui::style::Stylize;
+use ratatui::text::Line;
+use ratatui::text::Span;
+use ratatui::widgets::Paragraph;
+use ratatui::widgets::WidgetRef;
+
+pub(crate) enum Overlay {
+    Transcript(TranscriptOverlay),
+    Static(StaticOverlay),
+}
+
+impl Overlay {
+    pub(crate) fn new_transcript(lines: Vec<Line<'static>>) -> Self {
+        Self::Transcript(TranscriptOverlay::new(lines))
+    }
+
+    pub(crate) fn new_static_with_title(lines: Vec<Line<'static>>, title: String) -> Self {
+        Self::Static(StaticOverlay::with_title(lines, title))
+    }
+
+    pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
+        match self {
+            Overlay::Transcript(o) => o.handle_event(tui, event),
+            Overlay::Static(o) => o.handle_event(tui, event),
+        }
+    }
+
+    pub(crate) fn is_done(&self) -> bool {
+        match self {
+            Overlay::Transcript(o) => o.is_done(),
+            Overlay::Static(o) => o.is_done(),
+        }
+    }
+}
+
+// Common pager navigation hints rendered on the first line
+const PAGER_KEY_HINTS: &[(&str, &str)] = &[
+    ("↑/↓", "scroll"),
+    ("PgUp/PgDn", "page"),
+    ("Home/End", "jump"),
+];
+
+// Render a single line of key hints from (key, description) pairs.
+fn render_key_hints(area: Rect, buf: &mut Buffer, pairs: &[(&str, &str)]) {
+    let key_hint_style = Style::default().fg(Color::Cyan);
+    let mut spans: Vec<Span<'static>> = vec![" ".into()];
+    let mut first = true;
+    for (key, desc) in pairs {
+        if !first {
+            spans.push("   ".into());
+        }
+        spans.push(Span::from(key.to_string()).set_style(key_hint_style));
+        spans.push(" ".into());
+        spans.push(Span::from(desc.to_string()));
+        first = false;
+    }
+    Paragraph::new(vec![Line::from(spans).dim()]).render_ref(area, buf);
+}
+
+/// Generic widget for rendering a pager view.
+struct PagerView {
+    lines: Vec<Line<'static>>,
+    scroll_offset: usize,
+    title: String,
+    wrap_cache: Option<WrapCache>,
+}
+
+impl PagerView {
+    fn new(lines: Vec<Line<'static>>, title: String, scroll_offset: usize) -> Self {
+        Self {
+            lines,
+            scroll_offset,
+            title,
+            wrap_cache: None,
+        }
+    }
+
+    fn render(&mut self, area: Rect, buf: &mut Buffer) {
+        self.render_header(area, buf);
+        let content_area = self.scroll_area(area);
+        self.ensure_wrapped(content_area.width);
+        // Compute page bounds without holding an immutable borrow on cache while mutating self
+        let wrapped_len = self
+            .wrap_cache
+            .as_ref()
+            .map(|c| c.wrapped.len())
+            .unwrap_or(0);
+        self.scroll_offset = self
+            .scroll_offset
+            .min(wrapped_len.saturating_sub(content_area.height as usize));
+        let start = self.scroll_offset;
+        let end = (start + content_area.height as usize).min(wrapped_len);
+
+        let (wrapped, _src_idx) = self.cached();
+        let page = &wrapped[start..end];
+        self.render_content_page_prepared(content_area, buf, page);
+        self.render_bottom_bar(area, content_area, buf, wrapped);
+    }
+
+    fn render_with_highlight(
+        &mut self,
+        area: Rect,
+        buf: &mut Buffer,
+        highlight: Option<(usize, usize)>,
+    ) {
+        self.render_header(area, buf);
+        let content_area = self.scroll_area(area);
+        self.ensure_wrapped(content_area.width);
+        // Compute page bounds first to avoid borrow conflicts
+        let wrapped_len = self
+            .wrap_cache
+            .as_ref()
+            .map(|c| c.wrapped.len())
+            .unwrap_or(0);
+        self.scroll_offset = self
+            .scroll_offset
+            .min(wrapped_len.saturating_sub(content_area.height as usize));
+        let start = self.scroll_offset;
+        let end = (start + content_area.height as usize).min(wrapped_len);
+
+        let (wrapped, src_idx) = self.cached();
+        let page = self.page_with_optional_highlight(wrapped, src_idx, start, end, highlight);
+        self.render_content_page_prepared(content_area, buf, &page);
+        self.render_bottom_bar(area, content_area, buf, wrapped);
+    }
+
+    fn render_header(&self, area: Rect, buf: &mut Buffer) {
+        Span::from("/ ".repeat(area.width as usize / 2))
+            .dim()
+            .render_ref(area, buf);
+        let header = format!("/ {}", self.title);
+        Span::from(header).dim().render_ref(area, buf);
+    }
+
+    // Removed unused render_content_page (replaced by render_content_page_prepared)
+
+    fn render_content_page_prepared(&self, area: Rect, buf: &mut Buffer, page: &[Line<'static>]) {
+        Paragraph::new(page.to_vec()).render_ref(area, buf);
+
+        let visible = page.len();
+        if visible < area.height as usize {
+            for i in 0..(area.height as usize - visible) {
+                let add = ((visible + i).min(u16::MAX as usize)) as u16;
+                let y = area.y.saturating_add(add);
+                Span::from("~")
+                    .dim()
+                    .render_ref(Rect::new(area.x, y, 1, 1), buf);
+            }
+        }
+    }
+
+    fn render_bottom_bar(
+        &self,
+        full_area: Rect,
+        content_area: Rect,
+        buf: &mut Buffer,
+        wrapped: &[Line<'static>],
+    ) {
+        let sep_y = content_area.bottom();
+        let sep_rect = Rect::new(full_area.x, sep_y, full_area.width, 1);
+
+        Span::from("─".repeat(sep_rect.width as usize))
+            .dim()
+            .render_ref(sep_rect, buf);
+        let percent = if wrapped.is_empty() {
+            100
+        } else {
+            let max_scroll = wrapped.len().saturating_sub(content_area.height as usize);
+            if max_scroll == 0 {
+                100
+            } else {
+                (((self.scroll_offset.min(max_scroll)) as f32 / max_scroll as f32) * 100.0).round()
+                    as u8
+            }
+        };
+        let pct_text = format!(" {percent}% ");
+        let pct_w = pct_text.chars().count() as u16;
+        let pct_x = sep_rect.x + sep_rect.width - pct_w - 1;
+        Span::from(pct_text)
+            .dim()
+            .render_ref(Rect::new(pct_x, sep_rect.y, pct_w, 1), buf);
+    }
+
+    fn handle_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) -> Result<()> {
+        match key_event {
+            KeyEvent {
+                code: KeyCode::Up,
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                self.scroll_offset = self.scroll_offset.saturating_sub(1);
+            }
+            KeyEvent {
+                code: KeyCode::Down,
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                self.scroll_offset = self.scroll_offset.saturating_add(1);
+            }
+            KeyEvent {
+                code: KeyCode::PageUp,
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                let area = self.scroll_area(tui.terminal.viewport_area);
+                self.scroll_offset = self.scroll_offset.saturating_sub(area.height as usize);
+            }
+            KeyEvent {
+                code: KeyCode::PageDown | KeyCode::Char(' '),
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                let area = self.scroll_area(tui.terminal.viewport_area);
+                self.scroll_offset = self.scroll_offset.saturating_add(area.height as usize);
+            }
+            KeyEvent {
+                code: KeyCode::Home,
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                self.scroll_offset = 0;
+            }
+            KeyEvent {
+                code: KeyCode::End,
+                kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                ..
+            } => {
+                self.scroll_offset = usize::MAX;
+            }
+            _ => {
+                return Ok(());
+            }
+        }
+        tui.frame_requester()
+            .schedule_frame_in(Duration::from_millis(16));
+        Ok(())
+    }
+
+    fn scroll_area(&self, area: Rect) -> Rect {
+        let mut area = area;
+        area.y = area.y.saturating_add(1);
+        area.height = area.height.saturating_sub(2);
+        area
+    }
+}
+
+#[derive(Debug, Clone)]
+struct WrapCache {
+    width: u16,
+    wrapped: Vec<Line<'static>>,
+    src_idx: Vec<usize>,
+    base_len: usize,
+}
+
+impl PagerView {
+    fn ensure_wrapped(&mut self, width: u16) {
+        let width = width.max(1);
+        let needs = match self.wrap_cache {
+            Some(ref c) => c.width != width || c.base_len != self.lines.len(),
+            None => true,
+        };
+        if !needs {
+            return;
+        }
+        let mut wrapped: Vec<Line<'static>> = Vec::new();
+        let mut src_idx: Vec<usize> = Vec::new();
+        for (i, line) in self.lines.iter().enumerate() {
+            let ws = insert_history::word_wrap_lines(std::slice::from_ref(line), width);
+            src_idx.extend(std::iter::repeat_n(i, ws.len()));
+            wrapped.extend(ws);
+        }
+        self.wrap_cache = Some(WrapCache {
+            width,
+            wrapped,
+            src_idx,
+            base_len: self.lines.len(),
+        });
+    }
+
+    fn cached(&self) -> (&[Line<'static>], &[usize]) {
+        if let Some(cache) = self.wrap_cache.as_ref() {
+            (&cache.wrapped, &cache.src_idx)
+        } else {
+            (&[], &[])
+        }
+    }
+
+    fn page_with_optional_highlight<'a>(
+        &self,
+        wrapped: &'a [Line<'static>],
+        src_idx: &[usize],
+        start: usize,
+        end: usize,
+        highlight: Option<(usize, usize)>,
+    ) -> std::borrow::Cow<'a, [Line<'static>]> {
+        use ratatui::style::Modifier;
+        let (hi_start, hi_end) = match highlight {
+            Some(r) => r,
+            None => return std::borrow::Cow::Borrowed(&wrapped[start..end]),
+        };
+        let mut out: Vec<Line<'static>> = Vec::with_capacity(end - start);
+        let mut bold_done = false;
+        for (row, src_line) in wrapped
+            .iter()
+            .enumerate()
+            .skip(start)
+            .take(end.saturating_sub(start))
+        {
+            let mut line = src_line.clone();
+            if let Some(src) = src_idx.get(row).copied()
+                && src >= hi_start
+                && src < hi_end
+            {
+                for (i, s) in line.spans.iter_mut().enumerate() {
+                    s.style.add_modifier |= Modifier::REVERSED;
+                    if !bold_done && i == 0 {
+                        s.style.add_modifier |= Modifier::BOLD;
+                        bold_done = true;
+                    }
+                }
+            }
+            out.push(line);
+        }
+        std::borrow::Cow::Owned(out)
+    }
+}
+
+pub(crate) struct TranscriptOverlay {
+    view: PagerView,
+    highlight_range: Option<(usize, usize)>,
+    is_done: bool,
+}
+
+impl TranscriptOverlay {
+    pub(crate) fn new(transcript_lines: Vec<Line<'static>>) -> Self {
+        Self {
+            view: PagerView::new(
+                transcript_lines,
+                "T R A N S C R I P T".to_string(),
+                usize::MAX,
+            ),
+            highlight_range: None,
+            is_done: false,
+        }
+    }
+
+    pub(crate) fn insert_lines(&mut self, lines: Vec<Line<'static>>) {
+        self.view.lines.extend(lines);
+        self.view.wrap_cache = None;
+    }
+
+    pub(crate) fn set_highlight_range(&mut self, range: Option<(usize, usize)>) {
+        self.highlight_range = range;
+    }
+
+    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);
+        render_key_hints(line1, buf, PAGER_KEY_HINTS);
+        let mut pairs: Vec<(&str, &str)> = vec![("q", "quit"), ("Esc", "edit prev")];
+        if let Some((start, end)) = self.highlight_range
+            && end > start
+        {
+            pairs.push(("⏎", "edit message"));
+        }
+        render_key_hints(line2, buf, &pairs);
+    }
+
+    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);
+        let bottom = Rect::new(area.x, area.y + top_h, area.width, 3);
+        self.view
+            .render_with_highlight(top, buf, self.highlight_range);
+        self.render_hints(bottom, buf);
+    }
+}
+
+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 {
+                KeyEvent {
+                    code: KeyCode::Char('q'),
+                    kind: KeyEventKind::Press,
+                    ..
+                }
+                | KeyEvent {
+                    code: KeyCode::Char('t'),
+                    modifiers: crossterm::event::KeyModifiers::CONTROL,
+                    kind: KeyEventKind::Press,
+                    ..
+                }
+                | KeyEvent {
+                    code: KeyCode::Char('c'),
+                    modifiers: crossterm::event::KeyModifiers::CONTROL,
+                    kind: KeyEventKind::Press,
+                    ..
+                } => {
+                    self.is_done = true;
+                    Ok(())
+                }
+                other => self.view.handle_key_event(tui, other),
+            },
+            TuiEvent::Draw => {
+                tui.draw(u16::MAX, |frame| {
+                    self.render(frame.area(), frame.buffer);
+                })?;
+                Ok(())
+            }
+            _ => Ok(()),
+        }
+    }
+    pub(crate) fn is_done(&self) -> bool {
+        self.is_done
+    }
+    pub(crate) fn set_scroll_offset(&mut self, offset: usize) {
+        self.view.scroll_offset = offset;
+    }
+}
+
+pub(crate) struct StaticOverlay {
+    view: PagerView,
+    is_done: bool,
+}
+
+impl StaticOverlay {
+    pub(crate) fn with_title(lines: Vec<Line<'static>>, title: String) -> Self {
+        Self {
+            view: PagerView::new(lines, title, 0),
+            is_done: false,
+        }
+    }
+
+    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);
+        render_key_hints(line1, buf, PAGER_KEY_HINTS);
+        let pairs = [("q", "quit")];
+        render_key_hints(line2, buf, &pairs);
+    }
+
+    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);
+        let bottom = Rect::new(area.x, area.y + top_h, area.width, 3);
+        self.view.render(top, buf);
+        self.render_hints(bottom, buf);
+    }
+}
+
+impl StaticOverlay {
+    pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
+        match event {
+            TuiEvent::Key(key_event) => match key_event {
+                KeyEvent {
+                    code: KeyCode::Char('q'),
+                    kind: KeyEventKind::Press,
+                    ..
+                }
+                | KeyEvent {
+                    code: KeyCode::Char('c'),
+                    modifiers: crossterm::event::KeyModifiers::CONTROL,
+                    kind: KeyEventKind::Press,
+                    ..
+                } => {
+                    self.is_done = true;
+                    Ok(())
+                }
+                other => self.view.handle_key_event(tui, other),
+            },
+            TuiEvent::Draw => {
+                tui.draw(u16::MAX, |frame| {
+                    self.render(frame.area(), frame.buffer);
+                })?;
+                Ok(())
+            }
+            _ => Ok(()),
+        }
+    }
+    pub(crate) fn is_done(&self) -> bool {
+        self.is_done
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use insta::assert_snapshot;
+    use ratatui::Terminal;
+    use ratatui::backend::TestBackend;
+
+    #[test]
+    fn edit_prev_hint_is_visible() {
+        let mut overlay = TranscriptOverlay::new(vec![Line::from("hello")]);
+
+        // Render into a small buffer and assert the backtrack hint is present
+        let area = Rect::new(0, 0, 40, 10);
+        let mut buf = Buffer::empty(area);
+        overlay.render(area, &mut buf);
+
+        // Flatten buffer to a string and check for the hint text
+        let mut s = String::new();
+        for y in area.y..area.bottom() {
+            for x in area.x..area.right() {
+                s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
+            }
+            s.push('\n');
+        }
+        assert!(
+            s.contains("edit prev"),
+            "expected 'edit prev' hint in overlay footer, got: {s:?}"
+        );
+    }
+
+    #[test]
+    fn transcript_overlay_snapshot_basic() {
+        // Prepare a transcript overlay with a few lines
+        let mut overlay = TranscriptOverlay::new(vec![
+            Line::from("alpha"),
+            Line::from("beta"),
+            Line::from("gamma"),
+        ]);
+        let mut term = Terminal::new(TestBackend::new(40, 10)).expect("term");
+        term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
+            .expect("draw");
+        assert_snapshot!(term.backend());
+    }
+
+    #[test]
+    fn static_overlay_snapshot_basic() {
+        // Prepare a static overlay with a few lines and a title
+        let mut overlay = StaticOverlay::with_title(
+            vec![Line::from("one"), Line::from("two"), Line::from("three")],
+            "S T A T I C".to_string(),
+        );
+        let mut term = Terminal::new(TestBackend::new(40, 10)).expect("term");
+        term.draw(|f| overlay.render(f.area(), f.buffer_mut()))
+            .expect("draw");
+        assert_snapshot!(term.backend());
+    }
+
+    #[test]
+    fn pager_wrap_cache_reuses_for_same_width_and_rebuilds_on_change() {
+        let long = "This is a long line that should wrap multiple times to ensure non-empty wrapped output.";
+        let mut pv = PagerView::new(vec![Line::from(long), Line::from(long)], "T".to_string(), 0);
+
+        // Build cache at width 24
+        pv.ensure_wrapped(24);
+        let (w1, _) = pv.cached();
+        assert!(!w1.is_empty(), "expected wrapped output to be non-empty");
+        let ptr1 = w1.as_ptr();
+
+        // Re-run with same width: cache should be reused (pointer stability heuristic)
+        pv.ensure_wrapped(24);
+        let (w2, _) = pv.cached();
+        let ptr2 = w2.as_ptr();
+        assert_eq!(ptr1, ptr2, "cache should not rebuild for unchanged width");
+
+        // Change width: cache should rebuild and likely produce different length
+        // Drop immutable borrow before mutating
+        let prev_len = w2.len();
+        pv.ensure_wrapped(36);
+        let (w3, _) = pv.cached();
+        assert_ne!(
+            prev_len,
+            w3.len(),
+            "wrapped length should change on width change"
+        );
+    }
+
+    #[test]
+    fn pager_wrap_cache_invalidates_on_append() {
+        let long = "Another long line for wrapping behavior verification.";
+        let mut pv = PagerView::new(vec![Line::from(long)], "T".to_string(), 0);
+        pv.ensure_wrapped(28);
+        let (w1, _) = pv.cached();
+        let len1 = w1.len();
+
+        // Append new lines should cause ensure_wrapped to rebuild due to len change
+        pv.lines.extend([Line::from(long), Line::from(long)]);
+        pv.ensure_wrapped(28);
+        let (w2, _) = pv.cached();
+        assert!(
+            w2.len() >= len1,
+            "wrapped length should grow or stay same after append"
+        );
+    }
+}

codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__static_overlay_snapshot_basic.snap

@@ -0,0 +1,14 @@
+---
+source: tui/src/pager_overlay.rs
+expression: term.backend()
+---
+"/ S T A T I C / / / / / / / / / / / / / "
+"one                                     "
+"two                                     "
+"three                                   "
+"~                                       "
+"~                                       "
+"───────────────────────────────── 100% ─"
+" ↑/↓ scroll   PgUp/PgDn page   Home/End "
+" q quit                                 "
+"                                        "

codex-rs/tui/src/snapshots/codex_tui__pager_overlay__tests__transcript_overlay_snapshot_basic.snap

@@ -0,0 +1,14 @@
+---
+source: tui/src/pager_overlay.rs
+expression: term.backend()
+---
+"/ T R A N S C R I P T / / / / / / / / / "
+"alpha                                   "
+"beta                                    "
+"gamma                                   "
+"~                                       "
+"~                                       "
+"───────────────────────────────── 100% ─"
+" ↑/↓ scroll   PgUp/PgDn page   Home/End "
+" q quit   Esc edit prev                 "
+"                                        "

codex-rs/tui/src/status_indicator_widget.rs

@@ -123,10 +123,10 @@ impl WidgetRef for StatusIndicatorWidget {
             for (i, piece) in wrapped.iter().take(3).enumerate() {
                 let prefix = if i == 0 { " ↳ " } else { "   " };
                 let content = format!("{prefix}{piece}");
-                lines.push(Line::from(content.dim()));
+                lines.push(Line::from(content.dim().italic()));
             }
             if wrapped.len() > 3 {
-                lines.push(Line::from("   …".dim()));
+                lines.push(Line::from("   …".dim().italic()));
             }
         }
         if !self.queued_messages.is_empty() {

codex-rs/tui/src/transcript_app.rs

@@ -1,337 +0,0 @@
-use std::io::Result;
-
-use crate::insert_history;
-use crate::tui;
-use crate::tui::TuiEvent;
-use crossterm::event::KeyCode;
-use crossterm::event::KeyEvent;
-use crossterm::event::KeyEventKind;
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::style::Color;
-use ratatui::style::Style;
-use ratatui::style::Styled;
-use ratatui::style::Stylize;
-use ratatui::text::Line;
-use ratatui::text::Span;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::WidgetRef;
-
-pub(crate) struct TranscriptApp {
-    pub(crate) transcript_lines: Vec<Line<'static>>,
-    pub(crate) scroll_offset: usize,
-    pub(crate) is_done: bool,
-    title: String,
-    highlight_range: Option<(usize, usize)>,
-}
-
-impl TranscriptApp {
-    pub(crate) fn new(transcript_lines: Vec<Line<'static>>) -> Self {
-        Self {
-            transcript_lines,
-            scroll_offset: usize::MAX,
-            is_done: false,
-            title: "T R A N S C R I P T".to_string(),
-            highlight_range: None,
-        }
-    }
-
-    pub(crate) fn with_title(transcript_lines: Vec<Line<'static>>, title: String) -> Self {
-        Self {
-            transcript_lines,
-            scroll_offset: 0,
-            is_done: false,
-            title,
-            highlight_range: None,
-        }
-    }
-    pub(crate) fn insert_lines(&mut self, lines: Vec<Line<'static>>) {
-        self.transcript_lines.extend(lines);
-    }
-
-    /// Highlight the specified range [start, end) of transcript lines.
-    pub(crate) fn set_highlight_range(&mut self, range: Option<(usize, usize)>) {
-        self.highlight_range = range;
-    }
-
-    pub(crate) fn handle_event(&mut self, tui: &mut tui::Tui, event: TuiEvent) -> Result<()> {
-        match event {
-            TuiEvent::Key(key_event) => self.handle_key_event(tui, key_event),
-            TuiEvent::Draw => {
-                tui.draw(u16::MAX, |frame| {
-                    self.render(frame.area(), frame.buffer);
-                })?;
-            }
-            _ => {}
-        }
-        Ok(())
-    }
-
-    // set_backtrack_mode removed: overlay always shows backtrack guidance now.
-
-    fn render(&mut self, area: Rect, buf: &mut Buffer) {
-        self.render_header(area, buf);
-
-        // Main content area (excludes header and bottom status section)
-        let content_area = self.scroll_area(area);
-        let mut lines = self.transcript_lines.clone();
-        self.apply_highlight_to_lines(&mut lines);
-        let wrapped = insert_history::word_wrap_lines(&lines, content_area.width);
-
-        self.render_content_page(content_area, buf, &wrapped);
-        self.render_bottom_section(area, content_area, buf, &wrapped);
-    }
-
-    // Private helpers
-    fn render_header(&self, area: Rect, buf: &mut Buffer) {
-        Span::from("/ ".repeat(area.width as usize / 2))
-            .dim()
-            .render_ref(area, buf);
-        let header = format!("/ {}", self.title);
-        Span::from(header).dim().render_ref(area, buf);
-    }
-
-    fn apply_highlight_to_lines(&self, lines: &mut [Line<'static>]) {
-        if let Some((start, end)) = self.highlight_range {
-            use ratatui::style::Modifier;
-            let len = lines.len();
-            let start = start.min(len);
-            let end = end.min(len);
-            for (idx, line) in lines.iter_mut().enumerate().take(end).skip(start) {
-                let mut spans = Vec::with_capacity(line.spans.len());
-                for (i, s) in line.spans.iter().enumerate() {
-                    let mut style = s.style;
-                    style.add_modifier |= Modifier::REVERSED;
-                    if idx == start && i == 0 {
-                        style.add_modifier |= Modifier::BOLD;
-                    }
-                    spans.push(Span {
-                        style,
-                        content: s.content.clone(),
-                    });
-                }
-                line.spans = spans;
-            }
-        }
-    }
-
-    fn render_content_page(&mut self, area: Rect, buf: &mut Buffer, wrapped: &[Line<'static>]) {
-        // Clamp scroll offset to valid range
-        self.scroll_offset = self
-            .scroll_offset
-            .min(wrapped.len().saturating_sub(area.height as usize));
-        let start = self.scroll_offset;
-        let end = (start + area.height as usize).min(wrapped.len());
-        let page = &wrapped[start..end];
-        Paragraph::new(page.to_vec()).render_ref(area, buf);
-
-        // Fill remaining visible lines (if any) with a leading '~' in the first column.
-        let visible = (end - start) as u16;
-        if area.height > visible {
-            let extra = area.height - visible;
-            for i in 0..extra {
-                let y = area.y.saturating_add(visible + i);
-                Span::from("~")
-                    .dim()
-                    .render_ref(Rect::new(area.x, y, 1, 1), buf);
-            }
-        }
-    }
-
-    /// Render the bottom status section (separator, percent scrolled, key hints).
-    fn render_bottom_section(
-        &self,
-        full_area: Rect,
-        content_area: Rect,
-        buf: &mut Buffer,
-        wrapped: &[Line<'static>],
-    ) {
-        let sep_y = content_area.bottom();
-        let sep_rect = Rect::new(full_area.x, sep_y, full_area.width, 1);
-        let hints_rect = Rect::new(full_area.x, sep_y + 1, full_area.width, 2);
-
-        self.render_separator(buf, sep_rect);
-        let percent = self.compute_scroll_percent(wrapped.len(), content_area.height);
-        self.render_scroll_percentage(buf, sep_rect, percent);
-        self.render_hints(buf, hints_rect);
-    }
-
-    /// Draw a dim horizontal separator line across the provided rect.
-    fn render_separator(&self, buf: &mut Buffer, sep_rect: Rect) {
-        Span::from("─".repeat(sep_rect.width as usize))
-            .dim()
-            .render_ref(sep_rect, buf);
-    }
-
-    /// Compute percent scrolled (0–100) based on wrapped length and content height.
-    fn compute_scroll_percent(&self, wrapped_len: usize, content_height: u16) -> u8 {
-        let max_scroll = wrapped_len.saturating_sub(content_height as usize);
-        if max_scroll == 0 {
-            100
-        } else {
-            (((self.scroll_offset.min(max_scroll)) as f32 / max_scroll as f32) * 100.0).round()
-                as u8
-        }
-    }
-
-    /// Right-align and render the dim percent scrolled label on the separator line.
-    fn render_scroll_percentage(&self, buf: &mut Buffer, sep_rect: Rect, percent: u8) {
-        let pct_text = format!(" {percent}% ");
-        let pct_w = pct_text.chars().count() as u16;
-        let pct_x = sep_rect.x + sep_rect.width - pct_w - 1;
-        Span::from(pct_text)
-            .dim()
-            .render_ref(Rect::new(pct_x, sep_rect.y, pct_w, 1), buf);
-    }
-
-    /// Render the dimmed key hints (scroll/page/jump and backtrack cue).
-    fn render_hints(&self, buf: &mut Buffer, hints_rect: Rect) {
-        let key_hint_style = Style::default().fg(Color::Cyan);
-        let hints1 = vec![
-            " ".into(),
-            "↑".set_style(key_hint_style),
-            "/".into(),
-            "↓".set_style(key_hint_style),
-            " scroll   ".into(),
-            "PgUp".set_style(key_hint_style),
-            "/".into(),
-            "PgDn".set_style(key_hint_style),
-            " page   ".into(),
-            "Home".set_style(key_hint_style),
-            "/".into(),
-            "End".set_style(key_hint_style),
-            " jump".into(),
-        ];
-        let mut hints2 = vec![" ".into(), "q".set_style(key_hint_style), " quit".into()];
-        hints2.extend([
-            "   ".into(),
-            "Esc".set_style(key_hint_style),
-            " edit prev".into(),
-        ]);
-        self.maybe_append_enter_edit_hint(&mut hints2, key_hint_style);
-        Paragraph::new(vec![Line::from(hints1).dim(), Line::from(hints2).dim()])
-            .render_ref(hints_rect, buf);
-    }
-
-    /// Conditionally append the "⏎ edit message" hint when a valid highlight is active.
-    fn maybe_append_enter_edit_hint(&self, hints: &mut Vec<Span<'static>>, key_hint_style: Style) {
-        if let Some((start, end)) = self.highlight_range
-            && end > start
-        {
-            hints.extend([
-                "   ".into(),
-                "⏎".set_style(key_hint_style),
-                " edit message".into(),
-            ]);
-        }
-    }
-
-    fn handle_key_event(&mut self, tui: &mut tui::Tui, key_event: KeyEvent) {
-        match key_event {
-            // Ctrl+Z is handled at the App level when transcript overlay is active
-            KeyEvent {
-                code: KeyCode::Char('q'),
-                kind: KeyEventKind::Press,
-                ..
-            }
-            | KeyEvent {
-                code: KeyCode::Char('t'),
-                modifiers: crossterm::event::KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            }
-            | KeyEvent {
-                code: KeyCode::Char('c'),
-                modifiers: crossterm::event::KeyModifiers::CONTROL,
-                kind: KeyEventKind::Press,
-                ..
-            } => {
-                self.is_done = true;
-            }
-            KeyEvent {
-                code: KeyCode::Up,
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                self.scroll_offset = self.scroll_offset.saturating_sub(1);
-            }
-            KeyEvent {
-                code: KeyCode::Down,
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                self.scroll_offset = self.scroll_offset.saturating_add(1);
-            }
-            KeyEvent {
-                code: KeyCode::PageUp,
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                let area = self.scroll_area(tui.terminal.viewport_area);
-                self.scroll_offset = self.scroll_offset.saturating_sub(area.height as usize);
-            }
-            KeyEvent {
-                code: KeyCode::PageDown | KeyCode::Char(' '),
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                let area = self.scroll_area(tui.terminal.viewport_area);
-                self.scroll_offset = self.scroll_offset.saturating_add(area.height as usize);
-            }
-            KeyEvent {
-                code: KeyCode::Home,
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                self.scroll_offset = 0;
-            }
-            KeyEvent {
-                code: KeyCode::End,
-                kind: KeyEventKind::Press | KeyEventKind::Repeat,
-                ..
-            } => {
-                self.scroll_offset = usize::MAX;
-            }
-            _ => {
-                return;
-            }
-        }
-        tui.frame_requester().schedule_frame();
-    }
-
-    fn scroll_area(&self, area: Rect) -> Rect {
-        let mut area = area;
-        // Reserve 1 line for the header and 4 lines for the bottom status section. This matches the chat composer.
-        area.y = area.y.saturating_add(1);
-        area.height = area.height.saturating_sub(5);
-        area
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn edit_prev_hint_is_visible() {
-        let mut app = TranscriptApp::new(vec![Line::from("hello")]);
-
-        // Render into a small buffer and assert the backtrack hint is present
-        let area = Rect::new(0, 0, 40, 10);
-        let mut buf = Buffer::empty(area);
-        app.render(area, &mut buf);
-
-        // Flatten buffer to a string and check for the hint text
-        let mut s = String::new();
-        for y in area.y..area.bottom() {
-            for x in area.x..area.right() {
-                s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
-            }
-            s.push('\n');
-        }
-        assert!(
-            s.contains("edit prev"),
-            "expected 'edit prev' hint in overlay footer, got: {s:?}"
-        );
-    }
-}

codex-rs/tui/src/tui.rs

@@ -11,6 +11,7 @@ use std::sync::atomic::Ordering;
 use std::time::Duration;
 use std::time::Instant;
 
+use crossterm::Command;
 use crossterm::SynchronizedUpdate;
 use crossterm::cursor;
 use crossterm::cursor::MoveTo;
@@ -65,6 +66,48 @@ pub fn set_modes() -> Result<()> {
     Ok(())
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct EnableAlternateScroll;
+
+impl Command for EnableAlternateScroll {
+    fn write_ansi(&self, f: &mut impl std::fmt::Write) -> std::fmt::Result {
+        write!(f, "\x1b[?1007h")
+    }
+
+    #[cfg(windows)]
+    fn execute_winapi(&self) -> std::io::Result<()> {
+        Err(std::io::Error::other(
+            "tried to execute EnableAlternateScroll using WinAPI; use ANSI instead",
+        ))
+    }
+
+    #[cfg(windows)]
+    fn is_ansi_code_supported(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct DisableAlternateScroll;
+
+impl Command for DisableAlternateScroll {
+    fn write_ansi(&self, f: &mut impl std::fmt::Write) -> std::fmt::Result {
+        write!(f, "\x1b[?1007l")
+    }
+
+    #[cfg(windows)]
+    fn execute_winapi(&self) -> std::io::Result<()> {
+        Err(std::io::Error::other(
+            "tried to execute DisableAlternateScroll using WinAPI; use ANSI instead",
+        ))
+    }
+
+    #[cfg(windows)]
+    fn is_ansi_code_supported(&self) -> bool {
+        true
+    }
+}
+
 /// Restore the terminal to its original state.
 /// Inverse of `set_modes`.
 pub fn restore() -> Result<()> {
@@ -290,6 +333,8 @@ impl Tui {
                                 )
                                 {
                                     if alt_screen_active.load(Ordering::Relaxed) {
+                                        // Disable alternate scroll when suspending from alt-screen
+                                        let _ = execute!(stdout(), DisableAlternateScroll);
                                         let _ = execute!(stdout(), LeaveAlternateScreen);
                                         resume_pending.store(ResumeAction::RestoreAlt as u8, Ordering::Relaxed);
                                     } else {
@@ -370,6 +415,8 @@ impl Tui {
             }
             PreparedResumeAction::RestoreAltScreen => {
                 execute!(self.terminal.backend_mut(), EnterAlternateScreen)?;
+                // Enable "alternate scroll" so terminals may translate wheel to arrows
+                execute!(self.terminal.backend_mut(), EnableAlternateScroll)?;
                 if let Ok(size) = self.terminal.size() {
                     self.terminal.set_viewport_area(ratatui::layout::Rect::new(
                         0,
@@ -388,6 +435,8 @@ impl Tui {
     /// inline viewport for restoration when leaving.
     pub fn enter_alt_screen(&mut self) -> Result<()> {
         let _ = execute!(self.terminal.backend_mut(), EnterAlternateScreen);
+        // Enable "alternate scroll" so terminals may translate wheel to arrows
+        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.set_viewport_area(ratatui::layout::Rect::new(
@@ -404,6 +453,8 @@ impl Tui {
 
     /// Leave alternate screen and restore the previously saved inline viewport, if any.
     pub fn leave_alt_screen(&mut self) -> Result<()> {
+        // Disable alternate scroll when leaving alt-screen
+        let _ = execute!(self.terminal.backend_mut(), DisableAlternateScroll);
         let _ = execute!(self.terminal.backend_mut(), LeaveAlternateScreen);
         if let Some(saved) = self.alt_saved_viewport.take() {
             self.terminal.set_viewport_area(saved);

codex-rs/tui/src/user_approval_widget.rs

@@ -69,20 +69,9 @@ static COMMAND_SELECT_OPTIONS: LazyLock<Vec<SelectOption>> = LazyLock::new(|| {
             decision: ReviewDecision::ApprovedForSession,
         },
         SelectOption {
-            label: Line::from(vec!["N".underlined(), "o".into()]),
-            description: "Do not run the command",
-            key: KeyCode::Char('n'),
-            decision: ReviewDecision::Denied,
-        },
-        SelectOption {
-            label: Line::from(vec![
-                "No, ".into(),
-                "provide ".into(),
-                "f".underlined(),
-                "eedback".into(),
-            ]),
+            label: Line::from(vec!["N".underlined(), "o, provide feedback".into()]),
             description: "Do not run the command; provide feedback",
-            key: KeyCode::Char('f'),
+            key: KeyCode::Char('n'),
             decision: ReviewDecision::Abort,
         },
     ]
@@ -97,20 +86,9 @@ static PATCH_SELECT_OPTIONS: LazyLock<Vec<SelectOption>> = LazyLock::new(|| {
             decision: ReviewDecision::Approved,
         },
         SelectOption {
-            label: Line::from(vec!["N".underlined(), "o".into()]),
-            description: "Do not apply the changes",
-            key: KeyCode::Char('n'),
-            decision: ReviewDecision::Denied,
-        },
-        SelectOption {
-            label: Line::from(vec![
-                "No, ".into(),
-                "provide ".into(),
-                "f".underlined(),
-                "eedback".into(),
-            ]),
+            label: Line::from(vec!["N".underlined(), "o, provide feedback".into()]),
             description: "Do not apply the changes; provide feedback",
-            key: KeyCode::Char('f'),
+            key: KeyCode::Char('n'),
             decision: ReviewDecision::Abort,
         },
     ]

codex-rs/tui/tests/fixtures/binary-size-log.jsonl

@@ -3698,7 +3698,7 @@
 {"ts":"2025-08-09T15:53:04.318Z","dir":"to_tui","kind":"app_event","variant":"RequestRedraw"}
 {"ts":"2025-08-09T15:53:04.320Z","dir":"to_tui","kind":"app_event","variant":"Redraw"}
 {"ts":"2025-08-09T15:53:04.353Z","dir":"to_tui","kind":"codex_event","payload":{"id":"1","msg":{"type":"exec_command_output_delta","call_id":"call_KOxVodT3X5ci7LJmudvcovhW","stream":"stderr","chunk":[32,32,32,32,70,105,110,105,115,104,101,100,32,96,100,101,118,96,32,112,114,111,102,105,108,101,32,91,117,110,111,112,116,105,109,105,122,101,100,32,43,32,100,101,98,117,103,105,110,102,111,93,32,116,97,114,103,101,116,40,115,41,32,105,110,32,53,56,46,50,49,115,10]}}}
-{"ts":"2025-08-09T15:53:04.389Z","dir":"to_tui","kind":"codex_event","payload":{"id":"1","msg":{"type":"exec_command_end","call_id":"call_KOxVodT3X5ci7LJmudvcovhW","stdout":"","stderr":"sandbox error: command timed out","exit_code":-1,"duration":{"secs":0,"nanos":0}}}}
+{"ts":"2025-08-09T15:53:04.389Z","dir":"to_tui","kind":"codex_event","payload":{"id":"1","msg":{"type":"exec_command_end","call_id":"call_KOxVodT3X5ci7LJmudvcovhW","stdout":"","stderr":"error: command timed out","exit_code":-1,"duration":{"secs":0,"nanos":0}}}}
 {"ts":"2025-08-09T15:53:04.389Z","dir":"to_tui","kind":"codex_event","payload":{"id":"1","msg":{"type":"token_count","input_tokens":14859,"cached_input_tokens":14625,"output_tokens":117,"reasoning_output_tokens":64,"total_tokens":14976}}}
 {"ts":"2025-08-09T15:53:04.389Z","dir":"to_tui","kind":"codex_event","payload":{"id":"1","msg":{"type":"turn_diff","unified_diff":"diff --git a/codex-rs/core/tests/common/lib.rs b/codex-rs/core/tests/common/lib.rs\nindex a0bb4e69e27ae82c5f70d2f4cd079c5cea3ae4f7..18bae310be9cfb81ca73e136be05148ba0510cc5\n--- a/codex-rs/core/tests/common/lib.rs\n+++ b/codex-rs/core/tests/common/lib.rs\n@@ -90,14 +90,11 @@\n where\n     F: FnMut(&codex_core::protocol::EventMsg) -> bool,\n {\n+    use tokio::time::Duration;\n     use tokio::time::timeout;\n     loop {\n-<<<<<<< HEAD\n         // Allow a bit more time to accommodate async startup work (e.g. config IO, tool discovery)\n-        let ev = timeout(Duration::from_secs(5), codex.next_event())\n-=======\n-        let ev = timeout(wait_time, codex.next_event())\n->>>>>>> origin/main\n+        let ev = timeout(wait_time.max(Duration::from_secs(5)), codex.next_event())\n             .await\n             .expect(\"timeout waiting for event\")\n             .expect(\"stream ended unexpectedly\");\n"}}}
 {"ts":"2025-08-09T15:53:04.389Z","dir":"to_tui","kind":"insert_history","lines":3}