Release 0.9.0

.github/actions/codex/bun.lock

@@ -8,8 +8,8 @@
         "@actions/github": "^6.0.1",
       },
       "devDependencies": {
-        "@types/bun": "^1.2.19",
-        "@types/node": "^24.1.0",
+        "@types/bun": "^1.2.18",
+        "@types/node": "^24.0.13",
         "prettier": "^3.6.2",
         "typescript": "^5.8.3",
       },
@@ -48,15 +48,15 @@
 
     "@octokit/types": ["@octokit/types@13.10.0", "", { "dependencies": { "@octokit/openapi-types": "^24.2.0" } }, "sha512-ifLaO34EbbPj0Xgro4G5lP5asESjwHracYJvVaPIyXMuiuXLlhic3S47cBdTb+jfODkTE5YtGCLt3Ay3+J97sA=="],
 
-    "@types/bun": ["@types/bun@1.2.19", "", { "dependencies": { "bun-types": "1.2.19" } }, "sha512-d9ZCmrH3CJ2uYKXQIUuZ/pUnTqIvLDS0SK7pFmbx8ma+ziH/FRMoAq5bYpRG7y+w1gl+HgyNZbtqgMq4W4e2Lg=="],
+    "@types/bun": ["@types/bun@1.2.18", "", { "dependencies": { "bun-types": "1.2.18" } }, "sha512-Xf6RaWVheyemaThV0kUfaAUvCNokFr+bH8Jxp+tTZfx7dAPA8z9ePnP9S9+Vspzuxxx9JRAXhnyccRj3GyCMdQ=="],
 
-    "@types/node": ["@types/node@24.1.0", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w=="],
+    "@types/node": ["@types/node@24.0.13", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-Qm9OYVOFHFYg3wJoTSrz80hoec5Lia/dPp84do3X7dZvLikQvM1YpmvTBEdIr/e+U8HTkFjLHLnl78K/qjf+jQ=="],
 
     "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],
 
     "before-after-hook": ["before-after-hook@2.2.3", "", {}, "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="],
 
-    "bun-types": ["bun-types@1.2.19", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-uAOTaZSPuYsWIXRpj7o56Let0g/wjihKCkeRqUBhlLVM/Bt+Fj9xTo+LhC1OV1XDaGkz4hNC80et5xgy+9KTHQ=="],
+    "bun-types": ["bun-types@1.2.18", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-04+Eha5NP7Z0A9YgDAzMk5PHR16ZuLVa83b26kH5+cp1qZW4F6FmAURngE7INf4tKOvCE69vYvDEwoNl1tGiWw=="],
 
     "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
 
@@ -82,8 +82,6 @@
 
     "@octokit/plugin-rest-endpoint-methods/@octokit/types": ["@octokit/types@12.6.0", "", { "dependencies": { "@octokit/openapi-types": "^20.0.0" } }, "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw=="],
 
-    "bun-types/@types/node": ["@types/node@24.0.13", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-Qm9OYVOFHFYg3wJoTSrz80hoec5Lia/dPp84do3X7dZvLikQvM1YpmvTBEdIr/e+U8HTkFjLHLnl78K/qjf+jQ=="],
-
     "@octokit/plugin-paginate-rest/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@20.0.0", "", {}, "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA=="],
 
     "@octokit/plugin-rest-endpoint-methods/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@20.0.0", "", {}, "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA=="],

.github/actions/codex/package.json

@@ -13,8 +13,8 @@
         "@actions/github": "^6.0.1"
     },
     "devDependencies": {
-        "@types/bun": "^1.2.19",
-        "@types/node": "^24.1.0",
+        "@types/bun": "^1.2.18",
+        "@types/node": "^24.0.13",
         "prettier": "^3.6.2",
         "typescript": "^5.8.3"
     }

codex-rs/Cargo.lock

@@ -649,7 +649,7 @@ dependencies = [
  "clap",
  "codex-core",
  "serde",
- "toml 0.9.2",
+ "toml 0.9.1",
 ]
 
 [[package]]
@@ -663,7 +663,6 @@ dependencies = [
  "bytes",
  "codex-apply-patch",
  "codex-mcp-client",
- "core_test_support",
  "dirs",
  "env-flags",
  "eventsource-stream",
@@ -677,20 +676,20 @@ dependencies = [
  "openssl-sys",
  "predicates",
  "pretty_assertions",
- "rand 0.9.2",
+ "rand 0.9.1",
  "reqwest",
  "seccompiler",
  "serde",
  "serde_json",
  "sha1",
- "strum_macros 0.27.2",
+ "strum_macros 0.27.1",
  "tempfile",
  "thiserror 2.0.12",
  "time",
  "tokio",
  "tokio-test",
  "tokio-util",
- "toml 0.9.2",
+ "toml 0.9.1",
  "tracing",
  "tree-sitter",
  "tree-sitter-bash",
@@ -800,7 +799,6 @@ dependencies = [
  "codex-core",
  "codex-linux-sandbox",
  "mcp-types",
- "mcp_test_support",
  "pretty_assertions",
  "schemars 0.8.22",
  "serde",
@@ -809,7 +807,7 @@ dependencies = [
  "tempfile",
  "tokio",
  "tokio-test",
- "toml 0.9.2",
+ "toml 0.9.1",
  "tracing",
  "tracing-subscriber",
  "uuid",
@@ -842,8 +840,8 @@ dependencies = [
  "regex-lite",
  "serde_json",
  "shlex",
- "strum 0.27.2",
- "strum_macros 0.27.2",
+ "strum 0.27.1",
+ "strum_macros 0.27.1",
  "tokio",
  "tracing",
  "tracing-appender",
@@ -852,7 +850,6 @@ dependencies = [
  "tui-markdown",
  "tui-textarea",
  "unicode-segmentation",
- "unicode-width 0.1.14",
  "uuid",
 ]
 
@@ -955,16 +952,6 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
-[[package]]
-name = "core_test_support"
-version = "0.0.0"
-dependencies = [
- "codex-core",
- "serde_json",
- "tempfile",
- "tokio",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.2.17"
@@ -2617,22 +2604,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "mcp_test_support"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "assert_cmd",
- "codex-mcp-server",
- "mcp-types",
- "pretty_assertions",
- "serde_json",
- "shlex",
- "tempfile",
- "tokio",
- "wiremock",
-]
-
 [[package]]
 name = "memchr"
 version = "2.7.5"
@@ -3308,9 +3279,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
@@ -4292,9 +4263,9 @@ dependencies = [
 
 [[package]]
 name = "strum"
-version = "0.27.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
 
 [[package]]
 name = "strum_macros"
@@ -4311,13 +4282,14 @@ dependencies = [
 
 [[package]]
 name = "strum_macros"
-version = "0.27.2"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
+ "rustversion",
  "syn 2.0.104",
 ]
 
@@ -4694,9 +4666,9 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.9.2"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed0aee96c12fa71097902e0bb061a5e1ebd766a6636bb605ba401c45c1650eac"
+checksum = "0207d6ed1852c2a124c1fbec61621acb8330d2bf969a5d0643131e9affd985a5"
 dependencies = [
  "indexmap 2.10.0",
  "serde",
@@ -4740,9 +4712,9 @@ dependencies = [
 
 [[package]]
 name = "toml_parser"
-version = "1.0.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97200572db069e74c512a14117b296ba0a80a30123fbbb5aa1f4a348f639ca30"
+checksum = "b5c1c469eda89749d2230d8156a5969a69ffe0d6d01200581cdc6110674d293e"
 dependencies = [
  "winnow",
 ]
@@ -4884,9 +4856,9 @@ dependencies = [
 
 [[package]]
 name = "tree-sitter"
-version = "0.25.8"
+version = "0.25.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d7b8994f367f16e6fa14b5aebbcb350de5d7cbea82dc5b00ae997dd71680dd2"
+checksum = "a7cf18d43cbf0bfca51f657132cc616a5097edc4424d538bae6fa60142eaf9f0"
 dependencies = [
  "cc",
  "regex",

codex-rs/Cargo.toml

@@ -18,7 +18,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.0.0"
+version = "0.9.0"
 # Track the edition for all workspace crates in one place. Individual
 # crates can still override this value, but keeping it here means new
 # crates created with `cargo new -w ...` automatically inherit the 2024

codex-rs/apply-patch/Cargo.toml

@@ -14,7 +14,7 @@ workspace = true
 anyhow = "1"
 similar = "2.7.0"
 thiserror = "2.0.12"
-tree-sitter = "0.25.8"
+tree-sitter = "0.25.3"
 tree-sitter-bash = "0.25.0"
 
 [dev-dependencies]

codex-rs/chatgpt/src/apply_command.rs

@@ -1,5 +1,3 @@
-use std::path::PathBuf;
-
 use clap::Parser;
 use codex_common::CliConfigOverrides;
 use codex_core::config::Config;
@@ -19,10 +17,7 @@ pub struct ApplyCommand {
     #[clap(flatten)]
     pub config_overrides: CliConfigOverrides,
 }
-pub async fn run_apply_command(
-    apply_cli: ApplyCommand,
-    cwd: Option<PathBuf>,
-) -> anyhow::Result<()> {
+pub async fn run_apply_command(apply_cli: ApplyCommand) -> anyhow::Result<()> {
     let config = Config::load_with_cli_overrides(
         apply_cli
             .config_overrides
@@ -34,13 +29,10 @@ pub async fn run_apply_command(
     init_chatgpt_token_from_auth(&config.codex_home).await?;
 
     let task_response = get_task(&config, apply_cli.task_id).await?;
-    apply_diff_from_task(task_response, cwd).await
+    apply_diff_from_task(task_response).await
 }
 
-pub async fn apply_diff_from_task(
-    task_response: GetTaskResponse,
-    cwd: Option<PathBuf>,
-) -> anyhow::Result<()> {
+pub async fn apply_diff_from_task(task_response: GetTaskResponse) -> anyhow::Result<()> {
     let diff_turn = match task_response.current_diff_task_turn {
         Some(turn) => turn,
         None => anyhow::bail!("No diff turn found"),
@@ -50,17 +42,13 @@ pub async fn apply_diff_from_task(
         _ => None,
     });
     match output_diff {
-        Some(output_diff) => apply_diff(&output_diff.diff, cwd).await,
+        Some(output_diff) => apply_diff(&output_diff.diff).await,
         None => anyhow::bail!("No PR output item found"),
     }
 }
 
-async fn apply_diff(diff: &str, cwd: Option<PathBuf>) -> anyhow::Result<()> {
-    let mut cmd = tokio::process::Command::new("git");
-    if let Some(cwd) = cwd {
-        cmd.current_dir(cwd);
-    }
-    let toplevel_output = cmd
+async fn apply_diff(diff: &str) -> anyhow::Result<()> {
+    let toplevel_output = tokio::process::Command::new("git")
         .args(vec!["rev-parse", "--show-toplevel"])
         .output()
         .await?;

codex-rs/chatgpt/tests/apply_command_e2e.rs

@@ -78,7 +78,17 @@ async fn test_apply_command_creates_fibonacci_file() {
         .await
         .expect("Failed to load fixture");
 
-    apply_diff_from_task(task_response, Some(repo_path.to_path_buf()))
+    let original_dir = std::env::current_dir().expect("Failed to get current dir");
+    std::env::set_current_dir(repo_path).expect("Failed to change directory");
+    struct DirGuard(std::path::PathBuf);
+    impl Drop for DirGuard {
+        fn drop(&mut self) {
+            let _ = std::env::set_current_dir(&self.0);
+        }
+    }
+    let _guard = DirGuard(original_dir);
+
+    apply_diff_from_task(task_response)
         .await
         .expect("Failed to apply diff from task");
 
@@ -163,7 +173,7 @@ console.log(fib(10));
         .await
         .expect("Failed to load fixture");
 
-    let apply_result = apply_diff_from_task(task_response, Some(repo_path.to_path_buf())).await;
+    let apply_result = apply_diff_from_task(task_response).await;
 
     assert!(
         apply_result.is_err(),

codex-rs/cli/src/main.rs

@@ -105,8 +105,7 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
         None => {
             let mut tui_cli = cli.interactive;
             prepend_config_flags(&mut tui_cli.config_overrides, cli.config_overrides);
-            let usage = codex_tui::run_main(tui_cli, codex_linux_sandbox_exe)?;
-            println!("{}", codex_core::protocol::FinalOutput::from(usage));
+            codex_tui::run_main(tui_cli, codex_linux_sandbox_exe)?;
         }
         Some(Subcommand::Exec(mut exec_cli)) => {
             prepend_config_flags(&mut exec_cli.config_overrides, cli.config_overrides);
@@ -146,7 +145,7 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
         },
         Some(Subcommand::Apply(mut apply_cli)) => {
             prepend_config_flags(&mut apply_cli.config_overrides, cli.config_overrides);
-            run_apply_command(apply_cli, None).await?;
+            run_apply_command(apply_cli).await?;
         }
     }
 

codex-rs/config.md

@@ -498,5 +498,14 @@ Options that are specific to the TUI.
 
 ```toml
 [tui]
-# More to come here
+# This will make it so that Codex does not try to process mouse events, which
+# means your Terminal's native drag-to-text to text selection and copy/paste
+# should work. The tradeoff is that Codex will not receive any mouse events, so
+# it will not be possible to use the mouse to scroll conversation history.
+#
+# Note that most terminals support holding down a modifier key when using the
+# mouse to support text selection. For example, even if Codex mouse capture is
+# enabled (i.e., this is set to `false`), you can still hold down alt while
+# dragging the mouse to select text.
+disable_mouse_capture = true  # defaults to `false`
 ```

codex-rs/core/Cargo.toml

@@ -30,7 +30,7 @@ reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sha1 = "0.10.6"
-strum_macros = "0.27.2"
+strum_macros = "0.27.1"
 thiserror = "2.0.12"
 time = { version = "0.3", features = ["formatting", "local-offset", "macros"] }
 tokio = { version = "1", features = [
@@ -41,9 +41,9 @@ tokio = { version = "1", features = [
     "signal",
 ] }
 tokio-util = "0.7.14"
-toml = "0.9.2"
+toml = "0.9.1"
 tracing = { version = "0.1.41", features = ["log"] }
-tree-sitter = "0.25.8"
+tree-sitter = "0.25.3"
 tree-sitter-bash = "0.25.0"
 uuid = { version = "1", features = ["serde", "v4"] }
 wildmatch = "2.4.0"
@@ -62,7 +62,6 @@ openssl-sys = { version = "*", features = ["vendored"] }
 
 [dev-dependencies]
 assert_cmd = "2"
-core_test_support = { path = "tests/common" }
 maplit = "1.0.2"
 predicates = "3"
 pretty_assertions = "1.4.1"

codex-rs/core/src/bash.rs

@@ -1,219 +0,0 @@
-use tree_sitter::Parser;
-use tree_sitter::Tree;
-use tree_sitter_bash::LANGUAGE as BASH;
-
-/// Parse the provided bash source using tree-sitter-bash, returning a Tree on
-/// success or None if parsing failed.
-pub fn try_parse_bash(bash_lc_arg: &str) -> Option<Tree> {
-    let lang = BASH.into();
-    let mut parser = Parser::new();
-    #[expect(clippy::expect_used)]
-    parser.set_language(&lang).expect("load bash grammar");
-    let old_tree: Option<&Tree> = None;
-    parser.parse(bash_lc_arg, old_tree)
-}
-
-/// Parse a script which may contain multiple simple commands joined only by
-/// the safe logical/pipe/sequencing operators: `&&`, `||`, `;`, `|`.
-///
-/// Returns `Some(Vec<command_words>)` if every command is a plain word‑only
-/// command and the parse tree does not contain disallowed constructs
-/// (parentheses, redirections, substitutions, control flow, etc.). Otherwise
-/// returns `None`.
-pub fn try_parse_word_only_commands_sequence(tree: &Tree, src: &str) -> Option<Vec<Vec<String>>> {
-    if tree.root_node().has_error() {
-        return None;
-    }
-
-    // List of allowed (named) node kinds for a "word only commands sequence".
-    // If we encounter a named node that is not in this list we reject.
-    const ALLOWED_KINDS: &[&str] = &[
-        // top level containers
-        "program",
-        "list",
-        "pipeline",
-        // commands & words
-        "command",
-        "command_name",
-        "word",
-        "string",
-        "string_content",
-        "raw_string",
-        "number",
-    ];
-    // Allow only safe punctuation / operator tokens; anything else causes reject.
-    const ALLOWED_PUNCT_TOKENS: &[&str] = &["&&", "||", ";", "|", "\"", "'"];
-
-    let root = tree.root_node();
-    let mut cursor = root.walk();
-    let mut stack = vec![root];
-    let mut command_nodes = Vec::new();
-    while let Some(node) = stack.pop() {
-        let kind = node.kind();
-        if node.is_named() {
-            if !ALLOWED_KINDS.contains(&kind) {
-                return None;
-            }
-            if kind == "command" {
-                command_nodes.push(node);
-            }
-        } else {
-            // Reject any punctuation / operator tokens that are not explicitly allowed.
-            if kind.chars().any(|c| "&;|".contains(c)) && !ALLOWED_PUNCT_TOKENS.contains(&kind) {
-                return None;
-            }
-            if !(ALLOWED_PUNCT_TOKENS.contains(&kind) || kind.trim().is_empty()) {
-                // If it's a quote token or operator it's allowed above; we also allow whitespace tokens.
-                // Any other punctuation like parentheses, braces, redirects, backticks, etc are rejected.
-                return None;
-            }
-        }
-        for child in node.children(&mut cursor) {
-            stack.push(child);
-        }
-    }
-
-    let mut commands = Vec::new();
-    for node in command_nodes {
-        if let Some(words) = parse_plain_command_from_node(node, src) {
-            commands.push(words);
-        } else {
-            return None;
-        }
-    }
-    Some(commands)
-}
-
-fn parse_plain_command_from_node(cmd: tree_sitter::Node, src: &str) -> Option<Vec<String>> {
-    if cmd.kind() != "command" {
-        return None;
-    }
-    let mut words = Vec::new();
-    let mut cursor = cmd.walk();
-    for child in cmd.named_children(&mut cursor) {
-        match child.kind() {
-            "command_name" => {
-                let word_node = child.named_child(0)?;
-                if word_node.kind() != "word" {
-                    return None;
-                }
-                words.push(word_node.utf8_text(src.as_bytes()).ok()?.to_owned());
-            }
-            "word" | "number" => {
-                words.push(child.utf8_text(src.as_bytes()).ok()?.to_owned());
-            }
-            "string" => {
-                if child.child_count() == 3
-                    && child.child(0)?.kind() == "\""
-                    && child.child(1)?.kind() == "string_content"
-                    && child.child(2)?.kind() == "\""
-                {
-                    words.push(child.child(1)?.utf8_text(src.as_bytes()).ok()?.to_owned());
-                } else {
-                    return None;
-                }
-            }
-            "raw_string" => {
-                let raw_string = child.utf8_text(src.as_bytes()).ok()?;
-                let stripped = raw_string
-                    .strip_prefix('\'')
-                    .and_then(|s| s.strip_suffix('\''));
-                if let Some(s) = stripped {
-                    words.push(s.to_owned());
-                } else {
-                    return None;
-                }
-            }
-            _ => return None,
-        }
-    }
-    Some(words)
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used)]
-    use super::*;
-
-    fn parse_seq(src: &str) -> Option<Vec<Vec<String>>> {
-        let tree = try_parse_bash(src)?;
-        try_parse_word_only_commands_sequence(&tree, src)
-    }
-
-    #[test]
-    fn accepts_single_simple_command() {
-        let cmds = parse_seq("ls -1").unwrap();
-        assert_eq!(cmds, vec![vec!["ls".to_string(), "-1".to_string()]]);
-    }
-
-    #[test]
-    fn accepts_multiple_commands_with_allowed_operators() {
-        let src = "ls && pwd; echo 'hi there' | wc -l";
-        let cmds = parse_seq(src).unwrap();
-        let expected: Vec<Vec<String>> = vec![
-            vec!["wc".to_string(), "-l".to_string()],
-            vec!["echo".to_string(), "hi there".to_string()],
-            vec!["pwd".to_string()],
-            vec!["ls".to_string()],
-        ];
-        assert_eq!(cmds, expected);
-    }
-
-    #[test]
-    fn extracts_double_and_single_quoted_strings() {
-        let cmds = parse_seq("echo \"hello world\"").unwrap();
-        assert_eq!(
-            cmds,
-            vec![vec!["echo".to_string(), "hello world".to_string()]]
-        );
-
-        let cmds2 = parse_seq("echo 'hi there'").unwrap();
-        assert_eq!(
-            cmds2,
-            vec![vec!["echo".to_string(), "hi there".to_string()]]
-        );
-    }
-
-    #[test]
-    fn accepts_numbers_as_words() {
-        let cmds = parse_seq("echo 123 456").unwrap();
-        assert_eq!(
-            cmds,
-            vec![vec![
-                "echo".to_string(),
-                "123".to_string(),
-                "456".to_string()
-            ]]
-        );
-    }
-
-    #[test]
-    fn rejects_parentheses_and_subshells() {
-        assert!(parse_seq("(ls)").is_none());
-        assert!(parse_seq("ls || (pwd && echo hi)").is_none());
-    }
-
-    #[test]
-    fn rejects_redirections_and_unsupported_operators() {
-        assert!(parse_seq("ls > out.txt").is_none());
-        assert!(parse_seq("echo hi & echo bye").is_none());
-    }
-
-    #[test]
-    fn rejects_command_and_process_substitutions_and_expansions() {
-        assert!(parse_seq("echo $(pwd)").is_none());
-        assert!(parse_seq("echo `pwd`").is_none());
-        assert!(parse_seq("echo $HOME").is_none());
-        assert!(parse_seq("echo \"hi $USER\"").is_none());
-    }
-
-    #[test]
-    fn rejects_variable_assignment_prefix() {
-        assert!(parse_seq("FOO=bar ls").is_none());
-    }
-
-    #[test]
-    fn rejects_trailing_operator_parse_error() {
-        assert!(parse_seq("ls &&").is_none());
-    }
-}

codex-rs/core/src/chat_completions.rs

@@ -41,7 +41,7 @@ pub(crate) async fn stream_chat_completions(
 
     for item in &prompt.input {
         match item {
-            ResponseItem::Message { role, content, .. } => {
+            ResponseItem::Message { role, content } => {
                 let mut text = String::new();
                 for c in content {
                     match c {
@@ -58,7 +58,6 @@ pub(crate) async fn stream_chat_completions(
                 name,
                 arguments,
                 call_id,
-                ..
             } => {
                 messages.push(json!({
                     "role": "assistant",
@@ -260,7 +259,6 @@ async fn process_chat_sse<S>(
                     content: vec![ContentItem::OutputText {
                         text: content.to_string(),
                     }],
-                    id: None,
                 };
 
                 let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
@@ -302,7 +300,6 @@ async fn process_chat_sse<S>(
                     "tool_calls" if fn_call_state.active => {
                         // Build the FunctionCall response item.
                         let item = ResponseItem::FunctionCall {
-                            id: None,
                             name: fn_call_state.name.clone().unwrap_or_else(|| "".to_string()),
                             arguments: fn_call_state.arguments.clone(),
                             call_id: fn_call_state.call_id.clone().unwrap_or_else(String::new),
@@ -405,7 +402,6 @@ where
                 }))) => {
                     if !this.cumulative.is_empty() {
                         let aggregated_item = crate::models::ResponseItem::Message {
-                            id: None,
                             role: "assistant".to_string(),
                             content: vec![crate::models::ContentItem::OutputText {
                                 text: std::mem::take(&mut this.cumulative),

codex-rs/core/src/client.rs

@@ -117,15 +117,6 @@ impl ModelClient {
         let full_instructions = prompt.get_full_instructions(&self.config.model);
         let tools_json = create_tools_json_for_responses_api(prompt, &self.config.model)?;
         let reasoning = create_reasoning_param_for_request(&self.config, self.effort, self.summary);
-
-        // Request encrypted COT if we are not storing responses,
-        // otherwise reasoning items will be referenced by ID
-        let include = if !prompt.store && reasoning.is_some() {
-            vec!["reasoning.encrypted_content".to_string()]
-        } else {
-            vec![]
-        };
-
         let payload = ResponsesApiRequest {
             model: &self.config.model,
             instructions: &full_instructions,
@@ -134,10 +125,10 @@ impl ModelClient {
             tool_choice: "auto",
             parallel_tool_calls: false,
             reasoning,
+            previous_response_id: prompt.prev_id.clone(),
             store: prompt.store,
             // TODO: make this configurable
             stream: true,
-            include,
         };
 
         trace!(

codex-rs/core/src/client_common.rs

@@ -22,6 +22,8 @@ const BASE_INSTRUCTIONS: &str = include_str!("../prompt.md");
 pub struct Prompt {
     /// Conversation context input items.
     pub input: Vec<ResponseItem>,
+    /// Optional previous response ID (when storage is enabled).
+    pub prev_id: Option<String>,
     /// Optional instructions from the user to amend to the built-in agent
     /// instructions.
     pub user_instructions: Option<String>,
@@ -131,10 +133,11 @@ pub(crate) struct ResponsesApiRequest<'a> {
     pub(crate) tool_choice: &'static str,
     pub(crate) parallel_tool_calls: bool,
     pub(crate) reasoning: Option<Reasoning>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub(crate) previous_response_id: Option<String>,
     /// true when using the Responses API.
     pub(crate) store: bool,
     pub(crate) stream: bool,
-    pub(crate) include: Vec<String>,
 }
 
 use crate::config::Config;

codex-rs/core/src/codex.rs

@@ -34,6 +34,7 @@ use tracing::trace;
 use tracing::warn;
 use uuid::Uuid;
 
+use crate::WireApi;
 use crate::client::ModelClient;
 use crate::client_common::Prompt;
 use crate::client_common::ResponseEvent;
@@ -190,7 +191,6 @@ pub(crate) struct Session {
     sandbox_policy: SandboxPolicy,
     shell_environment_policy: ShellEnvironmentPolicy,
     writable_roots: Mutex<Vec<PathBuf>>,
-    disable_response_storage: bool,
 
     /// Manager for external MCP servers/tools.
     mcp_connection_manager: McpConnectionManager,
@@ -219,9 +219,13 @@ impl Session {
 struct State {
     approved_commands: HashSet<Vec<String>>,
     current_task: Option<AgentTask>,
+    /// Call IDs that have been sent from the Responses API but have not been sent back yet.
+    /// You CANNOT send a Responses API follow-up message unless you have sent back the output for all pending calls or else it will 400.
+    pending_call_ids: HashSet<String>,
+    previous_response_id: Option<String>,
     pending_approvals: HashMap<String, oneshot::Sender<ReviewDecision>>,
     pending_input: Vec<ResponseInputItem>,
-    history: ConversationHistory,
+    zdr_transcript: Option<ConversationHistory>,
 }
 
 impl Session {
@@ -253,7 +257,6 @@ impl Session {
     pub async fn request_command_approval(
         &self,
         sub_id: String,
-        call_id: String,
         command: Vec<String>,
         cwd: PathBuf,
         reason: Option<String>,
@@ -262,7 +265,6 @@ impl Session {
         let event = Event {
             id: sub_id.clone(),
             msg: EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
-                call_id,
                 command,
                 cwd,
                 reason,
@@ -279,7 +281,6 @@ impl Session {
     pub async fn request_patch_approval(
         &self,
         sub_id: String,
-        call_id: String,
         action: &ApplyPatchAction,
         reason: Option<String>,
         grant_root: Option<PathBuf>,
@@ -288,7 +289,6 @@ impl Session {
         let event = Event {
             id: sub_id.clone(),
             msg: EventMsg::ApplyPatchApprovalRequest(ApplyPatchApprovalRequestEvent {
-                call_id,
                 changes: convert_apply_patch_to_protocol(action),
                 reason,
                 grant_root,
@@ -320,11 +320,18 @@ impl Session {
         debug!("Recording items for conversation: {items:?}");
         self.record_state_snapshot(items).await;
 
-        self.state.lock().unwrap().history.record_items(items);
+        if let Some(transcript) = self.state.lock().unwrap().zdr_transcript.as_mut() {
+            transcript.record_items(items);
+        }
     }
 
     async fn record_state_snapshot(&self, items: &[ResponseItem]) {
-        let snapshot = { crate::rollout::SessionStateSnapshot {} };
+        let snapshot = {
+            let state = self.state.lock().unwrap();
+            crate::rollout::SessionStateSnapshot {
+                previous_response_id: state.previous_response_id.clone(),
+            }
+        };
 
         let recorder = {
             let guard = self.rollout.lock().unwrap();
@@ -426,6 +433,8 @@ impl Session {
     pub fn abort(&self) {
         info!("Aborting existing session");
         let mut state = self.state.lock().unwrap();
+        // Don't clear pending_call_ids because we need to keep track of them to ensure we don't 400 on the next turn.
+        // We will generate a synthetic aborted response for each pending call id.
         state.pending_approvals.clear();
         state.pending_input.clear();
         if let Some(task) = state.current_task.take() {
@@ -470,10 +479,15 @@ impl Drop for Session {
 }
 
 impl State {
-    pub fn partial_clone(&self) -> Self {
+    pub fn partial_clone(&self, retain_zdr_transcript: bool) -> Self {
         Self {
             approved_commands: self.approved_commands.clone(),
-            history: self.history.clone(),
+            previous_response_id: self.previous_response_id.clone(),
+            zdr_transcript: if retain_zdr_transcript {
+                self.zdr_transcript.clone()
+            } else {
+                None
+            },
             ..Default::default()
         }
     }
@@ -592,11 +606,13 @@ async fn submission_loop(
                 }
                 // Optionally resume an existing rollout.
                 let mut restored_items: Option<Vec<ResponseItem>> = None;
+                let mut restored_prev_id: Option<String> = None;
                 let rollout_recorder: Option<RolloutRecorder> =
                     if let Some(path) = resume_path.as_ref() {
-                        match RolloutRecorder::resume(path, cwd.clone()).await {
+                        match RolloutRecorder::resume(path).await {
                             Ok((rec, saved)) => {
                                 session_id = saved.session_id;
+                                restored_prev_id = saved.state.previous_response_id;
                                 if !saved.items.is_empty() {
                                     restored_items = Some(saved.items);
                                 }
@@ -635,13 +651,22 @@ async fn submission_loop(
                 );
 
                 // abort any current running session and clone its state
+                let retain_zdr_transcript =
+                    record_conversation_history(disable_response_storage, provider.wire_api);
                 let state = match sess.take() {
                     Some(sess) => {
                         sess.abort();
-                        sess.state.lock().unwrap().partial_clone()
+                        sess.state
+                            .lock()
+                            .unwrap()
+                            .partial_clone(retain_zdr_transcript)
                     }
                     None => State {
-                        history: ConversationHistory::new(),
+                        zdr_transcript: if retain_zdr_transcript {
+                            Some(ConversationHistory::new())
+                        } else {
+                            None
+                        },
                         ..Default::default()
                     },
                 };
@@ -692,14 +717,18 @@ async fn submission_loop(
                     state: Mutex::new(state),
                     rollout: Mutex::new(rollout_recorder),
                     codex_linux_sandbox_exe: config.codex_linux_sandbox_exe.clone(),
-                    disable_response_storage,
                 }));
 
                 // Patch restored state into the newly created session.
                 if let Some(sess_arc) = &sess {
-                    if restored_items.is_some() {
+                    if restored_prev_id.is_some() || restored_items.is_some() {
                         let mut st = sess_arc.state.lock().unwrap();
-                        st.history.record_items(restored_items.unwrap().iter());
+                        st.previous_response_id = restored_prev_id;
+                        if let (Some(hist), Some(items)) =
+                            (st.zdr_transcript.as_mut(), restored_items.as_ref())
+                        {
+                            hist.record_items(items.iter());
+                        }
                     }
                 }
 
@@ -812,37 +841,6 @@ async fn submission_loop(
                     }
                 });
             }
-            Op::Shutdown => {
-                info!("Shutting down Codex instance");
-
-                // Gracefully flush and shutdown rollout recorder on session end so tests
-                // that inspect the rollout file do not race with the background writer.
-                if let Some(sess_arc) = sess {
-                    let recorder_opt = sess_arc.rollout.lock().unwrap().take();
-                    if let Some(rec) = recorder_opt {
-                        if let Err(e) = rec.shutdown().await {
-                            warn!("failed to shutdown rollout recorder: {e}");
-                            let event = Event {
-                                id: sub.id.clone(),
-                                msg: EventMsg::Error(ErrorEvent {
-                                    message: "Failed to shutdown rollout recorder".to_string(),
-                                }),
-                            };
-                            if let Err(e) = tx_event.send(event).await {
-                                warn!("failed to send error message: {e:?}");
-                            }
-                        }
-                    }
-                }
-                let event = Event {
-                    id: sub.id.clone(),
-                    msg: EventMsg::ShutdownComplete,
-                };
-                if let Err(e) = tx_event.send(event).await {
-                    warn!("failed to send Shutdown event: {e}");
-                }
-                break;
-            }
         }
     }
     debug!("Agent loop exited");
@@ -877,8 +875,14 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
     sess.record_conversation_items(&[initial_input_for_turn.clone().into()])
         .await;
 
+    let mut input_for_next_turn: Vec<ResponseInputItem> = vec![initial_input_for_turn];
     let last_agent_message: Option<String>;
     loop {
+        let mut net_new_turn_input = input_for_next_turn
+            .drain(..)
+            .map(ResponseItem::from)
+            .collect::<Vec<_>>();
+
         // Note that pending_input would be something like a message the user
         // submitted through the UI while the model was running. Though the UI
         // may support this, the model might not.
@@ -895,7 +899,29 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
         // only record the new items that originated in this turn so that it
         // represents an append-only log without duplicates.
         let turn_input: Vec<ResponseItem> =
-            [sess.state.lock().unwrap().history.contents(), pending_input].concat();
+            if let Some(transcript) = sess.state.lock().unwrap().zdr_transcript.as_mut() {
+                // If we are using Chat/ZDR, we need to send the transcript with
+                // every turn. By induction, `transcript` already contains:
+                // - The `input` that kicked off this task.
+                // - Each `ResponseItem` that was recorded in the previous turn.
+                // - Each response to a `ResponseItem` (in practice, the only
+                //   response type we seem to have is `FunctionCallOutput`).
+                //
+                // The only thing the `transcript` does not contain is the
+                // `pending_input` that was injected while the model was
+                // running. We need to add that to the conversation history
+                // so that the model can see it in the next turn.
+                [transcript.contents(), pending_input].concat()
+            } else {
+                // In practice, net_new_turn_input should contain only:
+                // - User messages
+                // - Outputs for function calls requested by the model
+                net_new_turn_input.extend(pending_input);
+
+                // Responses API path – we can just send the new items and
+                // record the same.
+                net_new_turn_input
+            };
 
         let turn_input_messages: Vec<String> = turn_input
             .iter()
@@ -971,19 +997,8 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                                 },
                             );
                         }
-                        (
-                            ResponseItem::Reasoning {
-                                id,
-                                summary,
-                                encrypted_content,
-                            },
-                            None,
-                        ) => {
-                            items_to_record_in_conversation_history.push(ResponseItem::Reasoning {
-                                id: id.clone(),
-                                summary: summary.clone(),
-                                encrypted_content: encrypted_content.clone(),
-                            });
+                        (ResponseItem::Reasoning { .. }, None) => {
+                            // Omit from conversation history.
                         }
                         _ => {
                             warn!("Unexpected response item: {item:?} with response: {response:?}");
@@ -1012,6 +1027,8 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                     });
                     break;
                 }
+
+                input_for_next_turn = responses;
             }
             Err(e) => {
                 info!("Turn error: {e:#}");
@@ -1039,11 +1056,26 @@ async fn run_turn(
     sub_id: String,
     input: Vec<ResponseItem>,
 ) -> CodexResult<Vec<ProcessedResponseItem>> {
+    // Decide whether to use server-side storage (previous_response_id) or disable it
+    let (prev_id, store) = {
+        let state = sess.state.lock().unwrap();
+        let store = state.zdr_transcript.is_none();
+        let prev_id = if store {
+            state.previous_response_id.clone()
+        } else {
+            // When using ZDR, the Responses API may send previous_response_id
+            // back, but trying to use it results in a 400.
+            None
+        };
+        (prev_id, store)
+    };
+
     let extra_tools = sess.mcp_connection_manager.list_all_tools();
     let prompt = Prompt {
         input,
+        prev_id,
         user_instructions: sess.user_instructions.clone(),
-        store: !sess.disable_response_storage,
+        store,
         extra_tools,
         base_instructions_override: sess.base_instructions.clone(),
     };
@@ -1117,17 +1149,11 @@ async fn try_run_turn(
     // This usually happens because the user interrupted the model before we responded to one of its tool calls
     // and then the user sent a follow-up message.
     let missing_calls = {
-        prompt
-            .input
+        sess.state
+            .lock()
+            .unwrap()
+            .pending_call_ids
             .iter()
-            .filter_map(|ri| match ri {
-                ResponseItem::FunctionCall { call_id, .. } => Some(call_id),
-                ResponseItem::LocalShellCall {
-                    call_id: Some(call_id),
-                    ..
-                } => Some(call_id),
-                _ => None,
-            })
             .filter_map(|call_id| {
                 if completed_call_ids.contains(&call_id) {
                     None
@@ -1181,14 +1207,31 @@ async fn try_run_turn(
         };
 
         match event {
-            ResponseEvent::Created => {}
+            ResponseEvent::Created => {
+                let mut state = sess.state.lock().unwrap();
+                // We successfully created a new response and ensured that all pending calls were included so we can clear the pending call ids.
+                state.pending_call_ids.clear();
+            }
             ResponseEvent::OutputItemDone(item) => {
+                let call_id = match &item {
+                    ResponseItem::LocalShellCall {
+                        call_id: Some(call_id),
+                        ..
+                    } => Some(call_id),
+                    ResponseItem::FunctionCall { call_id, .. } => Some(call_id),
+                    _ => None,
+                };
+                if let Some(call_id) = call_id {
+                    // We just got a new call id so we need to make sure to respond to it in the next turn.
+                    let mut state = sess.state.lock().unwrap();
+                    state.pending_call_ids.insert(call_id.clone());
+                }
                 let response = handle_response_item(sess, sub_id, item.clone()).await?;
 
                 output.push(ProcessedResponseItem { item, response });
             }
             ResponseEvent::Completed {
-                response_id: _,
+                response_id,
                 token_usage,
             } => {
                 if let Some(token_usage) = token_usage {
@@ -1201,6 +1244,8 @@ async fn try_run_turn(
                         .ok();
                 }
 
+                let mut state = sess.state.lock().unwrap();
+                state.previous_response_id = Some(response_id);
                 return Ok(output);
             }
             ResponseEvent::OutputTextDelta(delta) => {
@@ -1240,7 +1285,7 @@ async fn handle_response_item(
             }
             None
         }
-        ResponseItem::Reasoning { summary, .. } => {
+        ResponseItem::Reasoning { id: _, summary } => {
             for item in summary {
                 let text = match item {
                     ReasoningItemReasoningSummary::SummaryText { text } => text,
@@ -1257,7 +1302,6 @@ async fn handle_response_item(
             name,
             arguments,
             call_id,
-            ..
         } => {
             info!("FunctionCall: {arguments}");
             Some(handle_function_call(sess, sub_id.to_string(), name, arguments, call_id).await)
@@ -1428,7 +1472,6 @@ async fn handle_container_exec_with_params(
             let rx_approve = sess
                 .request_command_approval(
                     sub_id.clone(),
-                    call_id.clone(),
                     params.command.clone(),
                     params.cwd.clone(),
                     None,
@@ -1556,7 +1599,6 @@ async fn handle_sandbox_error(
     let rx_approve = sess
         .request_command_approval(
             sub_id.clone(),
-            call_id.clone(),
             params.command.clone(),
             params.cwd.clone(),
             Some("command failed; retry without sandbox?".to_string()),
@@ -1574,7 +1616,9 @@ async fn handle_sandbox_error(
             sess.notify_background_event(&sub_id, "retrying command without sandbox")
                 .await;
 
-            sess.notify_exec_command_begin(&sub_id, &call_id, &params)
+            // Emit a fresh Begin event so progress bars reset.
+            let retry_call_id = format!("{call_id}-retry");
+            sess.notify_exec_command_begin(&sub_id, &retry_call_id, &params)
                 .await;
 
             // This is an escalated retry; the policy will not be
@@ -1597,8 +1641,14 @@ async fn handle_sandbox_error(
                         duration,
                     } = retry_output;
 
-                    sess.notify_exec_command_end(&sub_id, &call_id, &stdout, &stderr, exit_code)
-                        .await;
+                    sess.notify_exec_command_end(
+                        &sub_id,
+                        &retry_call_id,
+                        &stdout,
+                        &stderr,
+                        exit_code,
+                    )
+                    .await;
 
                     let is_success = exit_code == 0;
                     let content = format_exec_output(
@@ -1662,7 +1712,7 @@ async fn apply_patch(
             // Compute a readable summary of path changes to include in the
             // approval request so the user can make an informed decision.
             let rx_approve = sess
-                .request_patch_approval(sub_id.clone(), call_id.clone(), &action, None, None)
+                .request_patch_approval(sub_id.clone(), &action, None, None)
                 .await;
             match rx_approve.await.unwrap_or_default() {
                 ReviewDecision::Approved | ReviewDecision::ApprovedForSession => false,
@@ -1700,13 +1750,7 @@ async fn apply_patch(
         ));
 
         let rx = sess
-            .request_patch_approval(
-                sub_id.clone(),
-                call_id.clone(),
-                &action,
-                reason.clone(),
-                Some(root.clone()),
-            )
+            .request_patch_approval(sub_id.clone(), &action, reason.clone(), Some(root.clone()))
             .await;
 
         if !matches!(
@@ -1790,7 +1834,6 @@ async fn apply_patch(
                 let rx = sess
                     .request_patch_approval(
                         sub_id.clone(),
-                        call_id.clone(),
                         &action,
                         reason.clone(),
                         Some(root.clone()),
@@ -2049,7 +2092,7 @@ fn format_exec_output(output: &str, exit_code: i32, duration: Duration) -> Strin
 
 fn get_last_assistant_message_from_turn(responses: &[ResponseItem]) -> Option<String> {
     responses.iter().rev().find_map(|item| {
-        if let ResponseItem::Message { role, content, .. } = item {
+        if let ResponseItem::Message { role, content } = item {
             if role == "assistant" {
                 content.iter().rev().find_map(|ci| {
                     if let ContentItem::OutputText { text } = ci {
@@ -2066,3 +2109,15 @@ fn get_last_assistant_message_from_turn(responses: &[ResponseItem]) -> Option<St
         }
     })
 }
+
+/// See [`ConversationHistory`] for details.
+fn record_conversation_history(disable_response_storage: bool, wire_api: WireApi) -> bool {
+    if disable_response_storage {
+        return true;
+    }
+
+    match wire_api {
+        WireApi::Responses => false,
+        WireApi::Chat => true,
+    }
+}

codex-rs/core/src/config_types.rs

@@ -76,7 +76,20 @@ pub enum HistoryPersistence {
 
 /// Collection of settings that are specific to the TUI.
 #[derive(Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct Tui {}
+pub struct Tui {
+    /// By default, mouse capture is enabled in the TUI so that it is possible
+    /// to scroll the conversation history with a mouse. This comes at the cost
+    /// of not being able to use the mouse to select text in the TUI.
+    /// (Most terminals support a modifier key to allow this. For example,
+    /// text selection works in iTerm if you hold down the `Option` key while
+    /// clicking and dragging.)
+    ///
+    /// Setting this option to `true` disables mouse capture, so scrolling with
+    /// the mouse is not possible, though the keyboard shortcuts e.g. `b` and
+    /// `space` still work. This allows the user to select text in the TUI
+    /// using the mouse without needing to hold down a modifier key.
+    pub disable_mouse_capture: bool,
+}
 
 #[derive(Deserialize, Debug, Clone, Copy, PartialEq, Default)]
 #[serde(rename_all = "kebab-case")]

codex-rs/core/src/conversation_history.rs

@@ -1,7 +1,12 @@
 use crate::models::ResponseItem;
 
-/// Transcript of conversation history
-#[derive(Debug, Clone, Default)]
+/// Transcript of conversation history that is needed:
+/// - for ZDR clients for which previous_response_id is not available, so we
+///   must include the transcript with every API call. This must include each
+///   `function_call` and its corresponding `function_call_output`.
+/// - for clients using the "chat completions" API as opposed to the
+///   "responses" API.
+#[derive(Debug, Clone)]
 pub(crate) struct ConversationHistory {
     /// The oldest items are at the beginning of the vector.
     items: Vec<ResponseItem>,
@@ -39,8 +44,7 @@ fn is_api_message(message: &ResponseItem) -> bool {
         ResponseItem::Message { role, .. } => role.as_str() != "system",
         ResponseItem::FunctionCallOutput { .. }
         | ResponseItem::FunctionCall { .. }
-        | ResponseItem::LocalShellCall { .. }
-        | ResponseItem::Reasoning { .. } => true,
-        ResponseItem::Other => false,
+        | ResponseItem::LocalShellCall { .. } => true,
+        ResponseItem::Reasoning { .. } | ResponseItem::Other => false,
     }
 }

codex-rs/core/src/git_info.rs

@@ -1,307 +0,0 @@
-use std::path::Path;
-
-use serde::Deserialize;
-use serde::Serialize;
-use tokio::process::Command;
-use tokio::time::Duration as TokioDuration;
-use tokio::time::timeout;
-
-/// Timeout for git commands to prevent freezing on large repositories
-const GIT_COMMAND_TIMEOUT: TokioDuration = TokioDuration::from_secs(5);
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct GitInfo {
-    /// Current commit hash (SHA)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub commit_hash: Option<String>,
-    /// Current branch name
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub branch: Option<String>,
-    /// Repository URL (if available from remote)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub repository_url: Option<String>,
-}
-
-/// Collect git repository information from the given working directory using command-line git.
-/// Returns None if no git repository is found or if git operations fail.
-/// Uses timeouts to prevent freezing on large repositories.
-/// All git commands (except the initial repo check) run in parallel for better performance.
-pub async fn collect_git_info(cwd: &Path) -> Option<GitInfo> {
-    // Check if we're in a git repository first
-    let is_git_repo = run_git_command_with_timeout(&["rev-parse", "--git-dir"], cwd)
-        .await?
-        .status
-        .success();
-
-    if !is_git_repo {
-        return None;
-    }
-
-    // Run all git info collection commands in parallel
-    let (commit_result, branch_result, url_result) = tokio::join!(
-        run_git_command_with_timeout(&["rev-parse", "HEAD"], cwd),
-        run_git_command_with_timeout(&["rev-parse", "--abbrev-ref", "HEAD"], cwd),
-        run_git_command_with_timeout(&["remote", "get-url", "origin"], cwd)
-    );
-
-    let mut git_info = GitInfo {
-        commit_hash: None,
-        branch: None,
-        repository_url: None,
-    };
-
-    // Process commit hash
-    if let Some(output) = commit_result {
-        if output.status.success() {
-            if let Ok(hash) = String::from_utf8(output.stdout) {
-                git_info.commit_hash = Some(hash.trim().to_string());
-            }
-        }
-    }
-
-    // Process branch name
-    if let Some(output) = branch_result {
-        if output.status.success() {
-            if let Ok(branch) = String::from_utf8(output.stdout) {
-                let branch = branch.trim();
-                if branch != "HEAD" {
-                    git_info.branch = Some(branch.to_string());
-                }
-            }
-        }
-    }
-
-    // Process repository URL
-    if let Some(output) = url_result {
-        if output.status.success() {
-            if let Ok(url) = String::from_utf8(output.stdout) {
-                git_info.repository_url = Some(url.trim().to_string());
-            }
-        }
-    }
-
-    Some(git_info)
-}
-
-/// Run a git command with a timeout to prevent blocking on large repositories
-async fn run_git_command_with_timeout(args: &[&str], cwd: &Path) -> Option<std::process::Output> {
-    let result = timeout(
-        GIT_COMMAND_TIMEOUT,
-        Command::new("git").args(args).current_dir(cwd).output(),
-    )
-    .await;
-
-    match result {
-        Ok(Ok(output)) => Some(output),
-        _ => None, // Timeout or error
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::expect_used)]
-    #![allow(clippy::unwrap_used)]
-
-    use super::*;
-
-    use std::fs;
-    use std::path::PathBuf;
-    use tempfile::TempDir;
-
-    // Helper function to create a test git repository
-    async fn create_test_git_repo(temp_dir: &TempDir) -> PathBuf {
-        let repo_path = temp_dir.path().to_path_buf();
-
-        // Initialize git repo
-        Command::new("git")
-            .args(["init"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to init git repo");
-
-        // Configure git user (required for commits)
-        Command::new("git")
-            .args(["config", "user.name", "Test User"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to set git user name");
-
-        Command::new("git")
-            .args(["config", "user.email", "test@example.com"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to set git user email");
-
-        // Create a test file and commit it
-        let test_file = repo_path.join("test.txt");
-        fs::write(&test_file, "test content").expect("Failed to write test file");
-
-        Command::new("git")
-            .args(["add", "."])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to add files");
-
-        Command::new("git")
-            .args(["commit", "-m", "Initial commit"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to commit");
-
-        repo_path
-    }
-
-    #[tokio::test]
-    async fn test_collect_git_info_non_git_directory() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let result = collect_git_info(temp_dir.path()).await;
-        assert!(result.is_none());
-    }
-
-    #[tokio::test]
-    async fn test_collect_git_info_git_repository() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let repo_path = create_test_git_repo(&temp_dir).await;
-
-        let git_info = collect_git_info(&repo_path)
-            .await
-            .expect("Should collect git info from repo");
-
-        // Should have commit hash
-        assert!(git_info.commit_hash.is_some());
-        let commit_hash = git_info.commit_hash.unwrap();
-        assert_eq!(commit_hash.len(), 40); // SHA-1 hash should be 40 characters
-        assert!(commit_hash.chars().all(|c| c.is_ascii_hexdigit()));
-
-        // Should have branch (likely "main" or "master")
-        assert!(git_info.branch.is_some());
-        let branch = git_info.branch.unwrap();
-        assert!(branch == "main" || branch == "master");
-
-        // Repository URL might be None for local repos without remote
-        // This is acceptable behavior
-    }
-
-    #[tokio::test]
-    async fn test_collect_git_info_with_remote() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let repo_path = create_test_git_repo(&temp_dir).await;
-
-        // Add a remote origin
-        Command::new("git")
-            .args([
-                "remote",
-                "add",
-                "origin",
-                "https://github.com/example/repo.git",
-            ])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to add remote");
-
-        let git_info = collect_git_info(&repo_path)
-            .await
-            .expect("Should collect git info from repo");
-
-        // Should have repository URL
-        assert_eq!(
-            git_info.repository_url,
-            Some("https://github.com/example/repo.git".to_string())
-        );
-    }
-
-    #[tokio::test]
-    async fn test_collect_git_info_detached_head() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let repo_path = create_test_git_repo(&temp_dir).await;
-
-        // Get the current commit hash
-        let output = Command::new("git")
-            .args(["rev-parse", "HEAD"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to get HEAD");
-        let commit_hash = String::from_utf8(output.stdout).unwrap().trim().to_string();
-
-        // Checkout the commit directly (detached HEAD)
-        Command::new("git")
-            .args(["checkout", &commit_hash])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to checkout commit");
-
-        let git_info = collect_git_info(&repo_path)
-            .await
-            .expect("Should collect git info from repo");
-
-        // Should have commit hash
-        assert!(git_info.commit_hash.is_some());
-        // Branch should be None for detached HEAD (since rev-parse --abbrev-ref HEAD returns "HEAD")
-        assert!(git_info.branch.is_none());
-    }
-
-    #[tokio::test]
-    async fn test_collect_git_info_with_branch() {
-        let temp_dir = TempDir::new().expect("Failed to create temp dir");
-        let repo_path = create_test_git_repo(&temp_dir).await;
-
-        // Create and checkout a new branch
-        Command::new("git")
-            .args(["checkout", "-b", "feature-branch"])
-            .current_dir(&repo_path)
-            .output()
-            .await
-            .expect("Failed to create branch");
-
-        let git_info = collect_git_info(&repo_path)
-            .await
-            .expect("Should collect git info from repo");
-
-        // Should have the new branch name
-        assert_eq!(git_info.branch, Some("feature-branch".to_string()));
-    }
-
-    #[test]
-    fn test_git_info_serialization() {
-        let git_info = GitInfo {
-            commit_hash: Some("abc123def456".to_string()),
-            branch: Some("main".to_string()),
-            repository_url: Some("https://github.com/example/repo.git".to_string()),
-        };
-
-        let json = serde_json::to_string(&git_info).expect("Should serialize GitInfo");
-        let parsed: serde_json::Value = serde_json::from_str(&json).expect("Should parse JSON");
-
-        assert_eq!(parsed["commit_hash"], "abc123def456");
-        assert_eq!(parsed["branch"], "main");
-        assert_eq!(
-            parsed["repository_url"],
-            "https://github.com/example/repo.git"
-        );
-    }
-
-    #[test]
-    fn test_git_info_serialization_with_nones() {
-        let git_info = GitInfo {
-            commit_hash: None,
-            branch: None,
-            repository_url: None,
-        };
-
-        let json = serde_json::to_string(&git_info).expect("Should serialize GitInfo");
-        let parsed: serde_json::Value = serde_json::from_str(&json).expect("Should parse JSON");
-
-        // Fields with None values should be omitted due to skip_serializing_if
-        assert!(!parsed.as_object().unwrap().contains_key("commit_hash"));
-        assert!(!parsed.as_object().unwrap().contains_key("branch"));
-        assert!(!parsed.as_object().unwrap().contains_key("repository_url"));
-    }
-}

codex-rs/core/src/is_safe_command.rs

@@ -1,57 +1,31 @@
-use crate::bash::try_parse_bash;
-use crate::bash::try_parse_word_only_commands_sequence;
+use tree_sitter::Parser;
+use tree_sitter::Tree;
+use tree_sitter_bash::LANGUAGE as BASH;
 
 pub fn is_known_safe_command(command: &[String]) -> bool {
     if is_safe_to_call_with_exec(command) {
         return true;
     }
 
-    // Support `bash -lc "..."` where the script consists solely of one or
-    // more "plain" commands (only bare words / quoted strings) combined with
-    // a conservative allow‑list of shell operators that themselves do not
-    // introduce side effects ( "&&", "||", ";", and "|" ). If every
-    // individual command in the script is itself a known‑safe command, then
-    // the composite expression is considered safe.
-    if let [bash, flag, script] = command {
-        if bash == "bash" && flag == "-lc" {
-            if let Some(tree) = try_parse_bash(script) {
-                if let Some(all_commands) = try_parse_word_only_commands_sequence(&tree, script) {
-                    if !all_commands.is_empty()
-                        && all_commands
-                            .iter()
-                            .all(|cmd| is_safe_to_call_with_exec(cmd))
-                    {
-                        return true;
-                    }
-                }
-            }
-        }
-    }
-
-    false
+    // TODO(mbolin): Also support safe commands that are piped together such
+    // as `cat foo | wc -l`.
+    matches!(
+        command,
+        [bash, flag, script]
+            if bash == "bash"
+            && flag == "-lc"
+            && try_parse_bash(script).and_then(|tree|
+                try_parse_single_word_only_command(&tree, script)).is_some_and(|parsed_bash_command| is_safe_to_call_with_exec(&parsed_bash_command))
+    )
 }
 
 fn is_safe_to_call_with_exec(command: &[String]) -> bool {
     let cmd0 = command.first().map(String::as_str);
 
     match cmd0 {
-        #[rustfmt::skip]
-        Some(
-            "cat" |
-            "cd" |
-            "echo" |
-            "false" |
-            "grep" |
-            "head" |
-            "ls" |
-            "nl" |
-            "pwd" |
-            "tail" |
-            "true" |
-            "wc" |
-            "which") => {
+        Some("cat" | "cd" | "echo" | "grep" | "head" | "ls" | "pwd" | "tail" | "wc" | "which") => {
             true
-        },
+        }
 
         Some("find") => {
             // Certain options to `find` can delete files, write to files, or
@@ -121,7 +95,90 @@ fn is_safe_to_call_with_exec(command: &[String]) -> bool {
     }
 }
 
-// (bash parsing helpers implemented in crate::bash)
+fn try_parse_bash(bash_lc_arg: &str) -> Option<Tree> {
+    let lang = BASH.into();
+    let mut parser = Parser::new();
+    #[expect(clippy::expect_used)]
+    parser.set_language(&lang).expect("load bash grammar");
+
+    let old_tree: Option<&Tree> = None;
+    parser.parse(bash_lc_arg, old_tree)
+}
+
+/// If `tree` represents a single Bash command whose name and every argument is
+/// an ordinary `word`, return those words in order; otherwise, return `None`.
+///
+/// `src` must be the exact source string that was parsed into `tree`, so we can
+/// extract the text for every node.
+pub fn try_parse_single_word_only_command(tree: &Tree, src: &str) -> Option<Vec<String>> {
+    // Any parse error is an immediate rejection.
+    if tree.root_node().has_error() {
+        return None;
+    }
+
+    // (program …) with exactly one statement
+    let root = tree.root_node();
+    if root.kind() != "program" || root.named_child_count() != 1 {
+        return None;
+    }
+
+    let cmd = root.named_child(0)?; // (command …)
+    if cmd.kind() != "command" {
+        return None;
+    }
+
+    let mut words = Vec::new();
+    let mut cursor = cmd.walk();
+
+    for child in cmd.named_children(&mut cursor) {
+        match child.kind() {
+            // The command name node wraps one `word` child.
+            "command_name" => {
+                let word_node = child.named_child(0)?; // make sure it's only a word
+                if word_node.kind() != "word" {
+                    return None;
+                }
+                words.push(word_node.utf8_text(src.as_bytes()).ok()?.to_owned());
+            }
+            // Positional‑argument word (allowed).
+            "word" | "number" => {
+                words.push(child.utf8_text(src.as_bytes()).ok()?.to_owned());
+            }
+            "string" => {
+                if child.child_count() == 3
+                    && child.child(0)?.kind() == "\""
+                    && child.child(1)?.kind() == "string_content"
+                    && child.child(2)?.kind() == "\""
+                {
+                    words.push(child.child(1)?.utf8_text(src.as_bytes()).ok()?.to_owned());
+                } else {
+                    // Anything else means the command is *not* plain words.
+                    return None;
+                }
+            }
+            "concatenation" => {
+                // TODO: Consider things like `'ab\'a'`.
+                return None;
+            }
+            "raw_string" => {
+                // Raw string is a single word, but we need to strip the quotes.
+                let raw_string = child.utf8_text(src.as_bytes()).ok()?;
+                let stripped = raw_string
+                    .strip_prefix('\'')
+                    .and_then(|s| s.strip_suffix('\''));
+                if let Some(stripped) = stripped {
+                    words.push(stripped.to_owned());
+                } else {
+                    return None;
+                }
+            }
+            // Anything else means the command is *not* plain words.
+            _ => return None,
+        }
+    }
+
+    Some(words)
+}
 
 /* ----------------------------------------------------------
 Example
@@ -159,7 +216,6 @@ fn is_valid_sed_n_arg(arg: Option<&str>) -> bool {
         _ => false,
     }
 }
-
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used)]
@@ -176,11 +232,6 @@ mod tests {
         assert!(is_safe_to_call_with_exec(&vec_str(&[
             "sed", "-n", "1,5p", "file.txt"
         ])));
-        assert!(is_safe_to_call_with_exec(&vec_str(&[
-            "nl",
-            "-nrz",
-            "Cargo.toml"
-        ])));
 
         // Safe `find` command (no unsafe options).
         assert!(is_safe_to_call_with_exec(&vec_str(&[
@@ -283,30 +334,6 @@ mod tests {
         ])));
     }
 
-    #[test]
-    fn bash_lc_safe_examples_with_operators() {
-        assert!(is_known_safe_command(&vec_str(&[
-            "bash",
-            "-lc",
-            "grep -R \"Cargo.toml\" -n || true"
-        ])));
-        assert!(is_known_safe_command(&vec_str(&[
-            "bash",
-            "-lc",
-            "ls && pwd"
-        ])));
-        assert!(is_known_safe_command(&vec_str(&[
-            "bash",
-            "-lc",
-            "echo 'hi' ; ls"
-        ])));
-        assert!(is_known_safe_command(&vec_str(&[
-            "bash",
-            "-lc",
-            "ls | wc -l"
-        ])));
-    }
-
     #[test]
     fn bash_lc_unsafe_examples() {
         assert!(
@@ -320,29 +347,44 @@ mod tests {
 
         assert!(
             !is_known_safe_command(&vec_str(&["bash", "-lc", "find . -name file.txt -delete"])),
-            "Unsafe find option should not be auto-approved."
-        );
-
-        // Disallowed because of unsafe command in sequence.
-        assert!(
-            !is_known_safe_command(&vec_str(&["bash", "-lc", "ls && rm -rf /"])),
-            "Sequence containing unsafe command must be rejected"
-        );
-
-        // Disallowed because of parentheses / subshell.
-        assert!(
-            !is_known_safe_command(&vec_str(&["bash", "-lc", "(ls)"])),
-            "Parentheses (subshell) are not provably safe with the current parser"
-        );
-        assert!(
-            !is_known_safe_command(&vec_str(&["bash", "-lc", "ls || (pwd && echo hi)"])),
-            "Nested parentheses are not provably safe with the current parser"
-        );
-
-        // Disallowed redirection.
-        assert!(
-            !is_known_safe_command(&vec_str(&["bash", "-lc", "ls > out.txt"])),
-            "> redirection should be rejected"
+            "Unsafe find option should not be auto‑approved."
         );
     }
+
+    #[test]
+    fn test_try_parse_single_word_only_command() {
+        let script_with_single_quoted_string = "sed -n '1,5p' file.txt";
+        let parsed_words = try_parse_bash(script_with_single_quoted_string)
+            .and_then(|tree| {
+                try_parse_single_word_only_command(&tree, script_with_single_quoted_string)
+            })
+            .unwrap();
+        assert_eq!(
+            vec![
+                "sed".to_string(),
+                "-n".to_string(),
+                // Ensure the single quotes are properly removed.
+                "1,5p".to_string(),
+                "file.txt".to_string()
+            ],
+            parsed_words,
+        );
+
+        let script_with_number_arg = "ls -1";
+        let parsed_words = try_parse_bash(script_with_number_arg)
+            .and_then(|tree| try_parse_single_word_only_command(&tree, script_with_number_arg))
+            .unwrap();
+        assert_eq!(vec!["ls", "-1"], parsed_words,);
+
+        let script_with_double_quoted_string_with_no_funny_stuff_arg = "grep -R \"Cargo.toml\" -n";
+        let parsed_words = try_parse_bash(script_with_double_quoted_string_with_no_funny_stuff_arg)
+            .and_then(|tree| {
+                try_parse_single_word_only_command(
+                    &tree,
+                    script_with_double_quoted_string_with_no_funny_stuff_arg,
+                )
+            })
+            .unwrap();
+        assert_eq!(vec!["grep", "-R", "Cargo.toml", "-n"], parsed_words);
+    }
 }

codex-rs/core/src/lib.rs

@@ -5,7 +5,6 @@
 // the TUI or the tracing stack).
 #![deny(clippy::print_stdout, clippy::print_stderr)]
 
-mod bash;
 mod chat_completions;
 mod client;
 mod client_common;
@@ -20,7 +19,6 @@ pub mod error;
 pub mod exec;
 pub mod exec_env;
 mod flags;
-pub mod git_info;
 mod is_safe_command;
 mod mcp_connection_manager;
 mod mcp_tool_call;

codex-rs/core/src/models.rs

@@ -3,7 +3,6 @@ use std::collections::HashMap;
 use base64::Engine;
 use mcp_types::CallToolResult;
 use serde::Deserialize;
-use serde::Deserializer;
 use serde::Serialize;
 use serde::ser::Serializer;
 
@@ -38,14 +37,12 @@ pub enum ContentItem {
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ResponseItem {
     Message {
-        id: Option<String>,
         role: String,
         content: Vec<ContentItem>,
     },
     Reasoning {
         id: String,
         summary: Vec<ReasoningItemReasoningSummary>,
-        encrypted_content: Option<String>,
     },
     LocalShellCall {
         /// Set when using the chat completions API.
@@ -56,7 +53,6 @@ pub enum ResponseItem {
         action: LocalShellAction,
     },
     FunctionCall {
-        id: Option<String>,
         name: String,
         // The Responses API returns the function call arguments as a *string* that contains
         // JSON, not as an already‑parsed object. We keep it as a raw string here and let
@@ -82,11 +78,7 @@ pub enum ResponseItem {
 impl From<ResponseInputItem> for ResponseItem {
     fn from(item: ResponseInputItem) -> Self {
         match item {
-            ResponseInputItem::Message { role, content } => Self::Message {
-                role,
-                content,
-                id: None,
-            },
+            ResponseInputItem::Message { role, content } => Self::Message { role, content },
             ResponseInputItem::FunctionCallOutput { call_id, output } => {
                 Self::FunctionCallOutput { call_id, output }
             }
@@ -185,7 +177,7 @@ pub struct ShellToolCallParams {
     pub timeout_ms: Option<u64>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Deserialize, Debug, Clone)]
 pub struct FunctionCallOutputPayload {
     pub content: String,
     #[expect(dead_code)]
@@ -213,19 +205,6 @@ impl Serialize for FunctionCallOutputPayload {
     }
 }
 
-impl<'de> Deserialize<'de> for FunctionCallOutputPayload {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        Ok(FunctionCallOutputPayload {
-            content: s,
-            success: None,
-        })
-    }
-}
-
 // Implement Display so callers can treat the payload like a plain string when logging or doing
 // trivial substring checks in tests (existing tests call `.contains()` on the output). Display
 // returns the raw `content` field.

codex-rs/core/src/protocol.rs

@@ -4,15 +4,13 @@
 //! between user and agent.
 
 use std::collections::HashMap;
-use std::fmt;
 use std::path::Path;
 use std::path::PathBuf;
-use std::str::FromStr; // Added for FinalOutput Display implementation
+use std::str::FromStr;
 
 use mcp_types::CallToolResult;
 use serde::Deserialize;
 use serde::Serialize;
-use strum_macros::Display;
 use uuid::Uuid;
 
 use crate::config_types::ReasoningEffort as ReasoningEffortConfig;
@@ -118,23 +116,18 @@ pub enum Op {
 
     /// Request a single history entry identified by `log_id` + `offset`.
     GetHistoryEntryRequest { offset: usize, log_id: u64 },
-
-    /// Request to shut down codex instance.
-    Shutdown,
 }
 
 /// Determines the conditions under which the user is consulted to approve
 /// running the command proposed by Codex.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize, Display)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
-#[strum(serialize_all = "kebab-case")]
 pub enum AskForApproval {
     /// Under this policy, only "known safe" commands—as determined by
     /// `is_safe_command()`—that **only read files** are auto‑approved.
     /// Everything else will ask the user to approve.
     #[default]
     #[serde(rename = "untrusted")]
-    #[strum(serialize = "untrusted")]
     UnlessTrusted,
 
     /// *All* commands are auto‑approved, but they are expected to run inside a
@@ -333,9 +326,6 @@ pub enum EventMsg {
 
     /// Response to GetHistoryEntryRequest.
     GetHistoryEntryResponse(GetHistoryEntryResponseEvent),
-
-    /// Notification that the agent is shutting down.
-    ShutdownComplete,
 }
 
 // Individual event payload types matching each `EventMsg` variant.
@@ -359,36 +349,6 @@ pub struct TokenUsage {
     pub total_tokens: u64,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct FinalOutput {
-    pub token_usage: TokenUsage,
-}
-
-impl From<TokenUsage> for FinalOutput {
-    fn from(token_usage: TokenUsage) -> Self {
-        Self { token_usage }
-    }
-}
-
-impl fmt::Display for FinalOutput {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let u = &self.token_usage;
-        write!(
-            f,
-            "Token usage: total={} input={}{} output={}{}",
-            u.total_tokens,
-            u.input_tokens,
-            u.cached_input_tokens
-                .map(|c| format!(" (cached {c})"))
-                .unwrap_or_default(),
-            u.output_tokens,
-            u.reasoning_output_tokens
-                .map(|r| format!(" (reasoning {r})"))
-                .unwrap_or_default()
-        )
-    }
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AgentMessageEvent {
     pub message: String,
@@ -462,8 +422,6 @@ pub struct ExecCommandEndEvent {
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ExecApprovalRequestEvent {
-    /// Identifier for the associated exec call, if available.
-    pub call_id: String,
     /// The command to be executed.
     pub command: Vec<String>,
     /// The command's working directory.
@@ -475,8 +433,6 @@ pub struct ExecApprovalRequestEvent {
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ApplyPatchApprovalRequestEvent {
-    /// Responses API call id for the associated patch apply call, if available.
-    pub call_id: String,
     pub changes: HashMap<PathBuf, FileChange>,
     /// Optional explanatory reason (e.g. request for extra write access).
     #[serde(skip_serializing_if = "Option::is_none")]

codex-rs/core/src/rollout.rs

@@ -14,14 +14,10 @@ use time::macros::format_description;
 use tokio::io::AsyncWriteExt;
 use tokio::sync::mpsc::Sender;
 use tokio::sync::mpsc::{self};
-use tokio::sync::oneshot;
 use tracing::info;
-use tracing::warn;
 use uuid::Uuid;
 
 use crate::config::Config;
-use crate::git_info::GitInfo;
-use crate::git_info::collect_git_info;
 use crate::models::ResponseItem;
 
 const SESSIONS_SUBDIR: &str = "sessions";
@@ -33,16 +29,10 @@ pub struct SessionMeta {
     pub instructions: Option<String>,
 }
 
-#[derive(Serialize)]
-struct SessionMetaWithGit {
-    #[serde(flatten)]
-    meta: SessionMeta,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    git: Option<GitInfo>,
-}
-
 #[derive(Serialize, Deserialize, Default, Clone)]
-pub struct SessionStateSnapshot {}
+pub struct SessionStateSnapshot {
+    pub previous_response_id: Option<String>,
+}
 
 #[derive(Serialize, Deserialize, Default, Clone)]
 pub struct SavedSession {
@@ -68,10 +58,10 @@ pub(crate) struct RolloutRecorder {
     tx: Sender<RolloutCmd>,
 }
 
+#[derive(Clone)]
 enum RolloutCmd {
     AddItems(Vec<ResponseItem>),
     UpdateState(SessionStateSnapshot),
-    Shutdown { ack: oneshot::Sender<()> },
 }
 
 impl RolloutRecorder {
@@ -96,12 +86,15 @@ impl RolloutRecorder {
             .format(timestamp_format)
             .map_err(|e| IoError::other(format!("failed to format timestamp: {e}")))?;
 
-        // Clone the cwd for the spawned task to collect git info asynchronously
-        let cwd = config.cwd.clone();
+        let meta = SessionMeta {
+            timestamp,
+            id: session_id,
+            instructions,
+        };
 
         // A reasonably-sized bounded channel. If the buffer fills up the send
         // future will yield, which is fine – we only need to ensure we do not
-        // perform *blocking* I/O on the caller's thread.
+        // perform *blocking* I/O on the caller’s thread.
         let (tx, rx) = mpsc::channel::<RolloutCmd>(256);
 
         // Spawn a Tokio task that owns the file handle and performs async
@@ -110,12 +103,7 @@ impl RolloutRecorder {
         tokio::task::spawn(rollout_writer(
             tokio::fs::File::from_std(file),
             rx,
-            Some(SessionMeta {
-                timestamp,
-                id: session_id,
-                instructions,
-            }),
-            cwd,
+            Some(meta),
         ));
 
         Ok(Self { tx })
@@ -131,9 +119,8 @@ impl RolloutRecorder {
                 ResponseItem::Message { .. }
                 | ResponseItem::LocalShellCall { .. }
                 | ResponseItem::FunctionCall { .. }
-                | ResponseItem::FunctionCallOutput { .. }
-                | ResponseItem::Reasoning { .. } => filtered.push(item.clone()),
-                ResponseItem::Other => {
+                | ResponseItem::FunctionCallOutput { .. } => filtered.push(item.clone()),
+                ResponseItem::Reasoning { .. } | ResponseItem::Other => {
                     // These should never be serialized.
                     continue;
                 }
@@ -155,10 +142,7 @@ impl RolloutRecorder {
             .map_err(|e| IoError::other(format!("failed to queue rollout state: {e}")))
     }
 
-    pub async fn resume(
-        path: &Path,
-        cwd: std::path::PathBuf,
-    ) -> std::io::Result<(Self, SavedSession)> {
+    pub async fn resume(path: &Path) -> std::io::Result<(Self, SavedSession)> {
         info!("Resuming rollout from {path:?}");
         let text = tokio::fs::read_to_string(path).await?;
         let mut lines = text.lines();
@@ -188,17 +172,13 @@ impl RolloutRecorder {
                 }
                 continue;
             }
-            match serde_json::from_value::<ResponseItem>(v.clone()) {
-                Ok(item) => match item {
+            if let Ok(item) = serde_json::from_value::<ResponseItem>(v.clone()) {
+                match item {
                     ResponseItem::Message { .. }
                     | ResponseItem::LocalShellCall { .. }
                     | ResponseItem::FunctionCall { .. }
-                    | ResponseItem::FunctionCallOutput { .. }
-                    | ResponseItem::Reasoning { .. } => items.push(item),
-                    ResponseItem::Other => {}
-                },
-                Err(e) => {
-                    warn!("failed to parse item: {v:?}, error: {e}");
+                    | ResponseItem::FunctionCallOutput { .. } => items.push(item),
+                    ResponseItem::Reasoning { .. } | ResponseItem::Other => {}
                 }
             }
         }
@@ -216,30 +196,10 @@ impl RolloutRecorder {
             .open(path)?;
 
         let (tx, rx) = mpsc::channel::<RolloutCmd>(256);
-        tokio::task::spawn(rollout_writer(
-            tokio::fs::File::from_std(file),
-            rx,
-            None,
-            cwd,
-        ));
+        tokio::task::spawn(rollout_writer(tokio::fs::File::from_std(file), rx, None));
         info!("Resumed rollout successfully from {path:?}");
         Ok((Self { tx }, saved))
     }
-
-    pub async fn shutdown(&self) -> std::io::Result<()> {
-        let (tx_done, rx_done) = oneshot::channel();
-        match self.tx.send(RolloutCmd::Shutdown { ack: tx_done }).await {
-            Ok(_) => rx_done
-                .await
-                .map_err(|e| IoError::other(format!("failed waiting for rollout shutdown: {e}"))),
-            Err(e) => {
-                warn!("failed to send rollout shutdown command: {e}");
-                Err(IoError::other(format!(
-                    "failed to send rollout shutdown command: {e}"
-                )))
-            }
-        }
-    }
 }
 
 struct LogFileInfo {
@@ -290,26 +250,15 @@ fn create_log_file(config: &Config, session_id: Uuid) -> std::io::Result<LogFile
 async fn rollout_writer(
     mut file: tokio::fs::File,
     mut rx: mpsc::Receiver<RolloutCmd>,
-    mut meta: Option<SessionMeta>,
-    cwd: std::path::PathBuf,
+    meta: Option<SessionMeta>,
 ) {
-    // If we have a meta, collect git info asynchronously and write meta first
-    if let Some(session_meta) = meta.take() {
-        let git_info = collect_git_info(&cwd).await;
-        let session_meta_with_git = SessionMetaWithGit {
-            meta: session_meta,
-            git: git_info,
-        };
-
-        // Write the SessionMeta as the first item in the file
-        if let Ok(json) = serde_json::to_string(&session_meta_with_git) {
+    if let Some(meta) = meta {
+        if let Ok(json) = serde_json::to_string(&meta) {
             let _ = file.write_all(json.as_bytes()).await;
             let _ = file.write_all(b"\n").await;
             let _ = file.flush().await;
         }
     }
-
-    // Process rollout commands
     while let Some(cmd) = rx.recv().await {
         match cmd {
             RolloutCmd::AddItems(items) => {
@@ -318,14 +267,13 @@ async fn rollout_writer(
                         ResponseItem::Message { .. }
                         | ResponseItem::LocalShellCall { .. }
                         | ResponseItem::FunctionCall { .. }
-                        | ResponseItem::FunctionCallOutput { .. }
-                        | ResponseItem::Reasoning { .. } => {
+                        | ResponseItem::FunctionCallOutput { .. } => {
                             if let Ok(json) = serde_json::to_string(&item) {
                                 let _ = file.write_all(json.as_bytes()).await;
                                 let _ = file.write_all(b"\n").await;
                             }
                         }
-                        ResponseItem::Other => {}
+                        ResponseItem::Reasoning { .. } | ResponseItem::Other => {}
                     }
                 }
                 let _ = file.flush().await;
@@ -346,9 +294,6 @@ async fn rollout_writer(
                     let _ = file.flush().await;
                 }
             }
-            RolloutCmd::Shutdown { ack } => {
-                let _ = ack.send(());
-            }
         }
     }
 }

codex-rs/core/tests/cli_stream.rs

@@ -329,7 +329,6 @@ async fn integration_creates_and_checks_session_file() {
         .env("OPENAI_API_KEY", "dummy")
         .env("CODEX_RS_SSE_FIXTURE", &fixture)
         .env("OPENAI_BASE_URL", "http://unused.local");
-
     let output2 = cmd2.output().unwrap();
     assert!(output2.status.success(), "resume codex-cli run failed");
 
@@ -360,125 +359,3 @@ async fn integration_creates_and_checks_session_file() {
         "rollout missing resumed marker"
     );
 }
-
-/// Integration test to verify git info is collected and recorded in session files.
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn integration_git_info_unit_test() {
-    // This test verifies git info collection works independently
-    // without depending on the full CLI integration
-
-    // 1. Create temp directory for git repo
-    let temp_dir = TempDir::new().unwrap();
-    let git_repo = temp_dir.path().to_path_buf();
-
-    // 2. Initialize a git repository with some content
-    let init_output = std::process::Command::new("git")
-        .args(["init"])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-    assert!(init_output.status.success(), "git init failed");
-
-    // Configure git user (required for commits)
-    std::process::Command::new("git")
-        .args(["config", "user.name", "Integration Test"])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-
-    std::process::Command::new("git")
-        .args(["config", "user.email", "test@example.com"])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-
-    // Create a test file and commit it
-    let test_file = git_repo.join("test.txt");
-    std::fs::write(&test_file, "integration test content").unwrap();
-
-    std::process::Command::new("git")
-        .args(["add", "."])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-
-    let commit_output = std::process::Command::new("git")
-        .args(["commit", "-m", "Integration test commit"])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-    assert!(commit_output.status.success(), "git commit failed");
-
-    // Create a branch to test branch detection
-    std::process::Command::new("git")
-        .args(["checkout", "-b", "integration-test-branch"])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-
-    // Add a remote to test repository URL detection
-    std::process::Command::new("git")
-        .args([
-            "remote",
-            "add",
-            "origin",
-            "https://github.com/example/integration-test.git",
-        ])
-        .current_dir(&git_repo)
-        .output()
-        .unwrap();
-
-    // 3. Test git info collection directly
-    let git_info = codex_core::git_info::collect_git_info(&git_repo).await;
-
-    // 4. Verify git info is present and contains expected data
-    assert!(git_info.is_some(), "Git info should be collected");
-
-    let git_info = git_info.unwrap();
-
-    // Check that we have a commit hash
-    assert!(
-        git_info.commit_hash.is_some(),
-        "Git info should contain commit_hash"
-    );
-    let commit_hash = git_info.commit_hash.as_ref().unwrap();
-    assert_eq!(commit_hash.len(), 40, "Commit hash should be 40 characters");
-    assert!(
-        commit_hash.chars().all(|c| c.is_ascii_hexdigit()),
-        "Commit hash should be hexadecimal"
-    );
-
-    // Check that we have the correct branch
-    assert!(git_info.branch.is_some(), "Git info should contain branch");
-    let branch = git_info.branch.as_ref().unwrap();
-    assert_eq!(
-        branch, "integration-test-branch",
-        "Branch should match what we created"
-    );
-
-    // Check that we have the repository URL
-    assert!(
-        git_info.repository_url.is_some(),
-        "Git info should contain repository_url"
-    );
-    let repo_url = git_info.repository_url.as_ref().unwrap();
-    assert_eq!(
-        repo_url, "https://github.com/example/integration-test.git",
-        "Repository URL should match what we configured"
-    );
-
-    println!("✅ Git info collection test passed!");
-    println!("   Commit: {commit_hash}");
-    println!("   Branch: {branch}");
-    println!("   Repo: {repo_url}");
-
-    // 5. Test serialization to ensure it works in SessionMeta
-    let serialized = serde_json::to_string(&git_info).unwrap();
-    let deserialized: codex_core::git_info::GitInfo = serde_json::from_str(&serialized).unwrap();
-
-    assert_eq!(git_info.commit_hash, deserialized.commit_hash);
-    assert_eq!(git_info.branch, deserialized.branch);
-    assert_eq!(git_info.repository_url, deserialized.repository_url);
-
-    println!("✅ Git info serialization test passed!");
-}

codex-rs/core/tests/client.rs

@@ -5,10 +5,10 @@ use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::protocol::SessionConfiguredEvent;
-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;
+mod test_support;
 use tempfile::TempDir;
+use test_support::load_default_config_for_test;
+use test_support::load_sse_fixture_with_id;
 use wiremock::Mock;
 use wiremock::MockServer;
 use wiremock::ResponseTemplate;
@@ -84,13 +84,14 @@ async fn includes_session_id_and_model_headers_in_request() {
         .unwrap();
 
     let EventMsg::SessionConfigured(SessionConfiguredEvent { session_id, .. }) =
-        wait_for_event(&codex, |ev| matches!(ev, EventMsg::SessionConfigured(_))).await
+        test_support::wait_for_event(&codex, |ev| matches!(ev, EventMsg::SessionConfigured(_)))
+            .await
     else {
         unreachable!()
     };
 
     let current_session_id = Some(session_id.to_string());
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+    test_support::wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     // get request from the server
     let request = &server.received_requests().await.unwrap()[0];
@@ -159,7 +160,7 @@ async fn includes_base_instructions_override_in_request() {
         .await
         .unwrap();
 
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
+    test_support::wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
 
     let request = &server.received_requests().await.unwrap()[0];
     let request_body = request.body_json::<serde_json::Value>().unwrap();

codex-rs/core/tests/common/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "core_test_support"
-version = { workspace = true }
-edition = "2024"
-
-[lib]
-path = "lib.rs"
-
-[dependencies]
-codex-core = { path = "../.." }
-serde_json = "1"
-tempfile = "3"
-tokio = { version = "1", features = ["time"] }

codex-rs/core/tests/live_agent.rs

@@ -26,8 +26,9 @@ use codex_core::protocol::ErrorEvent;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
-use core_test_support::load_default_config_for_test;
+mod test_support;
 use tempfile::TempDir;
+use test_support::load_default_config_for_test;
 use tokio::sync::Notify;
 use tokio::time::timeout;
 

codex-rs/core/tests/previous_response_id.rs

@@ -0,0 +1,165 @@
+use std::time::Duration;
+
+use codex_core::Codex;
+use codex_core::ModelProviderInfo;
+use codex_core::exec::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
+use codex_core::protocol::ErrorEvent;
+use codex_core::protocol::EventMsg;
+use codex_core::protocol::InputItem;
+use codex_core::protocol::Op;
+mod test_support;
+use serde_json::Value;
+use tempfile::TempDir;
+use test_support::load_default_config_for_test;
+use test_support::load_sse_fixture_with_id;
+use tokio::time::timeout;
+use wiremock::Match;
+use wiremock::Mock;
+use wiremock::MockServer;
+use wiremock::Request;
+use wiremock::ResponseTemplate;
+use wiremock::matchers::method;
+use wiremock::matchers::path;
+
+/// Matcher asserting that JSON body has NO `previous_response_id` field.
+struct NoPrevId;
+
+impl Match for NoPrevId {
+    fn matches(&self, req: &Request) -> bool {
+        serde_json::from_slice::<Value>(&req.body)
+            .map(|v| v.get("previous_response_id").is_none())
+            .unwrap_or(false)
+    }
+}
+
+/// Matcher asserting that JSON body HAS a `previous_response_id` field.
+struct HasPrevId;
+
+impl Match for HasPrevId {
+    fn matches(&self, req: &Request) -> bool {
+        serde_json::from_slice::<Value>(&req.body)
+            .map(|v| v.get("previous_response_id").is_some())
+            .unwrap_or(false)
+    }
+}
+
+/// Build minimal SSE stream with completed marker using the JSON fixture.
+fn sse_completed(id: &str) -> String {
+    load_sse_fixture_with_id("tests/fixtures/completed_template.json", id)
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn keeps_previous_response_id_between_tasks() {
+    #![allow(clippy::unwrap_used)]
+
+    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
+    let server = MockServer::start().await;
+
+    // First request – must NOT include `previous_response_id`.
+    let first = ResponseTemplate::new(200)
+        .insert_header("content-type", "text/event-stream")
+        .set_body_raw(sse_completed("resp1"), "text/event-stream");
+
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .and(NoPrevId)
+        .respond_with(first)
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    // Second request – MUST include `previous_response_id`.
+    let second = ResponseTemplate::new(200)
+        .insert_header("content-type", "text/event-stream")
+        .set_body_raw(sse_completed("resp2"), "text/event-stream");
+
+    Mock::given(method("POST"))
+        .and(path("/v1/responses"))
+        .and(HasPrevId)
+        .respond_with(second)
+        .expect(1)
+        .mount(&server)
+        .await;
+
+    // Configure retry behavior explicitly to avoid mutating process-wide
+    // environment variables.
+    let model_provider = ModelProviderInfo {
+        name: "openai".into(),
+        base_url: format!("{}/v1", server.uri()),
+        // Environment variable that should exist in the test environment.
+        // ModelClient will return an error if the environment variable for the
+        // provider is not set.
+        env_key: Some("PATH".into()),
+        env_key_instructions: None,
+        wire_api: codex_core::WireApi::Responses,
+        query_params: None,
+        http_headers: None,
+        env_http_headers: None,
+        // disable retries so we don't get duplicate calls in this test
+        request_max_retries: Some(0),
+        stream_max_retries: Some(0),
+        stream_idle_timeout_ms: None,
+    };
+
+    // Init session
+    let codex_home = TempDir::new().unwrap();
+    let mut config = load_default_config_for_test(&codex_home);
+    config.model_provider = model_provider;
+    let ctrl_c = std::sync::Arc::new(tokio::sync::Notify::new());
+    let (codex, _init_id, _session_id) = Codex::spawn(config, ctrl_c.clone()).await.unwrap();
+
+    // Task 1 – triggers first request (no previous_response_id)
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "hello".into(),
+            }],
+        })
+        .await
+        .unwrap();
+
+    // Wait for TaskComplete
+    loop {
+        let ev = timeout(Duration::from_secs(1), codex.next_event())
+            .await
+            .unwrap()
+            .unwrap();
+        if matches!(ev.msg, EventMsg::TaskComplete(_)) {
+            break;
+        }
+    }
+
+    // Task 2 – should include `previous_response_id` (triggers second request)
+    codex
+        .submit(Op::UserInput {
+            items: vec![InputItem::Text {
+                text: "again".into(),
+            }],
+        })
+        .await
+        .unwrap();
+
+    // Wait for TaskComplete or error
+    loop {
+        let ev = timeout(Duration::from_secs(1), codex.next_event())
+            .await
+            .unwrap()
+            .unwrap();
+        match ev.msg {
+            EventMsg::TaskComplete(_) => break,
+            EventMsg::Error(ErrorEvent { message }) => {
+                panic!("unexpected error: {message}")
+            }
+            _ => {
+                // Ignore other events.
+            }
+        }
+    }
+}

codex-rs/core/tests/stream_no_completed.rs

@@ -9,10 +9,11 @@ use codex_core::exec::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
-use core_test_support::load_default_config_for_test;
-use core_test_support::load_sse_fixture;
-use core_test_support::load_sse_fixture_with_id;
+mod test_support;
 use tempfile::TempDir;
+use test_support::load_default_config_for_test;
+use test_support::load_sse_fixture;
+use test_support::load_sse_fixture_with_id;
 use tokio::time::timeout;
 use wiremock::Mock;
 use wiremock::MockServer;

codex-rs/core/tests/test_support.rs

@@ -1,5 +1,9 @@
 #![allow(clippy::expect_used)]
 
+// Helpers shared by the integration tests.  These are located inside the
+// `tests/` tree on purpose so they never become part of the public API surface
+// of the `codex-core` crate.
+
 use tempfile::TempDir;
 
 use codex_core::config::Config;
@@ -26,6 +30,7 @@ pub fn load_default_config_for_test(codex_home: &TempDir) -> Config {
 /// with only a `type` field results in an event with no `data:` section. This
 /// makes it trivial to extend the fixtures as OpenAI adds new event kinds or
 /// fields.
+#[allow(dead_code)]
 pub fn load_sse_fixture(path: impl AsRef<std::path::Path>) -> String {
     let events: Vec<serde_json::Value> =
         serde_json::from_reader(std::fs::File::open(path).expect("read fixture"))
@@ -50,6 +55,7 @@ pub fn load_sse_fixture(path: impl AsRef<std::path::Path>) -> String {
 /// fixture template with the supplied identifier before parsing. This lets a
 /// single JSON template be reused by multiple tests that each need a unique
 /// `response_id`.
+#[allow(dead_code)]
 pub fn load_sse_fixture_with_id(path: impl AsRef<std::path::Path>, id: &str) -> String {
     let raw = std::fs::read_to_string(path).expect("read fixture template");
     let replaced = raw.replace("__ID__", id);
@@ -71,6 +77,7 @@ pub fn load_sse_fixture_with_id(path: impl AsRef<std::path::Path>, id: &str) ->
         .collect()
 }
 
+#[allow(dead_code)]
 pub async fn wait_for_event<F>(
     codex: &codex_core::Codex,
     mut predicate: F,

codex-rs/exec/src/event_processor.rs

@@ -1,23 +1,15 @@
-use std::path::Path;
-
 use codex_common::summarize_sandbox_policy;
 use codex_core::WireApi;
 use codex_core::config::Config;
 use codex_core::model_supports_reasoning_summaries;
 use codex_core::protocol::Event;
 
-pub(crate) enum CodexStatus {
-    Running,
-    InitiateShutdown,
-    Shutdown,
-}
-
 pub(crate) trait EventProcessor {
     /// Print summary of effective configuration and user prompt.
     fn print_config_summary(&mut self, config: &Config, prompt: &str);
 
     /// Handle a single event emitted by the agent.
-    fn process_event(&mut self, event: Event) -> CodexStatus;
+    fn process_event(&mut self, event: Event);
 }
 
 pub(crate) fn create_config_summary_entries(config: &Config) -> Vec<(&'static str, String)> {
@@ -25,7 +17,7 @@ pub(crate) fn create_config_summary_entries(config: &Config) -> Vec<(&'static st
         ("workdir", config.cwd.display().to_string()),
         ("model", config.model.clone()),
         ("provider", config.model_provider_id.clone()),
-        ("approval", config.approval_policy.to_string()),
+        ("approval", format!("{:?}", config.approval_policy)),
         ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
     ];
     if config.model_provider.wire_api == WireApi::Responses
@@ -43,28 +35,3 @@ pub(crate) fn create_config_summary_entries(config: &Config) -> Vec<(&'static st
 
     entries
 }
-
-pub(crate) fn handle_last_message(
-    last_agent_message: Option<&str>,
-    last_message_path: Option<&Path>,
-) {
-    match (last_message_path, last_agent_message) {
-        (Some(path), Some(msg)) => write_last_message_file(msg, Some(path)),
-        (Some(path), None) => {
-            write_last_message_file("", Some(path));
-            eprintln!(
-                "Warning: no last agent message; wrote empty content to {}",
-                path.display()
-            );
-        }
-        (None, _) => eprintln!("Warning: no file to write last message to."),
-    }
-}
-
-fn write_last_message_file(contents: &str, last_message_path: Option<&Path>) {
-    if let Some(path) = last_message_path {
-        if let Err(e) = std::fs::write(path, contents) {
-            eprintln!("Failed to write last message file {path:?}: {e}");
-        }
-    }
-}

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -15,20 +15,16 @@ use codex_core::protocol::McpToolCallEndEvent;
 use codex_core::protocol::PatchApplyBeginEvent;
 use codex_core::protocol::PatchApplyEndEvent;
 use codex_core::protocol::SessionConfiguredEvent;
-use codex_core::protocol::TaskCompleteEvent;
 use codex_core::protocol::TokenUsage;
 use owo_colors::OwoColorize;
 use owo_colors::Style;
 use shlex::try_join;
 use std::collections::HashMap;
 use std::io::Write;
-use std::path::PathBuf;
 use std::time::Instant;
 
-use crate::event_processor::CodexStatus;
 use crate::event_processor::EventProcessor;
 use crate::event_processor::create_config_summary_entries;
-use crate::event_processor::handle_last_message;
 
 /// This should be configurable. When used in CI, users may not want to impose
 /// a limit so they can see the full transcript.
@@ -58,15 +54,10 @@ pub(crate) struct EventProcessorWithHumanOutput {
     show_agent_reasoning: bool,
     answer_started: bool,
     reasoning_started: bool,
-    last_message_path: Option<PathBuf>,
 }
 
 impl EventProcessorWithHumanOutput {
-    pub(crate) fn create_with_ansi(
-        with_ansi: bool,
-        config: &Config,
-        last_message_path: Option<PathBuf>,
-    ) -> Self {
+    pub(crate) fn create_with_ansi(with_ansi: bool, config: &Config) -> Self {
         let call_id_to_command = HashMap::new();
         let call_id_to_patch = HashMap::new();
         let call_id_to_tool_call = HashMap::new();
@@ -86,7 +77,6 @@ impl EventProcessorWithHumanOutput {
                 show_agent_reasoning: !config.hide_agent_reasoning,
                 answer_started: false,
                 reasoning_started: false,
-                last_message_path,
             }
         } else {
             Self {
@@ -103,7 +93,6 @@ impl EventProcessorWithHumanOutput {
                 show_agent_reasoning: !config.hide_agent_reasoning,
                 answer_started: false,
                 reasoning_started: false,
-                last_message_path,
             }
         }
     }
@@ -169,7 +158,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
         );
     }
 
-    fn process_event(&mut self, event: Event) -> CodexStatus {
+    fn process_event(&mut self, event: Event) {
         let Event { id: _, msg } = event;
         match msg {
             EventMsg::Error(ErrorEvent { message }) => {
@@ -179,16 +168,9 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             EventMsg::BackgroundEvent(BackgroundEventEvent { message }) => {
                 ts_println!(self, "{}", message.style(self.dimmed));
             }
-            EventMsg::TaskStarted => {
+            EventMsg::TaskStarted | EventMsg::TaskComplete(_) => {
                 // Ignore.
             }
-            EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
-                handle_last_message(
-                    last_agent_message.as_deref(),
-                    self.last_message_path.as_deref(),
-                );
-                return CodexStatus::InitiateShutdown;
-            }
             EventMsg::TokenCount(TokenUsage { total_tokens, .. }) => {
                 ts_println!(self, "tokens used: {total_tokens}");
             }
@@ -203,7 +185,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             }
             EventMsg::AgentReasoningDelta(AgentReasoningDeltaEvent { delta }) => {
                 if !self.show_agent_reasoning {
-                    return CodexStatus::Running;
+                    return;
                 }
                 if !self.reasoning_started {
                     ts_println!(
@@ -516,9 +498,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
             EventMsg::GetHistoryEntryResponse(_) => {
                 // Currently ignored in exec output.
             }
-            EventMsg::ShutdownComplete => return CodexStatus::Shutdown,
         }
-        CodexStatus::Running
     }
 }
 

codex-rs/exec/src/event_processor_with_json_output.rs

@@ -1,24 +1,18 @@
 use std::collections::HashMap;
-use std::path::PathBuf;
 
 use codex_core::config::Config;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
-use codex_core::protocol::TaskCompleteEvent;
 use serde_json::json;
 
-use crate::event_processor::CodexStatus;
 use crate::event_processor::EventProcessor;
 use crate::event_processor::create_config_summary_entries;
-use crate::event_processor::handle_last_message;
 
-pub(crate) struct EventProcessorWithJsonOutput {
-    last_message_path: Option<PathBuf>,
-}
+pub(crate) struct EventProcessorWithJsonOutput;
 
 impl EventProcessorWithJsonOutput {
-    pub fn new(last_message_path: Option<PathBuf>) -> Self {
-        Self { last_message_path }
+    pub fn new() -> Self {
+        Self {}
     }
 }
 
@@ -39,25 +33,15 @@ impl EventProcessor for EventProcessorWithJsonOutput {
         println!("{prompt_json}");
     }
 
-    fn process_event(&mut self, event: Event) -> CodexStatus {
+    fn process_event(&mut self, event: Event) {
         match event.msg {
             EventMsg::AgentMessageDelta(_) | EventMsg::AgentReasoningDelta(_) => {
                 // Suppress streaming events in JSON mode.
-                CodexStatus::Running
             }
-            EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
-                handle_last_message(
-                    last_agent_message.as_deref(),
-                    self.last_message_path.as_deref(),
-                );
-                CodexStatus::InitiateShutdown
-            }
-            EventMsg::ShutdownComplete => CodexStatus::Shutdown,
             _ => {
                 if let Ok(line) = serde_json::to_string(&event) {
                     println!("{line}");
                 }
-                CodexStatus::Running
             }
         }
     }

codex-rs/exec/src/lib.rs

@@ -5,6 +5,7 @@ mod event_processor_with_json_output;
 
 use std::io::IsTerminal;
 use std::io::Read;
+use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
@@ -27,7 +28,6 @@ use tracing::error;
 use tracing::info;
 use tracing_subscriber::EnvFilter;
 
-use crate::event_processor::CodexStatus;
 use crate::event_processor::EventProcessor;
 
 pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()> {
@@ -123,12 +123,11 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
 
     let config = Config::load_with_cli_overrides(cli_kv_overrides, overrides)?;
     let mut event_processor: Box<dyn EventProcessor> = if json_mode {
-        Box::new(EventProcessorWithJsonOutput::new(last_message_file.clone()))
+        Box::new(EventProcessorWithJsonOutput::new())
     } else {
         Box::new(EventProcessorWithHumanOutput::create_with_ansi(
             stdout_with_ansi,
             &config,
-            last_message_file.clone(),
         ))
     };
 
@@ -225,17 +224,40 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
 
     // Run the loop until the task is complete.
     while let Some(event) = rx.recv().await {
-        let shutdown: CodexStatus = event_processor.process_event(event);
-        match shutdown {
-            CodexStatus::Running => continue,
-            CodexStatus::InitiateShutdown => {
-                codex.submit(Op::Shutdown).await?;
-            }
-            CodexStatus::Shutdown => {
-                break;
+        let (is_last_event, last_assistant_message) = match &event.msg {
+            EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
+                (true, last_agent_message.clone())
             }
+            _ => (false, None),
+        };
+        event_processor.process_event(event);
+        if is_last_event {
+            handle_last_message(last_assistant_message, last_message_file.as_deref())?;
+            break;
         }
     }
 
     Ok(())
 }
+
+fn handle_last_message(
+    last_agent_message: Option<String>,
+    last_message_file: Option<&Path>,
+) -> std::io::Result<()> {
+    match (last_agent_message, last_message_file) {
+        (Some(last_agent_message), Some(last_message_file)) => {
+            // Last message and a file to write to.
+            std::fs::write(last_message_file, last_agent_message)?;
+        }
+        (None, Some(last_message_file)) => {
+            eprintln!(
+                "Warning: No last message to write to file: {}",
+                last_message_file.to_string_lossy()
+            );
+        }
+        (_, None) => {
+            // No last message and no file to write to.
+        }
+    }
+    Ok(())
+}

codex-rs/mcp-server/Cargo.toml

@@ -37,7 +37,6 @@ uuid = { version = "1", features = ["serde", "v4"] }
 
 [dev-dependencies]
 assert_cmd = "2"
-mcp_test_support = { path = "tests/common" }
 pretty_assertions = "1.4.1"
 tempfile = "3"
 tokio-test = "0.4"

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

@@ -156,7 +156,6 @@ async fn run_codex_tool_session_inner(
                     EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
                         command,
                         cwd,
-                        call_id,
                         reason: _,
                     }) => {
                         handle_exec_approval_request(
@@ -167,7 +166,6 @@ async fn run_codex_tool_session_inner(
                             request_id.clone(),
                             request_id_str.clone(),
                             event.id.clone(),
-                            call_id,
                         )
                         .await;
                         continue;
@@ -181,13 +179,11 @@ async fn run_codex_tool_session_inner(
                         break;
                     }
                     EventMsg::ApplyPatchApprovalRequest(ApplyPatchApprovalRequestEvent {
-                        call_id,
                         reason,
                         grant_root,
                         changes,
                     }) => {
                         handle_patch_approval_request(
-                            call_id,
                             reason,
                             grant_root,
                             changes,
@@ -246,8 +242,7 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::BackgroundEvent(_)
                     | EventMsg::PatchApplyBegin(_)
                     | EventMsg::PatchApplyEnd(_)
-                    | EventMsg::GetHistoryEntryResponse(_)
-                    | EventMsg::ShutdownComplete => {
+                    | EventMsg::GetHistoryEntryResponse(_) => {
                         // For now, we do not do anything extra for these
                         // events. Note that
                         // send(codex_event_to_notification(&event)) above has

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

@@ -32,7 +32,6 @@ pub struct ExecApprovalElicitRequestParams {
     pub codex_elicitation: String,
     pub codex_mcp_tool_call_id: String,
     pub codex_event_id: String,
-    pub codex_call_id: String,
     pub codex_command: Vec<String>,
     pub codex_cwd: PathBuf,
 }
@@ -46,7 +45,6 @@ pub struct ExecApprovalResponse {
     pub decision: ReviewDecision,
 }
 
-#[allow(clippy::too_many_arguments)]
 pub(crate) async fn handle_exec_approval_request(
     command: Vec<String>,
     cwd: PathBuf,
@@ -55,7 +53,6 @@ pub(crate) async fn handle_exec_approval_request(
     request_id: RequestId,
     tool_call_id: String,
     event_id: String,
-    call_id: String,
 ) {
     let escaped_command =
         shlex::try_join(command.iter().map(|s| s.as_str())).unwrap_or_else(|_| command.join(" "));
@@ -74,7 +71,6 @@ pub(crate) async fn handle_exec_approval_request(
         codex_elicitation: "exec-approval".to_string(),
         codex_mcp_tool_call_id: tool_call_id.clone(),
         codex_event_id: event_id.clone(),
-        codex_call_id: call_id,
         codex_command: command,
         codex_cwd: cwd,
     };

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

@@ -27,7 +27,6 @@ pub struct PatchApprovalElicitRequestParams {
     pub codex_elicitation: String,
     pub codex_mcp_tool_call_id: String,
     pub codex_event_id: String,
-    pub codex_call_id: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub codex_reason: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -42,7 +41,6 @@ pub struct PatchApprovalResponse {
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) async fn handle_patch_approval_request(
-    call_id: String,
     reason: Option<String>,
     grant_root: Option<PathBuf>,
     changes: HashMap<PathBuf, FileChange>,
@@ -68,7 +66,6 @@ pub(crate) async fn handle_patch_approval_request(
         codex_elicitation: "patch-approval".to_string(),
         codex_mcp_tool_call_id: tool_call_id.clone(),
         codex_event_id: event_id.clone(),
-        codex_call_id: call_id,
         codex_reason: reason,
         codex_grant_root: grant_root,
         codex_changes: changes,

codex-rs/mcp-server/tests/codex_tool.rs

@@ -1,3 +1,5 @@
+mod common;
+
 use std::collections::HashMap;
 use std::env;
 use std::path::Path;
@@ -24,11 +26,11 @@ use tempfile::TempDir;
 use tokio::time::timeout;
 use wiremock::MockServer;
 
-use mcp_test_support::McpProcess;
-use mcp_test_support::create_apply_patch_sse_response;
-use mcp_test_support::create_final_assistant_message_sse_response;
-use mcp_test_support::create_mock_chat_completions_server;
-use mcp_test_support::create_shell_sse_response;
+use crate::common::McpProcess;
+use crate::common::create_apply_patch_sse_response;
+use crate::common::create_final_assistant_message_sse_response;
+use crate::common::create_mock_chat_completions_server;
+use crate::common::create_shell_sse_response;
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
@@ -169,7 +171,6 @@ fn create_expected_elicitation_request(
             codex_event_id,
             codex_command: command,
             codex_cwd: workdir.to_path_buf(),
-            codex_call_id: "call1234".to_string(),
         })?),
     })
 }
@@ -383,7 +384,6 @@ fn create_expected_patch_approval_elicitation_request(
             codex_reason: reason,
             codex_grant_root: grant_root,
             codex_changes: changes,
-            codex_call_id: "call1234".to_string(),
         })?),
     })
 }

codex-rs/mcp-server/tests/common/Cargo.toml

@@ -1,24 +0,0 @@
-[package]
-name = "mcp_test_support"
-version = { workspace = true }
-edition = "2024"
-
-[lib]
-path = "lib.rs"
-
-[dependencies]
-anyhow = "1"
-assert_cmd = "2"
-codex-mcp-server = { path = "../.." }
-mcp-types = { path = "../../../mcp-types" }
-pretty_assertions = "1.4.1"
-serde_json = "1"
-shlex = "1.3.0"
-tempfile = "3"
-tokio = { version = "1", features = [
-    "io-std",
-    "macros",
-    "process",
-    "rt-multi-thread",
-] }
-wiremock = "0.6"

codex-rs/mcp-server/tests/common/mcp_process.rs

@@ -191,6 +191,8 @@ impl McpProcess {
         Ok(request_id)
     }
 
+    // allow dead code
+    #[allow(dead_code)]
     pub async fn send_response(
         &mut self,
         id: RequestId,
@@ -218,6 +220,8 @@ impl McpProcess {
         let message = serde_json::from_str::<JSONRPCMessage>(&line)?;
         Ok(message)
     }
+    // allow dead code
+    #[allow(dead_code)]
     pub async fn read_stream_until_request_message(&mut self) -> anyhow::Result<JSONRPCRequest> {
         loop {
             let message = self.read_jsonrpc_message().await?;
@@ -240,6 +244,8 @@ impl McpProcess {
         }
     }
 
+    // allow dead code
+    #[allow(dead_code)]
     pub async fn read_stream_until_response_message(
         &mut self,
         request_id: RequestId,
@@ -306,6 +312,8 @@ impl McpProcess {
         }
     }
 
+    // allow dead code
+    #[allow(dead_code)]
     pub async fn send_notification(
         &mut self,
         method: &str,

codex-rs/mcp-server/tests/common/mod.rs

@@ -4,6 +4,8 @@ mod responses;
 
 pub use mcp_process::McpProcess;
 pub use mock_model_server::create_mock_chat_completions_server;
+#[allow(unused_imports)]
 pub use responses::create_apply_patch_sse_response;
+#[allow(unused_imports)]
 pub use responses::create_final_assistant_message_sse_response;
 pub use responses::create_shell_sse_response;

codex-rs/mcp-server/tests/common/responses.rs

@@ -39,6 +39,8 @@ pub fn create_shell_sse_response(
     Ok(sse)
 }
 
+// allow dead code
+#[allow(dead_code)]
 pub fn create_final_assistant_message_sse_response(message: &str) -> anyhow::Result<String> {
     let assistant_message = json!({
         "choices": [
@@ -58,6 +60,8 @@ pub fn create_final_assistant_message_sse_response(message: &str) -> anyhow::Res
     Ok(sse)
 }
 
+// allow dead code
+#[allow(dead_code)]
 pub fn create_apply_patch_sse_response(
     patch_content: &str,
     call_id: &str,

codex-rs/mcp-server/tests/interrupt.rs

@@ -1,5 +1,5 @@
 #![cfg(unix)]
-// Support code lives in the `mcp_test_support` crate under tests/common.
+mod common;
 
 use std::path::Path;
 
@@ -11,9 +11,9 @@ use serde_json::json;
 use tempfile::TempDir;
 use tokio::time::timeout;
 
-use mcp_test_support::McpProcess;
-use mcp_test_support::create_mock_chat_completions_server;
-use mcp_test_support::create_shell_sse_response;
+use crate::common::McpProcess;
+use crate::common::create_mock_chat_completions_server;
+use crate::common::create_shell_sse_response;
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 

codex-rs/tui/Cargo.toml

@@ -42,8 +42,8 @@ ratatui-image = "8.0.0"
 regex-lite = "0.1"
 serde_json = { version = "1", features = ["preserve_order"] }
 shlex = "1.3.0"
-strum = "0.27.2"
-strum_macros = "0.27.2"
+strum = "0.27.1"
+strum_macros = "0.27.1"
 tokio = { version = "1", features = [
     "io-std",
     "macros",
@@ -58,7 +58,6 @@ tui-input = "0.14.0"
 tui-markdown = "0.3.3"
 tui-textarea = "0.7.0"
 unicode-segmentation = "1.12.0"
-unicode-width = "0.1"
 uuid = "1"
 
 [dev-dependencies]

codex-rs/tui/src/app.rs

@@ -6,6 +6,7 @@ use crate::get_git_diff::get_git_diff;
 use crate::git_warning_screen::GitWarningOutcome;
 use crate::git_warning_screen::GitWarningScreen;
 use crate::login_screen::LoginScreen;
+use crate::mouse_capture::MouseCapture;
 use crate::scroll_event_helper::ScrollEventHelper;
 use crate::slash_command::SlashCommand;
 use crate::tui;
@@ -196,17 +197,17 @@ impl App<'_> {
         });
     }
 
-    pub(crate) fn run(&mut self, terminal: &mut tui::Tui) -> Result<()> {
+    pub(crate) fn run(
+        &mut self,
+        terminal: &mut tui::Tui,
+        mouse_capture: &mut MouseCapture,
+    ) -> Result<()> {
         // Insert an event to trigger the first render.
         let app_event_tx = self.app_event_tx.clone();
         app_event_tx.send(AppEvent::RequestRedraw);
 
         while let Ok(event) = self.app_event_rx.recv() {
             match event {
-                AppEvent::InsertHistory(lines) => {
-                    crate::insert_history::insert_history_lines(terminal, lines);
-                    self.app_event_tx.send(AppEvent::RequestRedraw);
-                }
                 AppEvent::RequestRedraw => {
                     self.schedule_redraw();
                 }
@@ -222,7 +223,9 @@ impl App<'_> {
                         } => {
                             match &mut self.app_state {
                                 AppState::Chat { widget } => {
-                                    widget.on_ctrl_c();
+                                    if widget.on_ctrl_c() {
+                                        self.app_event_tx.send(AppEvent::ExitRequest);
+                                    }
                                 }
                                 AppState::Login { .. } | AppState::GitWarning { .. } => {
                                     // No-op.
@@ -286,6 +289,11 @@ impl App<'_> {
                         self.app_state = AppState::Chat { widget: new_widget };
                         self.app_event_tx.send(AppEvent::RequestRedraw);
                     }
+                    SlashCommand::ToggleMouseMode => {
+                        if let Err(e) = mouse_capture.toggle() {
+                            tracing::error!("Failed to toggle mouse mode: {e}");
+                        }
+                    }
                     SlashCommand::Quit => {
                         break;
                     }
@@ -326,15 +334,6 @@ impl App<'_> {
         Ok(())
     }
 
-    pub(crate) fn token_usage(&self) -> codex_core::protocol::TokenUsage {
-        match &self.app_state {
-            AppState::Chat { widget } => widget.token_usage().clone(),
-            AppState::Login { .. } | AppState::GitWarning { .. } => {
-                codex_core::protocol::TokenUsage::default()
-            }
-        }
-    }
-
     fn draw_next_frame(&mut self, terminal: &mut tui::Tui) -> Result<()> {
         // TODO: add a throttle to avoid redrawing too often
 

codex-rs/tui/src/app_event.rs

@@ -1,7 +1,6 @@
 use codex_core::protocol::Event;
 use codex_file_search::FileMatch;
 use crossterm::event::KeyEvent;
-use ratatui::text::Line;
 
 use crate::slash_command::SlashCommand;
 
@@ -50,6 +49,4 @@ pub(crate) enum AppEvent {
         query: String,
         matches: Vec<FileMatch>,
     },
-
-    InsertHistory(Vec<Line<'static>>),
 }

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

@@ -50,6 +50,10 @@ impl<'a> BottomPaneView<'a> for ApprovalModalView<'a> {
         self.current.is_complete() && self.queue.is_empty()
     }
 
+    fn calculate_required_height(&self, area: &Rect) -> u16 {
+        self.current.get_height(area)
+    }
+
     fn render(&self, area: Rect, buf: &mut Buffer) {
         (&self.current).render_ref(area, buf);
     }

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

@@ -22,6 +22,9 @@ pub(crate) trait BottomPaneView<'a> {
         false
     }
 
+    /// Height required to render the view.
+    fn calculate_required_height(&self, area: &Rect) -> u16;
+
     /// Render the view: this will be displayed in place of the composer.
     fn render(&self, area: Rect, buf: &mut Buffer);
 

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

@@ -22,6 +22,11 @@ use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 use codex_file_search::FileMatch;
 
+/// Minimum number of visible text rows inside the textarea.
+const MIN_TEXTAREA_ROWS: usize = 1;
+/// Rows consumed by the border.
+const BORDER_LINES: u16 = 2;
+
 const BASE_PLACEHOLDER_TEXT: &str = "send a message";
 /// If the pasted content exceeds this number of characters, replace it with a
 /// placeholder in the UI.
@@ -604,6 +609,17 @@ impl ChatComposer<'_> {
         self.dismissed_file_popup_token = None;
     }
 
+    pub fn calculate_required_height(&self, area: &Rect) -> u16 {
+        let rows = self.textarea.lines().len().max(MIN_TEXTAREA_ROWS);
+        let num_popup_rows = match &self.active_popup {
+            ActivePopup::Command(popup) => popup.calculate_required_height(area),
+            ActivePopup::File(popup) => popup.calculate_required_height(area),
+            ActivePopup::None => 0,
+        };
+
+        rows as u16 + BORDER_LINES + num_popup_rows
+    }
+
     fn update_border(&mut self, has_focus: bool) {
         struct BlockState {
             right_title: Line<'static>,

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

@@ -65,8 +65,10 @@ impl BottomPane<'_> {
             if !view.is_complete() {
                 self.active_view = Some(view);
             } else if self.is_task_running {
+                let height = self.composer.calculate_required_height(&Rect::default());
                 self.active_view = Some(Box::new(StatusIndicatorView::new(
                     self.app_event_tx.clone(),
+                    height,
                 )));
             }
             self.request_redraw();
@@ -136,8 +138,10 @@ impl BottomPane<'_> {
         match (running, self.active_view.is_some()) {
             (true, false) => {
                 // Show status indicator overlay.
+                let height = self.composer.calculate_required_height(&Rect::default());
                 self.active_view = Some(Box::new(StatusIndicatorView::new(
                     self.app_event_tx.clone(),
+                    height,
                 )));
                 self.request_redraw();
             }
@@ -199,6 +203,14 @@ impl BottomPane<'_> {
     }
 
     /// Height (terminal rows) required by the current bottom pane.
+    pub fn calculate_required_height(&self, area: &Rect) -> u16 {
+        if let Some(view) = &self.active_view {
+            view.calculate_required_height(area)
+        } else {
+            self.composer.calculate_required_height(area)
+        }
+    }
+
     pub(crate) fn request_redraw(&self) {
         self.app_event_tx.send(AppEvent::RequestRedraw)
     }

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

@@ -1,4 +1,5 @@
 use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
 use ratatui::widgets::WidgetRef;
 
 use crate::app_event_sender::AppEventSender;
@@ -12,9 +13,9 @@ pub(crate) struct StatusIndicatorView {
 }
 
 impl StatusIndicatorView {
-    pub fn new(app_event_tx: AppEventSender) -> Self {
+    pub fn new(app_event_tx: AppEventSender, height: u16) -> Self {
         Self {
-            view: StatusIndicatorWidget::new(app_event_tx),
+            view: StatusIndicatorWidget::new(app_event_tx, height),
         }
     }
 
@@ -33,7 +34,11 @@ impl BottomPaneView<'_> for StatusIndicatorView {
         true
     }
 
-    fn render(&self, area: ratatui::layout::Rect, buf: &mut Buffer) {
+    fn calculate_required_height(&self, _area: &Rect) -> u16 {
+        self.view.get_height()
+    }
+
+    fn render(&self, area: Rect, buf: &mut Buffer) {
         self.view.render_ref(area, buf);
     }
 }

codex-rs/tui/src/chatwidget.rs

@@ -23,6 +23,9 @@ use codex_core::protocol::TaskCompleteEvent;
 use codex_core::protocol::TokenUsage;
 use crossterm::event::KeyEvent;
 use ratatui::buffer::Buffer;
+use ratatui::layout::Constraint;
+use ratatui::layout::Direction;
+use ratatui::layout::Layout;
 use ratatui::layout::Rect;
 use ratatui::widgets::Widget;
 use ratatui::widgets::WidgetRef;
@@ -49,9 +52,6 @@ pub(crate) struct ChatWidget<'a> {
     initial_user_message: Option<UserMessage>,
     token_usage: TokenUsage,
     reasoning_buffer: String,
-    // Buffer for streaming assistant answer text; we do not surface partial
-    // We wait for the final AgentMessage event and then emit the full text
-    // at once into scrollback so the history contains a single message.
     answer_buffer: String,
 }
 
@@ -187,13 +187,6 @@ impl ChatWidget<'_> {
         }
     }
 
-    /// Emits the last entry's plain lines from conversation_history, if any.
-    fn emit_last_history_entry(&mut self) {
-        if let Some(lines) = self.conversation_history.last_entry_plain_lines() {
-            self.app_event_tx.send(AppEvent::InsertHistory(lines));
-        }
-    }
-
     fn submit_user_message(&mut self, user_message: UserMessage) {
         let UserMessage { text, image_paths } = user_message;
         let mut items: Vec<InputItem> = Vec::new();
@@ -227,8 +220,7 @@ impl ChatWidget<'_> {
 
         // Only show text portion in conversation history for now.
         if !text.is_empty() {
-            self.conversation_history.add_user_message(text.clone());
-            self.emit_last_history_entry();
+            self.conversation_history.add_user_message(text);
         }
         self.conversation_history.scroll_to_bottom();
     }
@@ -240,10 +232,6 @@ impl ChatWidget<'_> {
                 // Record session information at the top of the conversation.
                 self.conversation_history
                     .add_session_info(&self.config, event.clone());
-                // Immediately surface the session banner / settings summary in
-                // scrollback so the user can review configuration (model,
-                // sandbox, approvals, etc.) before interacting.
-                self.emit_last_history_entry();
 
                 // Forward history metadata to the bottom pane so the chat
                 // composer can navigate through past messages.
@@ -259,50 +247,50 @@ impl ChatWidget<'_> {
                 self.request_redraw();
             }
             EventMsg::AgentMessage(AgentMessageEvent { message }) => {
-                // Final assistant answer. Prefer the fully provided message
-                // from the event; if it is empty fall back to any accumulated
-                // delta buffer (some providers may only stream deltas and send
-                // an empty final message).
-                let full = if message.is_empty() {
-                    std::mem::take(&mut self.answer_buffer)
-                } else {
-                    self.answer_buffer.clear();
-                    message
-                };
-                if !full.is_empty() {
+                // if the answer buffer is empty, this means we haven't received any
+                // delta. Thus, we need to print the message as a new answer.
+                if self.answer_buffer.is_empty() {
                     self.conversation_history
-                        .add_agent_message(&self.config, full);
-                    self.emit_last_history_entry();
+                        .add_agent_message(&self.config, message);
+                } else {
+                    self.conversation_history
+                        .replace_prev_agent_message(&self.config, message);
                 }
+                self.answer_buffer.clear();
                 self.request_redraw();
             }
             EventMsg::AgentMessageDelta(AgentMessageDeltaEvent { delta }) => {
-                // Buffer only – do not emit partial lines. This avoids cases
-                // where long responses appear truncated if the terminal
-                // wrapped early. The full message is emitted on
-                // AgentMessage.
-                self.answer_buffer.push_str(&delta);
+                if self.answer_buffer.is_empty() {
+                    self.conversation_history
+                        .add_agent_message(&self.config, "".to_string());
+                }
+                self.answer_buffer.push_str(&delta.clone());
+                self.conversation_history
+                    .replace_prev_agent_message(&self.config, self.answer_buffer.clone());
+                self.request_redraw();
             }
             EventMsg::AgentReasoningDelta(AgentReasoningDeltaEvent { delta }) => {
-                // Buffer only – disable incremental reasoning streaming so we
-                // avoid truncated intermediate lines. Full text emitted on
-                // AgentReasoning.
-                self.reasoning_buffer.push_str(&delta);
+                if self.reasoning_buffer.is_empty() {
+                    self.conversation_history
+                        .add_agent_reasoning(&self.config, "".to_string());
+                }
+                self.reasoning_buffer.push_str(&delta.clone());
+                self.conversation_history
+                    .replace_prev_agent_reasoning(&self.config, self.reasoning_buffer.clone());
+                self.request_redraw();
             }
             EventMsg::AgentReasoning(AgentReasoningEvent { text }) => {
-                // Emit full reasoning text once. Some providers might send
-                // final event with empty text if only deltas were used.
-                let full = if text.is_empty() {
-                    std::mem::take(&mut self.reasoning_buffer)
-                } else {
-                    self.reasoning_buffer.clear();
-                    text
-                };
-                if !full.is_empty() {
+                // if the reasoning buffer is empty, this means we haven't received any
+                // delta. Thus, we need to print the message as a new reasoning.
+                if self.reasoning_buffer.is_empty() {
                     self.conversation_history
-                        .add_agent_reasoning(&self.config, full);
-                    self.emit_last_history_entry();
+                        .add_agent_reasoning(&self.config, "".to_string());
+                } else {
+                    // else, we rerender one last time.
+                    self.conversation_history
+                        .replace_prev_agent_reasoning(&self.config, text);
                 }
+                self.reasoning_buffer.clear();
                 self.request_redraw();
             }
             EventMsg::TaskStarted => {
@@ -322,12 +310,10 @@ impl ChatWidget<'_> {
                     .set_token_usage(self.token_usage.clone(), self.config.model_context_window);
             }
             EventMsg::Error(ErrorEvent { message }) => {
-                self.conversation_history.add_error(message.clone());
-                self.emit_last_history_entry();
+                self.conversation_history.add_error(message);
                 self.bottom_pane.set_task_running(false);
             }
             EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
-                call_id: _,
                 command,
                 cwd,
                 reason,
@@ -341,7 +327,6 @@ impl ChatWidget<'_> {
                 self.bottom_pane.push_approval_request(request);
             }
             EventMsg::ApplyPatchApprovalRequest(ApplyPatchApprovalRequestEvent {
-                call_id: _,
                 changes,
                 reason,
                 grant_root,
@@ -359,7 +344,6 @@ impl ChatWidget<'_> {
 
                 self.conversation_history
                     .add_patch_event(PatchEventType::ApprovalRequest, changes);
-                self.emit_last_history_entry();
 
                 self.conversation_history.scroll_to_bottom();
 
@@ -379,7 +363,6 @@ impl ChatWidget<'_> {
             }) => {
                 self.conversation_history
                     .add_active_exec_command(call_id, command);
-                self.emit_last_history_entry();
                 self.request_redraw();
             }
             EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
@@ -391,7 +374,6 @@ impl ChatWidget<'_> {
                 // summary so the user can follow along.
                 self.conversation_history
                     .add_patch_event(PatchEventType::ApplyBegin { auto_approved }, changes);
-                self.emit_last_history_entry();
                 if !auto_approved {
                     self.conversation_history.scroll_to_bottom();
                 }
@@ -415,7 +397,6 @@ impl ChatWidget<'_> {
             }) => {
                 self.conversation_history
                     .add_active_mcp_tool_call(call_id, server, tool, arguments);
-                self.emit_last_history_entry();
                 self.request_redraw();
             }
             EventMsg::McpToolCallEnd(mcp_tool_call_end_event) => {
@@ -436,13 +417,9 @@ impl ChatWidget<'_> {
                 self.bottom_pane
                     .on_history_entry_response(log_id, offset, entry.map(|e| e.text));
             }
-            EventMsg::ShutdownComplete => {
-                self.app_event_tx.send(AppEvent::ExitRequest);
-            }
             event => {
                 self.conversation_history
                     .add_background_event(format!("{event:?}"));
-                self.emit_last_history_entry();
                 self.request_redraw();
             }
         }
@@ -459,9 +436,7 @@ impl ChatWidget<'_> {
     }
 
     pub(crate) fn add_diff_output(&mut self, diff_output: String) {
-        self.conversation_history
-            .add_diff_output(diff_output.clone());
-        self.emit_last_history_entry();
+        self.conversation_history.add_diff_output(diff_output);
         self.request_redraw();
     }
 
@@ -494,7 +469,6 @@ impl ChatWidget<'_> {
             self.reasoning_buffer.clear();
             false
         } else if self.bottom_pane.ctrl_c_quit_hint_visible() {
-            self.submit_op(Op::Shutdown);
             true
         } else {
             self.bottom_pane.show_ctrl_c_quit_hint();
@@ -512,18 +486,19 @@ impl ChatWidget<'_> {
             tracing::error!("failed to submit op: {e}");
         }
     }
-
-    pub(crate) fn token_usage(&self) -> &TokenUsage {
-        &self.token_usage
-    }
 }
 
 impl WidgetRef for &ChatWidget<'_> {
     fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        // In the hybrid inline viewport mode we only draw the interactive
-        // bottom pane; history entries are injected directly into scrollback
-        // via `Terminal::insert_before`.
-        (&self.bottom_pane).render(area, buf);
+        let bottom_height = self.bottom_pane.calculate_required_height(&area);
+
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Min(0), Constraint::Length(bottom_height)])
+            .split(area);
+
+        self.conversation_history.render(chunks[0], buf);
+        (&self.bottom_pane).render(chunks[1], buf);
     }
 }
 

codex-rs/tui/src/conversation_history_widget.rs

@@ -202,6 +202,14 @@ impl ConversationHistoryWidget {
         self.add_to_history(HistoryCell::new_agent_reasoning(config, text));
     }
 
+    pub fn replace_prev_agent_reasoning(&mut self, config: &Config, text: String) {
+        self.replace_last_agent_reasoning(config, text);
+    }
+
+    pub fn replace_prev_agent_message(&mut self, config: &Config, text: String) {
+        self.replace_last_agent_message(config, text);
+    }
+
     pub fn add_background_event(&mut self, message: String) {
         self.add_to_history(HistoryCell::new_background_event(message));
     }
@@ -249,10 +257,40 @@ impl ConversationHistoryWidget {
         });
     }
 
-    /// Return the lines for the most recently appended entry (if any) so the
-    /// parent widget can surface them via the new scrollback insertion path.
-    pub(crate) fn last_entry_plain_lines(&self) -> Option<Vec<Line<'static>>> {
-        self.entries.last().map(|e| e.cell.plain_lines())
+    pub fn replace_last_agent_reasoning(&mut self, config: &Config, text: String) {
+        if let Some(idx) = self
+            .entries
+            .iter()
+            .rposition(|entry| matches!(entry.cell, HistoryCell::AgentReasoning { .. }))
+        {
+            let width = self.cached_width.get();
+            let entry = &mut self.entries[idx];
+            entry.cell = HistoryCell::new_agent_reasoning(config, text);
+            let height = if width > 0 {
+                entry.cell.height(width)
+            } else {
+                0
+            };
+            entry.line_count.set(height);
+        }
+    }
+
+    pub fn replace_last_agent_message(&mut self, config: &Config, text: String) {
+        if let Some(idx) = self
+            .entries
+            .iter()
+            .rposition(|entry| matches!(entry.cell, HistoryCell::AgentMessage { .. }))
+        {
+            let width = self.cached_width.get();
+            let entry = &mut self.entries[idx];
+            entry.cell = HistoryCell::new_agent_message(config, text);
+            let height = if width > 0 {
+                entry.cell.height(width)
+            } else {
+                0
+            };
+            entry.line_count.set(height);
+        }
     }
 
     pub fn record_completed_exec_command(

codex-rs/tui/src/history_cell.rs

@@ -123,30 +123,6 @@ pub(crate) enum HistoryCell {
 const TOOL_CALL_MAX_LINES: usize = 5;
 
 impl HistoryCell {
-    /// Return a cloned, plain representation of the cell's lines suitable for
-    /// one‑shot insertion into the terminal scrollback. Image cells are
-    /// represented with a simple placeholder for now.
-    pub(crate) fn plain_lines(&self) -> Vec<Line<'static>> {
-        match self {
-            HistoryCell::WelcomeMessage { view }
-            | HistoryCell::UserPrompt { view }
-            | HistoryCell::AgentMessage { view }
-            | HistoryCell::AgentReasoning { view }
-            | HistoryCell::BackgroundEvent { view }
-            | HistoryCell::GitDiffOutput { view }
-            | HistoryCell::ErrorEvent { view }
-            | HistoryCell::SessionInfo { view }
-            | HistoryCell::CompletedExecCommand { view }
-            | HistoryCell::CompletedMcpToolCall { view }
-            | HistoryCell::PendingPatch { view }
-            | HistoryCell::ActiveExecCommand { view, .. }
-            | HistoryCell::ActiveMcpToolCall { view, .. } => view.lines.clone(),
-            HistoryCell::CompletedMcpToolCallWithImageOutput { .. } => vec![
-                Line::from("tool result (image output omitted)"),
-                Line::from(""),
-            ],
-        }
-    }
     pub(crate) fn new_session_info(
         config: &Config,
         event: SessionConfiguredEvent,
@@ -180,7 +156,7 @@ impl HistoryCell {
                 ("workdir", config.cwd.display().to_string()),
                 ("model", config.model.clone()),
                 ("provider", config.model_provider_id.clone()),
-                ("approval", config.approval_policy.to_string()),
+                ("approval", format!("{:?}", config.approval_policy)),
                 ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
             ];
             if config.model_provider.wire_api == WireApi::Responses

codex-rs/tui/src/insert_history.rs

@@ -1,181 +0,0 @@
-use ratatui::layout::Rect;
-use ratatui::style::Style;
-use ratatui::text::Line;
-use ratatui::text::Span;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::Widget;
-use unicode_width::UnicodeWidthChar;
-
-/// Insert a batch of history lines into the terminal scrollback above the
-/// inline viewport.
-///
-/// The incoming `lines` are the logical lines supplied by the
-/// `ConversationHistory`. They may contain embedded newlines and arbitrary
-/// runs of whitespace inside individual [`Span`]s. All of that must be
-/// normalised before writing to the backing terminal buffer because the
-/// ratatui [`Paragraph`] widget does not perform soft‑wrapping when used in
-/// conjunction with [`Terminal::insert_before`].
-///
-/// This function performs a minimal wrapping / normalisation pass:
-///
-/// * A terminal width is determined via `Terminal::size()` (falling back to
-///   80 columns if the size probe fails).
-/// * Each logical line is broken into words and whitespace. Consecutive
-///   whitespace is collapsed to a single space; leading whitespace is
-///   discarded.
-/// * Words that do not fit on the current line cause a soft wrap. Extremely
-///   long words (longer than the terminal width) are split character by
-///   character so they still populate the display instead of overflowing the
-///   line.
-/// * Explicit `\n` characters inside a span force a hard line break.
-/// * Empty lines (including a trailing newline at the end of the batch) are
-///   preserved so vertical spacing remains faithful to the logical history.
-///
-/// Finally the physical lines are rendered directly into the terminal's
-/// scrollback region using [`Terminal::insert_before`]. Any backend error is
-/// ignored: failing to insert history is non‑fatal and a subsequent redraw
-/// will eventually repaint a consistent view.
-fn display_width(s: &str) -> usize {
-    s.chars()
-        .map(|c| UnicodeWidthChar::width(c).unwrap_or(0))
-        .sum()
-}
-
-struct LineBuilder {
-    term_width: usize,
-    spans: Vec<Span<'static>>,
-    width: usize,
-}
-
-impl LineBuilder {
-    fn new(term_width: usize) -> Self {
-        Self {
-            term_width,
-            spans: Vec::new(),
-            width: 0,
-        }
-    }
-
-    fn flush_line(&mut self, out: &mut Vec<Line<'static>>) {
-        out.push(Line::from(std::mem::take(&mut self.spans)));
-        self.width = 0;
-    }
-
-    fn push_segment(&mut self, text: String, style: Style) {
-        self.width += display_width(&text);
-        self.spans.push(Span::styled(text, style));
-    }
-
-    fn push_word(&mut self, word: &mut String, style: Style, out: &mut Vec<Line<'static>>) {
-        if word.is_empty() {
-            return;
-        }
-        let w_len = display_width(word);
-        if self.width > 0 && self.width + w_len > self.term_width {
-            self.flush_line(out);
-        }
-        if w_len > self.term_width && self.width == 0 {
-            // Split an overlong word across multiple lines.
-            let mut cur = String::new();
-            let mut cur_w = 0;
-            for ch in word.chars() {
-                let ch_w = UnicodeWidthChar::width(ch).unwrap_or(0);
-                if cur_w + ch_w > self.term_width && cur_w > 0 {
-                    self.push_segment(cur.clone(), style);
-                    self.flush_line(out);
-                    cur.clear();
-                    cur_w = 0;
-                }
-                cur.push(ch);
-                cur_w += ch_w;
-            }
-            if !cur.is_empty() {
-                self.push_segment(cur, style);
-            }
-        } else {
-            self.push_segment(word.clone(), style);
-        }
-        word.clear();
-    }
-
-    fn consume_whitespace(&mut self, ws: &mut String, style: Style, out: &mut Vec<Line<'static>>) {
-        if ws.is_empty() {
-            return;
-        }
-        let space_w = display_width(ws);
-        if self.width > 0 && self.width + space_w > self.term_width {
-            self.flush_line(out);
-        }
-        if self.width > 0 {
-            self.push_segment(" ".to_string(), style);
-        }
-        ws.clear();
-    }
-}
-
-use ratatui::backend::Backend;
-
-pub fn insert_history_lines<B: Backend>(terminal: &mut ratatui::Terminal<B>, lines: Vec<Line<'static>>) {
-    let term_width = terminal.size().map(|a| a.width).unwrap_or(80) as usize;
-    let mut physical: Vec<Line<'static>> = Vec::new();
-
-    for logical in lines.into_iter() {
-        if logical.spans.is_empty() {
-            physical.push(logical);
-            continue;
-        }
-
-        let mut builder = LineBuilder::new(term_width);
-        let mut buf_space = String::new();
-
-        for span in logical.spans.into_iter() {
-            let style = span.style;
-            let mut buf_word = String::new();
-
-            for ch in span.content.chars() {
-                if ch == '\n' {
-                    builder.push_word(&mut buf_word, style, &mut physical);
-                    buf_space.clear();
-                    builder.flush_line(&mut physical);
-                    continue;
-                }
-                if ch.is_whitespace() {
-                    builder.push_word(&mut buf_word, style, &mut physical);
-                    buf_space.push(ch);
-                } else {
-                    builder.consume_whitespace(&mut buf_space, style, &mut physical);
-                    buf_word.push(ch);
-                }
-                if builder.width >= term_width {
-                    builder.flush_line(&mut physical);
-                }
-            }
-            builder.push_word(&mut buf_word, style, &mut physical);
-            // whitespace intentionally left to allow collapsing across spans
-        }
-        if !builder.spans.is_empty() {
-            physical.push(Line::from(std::mem::take(&mut builder.spans)));
-        } else {
-            // Preserve explicit blank line (e.g. due to a trailing newline).
-            physical.push(Line::from(Vec::<Span<'static>>::new()));
-        }
-    }
-
-    let total = physical.len() as u16;
-    terminal
-        .insert_before(total, |buf| {
-            let width = buf.area.width;
-            for (i, line) in physical.into_iter().enumerate() {
-                let area = Rect {
-                    x: 0,
-                    y: i as u16,
-                    width,
-                    height: 1,
-                };
-                Paragraph::new(line).render(area, buf);
-            }
-        })
-        .ok();
-}
-
-// Tests are implemented as integration tests (see tests/insert_history.rs)

codex-rs/tui/src/lib.rs

@@ -33,10 +33,10 @@ mod file_search;
 mod get_git_diff;
 mod git_warning_screen;
 mod history_cell;
-mod insert_history;
 mod log_layer;
 mod login_screen;
 mod markdown;
+mod mouse_capture;
 mod scroll_event_helper;
 mod slash_command;
 mod status_indicator_widget;
@@ -45,15 +45,9 @@ mod text_formatting;
 mod tui;
 mod user_approval_widget;
 
-// Re-export for integration tests
-pub use insert_history::insert_history_lines;
-
 pub use cli::Cli;
 
-pub fn run_main(
-    cli: Cli,
-    codex_linux_sandbox_exe: Option<PathBuf>,
-) -> std::io::Result<codex_core::protocol::TokenUsage> {
+pub fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> std::io::Result<()> {
     let (sandbox_mode, approval_policy) = if cli.full_auto {
         (
             Some(SandboxMode::WorkspaceWrite),
@@ -153,8 +147,24 @@ pub fn run_main(
     // `--allow-no-git-exec` flag.
     let show_git_warning = !cli.skip_git_repo_check && !is_inside_git_repo(&config);
 
-    run_ratatui_app(cli, config, show_login_screen, show_git_warning, log_rx)
-        .map_err(|err| std::io::Error::other(err.to_string()))
+    try_run_ratatui_app(cli, config, show_login_screen, show_git_warning, log_rx);
+    Ok(())
+}
+
+#[expect(
+    clippy::print_stderr,
+    reason = "Resort to stderr in exceptional situations."
+)]
+fn try_run_ratatui_app(
+    cli: Cli,
+    config: Config,
+    show_login_screen: bool,
+    show_git_warning: bool,
+    log_rx: tokio::sync::mpsc::UnboundedReceiver<String>,
+) {
+    if let Err(report) = run_ratatui_app(cli, config, show_login_screen, show_git_warning, log_rx) {
+        eprintln!("Error: {report:?}");
+    }
 }
 
 fn run_ratatui_app(
@@ -163,15 +173,16 @@ fn run_ratatui_app(
     show_login_screen: bool,
     show_git_warning: bool,
     mut log_rx: tokio::sync::mpsc::UnboundedReceiver<String>,
-) -> color_eyre::Result<codex_core::protocol::TokenUsage> {
+) -> color_eyre::Result<()> {
     color_eyre::install()?;
 
-    // Forward panic reports through tracing so they appear in the UI status
-    // line instead of interleaving raw panic output with the interface.
+    // Forward panic reports through the tracing stack so that they appear in
+    // the status indicator instead of breaking the alternate screen – the
+    // normal colour‑eyre hook writes to stderr which would corrupt the UI.
     std::panic::set_hook(Box::new(|info| {
         tracing::error!("panic: {info}");
     }));
-    let mut terminal = tui::init(&config)?;
+    let (mut terminal, mut mouse_capture) = tui::init(&config)?;
     terminal.clear()?;
 
     let Cli { prompt, images, .. } = cli;
@@ -193,12 +204,10 @@ fn run_ratatui_app(
         });
     }
 
-    let app_result = app.run(&mut terminal);
-    let usage = app.token_usage();
+    let app_result = app.run(&mut terminal, &mut mouse_capture);
 
     restore();
-    // ignore error when collecting usage – report underlying error instead
-    app_result.map(|_| usage)
+    app_result
 }
 
 #[expect(

codex-rs/tui/src/main.rs

@@ -20,8 +20,7 @@ fn main() -> anyhow::Result<()> {
             .config_overrides
             .raw_overrides
             .splice(0..0, top_cli.config_overrides.raw_overrides);
-        let usage = run_main(inner, codex_linux_sandbox_exe)?;
-        println!("{}", codex_core::protocol::FinalOutput::from(usage));
+        run_main(inner, codex_linux_sandbox_exe)?;
         Ok(())
     })
 }

codex-rs/tui/src/mouse_capture.rs

@@ -0,0 +1,69 @@
+use crossterm::event::DisableMouseCapture;
+use crossterm::event::EnableMouseCapture;
+use ratatui::crossterm::execute;
+use std::io::Result;
+use std::io::stdout;
+
+pub(crate) struct MouseCapture {
+    mouse_capture_is_active: bool,
+}
+
+impl MouseCapture {
+    pub(crate) fn new_with_capture(mouse_capture_is_active: bool) -> Result<Self> {
+        if mouse_capture_is_active {
+            enable_capture()?;
+        }
+
+        Ok(Self {
+            mouse_capture_is_active,
+        })
+    }
+}
+
+impl MouseCapture {
+    /// Idempotent method to set the mouse capture state.
+    pub fn set_active(&mut self, is_active: bool) -> Result<()> {
+        match (self.mouse_capture_is_active, is_active) {
+            (true, true) => {}
+            (false, false) => {}
+            (true, false) => {
+                disable_capture()?;
+                self.mouse_capture_is_active = false;
+            }
+            (false, true) => {
+                enable_capture()?;
+                self.mouse_capture_is_active = true;
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn toggle(&mut self) -> Result<()> {
+        self.set_active(!self.mouse_capture_is_active)
+    }
+
+    pub(crate) fn disable(&mut self) -> Result<()> {
+        if self.mouse_capture_is_active {
+            disable_capture()?;
+            self.mouse_capture_is_active = false;
+        }
+        Ok(())
+    }
+}
+
+impl Drop for MouseCapture {
+    fn drop(&mut self) {
+        if self.disable().is_err() {
+            // The user is likely shutting down, so ignore any errors so the
+            // shutdown process can complete.
+        }
+    }
+}
+
+fn enable_capture() -> Result<()> {
+    execute!(stdout(), EnableMouseCapture)
+}
+
+fn disable_capture() -> Result<()> {
+    execute!(stdout(), DisableMouseCapture)
+}

codex-rs/tui/src/slash_command.rs

@@ -15,6 +15,7 @@ pub enum SlashCommand {
     New,
     Diff,
     Quit,
+    ToggleMouseMode,
 }
 
 impl SlashCommand {
@@ -22,6 +23,9 @@ impl SlashCommand {
     pub fn description(self) -> &'static str {
         match self {
             SlashCommand::New => "Start a new chat.",
+            SlashCommand::ToggleMouseMode => {
+                "Toggle mouse mode (enable for scrolling, disable for text selection)"
+            }
             SlashCommand::Quit => "Exit the application.",
             SlashCommand::Diff => {
                 "Show git diff of the working directory (including untracked files)"

codex-rs/tui/src/status_indicator_widget.rs

@@ -34,6 +34,11 @@ pub(crate) struct StatusIndicatorWidget {
     /// time).
     text: String,
 
+    /// Height in terminal rows – matches the height of the textarea at the
+    /// moment the task started so the UI does not jump when we toggle between
+    /// input mode and loading mode.
+    height: u16,
+
     frame_idx: Arc<AtomicUsize>,
     running: Arc<AtomicBool>,
     // Keep one sender alive to prevent the channel from closing while the
@@ -45,7 +50,7 @@ pub(crate) struct StatusIndicatorWidget {
 
 impl StatusIndicatorWidget {
     /// Create a new status indicator and start the animation timer.
-    pub(crate) fn new(app_event_tx: AppEventSender) -> Self {
+    pub(crate) fn new(app_event_tx: AppEventSender, height: u16) -> Self {
         let frame_idx = Arc::new(AtomicUsize::new(0));
         let running = Arc::new(AtomicBool::new(true));
 
@@ -67,12 +72,18 @@ impl StatusIndicatorWidget {
 
         Self {
             text: String::from("waiting for logs…"),
+            height: height.max(3),
             frame_idx,
             running,
             _app_event_tx: app_event_tx,
         }
     }
 
+    /// Preferred height in terminal rows.
+    pub(crate) fn get_height(&self) -> u16 {
+        self.height
+    }
+
     /// Update the line that is displayed in the widget.
     pub(crate) fn update_text(&mut self, text: String) {
         self.text = text.replace(['\n', '\r'], " ");

codex-rs/tui/src/tui.rs

@@ -4,39 +4,31 @@ use std::io::stdout;
 
 use codex_core::config::Config;
 use crossterm::event::DisableBracketedPaste;
+use crossterm::event::DisableMouseCapture;
 use crossterm::event::EnableBracketedPaste;
 use ratatui::Terminal;
-use ratatui::TerminalOptions;
-use ratatui::Viewport;
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::execute;
+use ratatui::crossterm::terminal::EnterAlternateScreen;
+use ratatui::crossterm::terminal::LeaveAlternateScreen;
 use ratatui::crossterm::terminal::disable_raw_mode;
 use ratatui::crossterm::terminal::enable_raw_mode;
 
+use crate::mouse_capture::MouseCapture;
+
 /// A type alias for the terminal type used in this application
 pub type Tui = Terminal<CrosstermBackend<Stdout>>;
 
-/// Initialize the terminal (inline viewport; history stays in normal scrollback)
-pub fn init(_config: &Config) -> Result<Tui> {
+/// Initialize the terminal
+pub fn init(config: &Config) -> Result<(Tui, MouseCapture)> {
+    execute!(stdout(), EnterAlternateScreen)?;
     execute!(stdout(), EnableBracketedPaste)?;
+    let mouse_capture = MouseCapture::new_with_capture(!config.tui.disable_mouse_capture)?;
 
     enable_raw_mode()?;
     set_panic_hook();
-
-    // Reserve a fixed number of lines for the interactive viewport (composer,
-    // status, popups). History is injected above using `insert_before`. This
-    // is an initial step of the refactor – later the height can become
-    // dynamic. For now a conservative default keeps enough room for the
-    // multi‑line composer while not occupying the whole screen.
-    const BOTTOM_VIEWPORT_HEIGHT: u16 = 8;
-    let backend = CrosstermBackend::new(stdout());
-    let tui = Terminal::with_options(
-        backend,
-        TerminalOptions {
-            viewport: Viewport::Inline(BOTTOM_VIEWPORT_HEIGHT),
-        },
-    )?;
-    Ok(tui)
+    let tui = Terminal::new(CrosstermBackend::new(stdout()))?;
+    Ok((tui, mouse_capture))
 }
 
 fn set_panic_hook() {
@@ -49,7 +41,14 @@ fn set_panic_hook() {
 
 /// Restore the terminal to its original state
 pub fn restore() -> Result<()> {
+    // We are shutting down, and we cannot reference the `MouseCapture`, so we
+    // categorically disable mouse capture just to be safe.
+    if execute!(stdout(), DisableMouseCapture).is_err() {
+        // It is possible that `DisableMouseCapture` is written more than once
+        // on shutdown, so ignore the error in this case.
+    }
     execute!(stdout(), DisableBracketedPaste)?;
+    execute!(stdout(), LeaveAlternateScreen)?;
     disable_raw_mode()?;
     Ok(())
 }

codex-rs/tui/src/user_approval_widget.rs

@@ -116,6 +116,10 @@ pub(crate) struct UserApprovalWidget<'a> {
     done: bool,
 }
 
+// Number of lines automatically added by ratatui’s [`Block`] when
+// borders are enabled (one at the top, one at the bottom).
+const BORDER_LINES: u16 = 2;
+
 impl UserApprovalWidget<'_> {
     pub(crate) fn new(approval_request: ApprovalRequest, app_event_tx: AppEventSender) -> Self {
         let input = Input::default();
@@ -186,6 +190,28 @@ impl UserApprovalWidget<'_> {
         }
     }
 
+    pub(crate) fn get_height(&self, area: &Rect) -> u16 {
+        let confirmation_prompt_height =
+            self.get_confirmation_prompt_height(area.width - BORDER_LINES);
+
+        match self.mode {
+            Mode::Select => {
+                let num_option_lines = SELECT_OPTIONS.len() as u16;
+                confirmation_prompt_height + num_option_lines + BORDER_LINES
+            }
+            Mode::Input => {
+                //   1. "Give the model feedback ..." prompt
+                //   2. A single‑line input field (we allocate exactly one row;
+                //      the `tui-input` widget will scroll horizontally if the
+                //      text exceeds the width).
+                const INPUT_PROMPT_LINES: u16 = 1;
+                const INPUT_FIELD_LINES: u16 = 1;
+
+                confirmation_prompt_height + INPUT_PROMPT_LINES + INPUT_FIELD_LINES + BORDER_LINES
+            }
+        }
+    }
+
     fn get_confirmation_prompt_height(&self, width: u16) -> u16 {
         // Should cache this for last value of width.
         self.confirmation_prompt.line_count(width) as u16
@@ -307,32 +333,7 @@ impl WidgetRef for &UserApprovalWidget<'_> {
             .borders(Borders::ALL)
             .border_type(BorderType::Rounded);
         let inner = outer.inner(area);
-
-        // Determine how many rows we can allocate for the static confirmation
-        // prompt while *always* keeping enough space for the interactive
-        // response area (select list or input field). When the full prompt
-        // would exceed the available height we truncate it so the response
-        // options never get pushed out of view. This keeps the approval modal
-        // usable even when the overall bottom viewport is small.
-
-        // Full height of the prompt (may be larger than the available area).
-        let full_prompt_height = self.get_confirmation_prompt_height(inner.width);
-
-        // Minimum rows that must remain for the interactive section.
-        let min_response_rows = match self.mode {
-            Mode::Select => SELECT_OPTIONS.len() as u16,
-            // In input mode we need exactly two rows: one for the guidance
-            // prompt and one for the single-line input field.
-            Mode::Input => 2,
-        };
-
-        // Clamp prompt height so confirmation + response never exceed the
-        // available space. `saturating_sub` avoids underflow when the area is
-        // too small even for the minimal layout – in this unlikely case we
-        // fall back to zero-height prompt so at least the options are
-        // visible.
-        let prompt_height = full_prompt_height.min(inner.height.saturating_sub(min_response_rows));
-
+        let prompt_height = self.get_confirmation_prompt_height(inner.width);
         let chunks = Layout::default()
             .direction(Direction::Vertical)
             .constraints([Constraint::Length(prompt_height), Constraint::Min(0)])
@@ -341,7 +342,8 @@ impl WidgetRef for &UserApprovalWidget<'_> {
         let response_chunk = chunks[1];
 
         // Build the inner lines based on the mode. Collect them into a List of
-        // non-wrapping lines rather than a Paragraph for predictable layout.
+        // non-wrapping lines rather than a Paragraph because get_height(Rect)
+        // depends on this behavior for its calculation.
         let lines = match self.mode {
             Mode::Select => SELECT_OPTIONS
                 .iter()

codex-rs/tui/tests/insert_history.rs

@@ -1,132 +0,0 @@
-use codex_tui::insert_history_lines;
-use ratatui::backend::TestBackend;
-use ratatui::text::{Line, Span};
-use ratatui::{Terminal, TerminalOptions, Viewport};
-use ratatui::widgets::Paragraph;
-
-// Helper to initialise a terminal with an inline viewport.
-fn test_terminal(width: u16, height: u16, bottom_height: u16) -> Terminal<TestBackend> {
-    Terminal::with_options(
-        TestBackend::new(width, height),
-        TerminalOptions { viewport: Viewport::Inline(bottom_height) },
-    )
-    .expect("terminal")
-}
-
-// Extract the buffer contents as Strings (one per row) trimming trailing spaces.
-fn buffer_lines(term: &Terminal<TestBackend>) -> Vec<String> {
-    let backend = term.backend();
-    let size = term.size().expect("size");
-    let mut out = Vec::new();
-    for y in 0..size.height {
-        let mut row = String::new();
-        for x in 0..size.width {
-            let cell = backend.buffer().get(x, y);
-            row.push_str(cell.symbol());
-        }
-        out.push(row.trim_end().to_string());
-    }
-    out
-}
-
-#[test]
-fn single_line_passthrough() {
-    let mut term = test_terminal(20, 10, 3); // 7 lines history space
-    insert_history_lines(&mut term, vec![Line::from("hello world")]);
-    let lines = buffer_lines(&term);
-    assert!(lines.iter().any(|l| l.contains("hello world")), "history line visible");
-}
-
-#[test]
-fn explicit_newlines_preserved() {
-    let mut term = test_terminal(20, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from(Span::raw("foo\nbar\n"))]);
-    let lines = buffer_lines(&term);
-    assert!(lines.contains(&"foo".to_string()));
-    assert!(lines.contains(&"bar".to_string()));
-    assert!(lines.iter().filter(|l| l.is_empty()).count() >= 1);
-}
-
-#[test]
-fn whitespace_normalisation() {
-    let mut term = test_terminal(30, 10, 3);
-    insert_history_lines(
-        &mut term,
-        vec![Line::from(vec![Span::raw("   a"), Span::raw("\t\tb"), Span::raw("   c")])],
-    );
-    let joined = buffer_lines(&term).join("\n");
-    assert!(joined.contains("a b c"));
-}
-
-#[test]
-fn soft_wrapping() {
-    let mut term = test_terminal(10, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from("hello world test")]);
-    let lines = buffer_lines(&term);
-    assert!(lines.iter().any(|l| l == "hello"));
-    assert!(lines.iter().any(|l| l == "world test"));
-}
-
-#[test]
-fn overlong_word_splitting() {
-    let mut term = test_terminal(5, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from("abcdefgh")]);
-    let lines = buffer_lines(&term);
-    assert!(lines.iter().any(|l| l == "abcde"));
-    assert!(lines.iter().any(|l| l == "fgh"));
-}
-
-#[test]
-fn whitespace_collapse_across_spans() {
-    let mut term = test_terminal(20, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from(vec![Span::raw("foo "), Span::raw("   bar")])]);
-    let joined = buffer_lines(&term).join("\n");
-    assert!(joined.contains("foo bar"));
-    assert!(!joined.contains("foo   bar"));
-}
-
-#[test]
-fn trailing_newline_preserved() {
-    let mut term = test_terminal(20, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from(Span::raw("xyz\n"))]);
-    let lines = buffer_lines(&term);
-    assert!(lines.contains(&"xyz".to_string()));
-    assert!(lines.iter().filter(|l| l.is_empty()).count() >= 1);
-}
-
-#[test]
-fn wide_unicode_wrapping() {
-    let mut term = test_terminal(6, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from("ＡＢＣＤＥ")]);
-    let lines = buffer_lines(&term);
-    assert!(lines.iter().any(|l| l.contains("Ａ Ｂ Ｃ")));
-    assert!(lines.iter().any(|l| l.contains("Ｄ Ｅ")));
-}
-
-#[test]
-fn sequential_insertions_order() {
-    let mut term = test_terminal(20, 10, 3);
-    insert_history_lines(&mut term, vec![Line::from("first")]);
-    insert_history_lines(&mut term, vec![Line::from("second")]);
-    let lines = buffer_lines(&term);
-    let mut first_idx = None;
-    let mut second_idx = None;
-    for (i, l) in lines.iter().enumerate() {
-        if l.contains("first") { first_idx = Some(i); }
-        if l.contains("second") { second_idx = Some(i); }
-    }
-    let (Some(fi), Some(si)) = (first_idx, second_idx) else { panic!("missing lines") };
-    assert!(fi < si, "expected 'first' above 'second'");
-}
-
-#[test]
-fn integration_bottom_viewport_render() {
-    let mut term = test_terminal(15, 8, 3);
-    insert_history_lines(&mut term, vec![Line::from("history one"), Line::from("history two")]);
-    term.draw(|f| f.render_widget(Paragraph::new("bottom"), f.area())).unwrap();
-    let lines = buffer_lines(&term);
-    assert!(lines.iter().any(|l| l.contains("history one")));
-    assert!(lines.iter().any(|l| l.contains("history two")));
-    assert!(lines.iter().any(|l| l.contains("bottom")));
-}
-