improvements, more dry

tests
Merge remote-tracking branch 'origin/main' into scrollable-slash-menu
2026-04-23 22:24:57 +00:00 · 2025-08-01 20:01:49 -07:00 · 2025-08-01 17:38:30 -07:00 · 2025-08-01 10:15:54 -07:00 · 2025-08-01 10:15:07 -07:00 · 2025-08-01 05:00:45 -07:00
61 changed files with 956 additions and 4742 deletions
--- a/.github/actions/codex/bun.lock
+++ b/.github/actions/codex/bun.lock
@@ -11,7 +11,7 @@
        "@types/bun": "^1.2.19",
        "@types/node": "^24.1.0",
        "prettier": "^3.6.2",
-        "typescript": "^5.9.2",
+        "typescript": "^5.8.3",
      },
    },
  },
@@ -68,7 +68,7 @@

    "tunnel": ["tunnel@0.0.6", "", {}, "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg=="],

-    "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+    "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],

    "undici": ["undici@5.29.0", "", { "dependencies": { "@fastify/busboy": "^2.0.0" } }, "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg=="],

--- a/.github/actions/codex/package.json
+++ b/.github/actions/codex/package.json
@@ -16,6 +16,6 @@
        "@types/bun": "^1.2.19",
        "@types/node": "^24.1.0",
        "prettier": "^3.6.2",
-        "typescript": "^5.9.2"
+        "typescript": "^5.8.3"
    }
 }
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,9 +2,7 @@

 In the codex-rs folder where the rust code lives:

- Never add or modify any code related to `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` or `CODEX_SANDBOX_ENV_VAR`.
-  - You operate in a sandbox where `CODEX_SANDBOX_NETWORK_DISABLED=1` will be set whenever you use the `shell` tool. Any existing code that uses `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` was authored with this fact in mind. It is often used to early exit out of tests that the author knew you would not be able to run given your sandbox limitations.
-  - Similarly, when you spawn a process using Seatbelt (`/usr/bin/sandbox-exec`), `CODEX_SANDBOX=seatbelt` will be set on the child process. Integration tests that want to run Seatbelt themselves cannot be run under Seatbelt, so checks for `CODEX_SANDBOX=seatbelt` are also often used to early exit out of tests, as appropriate.
+- Never add or modify any code related to `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR`. You operate in a sandbox where `CODEX_SANDBOX_NETWORK_DISABLED=1` will be set whenever you use the `shell` tool. Any existing code that uses `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` was authored with this fact in mind. It is often used to early exit out of tests that the author knew you would not be able to run given your sandbox limitations.

 Before creating a pull request with changes to `codex-rs`, run `just fmt` (in `codex-rs` directory) to format the code and `just fix` (in `codex-rs` directory) to fix any linter issues in the code, ensure the test suite passes by running `cargo test --all-features` in the `codex-rs` directory.

--- a/codex-cli/bin/codex.js
+++ b/codex-cli/bin/codex.js
@@ -83,7 +83,6 @@ if (wantsNative && process.platform !== 'win32') {

  const child = spawn(binaryPath, process.argv.slice(2), {
    stdio: "inherit",
-    env: { ...process.env, CODEX_MANAGED_BY_NPM: "1" },
  });

  child.on("error", (err) => {
--- a/codex-cli/src/utils/agent/sandbox/macos-seatbelt.ts
+++ b/codex-cli/src/utils/agent/sandbox/macos-seatbelt.ts
@@ -147,8 +147,4 @@ const READ_ONLY_SEATBELT_POLICY = `
  (sysctl-name "kern.version")
  (sysctl-name "sysctl.proc_cputype")
  (sysctl-name-prefix "hw.perflevel")
-)
-
-; Added on top of Chrome profile
-; Needed for python multiprocessing on MacOS for the SemLock
-(allow ipc-posix-sem)`.trim();
+)`.trim();
--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -661,7 +661,7 @@ dependencies = [
 "clap",
 "codex-core",
 "serde",
- "toml 0.9.4",
+ "toml 0.9.2",
 ]

 [[package]]
@@ -695,11 +695,9 @@ dependencies = [
 "reqwest",
 "seccompiler",
 "serde",
- "serde_bytes",
 "serde_json",
 "sha1",
 "shlex",
- "similar",
 "strum_macros 0.27.2",
 "tempfile",
 "thiserror 2.0.12",
@@ -707,7 +705,7 @@ dependencies = [
 "tokio",
 "tokio-test",
 "tokio-util",
- "toml 0.9.4",
+ "toml 0.9.2",
 "tracing",
 "tree-sitter",
 "tree-sitter-bash",
@@ -831,7 +829,7 @@ dependencies = [
 "tempfile",
 "tokio",
 "tokio-test",
- "toml 0.9.4",
+ "toml 0.9.2",
 "tracing",
 "tracing-subscriber",
 "uuid",
@@ -844,7 +842,6 @@ version = "0.0.0"
 dependencies = [
 "anyhow",
 "base64 0.22.1",
- "chrono",
 "clap",
 "codex-ansi-escape",
 "codex-arg0",
@@ -860,24 +857,20 @@ dependencies = [
 "mcp-types",
 "path-clean",
 "pretty_assertions",
- "rand 0.8.5",
 "ratatui",
 "ratatui-image",
 "regex-lite",
- "reqwest",
- "serde",
 "serde_json",
 "shlex",
 "strum 0.27.2",
 "strum_macros 0.27.2",
- "supports-color",
- "textwrap 0.16.2",
 "tokio",
 "tracing",
 "tracing-appender",
 "tracing-subscriber",
 "tui-input",
 "tui-markdown",
+ "tui-textarea",
 "unicode-segmentation",
 "unicode-width 0.1.14",
 "uuid",
@@ -2017,7 +2010,7 @@ dependencies = [
 "libc",
 "percent-encoding",
 "pin-project-lite",
- "socket2",
+ "socket2 0.6.0",
 "system-configuration",
 "tokio",
 "tower-service",
@@ -2339,12 +2332,6 @@ dependencies = [
 "windows-sys 0.59.0",
 ]

-[[package]]
-name = "is_ci"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
-
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.1"
@@ -3964,15 +3951,6 @@ dependencies = [
 "serde_derive",
 ]

-[[package]]
-name = "serde_bytes"
-version = "0.11.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8437fd221bde2d4ca316d61b90e337e9e702b3820b87d63caa9ba6c02bd06d96"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "serde_derive"
 version = "1.0.219"
@@ -3997,9 +3975,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.142"
+version = "1.0.141"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "030fedb782600dcbd6f02d479bf0d817ac3bb40d644745b769d6a96bc3afc5a7"
+checksum = "30b9eff21ebe718216c6ec64e1d9ac57087aad11efc64e32002bce4a0d4c03d3"
 dependencies = [
 "indexmap 2.10.0",
 "itoa",
@@ -4183,10 +4161,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"

 [[package]]
-name = "smawk"
-version = "0.3.2"
+name = "socket2"
+version = "0.5.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]

 [[package]]
 name = "socket2"
@@ -4240,7 +4222,7 @@ dependencies = [
 "starlark_syntax",
 "static_assertions",
 "strsim 0.10.0",
- "textwrap 0.11.0",
+ "textwrap",
 "thiserror 1.0.69",
 ]

@@ -4376,15 +4358,6 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"

-[[package]]
-name = "supports-color"
-version = "3.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6"
-dependencies = [
- "is_ci",
-]
-
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -4538,17 +4511,6 @@ dependencies = [
 "unicode-width 0.1.14",
 ]

-[[package]]
-name = "textwrap"
-version = "0.16.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
-dependencies = [
- "smawk",
- "unicode-linebreak",
- "unicode-width 0.2.0",
-]
-
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -4663,9 +4625,9 @@ dependencies = [

 [[package]]
 name = "tokio"
-version = "1.47.1"
+version = "1.46.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+checksum = "0cc3a2344dafbe23a245241fe8b09735b521110d30fcefbbd5feb1797ca35d17"
 dependencies = [
 "backtrace",
 "bytes",
@@ -4676,9 +4638,9 @@ dependencies = [
 "pin-project-lite",
 "signal-hook-registry",
 "slab",
- "socket2",
+ "socket2 0.5.10",
 "tokio-macros",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -4763,9 +4725,9 @@ dependencies = [

 [[package]]
 name = "toml"
-version = "0.9.4"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41ae868b5a0f67631c14589f7e250c1ea2c574ee5ba21c6c8dd4b1485705a5a1"
+checksum = "ed0aee96c12fa71097902e0bb061a5e1ebd766a6636bb605ba401c45c1650eac"
 dependencies = [
 "indexmap 2.10.0",
 "serde",
@@ -5013,6 +4975,17 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "tui-textarea"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5318dd619ed73c52a9417ad19046724effc1287fb75cdcc4eca1d6ac1acbae"
+dependencies = [
+ "crossterm",
+ "ratatui",
+ "unicode-width 0.2.0",
+]
+
 [[package]]
 name = "typenum"
 version = "1.18.0"
@@ -5031,12 +5004,6 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"

-[[package]]
-name = "unicode-linebreak"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
-
 [[package]]
 name = "unicode-segmentation"
 version = "1.12.0"
--- a/codex-rs/common/src/sandbox_summary.rs
+++ b/codex-rs/common/src/sandbox_summary.rs
@@ -7,7 +7,6 @@ pub fn summarize_sandbox_policy(sandbox_policy: &SandboxPolicy) -> String {
        SandboxPolicy::WorkspaceWrite {
            writable_roots,
            network_access,
-            include_default_writable_roots,
        } => {
            let mut summary = "workspace-write".to_string();
            if !writable_roots.is_empty() {
@@ -20,9 +19,6 @@ pub fn summarize_sandbox_policy(sandbox_policy: &SandboxPolicy) -> String {
                        .join(", ")
                ));
            }
-            if !*include_default_writable_roots {
-                summary.push_str(" (exact writable roots)");
-            }
            if *network_access {
                summary.push_str(" (network access enabled)");
            }
--- a/codex-rs/config.md
+++ b/codex-rs/config.md
@@ -259,8 +259,6 @@ disk, but attempts to write a file or access the network will be blocked.

 A more relaxed policy is `workspace-write`. When specified, the current working directory for the Codex task will be writable (as well as `$TMPDIR` on macOS). Note that the CLI defaults to using the directory where it was spawned as `cwd`, though this can be overridden using `--cwd/-C`.

-On macOS (and soon Linux), all writable roots (including `cwd`) that contain a `.git/` folder _as an immediate child_ will configure the `.git/` folder to be read-only while the rest of the Git repository will be writable. This means that commands like `git commit` will fail, by default (as it entails writing to `.git/`), and will require Codex to ask for permission.
-
 ```toml
 # same as `--sandbox workspace-write`
 sandbox_mode = "workspace-write"
--- a/codex-rs/core/Cargo.toml
+++ b/codex-rs/core/Cargo.toml
@@ -31,10 +31,8 @@ rand = "0.9"
 reqwest = { version = "0.12", features = ["json", "stream"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde_bytes = "0.11"
 sha1 = "0.10.6"
 shlex = "1.3.0"
-similar = "2.7.0"
 strum_macros = "0.27.2"
 thiserror = "2.0.12"
 time = { version = "0.3", features = ["formatting", "local-offset", "macros"] }
@@ -46,7 +44,7 @@ tokio = { version = "1", features = [
    "signal",
 ] }
 tokio-util = "0.7.14"
-toml = "0.9.4"
+toml = "0.9.2"
 tracing = { version = "0.1.41", features = ["log"] }
 tree-sitter = "0.25.8"
 tree-sitter-bash = "0.25.0"
--- a/codex-rs/core/prompt.md
+++ b/codex-rs/core/prompt.md
@@ -10,7 +10,7 @@ You MUST adhere to the following criteria when executing the task:
 - Showing user code and tool call details is allowed.
 - User instructions may overwrite the _CODING GUIDELINES_ section in this developer message.
 - Do not use \`ls -R\`, \`find\`, or \`grep\` - these are slow in large repos. Use \`rg\` and \`rg --files\`.
- Use \`apply_patch\` to edit files: {"command":["apply_patch","*** Begin Patch\\n*** Update File: path/to/file.py\\n@@ def example():\\n- pass\\n+ return 123\\n*** End Patch"]}
+- Use \`apply_patch\` to edit files: {"cmd":["apply_patch","*** Begin Patch\\n*** Update File: path/to/file.py\\n@@ def example():\\n- pass\\n+ return 123\\n*** End Patch"]}
 - If completing the user's task requires writing or modifying files:
  - Your code and final answer should follow these _CODING GUIDELINES_:
    - Fix the problem at the root cause rather than applying surface-level patches, when possible.
@@ -40,16 +40,16 @@ You MUST adhere to the following criteria when executing the task:

 Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:

-*** Begin Patch
+**_ Begin Patch
 [ one or more file sections ]
-*** End Patch
+_** End Patch

 Within that envelope, you get a sequence of file operations.
 You MUST include a header to specify the action you are taking.
 Each operation starts with one of three headers:

-*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
-*** Delete File: <path> - remove an existing file. Nothing follows.
+**_ Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+_** Delete File: <path> - remove an existing file. Nothing follows.
 \*\*\* Update File: <path> - patch an existing file in place (optionally with a rename).

 May be immediately followed by \*\*\* Move to: <new path> if you want to rename the file.
@@ -63,28 +63,28 @@ Within a hunk each line starts with:
  At the end of a truncated hunk you can emit \*\*\* End of File.

 Patch := Begin { FileOp } End
-Begin := "*** Begin Patch" NEWLINE
-End := "*** End Patch" NEWLINE
+Begin := "**_ Begin Patch" NEWLINE
+End := "_** End Patch" NEWLINE
 FileOp := AddFile | DeleteFile | UpdateFile
-AddFile := "*** Add File: " path NEWLINE { "+" line NEWLINE }
-DeleteFile := "*** Delete File: " path NEWLINE
-UpdateFile := "*** Update File: " path NEWLINE [ MoveTo ] { Hunk }
-MoveTo := "*** Move to: " newPath NEWLINE
+AddFile := "**_ Add File: " path NEWLINE { "+" line NEWLINE }
+DeleteFile := "_** Delete File: " path NEWLINE
+UpdateFile := "**_ Update File: " path NEWLINE [ MoveTo ] { Hunk }
+MoveTo := "_** Move to: " newPath NEWLINE
 Hunk := "@@" [ header ] NEWLINE { HunkLine } [ "*** End of File" NEWLINE ]
 HunkLine := (" " | "-" | "+") text NEWLINE

 A full patch can combine several operations:

-*** Begin Patch
-*** Add File: hello.txt
+**_ Begin Patch
+_** Add File: hello.txt
 +Hello world
-*** Update File: src/app.py
-*** Move to: src/main.py
+**_ Update File: src/app.py
+_** Move to: src/main.py
@@ def greet():
 -print("Hi")
 +print("Hello, world!")
-*** Delete File: obsolete.txt
-*** End Patch
+**_ Delete File: obsolete.txt
+_** End Patch

 It is important to remember:

@@ -101,7 +101,7 @@ Plan updates

 A tool named `update_plan` is available. Use it to keep an up‑to‑date, step‑by‑step plan for the task so you can follow your progress. When making your plans, keep in mind that you are a deployed coding agent - `update_plan` calls should not involve doing anything that you aren't capable of doing. For example, `update_plan` calls should NEVER contain tasks to merge your own pull requests. Only stop to ask the user if you genuinely need their feedback on a change.

- At the start of any nontrivial task, call `update_plan` with an initial plan: a short list of 1‑sentence steps with a `status` for each step (`pending`, `in_progress`, or `completed`). There should always be exactly one `in_progress` step until everything is done.
+- At the start of the task, call `update_plan` with an initial plan: a short list of 1‑sentence steps with a `status` for each step (`pending`, `in_progress`, or `completed`). There should always be exactly one `in_progress` step until everything is done.
 - Whenever you finish a step, call `update_plan` again, marking the finished step as `completed` and the next step as `in_progress`.
 - If your plan needs to change, call `update_plan` with the revised steps and include an `explanation` describing the change.
 - When all steps are complete, make a final `update_plan` call with all steps marked `completed`.
--- a/codex-rs/core/src/chat_completions.rs
+++ b/codex-rs/core/src/chat_completions.rs
@@ -207,7 +207,6 @@ async fn process_chat_sse<S>(
    }

    let mut fn_call_state = FunctionCallState::default();
-    let mut assistant_text = String::new();

    loop {
        let sse = match timeout(idle_timeout, stream.next()).await {
@@ -255,42 +254,21 @@ async fn process_chat_sse<S>(
        let choice_opt = chunk.get("choices").and_then(|c| c.get(0));

        if let Some(choice) = choice_opt {
-            // Handle assistant content tokens as streaming deltas.
+            // Handle assistant content tokens.
            if let Some(content) = choice
                .get("delta")
                .and_then(|d| d.get("content"))
                .and_then(|c| c.as_str())
            {
-                if !content.is_empty() {
-                    assistant_text.push_str(content);
-                    let _ = tx_event
-                        .send(Ok(ResponseEvent::OutputTextDelta(content.to_string())))
-                        .await;
-                }
-            }
+                let item = ResponseItem::Message {
+                    role: "assistant".to_string(),
+                    content: vec![ContentItem::OutputText {
+                        text: content.to_string(),
+                    }],
+                    id: None,
+                };

-            // Forward any reasoning/thinking deltas if present.
-            if let Some(reasoning) = choice
-                .get("delta")
-                .and_then(|d| d.get("reasoning"))
-                .and_then(|c| c.as_str())
-            {
-                let _ = tx_event
-                    .send(Ok(ResponseEvent::ReasoningSummaryDelta(
-                        reasoning.to_string(),
-                    )))
-                    .await;
-            }
-            if let Some(reasoning_content) = choice
-                .get("delta")
-                .and_then(|d| d.get("reasoning_content"))
-                .and_then(|c| c.as_str())
-            {
-                let _ = tx_event
-                    .send(Ok(ResponseEvent::ReasoningSummaryDelta(
-                        reasoning_content.to_string(),
-                    )))
-                    .await;
+                let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
            }

            // Handle streaming function / tool calls.
@@ -339,18 +317,7 @@ async fn process_chat_sse<S>(
                        let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
                    }
                    "stop" => {
-                        // Regular turn without tool-call. Emit the final assistant message
-                        // as a single OutputItemDone so non-delta consumers see the result.
-                        if !assistant_text.is_empty() {
-                            let item = ResponseItem::Message {
-                                role: "assistant".to_string(),
-                                content: vec![ContentItem::OutputText {
-                                    text: std::mem::take(&mut assistant_text),
-                                }],
-                                id: None,
-                            };
-                            let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
-                        }
+                        // Regular turn without tool-call.
                    }
                    _ => {}
                }
@@ -391,10 +358,7 @@ async fn process_chat_sse<S>(
 pub(crate) struct AggregatedChatStream<S> {
    inner: S,
    cumulative: String,
-    cumulative_reasoning: String,
-    pending: std::collections::VecDeque<ResponseEvent>,
-    // When true, do not emit a cumulative assistant message at Completed.
-    streaming_mode: bool,
+    pending_completed: Option<ResponseEvent>,
 }

 impl<S> Stream for AggregatedChatStream<S>
@@ -406,8 +370,8 @@ where
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let this = self.get_mut();

-        // First, flush any buffered events from the previous call.
-        if let Some(ev) = this.pending.pop_front() {
+        // First, flush any buffered Completed event from the previous call.
+        if let Some(ev) = this.pending_completed.take() {
            return Poll::Ready(Some(Ok(ev)));
        }

@@ -424,21 +388,16 @@ where
                    let is_assistant_delta = matches!(&item, crate::models::ResponseItem::Message { role, .. } if role == "assistant");

                    if is_assistant_delta {
-                        // Only use the final assistant message if we have not
-                        // seen any deltas; otherwise, deltas already built the
-                        // cumulative text and this would duplicate it.
-                        if this.cumulative.is_empty() {
-                            if let crate::models::ResponseItem::Message { content, .. } = &item {
-                                if let Some(text) = content.iter().find_map(|c| match c {
-                                    crate::models::ContentItem::OutputText { text } => Some(text),
-                                    _ => None,
-                                }) {
-                                    this.cumulative.push_str(text);
-                                }
+                        if let crate::models::ResponseItem::Message { content, .. } = &item {
+                            if let Some(text) = content.iter().find_map(|c| match c {
+                                crate::models::ContentItem::OutputText { text } => Some(text),
+                                _ => None,
+                            }) {
+                                this.cumulative.push_str(text);
                            }
                        }

-                        // Swallow assistant message here; emit on Completed.
+                        // Swallow partial assistant chunk; keep polling.
                        continue;
                    }

@@ -449,48 +408,24 @@ where
                    response_id,
                    token_usage,
                }))) => {
-                    // Build any aggregated items in the correct order: Reasoning first, then Message.
-                    let mut emitted_any = false;
-
-                    if !this.cumulative_reasoning.is_empty() {
-                        let aggregated_reasoning = crate::models::ResponseItem::Reasoning {
-                            id: String::new(),
-                            summary: vec![
-                                crate::models::ReasoningItemReasoningSummary::SummaryText {
-                                    text: std::mem::take(&mut this.cumulative_reasoning),
-                                },
-                            ],
-                            content: None,
-                            encrypted_content: None,
-                        };
-                        this.pending
-                            .push_back(ResponseEvent::OutputItemDone(aggregated_reasoning));
-                        emitted_any = true;
-                    }
-
                    if !this.cumulative.is_empty() {
-                        let aggregated_message = crate::models::ResponseItem::Message {
+                        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),
                            }],
                        };
-                        this.pending
-                            .push_back(ResponseEvent::OutputItemDone(aggregated_message));
-                        emitted_any = true;
-                    }

-                    // Always emit Completed last when anything was aggregated.
-                    if emitted_any {
-                        this.pending.push_back(ResponseEvent::Completed {
-                            response_id: response_id.clone(),
-                            token_usage: token_usage.clone(),
+                        // Buffer Completed so it is returned *after* the aggregated message.
+                        this.pending_completed = Some(ResponseEvent::Completed {
+                            response_id,
+                            token_usage,
                        });
-                        // Return the first pending event now.
-                        if let Some(ev) = this.pending.pop_front() {
-                            return Poll::Ready(Some(Ok(ev)));
-                        }
+
+                        return Poll::Ready(Some(Ok(ResponseEvent::OutputItemDone(
+                            aggregated_item,
+                        ))));
                    }

                    // Nothing aggregated – forward Completed directly.
@@ -504,25 +439,11 @@ where
                    // will never appear in a Chat Completions stream.
                    continue;
                }
-                Poll::Ready(Some(Ok(ResponseEvent::OutputTextDelta(delta)))) => {
-                    // Always accumulate deltas so we can emit a final OutputItemDone at Completed.
-                    this.cumulative.push_str(&delta);
-                    if this.streaming_mode {
-                        // In streaming mode, also forward the delta immediately.
-                        return Poll::Ready(Some(Ok(ResponseEvent::OutputTextDelta(delta))));
-                    } else {
-                        continue;
-                    }
-                }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(delta)))) => {
-                    // Always accumulate reasoning deltas so we can emit a final Reasoning item at Completed.
-                    this.cumulative_reasoning.push_str(&delta);
-                    if this.streaming_mode {
-                        // In streaming mode, also forward the delta immediately.
-                        return Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(delta))));
-                    } else {
-                        continue;
-                    }
+                Poll::Ready(Some(Ok(ResponseEvent::OutputTextDelta(_))))
+                | Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(_)))) => {
+                    // Deltas are ignored here since aggregation waits for the
+                    // final OutputItemDone.
+                    continue;
                }
            }
        }
@@ -554,23 +475,9 @@ pub(crate) trait AggregateStreamExt: Stream<Item = Result<ResponseEvent>> + Size
        AggregatedChatStream {
            inner: self,
            cumulative: String::new(),
-            cumulative_reasoning: String::new(),
-            pending: std::collections::VecDeque::new(),
-            streaming_mode: false,
+            pending_completed: None,
        }
    }
 }

 impl<T> AggregateStreamExt for T where T: Stream<Item = Result<ResponseEvent>> + Sized {}
-
-impl<S> AggregatedChatStream<S> {
-    pub(crate) fn streaming_mode(inner: S) -> Self {
-        AggregatedChatStream {
-            inner,
-            cumulative: String::new(),
-            cumulative_reasoning: String::new(),
-            pending: std::collections::VecDeque::new(),
-            streaming_mode: true,
-        }
-    }
-}
--- a/codex-rs/core/src/client.rs
+++ b/codex-rs/core/src/client.rs
@@ -93,11 +93,7 @@ impl ModelClient {
                // Wrap it with the aggregation adapter so callers see *only*
                // the final assistant message per turn (matching the
                // behaviour of the Responses API).
-                let mut aggregated = if !self.config.hide_agent_reasoning {
-                    crate::chat_completions::AggregatedChatStream::streaming_mode(response_stream)
-                } else {
-                    response_stream.aggregate()
-                };
+                let mut aggregated = response_stream.aggregate();

                // Bridge the aggregated stream back into a standard
                // `ResponseStream` by forwarding events through a channel.
@@ -442,7 +438,7 @@ async fn process_sse<S>(
                    }
                }
            }
-            "response.reasoning_summary_text.delta" | "response.reasoning_text.delta" => {
+            "response.reasoning_summary_text.delta" => {
                if let Some(delta) = event.delta {
                    let event = ResponseEvent::ReasoningSummaryDelta(delta);
                    if tx_event.send(Ok(event)).await.is_err() {
--- a/codex-rs/core/src/codex.rs
+++ b/codex-rs/core/src/codex.rs
@@ -48,7 +48,6 @@ use crate::error::SandboxErr;
 use crate::exec::ExecParams;
 use crate::exec::ExecToolCallOutput;
 use crate::exec::SandboxType;
-use crate::exec::StdoutStream;
 use crate::exec::process_exec_tool_call;
 use crate::exec_env::create_env;
 use crate::mcp_connection_manager::McpConnectionManager;
@@ -56,7 +55,6 @@ use crate::mcp_tool_call::handle_mcp_tool_call;
 use crate::models::ContentItem;
 use crate::models::FunctionCallOutputPayload;
 use crate::models::LocalShellAction;
-use crate::models::ReasoningItemContent;
 use crate::models::ReasoningItemReasoningSummary;
 use crate::models::ResponseInputItem;
 use crate::models::ResponseItem;
@@ -65,7 +63,6 @@ use crate::plan_tool::handle_update_plan;
 use crate::project_doc::get_user_instructions;
 use crate::protocol::AgentMessageDeltaEvent;
 use crate::protocol::AgentMessageEvent;
-use crate::protocol::AgentReasoningContentEvent;
 use crate::protocol::AgentReasoningDeltaEvent;
 use crate::protocol::AgentReasoningEvent;
 use crate::protocol::ApplyPatchApprovalRequestEvent;
@@ -87,13 +84,11 @@ use crate::protocol::SandboxPolicy;
 use crate::protocol::SessionConfiguredEvent;
 use crate::protocol::Submission;
 use crate::protocol::TaskCompleteEvent;
-use crate::protocol::TurnDiffEvent;
 use crate::rollout::RolloutRecorder;
 use crate::safety::SafetyCheck;
 use crate::safety::assess_command_safety;
 use crate::safety::assess_safety_for_untrusted_command;
 use crate::shell;
-use crate::turn_diff_tracker::TurnDiffTracker;
 use crate::user_notification::UserNotification;
 use crate::util::backoff;

@@ -229,7 +224,6 @@ pub(crate) struct Session {
    state: Mutex<State>,
    codex_linux_sandbox_exe: Option<PathBuf>,
    user_shell: shell::Shell,
-    hide_agent_reasoning: bool,
 }

 impl Session {
@@ -367,11 +361,7 @@ impl Session {
        }
    }

-    async fn on_exec_command_begin(
-        &self,
-        turn_diff_tracker: &mut TurnDiffTracker,
-        exec_command_context: ExecCommandContext,
-    ) {
+    async fn notify_exec_command_begin(&self, exec_command_context: ExecCommandContext) {
        let ExecCommandContext {
            sub_id,
            call_id,
@@ -383,15 +373,11 @@ impl Session {
            Some(ApplyPatchCommandContext {
                user_explicitly_approved_this_action,
                changes,
-            }) => {
-                turn_diff_tracker.on_patch_begin(&changes);
-
-                EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
-                    call_id,
-                    auto_approved: !user_explicitly_approved_this_action,
-                    changes,
-                })
-            }
+            }) => EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
+                call_id,
+                auto_approved: !user_explicitly_approved_this_action,
+                changes,
+            }),
            None => EventMsg::ExecCommandBegin(ExecCommandBeginEvent {
                call_id,
                command: command_for_display.clone(),
@@ -405,21 +391,15 @@ impl Session {
        let _ = self.tx_event.send(event).await;
    }

-    #[allow(clippy::too_many_arguments)]
-    async fn on_exec_command_end(
+    async fn notify_exec_command_end(
        &self,
-        turn_diff_tracker: &mut TurnDiffTracker,
        sub_id: &str,
        call_id: &str,
-        output: &ExecToolCallOutput,
+        stdout: &str,
+        stderr: &str,
+        exit_code: i32,
        is_apply_patch: bool,
    ) {
-        let ExecToolCallOutput {
-            stdout,
-            stderr,
-            duration,
-            exit_code,
-        } = output;
        // Because stdout and stderr could each be up to 100 KiB, we send
        // truncated versions.
        const MAX_STREAM_OUTPUT: usize = 5 * 1024; // 5KiB
@@ -431,15 +411,14 @@ impl Session {
                call_id: call_id.to_string(),
                stdout,
                stderr,
-                success: *exit_code == 0,
+                success: exit_code == 0,
            })
        } else {
            EventMsg::ExecCommandEnd(ExecCommandEndEvent {
                call_id: call_id.to_string(),
                stdout,
                stderr,
-                duration: *duration,
-                exit_code: *exit_code,
+                exit_code,
            })
        };

@@ -448,20 +427,6 @@ impl Session {
            msg,
        };
        let _ = self.tx_event.send(event).await;
-
-        // If this is an apply_patch, after we emit the end patch, emit a second event
-        // with the full turn diff if there is one.
-        if is_apply_patch {
-            let unified_diff = turn_diff_tracker.get_unified_diff();
-            if let Ok(Some(unified_diff)) = unified_diff {
-                let msg = EventMsg::TurnDiff(TurnDiffEvent { unified_diff });
-                let event = Event {
-                    id: sub_id.into(),
-                    msg,
-                };
-                let _ = self.tx_event.send(event).await;
-            }
-        }
    }

    /// Helper that emits a BackgroundEvent with the given message. This keeps
@@ -825,7 +790,6 @@ async fn submission_loop(
                    codex_linux_sandbox_exe: config.codex_linux_sandbox_exe.clone(),
                    disable_response_storage,
                    user_shell: default_shell,
-                    hide_agent_reasoning: config.hide_agent_reasoning,
                }));

                // Patch restored state into the newly created session.
@@ -1036,10 +1000,6 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
        .await;

    let last_agent_message: Option<String>;
-    // Although from the perspective of codex.rs, TurnDiffTracker has the lifecycle of a Task which contains
-    // many turns, from the perspective of the user, it is a single turn.
-    let mut turn_diff_tracker = TurnDiffTracker::new();
-
    loop {
        // Note that pending_input would be something like a message the user
        // submitted through the UI while the model was running. Though the UI
@@ -1071,7 +1031,7 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                })
            })
            .collect();
-        match run_turn(&sess, &mut turn_diff_tracker, sub_id.clone(), turn_input).await {
+        match run_turn(&sess, sub_id.clone(), turn_input).await {
            Ok(turn_output) => {
                let mut items_to_record_in_conversation_history = Vec::<ResponseItem>::new();
                let mut responses = Vec::<ResponseInputItem>::new();
@@ -1136,7 +1096,6 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                            ResponseItem::Reasoning {
                                id,
                                summary,
-                                content,
                                encrypted_content,
                            },
                            None,
@@ -1144,7 +1103,6 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                            items_to_record_in_conversation_history.push(ResponseItem::Reasoning {
                                id: id.clone(),
                                summary: summary.clone(),
-                                content: content.clone(),
                                encrypted_content: encrypted_content.clone(),
                            });
                        }
@@ -1199,7 +1157,6 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {

 async fn run_turn(
    sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
    sub_id: String,
    input: Vec<ResponseItem>,
 ) -> CodexResult<Vec<ProcessedResponseItem>> {
@@ -1214,7 +1171,7 @@ async fn run_turn(

    let mut retries = 0;
    loop {
-        match try_run_turn(sess, turn_diff_tracker, &sub_id, &prompt).await {
+        match try_run_turn(sess, &sub_id, &prompt).await {
            Ok(output) => return Ok(output),
            Err(CodexErr::Interrupted) => return Err(CodexErr::Interrupted),
            Err(CodexErr::EnvVar(var)) => return Err(CodexErr::EnvVar(var)),
@@ -1260,7 +1217,6 @@ struct ProcessedResponseItem {

 async fn try_run_turn(
    sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
    sub_id: &str,
    prompt: &Prompt,
 ) -> CodexResult<Vec<ProcessedResponseItem>> {
@@ -1348,8 +1304,7 @@ async fn try_run_turn(
        match event {
            ResponseEvent::Created => {}
            ResponseEvent::OutputItemDone(item) => {
-                let response =
-                    handle_response_item(sess, turn_diff_tracker, sub_id, item.clone()).await?;
+                let response = handle_response_item(sess, sub_id, item.clone()).await?;

                output.push(ProcessedResponseItem { item, response });
            }
@@ -1367,16 +1322,6 @@ async fn try_run_turn(
                        .ok();
                }

-                let unified_diff = turn_diff_tracker.get_unified_diff();
-                if let Ok(Some(unified_diff)) = unified_diff {
-                    let msg = EventMsg::TurnDiff(TurnDiffEvent { unified_diff });
-                    let event = Event {
-                        id: sub_id.to_string(),
-                        msg,
-                    };
-                    let _ = sess.tx_event.send(event).await;
-                }
-
                return Ok(output);
            }
            ResponseEvent::OutputTextDelta(delta) => {
@@ -1387,13 +1332,11 @@ async fn try_run_turn(
                sess.tx_event.send(event).await.ok();
            }
            ResponseEvent::ReasoningSummaryDelta(delta) => {
-                if !sess.hide_agent_reasoning {
-                    let event = Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::AgentReasoningDelta(AgentReasoningDeltaEvent { delta }),
-                    };
-                    sess.tx_event.send(event).await.ok();
-                }
+                let event = Event {
+                    id: sub_id.to_string(),
+                    msg: EventMsg::AgentReasoningDelta(AgentReasoningDeltaEvent { delta }),
+                };
+                sess.tx_event.send(event).await.ok();
            }
        }
    }
@@ -1429,7 +1372,7 @@ async fn run_compact_task(
    let mut retries = 0;

    loop {
-        let attempt_result = drain_to_completed(&sess, &sub_id, &prompt).await;
+        let attempt_result = drain_to_completed(&sess, &prompt).await;

        match attempt_result {
            Ok(()) => break,
@@ -1483,7 +1426,6 @@ async fn run_compact_task(

 async fn handle_response_item(
    sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
    sub_id: &str,
    item: ResponseItem,
 ) -> CodexResult<Option<ResponseInputItem>> {
@@ -1501,36 +1443,16 @@ async fn handle_response_item(
            }
            None
        }
-        ResponseItem::Reasoning {
-            id: _,
-            summary,
-            content,
-            encrypted_content: _,
-        } => {
-            if !sess.hide_agent_reasoning {
-                for item in summary {
-                    let text = match item {
-                        ReasoningItemReasoningSummary::SummaryText { text } => text,
-                    };
-                    let event = Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::AgentReasoning(AgentReasoningEvent { text }),
-                    };
-                    sess.tx_event.send(event).await.ok();
-                }
-            }
-            if !sess.hide_agent_reasoning && content.is_some() {
-                let content = content.unwrap();
-                for item in content {
-                    let text = match item {
-                        ReasoningItemContent::ReasoningText { text } => text,
-                    };
-                    let event = Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::AgentReasoningContent(AgentReasoningContentEvent { text }),
-                    };
-                    sess.tx_event.send(event).await.ok();
-                }
+        ResponseItem::Reasoning { summary, .. } => {
+            for item in summary {
+                let text = match item {
+                    ReasoningItemReasoningSummary::SummaryText { text } => text,
+                };
+                let event = Event {
+                    id: sub_id.to_string(),
+                    msg: EventMsg::AgentReasoning(AgentReasoningEvent { text }),
+                };
+                sess.tx_event.send(event).await.ok();
            }
            None
        }
@@ -1541,17 +1463,7 @@ async fn handle_response_item(
            ..
        } => {
            info!("FunctionCall: {arguments}");
-            Some(
-                handle_function_call(
-                    sess,
-                    turn_diff_tracker,
-                    sub_id.to_string(),
-                    name,
-                    arguments,
-                    call_id,
-                )
-                .await,
-            )
+            Some(handle_function_call(sess, sub_id.to_string(), name, arguments, call_id).await)
        }
        ResponseItem::LocalShellCall {
            id,
@@ -1586,7 +1498,6 @@ async fn handle_response_item(
                handle_container_exec_with_params(
                    exec_params,
                    sess,
-                    turn_diff_tracker,
                    sub_id.to_string(),
                    effective_call_id,
                )
@@ -1604,7 +1515,6 @@ async fn handle_response_item(

 async fn handle_function_call(
    sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
    sub_id: String,
    name: String,
    arguments: String,
@@ -1618,8 +1528,7 @@ async fn handle_function_call(
                    return *output;
                }
            };
-            handle_container_exec_with_params(params, sess, turn_diff_tracker, sub_id, call_id)
-                .await
+            handle_container_exec_with_params(params, sess, sub_id, call_id).await
        }
        "update_plan" => handle_update_plan(sess, arguments, sub_id, call_id).await,
        _ => {
@@ -1693,7 +1602,6 @@ fn maybe_run_with_user_profile(params: ExecParams, sess: &Session) -> ExecParams
 async fn handle_container_exec_with_params(
    params: ExecParams,
    sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
    sub_id: String,
    call_id: String,
 ) -> ResponseInputItem {
@@ -1841,7 +1749,7 @@ async fn handle_container_exec_with_params(
            },
        ),
    };
-    sess.on_exec_command_begin(turn_diff_tracker, exec_command_context.clone())
+    sess.notify_exec_command_begin(exec_command_context.clone())
        .await;

    let params = maybe_run_with_user_profile(params, sess);
@@ -1851,11 +1759,6 @@ async fn handle_container_exec_with_params(
        sess.ctrl_c.clone(),
        &sess.sandbox_policy,
        &sess.codex_linux_sandbox_exe,
-        Some(StdoutStream {
-            sub_id: sub_id.clone(),
-            call_id: call_id.clone(),
-            tx_event: sess.tx_event.clone(),
-        }),
    )
    .await;

@@ -1866,22 +1769,23 @@ async fn handle_container_exec_with_params(
                stdout,
                stderr,
                duration,
-            } = &output;
+            } = output;

-            sess.on_exec_command_end(
-                turn_diff_tracker,
+            sess.notify_exec_command_end(
                &sub_id,
                &call_id,
-                &output,
+                &stdout,
+                &stderr,
+                exit_code,
                exec_command_context.apply_patch.is_some(),
            )
            .await;

-            let is_success = *exit_code == 0;
+            let is_success = exit_code == 0;
            let content = format_exec_output(
-                if is_success { stdout } else { stderr },
-                *exit_code,
-                *duration,
+                if is_success { &stdout } else { &stderr },
+                exit_code,
+                duration,
            );

            ResponseInputItem::FunctionCallOutput {
@@ -1893,15 +1797,7 @@ async fn handle_container_exec_with_params(
            }
        }
        Err(CodexErr::Sandbox(error)) => {
-            handle_sandbox_error(
-                turn_diff_tracker,
-                params,
-                exec_command_context,
-                error,
-                sandbox_type,
-                sess,
-            )
-            .await
+            handle_sandbox_error(params, exec_command_context, error, sandbox_type, sess).await
        }
        Err(e) => {
            // Handle non-sandbox errors
@@ -1917,7 +1813,6 @@ async fn handle_container_exec_with_params(
 }

 async fn handle_sandbox_error(
-    turn_diff_tracker: &mut TurnDiffTracker,
    params: ExecParams,
    exec_command_context: ExecCommandContext,
    error: SandboxErr,
@@ -1974,8 +1869,7 @@ async fn handle_sandbox_error(
            sess.notify_background_event(&sub_id, "retrying command without sandbox")
                .await;

-            sess.on_exec_command_begin(turn_diff_tracker, exec_command_context)
-                .await;
+            sess.notify_exec_command_begin(exec_command_context).await;

            // This is an escalated retry; the policy will not be
            // examined and the sandbox has been set to `None`.
@@ -1985,11 +1879,6 @@ async fn handle_sandbox_error(
                sess.ctrl_c.clone(),
                &sess.sandbox_policy,
                &sess.codex_linux_sandbox_exe,
-                Some(StdoutStream {
-                    sub_id: sub_id.clone(),
-                    call_id: call_id.clone(),
-                    tx_event: sess.tx_event.clone(),
-                }),
            )
            .await;

@@ -2000,22 +1889,23 @@ async fn handle_sandbox_error(
                        stdout,
                        stderr,
                        duration,
-                    } = &retry_output;
+                    } = retry_output;

-                    sess.on_exec_command_end(
-                        turn_diff_tracker,
+                    sess.notify_exec_command_end(
                        &sub_id,
                        &call_id,
-                        &retry_output,
+                        &stdout,
+                        &stderr,
+                        exit_code,
                        is_apply_patch,
                    )
                    .await;

-                    let is_success = *exit_code == 0;
+                    let is_success = exit_code == 0;
                    let content = format_exec_output(
-                        if is_success { stdout } else { stderr },
-                        *exit_code,
-                        *duration,
+                        if is_success { &stdout } else { &stderr },
+                        exit_code,
+                        duration,
                    );

                    ResponseInputItem::FunctionCallOutput {
@@ -2100,7 +1990,7 @@ fn get_last_assistant_message_from_turn(responses: &[ResponseItem]) -> Option<St
    })
 }

-async fn drain_to_completed(sess: &Session, sub_id: &str, prompt: &Prompt) -> CodexResult<()> {
+async fn drain_to_completed(sess: &Session, prompt: &Prompt) -> CodexResult<()> {
    let mut stream = sess.client.clone().stream(prompt).await?;
    loop {
        let maybe_event = stream.next().await;
@@ -2110,32 +2000,7 @@ async fn drain_to_completed(sess: &Session, sub_id: &str, prompt: &Prompt) -> Co
            ));
        };
        match event {
-            Ok(ResponseEvent::OutputItemDone(item)) => {
-                // Record only to in-memory conversation history; avoid state snapshot.
-                let mut state = sess.state.lock().unwrap();
-                state.history.record_items(std::slice::from_ref(&item));
-            }
-            Ok(ResponseEvent::Completed {
-                response_id: _,
-                token_usage,
-            }) => {
-                let token_usage = match token_usage {
-                    Some(usage) => usage,
-                    None => {
-                        return Err(CodexErr::Stream(
-                            "token_usage was None in ResponseEvent::Completed".into(),
-                        ));
-                    }
-                };
-                sess.tx_event
-                    .send(Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::TokenCount(token_usage),
-                    })
-                    .await
-                    .ok();
-                return Ok(());
-            }
+            Ok(ResponseEvent::Completed { .. }) => return Ok(()),
            Ok(_) => continue,
            Err(e) => return Err(e),
        }
--- a/codex-rs/core/src/config.rs
+++ b/codex-rs/core/src/config.rs
@@ -356,7 +356,6 @@ impl ConfigToml {
                Some(s) => SandboxPolicy::WorkspaceWrite {
                    writable_roots: s.writable_roots.clone(),
                    network_access: s.network_access,
-                    include_default_writable_roots: true,
                },
                None => SandboxPolicy::new_workspace_write_policy(),
            },
@@ -480,18 +479,12 @@ impl Config {
        // Load base instructions override from a file if specified. If the
        // path is relative, resolve it against the effective cwd so the
        // behaviour matches other path-like config values.
-        let experimental_instructions_path = config_profile
-            .experimental_instructions_file
-            .as_ref()
-            .or(cfg.experimental_instructions_file.as_ref());
-        let file_base_instructions =
-            Self::get_base_instructions(experimental_instructions_path, &resolved_cwd)?;
+        let file_base_instructions = Self::get_base_instructions(
+            cfg.experimental_instructions_file.as_ref(),
+            &resolved_cwd,
+        )?;
        let base_instructions = base_instructions.or(file_base_instructions);

-        // Resolve hide/show reasoning flags with consistent precedence:
-        // if hide is true, force show_reasoning_content to false.
-        let hide_agent_reasoning_val = cfg.hide_agent_reasoning.unwrap_or(false);
-
        let config = Self {
            model,
            model_context_window,
@@ -521,7 +514,7 @@ impl Config {
            tui: cfg.tui.unwrap_or_default(),
            codex_linux_sandbox_exe,

-            hide_agent_reasoning: hide_agent_reasoning_val,
+            hide_agent_reasoning: cfg.hide_agent_reasoning.unwrap_or(false),
            model_reasoning_effort: config_profile
                .model_reasoning_effort
                .or(cfg.model_reasoning_effort)
@@ -734,7 +727,6 @@ writable_roots = [
            SandboxPolicy::WorkspaceWrite {
                writable_roots: vec![PathBuf::from("/tmp")],
                network_access: false,
-                include_default_writable_roots: true,
            },
            sandbox_workspace_write_cfg.derive_sandbox_policy(sandbox_mode_override)
        );
--- a/codex-rs/core/src/config_profile.rs
+++ b/codex-rs/core/src/config_profile.rs
@@ -1,5 +1,4 @@
 use serde::Deserialize;
-use std::path::PathBuf;

 use crate::config_types::ReasoningEffort;
 use crate::config_types::ReasoningSummary;
@@ -18,5 +17,4 @@ pub struct ConfigProfile {
    pub model_reasoning_effort: Option<ReasoningEffort>,
    pub model_reasoning_summary: Option<ReasoningSummary>,
    pub chatgpt_base_url: Option<String>,
-    pub experimental_instructions_file: Option<PathBuf>,
 }
--- a/codex-rs/core/src/exec.rs
+++ b/codex-rs/core/src/exec.rs
@@ -10,7 +10,6 @@ use std::sync::Arc;
 use std::time::Duration;
 use std::time::Instant;

-use async_channel::Sender;
 use tokio::io::AsyncRead;
 use tokio::io::AsyncReadExt;
 use tokio::io::BufReader;
@@ -20,15 +19,10 @@ use tokio::sync::Notify;
 use crate::error::CodexErr;
 use crate::error::Result;
 use crate::error::SandboxErr;
-use crate::protocol::Event;
-use crate::protocol::EventMsg;
-use crate::protocol::ExecCommandOutputDeltaEvent;
-use crate::protocol::ExecOutputStream;
 use crate::protocol::SandboxPolicy;
 use crate::seatbelt::spawn_command_under_seatbelt;
 use crate::spawn::StdioPolicy;
 use crate::spawn::spawn_child_async;
-use serde_bytes::ByteBuf;

 // Maximum we send for each stream, which is either:
 // - 10KiB OR
@@ -62,26 +56,18 @@ pub enum SandboxType {
    LinuxSeccomp,
 }

-#[derive(Clone)]
-pub struct StdoutStream {
-    pub sub_id: String,
-    pub call_id: String,
-    pub tx_event: Sender<Event>,
-}
-
 pub async fn process_exec_tool_call(
    params: ExecParams,
    sandbox_type: SandboxType,
    ctrl_c: Arc<Notify>,
    sandbox_policy: &SandboxPolicy,
    codex_linux_sandbox_exe: &Option<PathBuf>,
-    stdout_stream: Option<StdoutStream>,
 ) -> Result<ExecToolCallOutput> {
    let start = Instant::now();

    let raw_output_result: std::result::Result<RawExecToolCallOutput, CodexErr> = match sandbox_type
    {
-        SandboxType::None => exec(params, sandbox_policy, ctrl_c, stdout_stream.clone()).await,
+        SandboxType::None => exec(params, sandbox_policy, ctrl_c).await,
        SandboxType::MacosSeatbelt => {
            let ExecParams {
                command,
@@ -97,7 +83,7 @@ pub async fn process_exec_tool_call(
                env,
            )
            .await?;
-            consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream.clone()).await
+            consume_truncated_output(child, ctrl_c, timeout_ms).await
        }
        SandboxType::LinuxSeccomp => {
            let ExecParams {
@@ -120,7 +106,7 @@ pub async fn process_exec_tool_call(
            )
            .await?;

-            consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream).await
+            consume_truncated_output(child, ctrl_c, timeout_ms).await
        }
    };
    let duration = start.elapsed();
@@ -140,7 +126,11 @@ pub async fn process_exec_tool_call(

            let exit_code = raw_output.exit_status.code().unwrap_or(-1);

-            if exit_code != 0 && is_likely_sandbox_denied(sandbox_type, exit_code) {
+            // NOTE(ragona): This is much less restrictive than the previous check. If we exec
+            // a command, and it returns anything other than success, we assume that it may have
+            // been a sandboxing error and allow the user to retry. (The user of course may choose
+            // not to retry, or in a non-interactive mode, would automatically reject the approval.)
+            if exit_code != 0 && sandbox_type != SandboxType::None {
                return Err(CodexErr::Sandbox(SandboxErr::Denied(
                    exit_code, stdout, stderr,
                )));
@@ -219,26 +209,6 @@ fn create_linux_sandbox_command_args(
    linux_cmd
 }

-/// We don't have a fully deterministic way to tell if our command failed
-/// because of the sandbox - a command in the user's zshrc file might hit an
-/// error, but the command itself might fail or succeed for other reasons.
-/// For now, we conservatively check for 'command not found' (exit code 127),
-/// and can add additional cases as necessary.
-fn is_likely_sandbox_denied(sandbox_type: SandboxType, exit_code: i32) -> bool {
-    if sandbox_type == SandboxType::None {
-        return false;
-    }
-
-    // Quick rejects: well-known non-sandbox shell exit codes
-    // 127: command not found, 2: misuse of shell builtins
-    if exit_code == 127 {
-        return false;
-    }
-
-    // For all other cases, we assume the sandbox is the cause
-    true
-}
-
 #[derive(Debug)]
 pub struct RawExecToolCallOutput {
    pub exit_status: ExitStatus,
@@ -263,7 +233,6 @@ async fn exec(
    }: ExecParams,
    sandbox_policy: &SandboxPolicy,
    ctrl_c: Arc<Notify>,
-    stdout_stream: Option<StdoutStream>,
 ) -> Result<RawExecToolCallOutput> {
    let (program, args) = command.split_first().ok_or_else(|| {
        CodexErr::Io(io::Error::new(
@@ -282,7 +251,7 @@ async fn exec(
        env,
    )
    .await?;
-    consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream).await
+    consume_truncated_output(child, ctrl_c, timeout_ms).await
 }

 /// Consumes the output of a child process, truncating it so it is suitable for
@@ -291,7 +260,6 @@ pub(crate) async fn consume_truncated_output(
    mut child: Child,
    ctrl_c: Arc<Notify>,
    timeout_ms: Option<u64>,
-    stdout_stream: Option<StdoutStream>,
 ) -> Result<RawExecToolCallOutput> {
    // Both stdout and stderr were configured with `Stdio::piped()`
    // above, therefore `take()` should normally return `Some`.  If it doesn't
@@ -312,15 +280,11 @@ pub(crate) async fn consume_truncated_output(
        BufReader::new(stdout_reader),
        MAX_STREAM_OUTPUT,
        MAX_STREAM_OUTPUT_LINES,
-        stdout_stream.clone(),
-        false,
    ));
    let stderr_handle = tokio::spawn(read_capped(
        BufReader::new(stderr_reader),
        MAX_STREAM_OUTPUT,
        MAX_STREAM_OUTPUT_LINES,
-        stdout_stream.clone(),
-        true,
    ));

    let interrupted = ctrl_c.notified();
@@ -354,12 +318,10 @@ pub(crate) async fn consume_truncated_output(
    })
 }

-async fn read_capped<R: AsyncRead + Unpin + Send + 'static>(
+async fn read_capped<R: AsyncRead + Unpin>(
    mut reader: R,
    max_output: usize,
    max_lines: usize,
-    stream: Option<StdoutStream>,
-    is_stderr: bool,
 ) -> io::Result<Vec<u8>> {
    let mut buf = Vec::with_capacity(max_output.min(8 * 1024));
    let mut tmp = [0u8; 8192];
@@ -373,25 +335,6 @@ async fn read_capped<R: AsyncRead + Unpin + Send + 'static>(
            break;
        }

-        if let Some(stream) = &stream {
-            let chunk = tmp[..n].to_vec();
-            let msg = EventMsg::ExecCommandOutputDelta(ExecCommandOutputDeltaEvent {
-                call_id: stream.call_id.clone(),
-                stream: if is_stderr {
-                    ExecOutputStream::Stderr
-                } else {
-                    ExecOutputStream::Stdout
-                },
-                chunk: ByteBuf::from(chunk),
-            });
-            let event = Event {
-                id: stream.sub_id.clone(),
-                msg,
-            };
-            #[allow(clippy::let_unit_value)]
-            let _ = stream.tx_event.send(event).await;
-        }
-
        // Copy into the buffer only while we still have byte and line budget.
        if remaining_bytes > 0 && remaining_lines > 0 {
            let mut copy_len = 0;
--- a/codex-rs/core/src/lib.rs
+++ b/codex-rs/core/src/lib.rs
@@ -38,14 +38,12 @@ pub mod plan_tool;
 mod project_doc;
 pub mod protocol;
 mod rollout;
-pub(crate) mod safety;
+mod safety;
 pub mod seatbelt;
 pub mod shell;
 pub mod spawn;
-pub mod turn_diff_tracker;
 mod user_notification;
 pub mod util;

 pub use apply_patch::CODEX_APPLY_PATCH_ARG1;
 pub use client_common::model_supports_reasoning_summaries;
-pub use safety::get_platform_sandbox;
--- a/codex-rs/core/src/models.rs
+++ b/codex-rs/core/src/models.rs
@@ -45,8 +45,6 @@ pub enum ResponseItem {
    Reasoning {
        id: String,
        summary: Vec<ReasoningItemReasoningSummary>,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        content: Option<Vec<ReasoningItemContent>>,
        encrypted_content: Option<String>,
    },
    LocalShellCall {
@@ -138,12 +136,6 @@ pub enum ReasoningItemReasoningSummary {
    SummaryText { text: String },
 }

-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type", rename_all = "snake_case")]
-pub enum ReasoningItemContent {
-    ReasoningText { text: String },
-}
-
 impl From<Vec<InputItem>> for ResponseInputItem {
    fn from(items: Vec<InputItem>) -> Self {
        Self::Message {
--- a/codex-rs/core/src/protocol.rs
+++ b/codex-rs/core/src/protocol.rs
@@ -13,7 +13,6 @@ use std::time::Duration;
 use mcp_types::CallToolResult;
 use serde::Deserialize;
 use serde::Serialize;
-use serde_bytes::ByteBuf;
 use strum_macros::Display;
 use uuid::Uuid;

@@ -180,29 +179,9 @@ pub enum SandboxPolicy {
        /// default.
        #[serde(default)]
        network_access: bool,
-
-        /// When set to `true`, will include defaults like the current working
-        /// directory and TMPDIR (on macOS). When `false`, only `writable_roots`
-        /// are used. (Mainly used for testing.)
-        #[serde(default = "default_true")]
-        include_default_writable_roots: bool,
    },
 }

-/// A writable root path accompanied by a list of subpaths that should remain
-/// read‑only even when the root is writable. This is primarily used to ensure
-/// top‑level VCS metadata directories (e.g. `.git`) under a writable root are
-/// not modified by the agent.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct WritableRoot {
-    pub root: PathBuf,
-    pub read_only_subpaths: Vec<PathBuf>,
-}
-
-fn default_true() -> bool {
-    true
-}
-
 impl FromStr for SandboxPolicy {
    type Err = serde_json::Error;

@@ -224,7 +203,6 @@ impl SandboxPolicy {
        SandboxPolicy::WorkspaceWrite {
            writable_roots: vec![],
            network_access: false,
-            include_default_writable_roots: true,
        }
    }

@@ -250,51 +228,27 @@ impl SandboxPolicy {
        }
    }

-    /// Returns the list of writable roots (tailored to the current working
-    /// directory) together with subpaths that should remain read‑only under
-    /// each writable root.
-    pub fn get_writable_roots_with_cwd(&self, cwd: &Path) -> Vec<WritableRoot> {
+    /// Returns the list of writable roots that should be passed down to the
+    /// Landlock rules installer, tailored to the current working directory.
+    pub fn get_writable_roots_with_cwd(&self, cwd: &Path) -> Vec<PathBuf> {
        match self {
            SandboxPolicy::DangerFullAccess => Vec::new(),
            SandboxPolicy::ReadOnly => Vec::new(),
-            SandboxPolicy::WorkspaceWrite {
-                writable_roots,
-                include_default_writable_roots,
-                ..
-            } => {
-                // Start from explicitly configured writable roots.
-                let mut roots: Vec<PathBuf> = writable_roots.clone();
+            SandboxPolicy::WorkspaceWrite { writable_roots, .. } => {
+                let mut roots = writable_roots.clone();
+                roots.push(cwd.to_path_buf());

-                // Optionally include defaults (cwd and TMPDIR on macOS).
-                if *include_default_writable_roots {
-                    roots.push(cwd.to_path_buf());
-
-                    // Also include the per-user tmp dir on macOS.
-                    // Note this is added dynamically rather than storing it in
-                    // `writable_roots` because `writable_roots` contains only static
-                    // values deserialized from the config file.
-                    if cfg!(target_os = "macos") {
-                        if let Some(tmpdir) = std::env::var_os("TMPDIR") {
-                            roots.push(PathBuf::from(tmpdir));
-                        }
+                // Also include the per-user tmp dir on macOS.
+                // Note this is added dynamically rather than storing it in
+                // writable_roots because writable_roots contains only static
+                // values deserialized from the config file.
+                if cfg!(target_os = "macos") {
+                    if let Some(tmpdir) = std::env::var_os("TMPDIR") {
+                        roots.push(PathBuf::from(tmpdir));
                    }
                }

-                // For each root, compute subpaths that should remain read-only.
                roots
-                    .into_iter()
-                    .map(|writable_root| {
-                        let mut subpaths = Vec::new();
-                        let top_level_git = writable_root.join(".git");
-                        if top_level_git.is_dir() {
-                            subpaths.push(top_level_git);
-                        }
-                        WritableRoot {
-                            root: writable_root,
-                            read_only_subpaths: subpaths,
-                        }
-                    })
-                    .collect()
            }
        }
    }
@@ -359,9 +313,6 @@ pub enum EventMsg {
    /// Agent reasoning delta event from agent.
    AgentReasoningDelta(AgentReasoningDeltaEvent),

-    /// Raw chain-of-thought from agent.
-    AgentReasoningContent(AgentReasoningContentEvent),
-
    /// Ack the client's configure message.
    SessionConfigured(SessionConfiguredEvent),

@@ -372,9 +323,6 @@ pub enum EventMsg {
    /// Notification that the server is about to execute a command.
    ExecCommandBegin(ExecCommandBeginEvent),

-    /// Incremental chunk of output from a running command.
-    ExecCommandOutputDelta(ExecCommandOutputDeltaEvent),
-
    ExecCommandEnd(ExecCommandEndEvent),

    ExecApprovalRequest(ExecApprovalRequestEvent),
@@ -390,8 +338,6 @@ pub enum EventMsg {
    /// Notification that a patch application has finished.
    PatchApplyEnd(PatchApplyEndEvent),

-    TurnDiff(TurnDiffEvent),
-
    /// Response to GetHistoryEntryRequest.
    GetHistoryEntryResponse(GetHistoryEntryResponseEvent),

@@ -467,11 +413,6 @@ pub struct AgentReasoningEvent {
    pub text: String,
 }

-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AgentReasoningContentEvent {
-    pub text: String,
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AgentReasoningDeltaEvent {
    pub delta: String,
@@ -533,26 +474,6 @@ pub struct ExecCommandEndEvent {
    pub stderr: String,
    /// The command's exit code.
    pub exit_code: i32,
-    /// The duration of the command execution.
-    pub duration: Duration,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ExecOutputStream {
-    Stdout,
-    Stderr,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ExecCommandOutputDeltaEvent {
-    /// Identifier for the ExecCommandBegin that produced this chunk.
-    pub call_id: String,
-    /// Which stream produced this chunk.
-    pub stream: ExecOutputStream,
-    /// Raw bytes from the stream (may not be valid UTF-8).
-    #[serde(with = "serde_bytes")]
-    pub chunk: ByteBuf,
 }

 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -608,11 +529,6 @@ pub struct PatchApplyEndEvent {
    pub success: bool,
 }

-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct TurnDiffEvent {
-    pub unified_diff: String,
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct GetHistoryEntryResponseEvent {
    pub offset: usize,
--- a/codex-rs/core/src/seatbelt.rs
+++ b/codex-rs/core/src/seatbelt.rs
@@ -4,7 +4,6 @@ use std::path::PathBuf;
 use tokio::process::Child;

 use crate::protocol::SandboxPolicy;
-use crate::spawn::CODEX_SANDBOX_ENV_VAR;
 use crate::spawn::StdioPolicy;
 use crate::spawn::spawn_child_async;

@@ -21,11 +20,10 @@ pub async fn spawn_command_under_seatbelt(
    sandbox_policy: &SandboxPolicy,
    cwd: PathBuf,
    stdio_policy: StdioPolicy,
-    mut env: HashMap<String, String>,
+    env: HashMap<String, String>,
 ) -> std::io::Result<Child> {
    let args = create_seatbelt_command_args(command, sandbox_policy, &cwd);
    let arg0 = None;
-    env.insert(CODEX_SANDBOX_ENV_VAR.to_string(), "seatbelt".to_string());
    spawn_child_async(
        PathBuf::from(MACOS_PATH_TO_SEATBELT_EXECUTABLE),
        args,
@@ -52,38 +50,16 @@ fn create_seatbelt_command_args(
            )
        } else {
            let writable_roots = sandbox_policy.get_writable_roots_with_cwd(cwd);
-
-            let mut writable_folder_policies: Vec<String> = Vec::new();
-            let mut cli_args: Vec<String> = Vec::new();
-
-            for (index, wr) in writable_roots.iter().enumerate() {
-                // Canonicalize to avoid mismatches like /var vs /private/var on macOS.
-                let canonical_root = wr.root.canonicalize().unwrap_or_else(|_| wr.root.clone());
-                let root_param = format!("WRITABLE_ROOT_{index}");
-                cli_args.push(format!(
-                    "-D{root_param}={}",
-                    canonical_root.to_string_lossy()
-                ));
-
-                if wr.read_only_subpaths.is_empty() {
-                    writable_folder_policies.push(format!("(subpath (param \"{root_param}\"))"));
-                } else {
-                    // Add parameters for each read-only subpath and generate
-                    // the `(require-not ...)` clauses.
-                    let mut require_parts: Vec<String> = Vec::new();
-                    require_parts.push(format!("(subpath (param \"{root_param}\"))"));
-                    for (subpath_index, ro) in wr.read_only_subpaths.iter().enumerate() {
-                        let canonical_ro = ro.canonicalize().unwrap_or_else(|_| ro.clone());
-                        let ro_param = format!("WRITABLE_ROOT_{index}_RO_{subpath_index}");
-                        cli_args.push(format!("-D{ro_param}={}", canonical_ro.to_string_lossy()));
-                        require_parts
-                            .push(format!("(require-not (subpath (param \"{ro_param}\")))"));
-                    }
-                    let policy_component = format!("(require-all {} )", require_parts.join(" "));
-                    writable_folder_policies.push(policy_component);
-                }
-            }
-
+            let (writable_folder_policies, cli_args): (Vec<String>, Vec<String>) = writable_roots
+                .iter()
+                .enumerate()
+                .map(|(index, root)| {
+                    let param_name = format!("WRITABLE_ROOT_{index}");
+                    let policy: String = format!("(subpath (param \"{param_name}\"))");
+                    let cli_arg = format!("-D{param_name}={}", root.to_string_lossy());
+                    (policy, cli_arg)
+                })
+                .unzip();
            if writable_folder_policies.is_empty() {
                ("".to_string(), Vec::<String>::new())
            } else {
@@ -112,201 +88,9 @@ fn create_seatbelt_command_args(
    let full_policy = format!(
        "{MACOS_SEATBELT_BASE_POLICY}\n{file_read_policy}\n{file_write_policy}\n{network_policy}"
    );
-
    let mut seatbelt_args: Vec<String> = vec!["-p".to_string(), full_policy];
    seatbelt_args.extend(extra_cli_args);
    seatbelt_args.push("--".to_string());
    seatbelt_args.extend(command);
    seatbelt_args
 }
-
-#[cfg(test)]
-mod tests {
-    #![expect(clippy::expect_used)]
-    use super::MACOS_SEATBELT_BASE_POLICY;
-    use super::create_seatbelt_command_args;
-    use crate::protocol::SandboxPolicy;
-    use pretty_assertions::assert_eq;
-    use std::fs;
-    use std::path::Path;
-    use std::path::PathBuf;
-    use tempfile::TempDir;
-
-    #[test]
-    fn create_seatbelt_args_with_read_only_git_subpath() {
-        // Create a temporary workspace with two writable roots: one containing
-        // a top-level .git directory and one without it.
-        let tmp = TempDir::new().expect("tempdir");
-        let PopulatedTmp {
-            root_with_git,
-            root_without_git,
-            root_with_git_canon,
-            root_with_git_git_canon,
-            root_without_git_canon,
-        } = populate_tmpdir(tmp.path());
-
-        // Build a policy that only includes the two test roots as writable and
-        // does not automatically include defaults like cwd or TMPDIR.
-        let policy = SandboxPolicy::WorkspaceWrite {
-            writable_roots: vec![root_with_git.clone(), root_without_git.clone()],
-            network_access: false,
-            include_default_writable_roots: false,
-        };
-
-        let args = create_seatbelt_command_args(
-            vec!["/bin/echo".to_string(), "hello".to_string()],
-            &policy,
-            tmp.path(),
-        );
-
-        // Build the expected policy text using a raw string for readability.
-        // Note that the policy includes:
-        // - the base policy,
-        // - read-only access to the filesystem,
-        // - write access to WRITABLE_ROOT_0 (but not its .git) and WRITABLE_ROOT_1.
-        let expected_policy = format!(
-            r#"{MACOS_SEATBELT_BASE_POLICY}
-; allow read-only file operations
-(allow file-read*)
-(allow file-write*
-(require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) ) (subpath (param "WRITABLE_ROOT_1"))
-)
-"#,
-        );
-
-        let expected_args = vec![
-            "-p".to_string(),
-            expected_policy,
-            format!(
-                "-DWRITABLE_ROOT_0={}",
-                root_with_git_canon.to_string_lossy()
-            ),
-            format!(
-                "-DWRITABLE_ROOT_0_RO_0={}",
-                root_with_git_git_canon.to_string_lossy()
-            ),
-            format!(
-                "-DWRITABLE_ROOT_1={}",
-                root_without_git_canon.to_string_lossy()
-            ),
-            "--".to_string(),
-            "/bin/echo".to_string(),
-            "hello".to_string(),
-        ];
-
-        assert_eq!(args, expected_args);
-    }
-
-    #[test]
-    fn create_seatbelt_args_for_cwd_as_git_repo() {
-        // Create a temporary workspace with two writable roots: one containing
-        // a top-level .git directory and one without it.
-        let tmp = TempDir::new().expect("tempdir");
-        let PopulatedTmp {
-            root_with_git,
-            root_with_git_canon,
-            root_with_git_git_canon,
-            ..
-        } = populate_tmpdir(tmp.path());
-
-        // Build a policy that does not specify any writable_roots, but does
-        // use the default ones (cwd and TMPDIR) and verifies the `.git` check
-        // is done properly for cwd.
-        let policy = SandboxPolicy::WorkspaceWrite {
-            writable_roots: vec![],
-            network_access: false,
-            include_default_writable_roots: true,
-        };
-
-        let args = create_seatbelt_command_args(
-            vec!["/bin/echo".to_string(), "hello".to_string()],
-            &policy,
-            root_with_git.as_path(),
-        );
-
-        let tmpdir_env_var = if cfg!(target_os = "macos") {
-            std::env::var("TMPDIR")
-                .ok()
-                .map(PathBuf::from)
-                .and_then(|p| p.canonicalize().ok())
-                .map(|p| p.to_string_lossy().to_string())
-        } else {
-            None
-        };
-        let tempdir_policy_entry = if tmpdir_env_var.is_some() {
-            " (subpath (param \"WRITABLE_ROOT_1\"))"
-        } else {
-            ""
-        };
-
-        // Build the expected policy text using a raw string for readability.
-        // Note that the policy includes:
-        // - the base policy,
-        // - read-only access to the filesystem,
-        // - write access to WRITABLE_ROOT_0 (but not its .git) and WRITABLE_ROOT_1.
-        let expected_policy = format!(
-            r#"{MACOS_SEATBELT_BASE_POLICY}
-; allow read-only file operations
-(allow file-read*)
-(allow file-write*
-(require-all (subpath (param "WRITABLE_ROOT_0")) (require-not (subpath (param "WRITABLE_ROOT_0_RO_0"))) ){tempdir_policy_entry}
-)
-"#,
-        );
-
-        let mut expected_args = vec![
-            "-p".to_string(),
-            expected_policy,
-            format!(
-                "-DWRITABLE_ROOT_0={}",
-                root_with_git_canon.to_string_lossy()
-            ),
-            format!(
-                "-DWRITABLE_ROOT_0_RO_0={}",
-                root_with_git_git_canon.to_string_lossy()
-            ),
-        ];
-
-        if let Some(p) = tmpdir_env_var {
-            expected_args.push(format!("-DWRITABLE_ROOT_1={p}"));
-        }
-
-        expected_args.extend(vec![
-            "--".to_string(),
-            "/bin/echo".to_string(),
-            "hello".to_string(),
-        ]);
-
-        assert_eq!(args, expected_args);
-    }
-
-    struct PopulatedTmp {
-        root_with_git: PathBuf,
-        root_without_git: PathBuf,
-        root_with_git_canon: PathBuf,
-        root_with_git_git_canon: PathBuf,
-        root_without_git_canon: PathBuf,
-    }
-
-    fn populate_tmpdir(tmp: &Path) -> PopulatedTmp {
-        let root_with_git = tmp.join("with_git");
-        let root_without_git = tmp.join("no_git");
-        fs::create_dir_all(&root_with_git).expect("create with_git");
-        fs::create_dir_all(&root_without_git).expect("create no_git");
-        fs::create_dir_all(root_with_git.join(".git")).expect("create .git");
-
-        // Ensure we have canonical paths for -D parameter matching.
-        let root_with_git_canon = root_with_git.canonicalize().expect("canonicalize with_git");
-        let root_with_git_git_canon = root_with_git_canon.join(".git");
-        let root_without_git_canon = root_without_git
-            .canonicalize()
-            .expect("canonicalize no_git");
-        PopulatedTmp {
-            root_with_git,
-            root_without_git,
-            root_with_git_canon,
-            root_with_git_git_canon,
-            root_without_git_canon,
-        }
-    }
-}
--- a/codex-rs/core/src/seatbelt_base_policy.sbpl
+++ b/codex-rs/core/src/seatbelt_base_policy.sbpl
@@ -65,7 +65,3 @@
  (sysctl-name "sysctl.proc_cputype")
  (sysctl-name-prefix "hw.perflevel")
 )
-
-; Added on top of Chrome profile
-; Needed for python multiprocessing on MacOS for the SemLock
-(allow ipc-posix-sem)
--- a/codex-rs/core/src/shell.rs
+++ b/codex-rs/core/src/shell.rs
@@ -220,7 +220,6 @@ mod tests {
                Arc::new(Notify::new()),
                &SandboxPolicy::DangerFullAccess,
                &None,
-                None,
            )
            .await
            .unwrap();
--- a/codex-rs/core/src/spawn.rs
+++ b/codex-rs/core/src/spawn.rs
@@ -17,11 +17,6 @@ use crate::protocol::SandboxPolicy;
 /// attributes, so this may change in the future.
 pub const CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR: &str = "CODEX_SANDBOX_NETWORK_DISABLED";

-/// Should be set when the process is spawned under a sandbox. Currently, the
-/// value is "seatbelt" for macOS, but it may change in the future to
-/// accommodate sandboxing configuration and other sandboxing mechanisms.
-pub const CODEX_SANDBOX_ENV_VAR: &str = "CODEX_SANDBOX";
-
 #[derive(Debug, Clone, Copy)]
 pub enum StdioPolicy {
    RedirectForShellTool,
--- a/codex-rs/core/src/turn_diff_tracker.rs
+++ b/codex-rs/core/src/turn_diff_tracker.rs
@@ -1,887 +0,0 @@
-use std::collections::HashMap;
-use std::fs;
-use std::path::Path;
-use std::path::PathBuf;
-use std::process::Command;
-
-use anyhow::Context;
-use anyhow::Result;
-use anyhow::anyhow;
-use sha1::digest::Output;
-use uuid::Uuid;
-
-use crate::protocol::FileChange;
-
-const ZERO_OID: &str = "0000000000000000000000000000000000000000";
-const DEV_NULL: &str = "/dev/null";
-
-struct BaselineFileInfo {
-    path: PathBuf,
-    content: Vec<u8>,
-    mode: FileMode,
-    oid: String,
-}
-
-/// Tracks sets of changes to files and exposes the overall unified diff.
-/// Internally, the way this works is now:
-/// 1. Maintain an in-memory baseline snapshot of files when they are first seen.
-///    For new additions, do not create a baseline so that diffs are shown as proper additions (using /dev/null).
-/// 2. Keep a stable internal filename (uuid) per external path for rename tracking.
-/// 3. To compute the aggregated unified diff, compare each baseline snapshot to the current file on disk entirely in-memory
-///    using the `similar` crate and emit unified diffs with rewritten external paths.
-#[derive(Default)]
-pub struct TurnDiffTracker {
-    /// Map external path -> internal filename (uuid).
-    external_to_temp_name: HashMap<PathBuf, String>,
-    /// Internal filename -> baseline file info.
-    baseline_file_info: HashMap<String, BaselineFileInfo>,
-    /// Internal filename -> external path as of current accumulated state (after applying all changes).
-    /// This is where renames are tracked.
-    temp_name_to_current_path: HashMap<String, PathBuf>,
-    /// Cache of known git worktree roots to avoid repeated filesystem walks.
-    git_root_cache: Vec<PathBuf>,
-}
-
-impl TurnDiffTracker {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Front-run apply patch calls to track the starting contents of any modified files.
-    /// - Creates an in-memory baseline snapshot for files that already exist on disk when first seen.
-    /// - For additions, we intentionally do not create a baseline snapshot so that diffs are proper additions.
-    /// - Also updates internal mappings for move/rename events.
-    pub fn on_patch_begin(&mut self, changes: &HashMap<PathBuf, FileChange>) {
-        for (path, change) in changes.iter() {
-            // Ensure a stable internal filename exists for this external path.
-            if !self.external_to_temp_name.contains_key(path) {
-                let internal = Uuid::new_v4().to_string();
-                self.external_to_temp_name
-                    .insert(path.clone(), internal.clone());
-                self.temp_name_to_current_path
-                    .insert(internal.clone(), path.clone());
-
-                // If the file exists on disk now, snapshot as baseline; else leave missing to represent /dev/null.
-                let baseline_file_info = if path.exists() {
-                    let mode = file_mode_for_path(path);
-                    let mode_val = mode.unwrap_or(FileMode::Regular);
-                    let content = blob_bytes(path, &mode_val).unwrap_or_default();
-                    let oid = if mode == Some(FileMode::Symlink) {
-                        format!("{:x}", git_blob_sha1_hex_bytes(&content))
-                    } else {
-                        self.git_blob_oid_for_path(path)
-                            .unwrap_or_else(|| format!("{:x}", git_blob_sha1_hex_bytes(&content)))
-                    };
-                    Some(BaselineFileInfo {
-                        path: path.clone(),
-                        content,
-                        mode: mode_val,
-                        oid,
-                    })
-                } else {
-                    Some(BaselineFileInfo {
-                        path: path.clone(),
-                        content: vec![],
-                        mode: FileMode::Regular,
-                        oid: ZERO_OID.to_string(),
-                    })
-                };
-
-                if let Some(baseline_file_info) = baseline_file_info {
-                    self.baseline_file_info
-                        .insert(internal.clone(), baseline_file_info);
-                }
-            }
-
-            // Track rename/move in current mapping if provided in an Update.
-            if let FileChange::Update {
-                move_path: Some(dest),
-                ..
-            } = change
-            {
-                let uuid_filename = match self.external_to_temp_name.get(path) {
-                    Some(i) => i.clone(),
-                    None => {
-                        // This should be rare, but if we haven't mapped the source, create it with no baseline.
-                        let i = Uuid::new_v4().to_string();
-                        self.baseline_file_info.insert(
-                            i.clone(),
-                            BaselineFileInfo {
-                                path: path.clone(),
-                                content: vec![],
-                                mode: FileMode::Regular,
-                                oid: ZERO_OID.to_string(),
-                            },
-                        );
-                        i
-                    }
-                };
-                // Update current external mapping for temp file name.
-                self.temp_name_to_current_path
-                    .insert(uuid_filename.clone(), dest.clone());
-                // Update forward file_mapping: external current -> internal name.
-                self.external_to_temp_name.remove(path);
-                self.external_to_temp_name
-                    .insert(dest.clone(), uuid_filename);
-            };
-        }
-    }
-
-    fn get_path_for_internal(&self, internal: &str) -> Option<PathBuf> {
-        self.temp_name_to_current_path
-            .get(internal)
-            .cloned()
-            .or_else(|| {
-                self.baseline_file_info
-                    .get(internal)
-                    .map(|info| info.path.clone())
-            })
-    }
-
-    /// Find the git worktree root for a file/directory by walking up to the first ancestor containing a `.git` entry.
-    /// Uses a simple cache of known roots and avoids negative-result caching for simplicity.
-    fn find_git_root_cached(&mut self, start: &Path) -> Option<PathBuf> {
-        let dir = if start.is_dir() {
-            start
-        } else {
-            start.parent()?
-        };
-
-        // Fast path: if any cached root is an ancestor of this path, use it.
-        if let Some(root) = self
-            .git_root_cache
-            .iter()
-            .find(|r| dir.starts_with(r))
-            .cloned()
-        {
-            return Some(root);
-        }
-
-        // Walk up to find a `.git` marker.
-        let mut cur = dir.to_path_buf();
-        loop {
-            let git_marker = cur.join(".git");
-            if git_marker.is_dir() || git_marker.is_file() {
-                if !self.git_root_cache.iter().any(|r| r == &cur) {
-                    self.git_root_cache.push(cur.clone());
-                }
-                return Some(cur);
-            }
-
-            // On Windows, avoid walking above the drive or UNC share root.
-            #[cfg(windows)]
-            {
-                if is_windows_drive_or_unc_root(&cur) {
-                    return None;
-                }
-            }
-
-            if let Some(parent) = cur.parent() {
-                cur = parent.to_path_buf();
-            } else {
-                return None;
-            }
-        }
-    }
-
-    /// Return a display string for `path` relative to its git root if found, else absolute.
-    fn relative_to_git_root_str(&mut self, path: &Path) -> String {
-        let s = if let Some(root) = self.find_git_root_cached(path) {
-            if let Ok(rel) = path.strip_prefix(&root) {
-                rel.display().to_string()
-            } else {
-                path.display().to_string()
-            }
-        } else {
-            path.display().to_string()
-        };
-        s.replace('\\', "/")
-    }
-
-    /// Ask git to compute the blob SHA-1 for the file at `path` within its repository.
-    /// Returns None if no repository is found or git invocation fails.
-    fn git_blob_oid_for_path(&mut self, path: &Path) -> Option<String> {
-        let root = self.find_git_root_cached(path)?;
-        // Compute a path relative to the repo root for better portability across platforms.
-        let rel = path.strip_prefix(&root).unwrap_or(path);
-        let output = Command::new("git")
-            .arg("-C")
-            .arg(&root)
-            .arg("hash-object")
-            .arg("--")
-            .arg(rel)
-            .output()
-            .ok()?;
-        if !output.status.success() {
-            return None;
-        }
-        let s = String::from_utf8_lossy(&output.stdout).trim().to_string();
-        if s.len() == 40 { Some(s) } else { None }
-    }
-
-    /// Recompute the aggregated unified diff by comparing all of the in-memory snapshots that were
-    /// collected before the first time they were touched by apply_patch during this turn with
-    /// the current repo state.
-    pub fn get_unified_diff(&mut self) -> Result<Option<String>> {
-        let mut aggregated = String::new();
-
-        // Compute diffs per tracked internal file in a stable order by external path.
-        let mut baseline_file_names: Vec<String> =
-            self.baseline_file_info.keys().cloned().collect();
-        // Sort lexicographically by full repo-relative path to match git behavior.
-        baseline_file_names.sort_by_key(|internal| {
-            self.get_path_for_internal(internal)
-                .map(|p| self.relative_to_git_root_str(&p))
-                .unwrap_or_default()
-        });
-
-        for internal in baseline_file_names {
-            aggregated.push_str(self.get_file_diff(&internal).as_str());
-            if !aggregated.ends_with('\n') {
-                aggregated.push('\n');
-            }
-        }
-
-        if aggregated.trim().is_empty() {
-            Ok(None)
-        } else {
-            Ok(Some(aggregated))
-        }
-    }
-
-    fn get_file_diff(&mut self, internal_file_name: &str) -> String {
-        let mut aggregated = String::new();
-
-        // Snapshot lightweight fields only.
-        let (baseline_external_path, baseline_mode, left_oid) = {
-            if let Some(info) = self.baseline_file_info.get(internal_file_name) {
-                (info.path.clone(), info.mode, info.oid.clone())
-            } else {
-                (PathBuf::new(), FileMode::Regular, ZERO_OID.to_string())
-            }
-        };
-        let current_external_path = match self.get_path_for_internal(internal_file_name) {
-            Some(p) => p,
-            None => return aggregated,
-        };
-
-        let current_mode = file_mode_for_path(&current_external_path).unwrap_or(FileMode::Regular);
-        let right_bytes = blob_bytes(&current_external_path, &current_mode);
-
-        // Compute displays with &mut self before borrowing any baseline content.
-        let left_display = self.relative_to_git_root_str(&baseline_external_path);
-        let right_display = self.relative_to_git_root_str(&current_external_path);
-
-        // Compute right oid before borrowing baseline content.
-        let right_oid = if let Some(b) = right_bytes.as_ref() {
-            if current_mode == FileMode::Symlink {
-                format!("{:x}", git_blob_sha1_hex_bytes(b))
-            } else {
-                self.git_blob_oid_for_path(&current_external_path)
-                    .unwrap_or_else(|| format!("{:x}", git_blob_sha1_hex_bytes(b)))
-            }
-        } else {
-            ZERO_OID.to_string()
-        };
-
-        // Borrow baseline content only after all &mut self uses are done.
-        let left_present = left_oid.as_str() != ZERO_OID;
-        let left_bytes: Option<&[u8]> = if left_present {
-            self.baseline_file_info
-                .get(internal_file_name)
-                .map(|i| i.content.as_slice())
-        } else {
-            None
-        };
-
-        // Fast path: identical bytes or both missing.
-        if left_bytes == right_bytes.as_deref() {
-            return aggregated;
-        }
-
-        aggregated.push_str(&format!("diff --git a/{left_display} b/{right_display}\n"));
-
-        let is_add = !left_present && right_bytes.is_some();
-        let is_delete = left_present && right_bytes.is_none();
-
-        if is_add {
-            aggregated.push_str(&format!("new file mode {current_mode}\n"));
-        } else if is_delete {
-            aggregated.push_str(&format!("deleted file mode {baseline_mode}\n"));
-        } else if baseline_mode != current_mode {
-            aggregated.push_str(&format!("old mode {baseline_mode}\n"));
-            aggregated.push_str(&format!("new mode {current_mode}\n"));
-        }
-
-        let left_text = left_bytes.and_then(|b| std::str::from_utf8(b).ok());
-        let right_text = right_bytes
-            .as_deref()
-            .and_then(|b| std::str::from_utf8(b).ok());
-
-        let can_text_diff = matches!(
-            (left_text, right_text, is_add, is_delete),
-            (Some(_), Some(_), _, _) | (_, Some(_), true, _) | (Some(_), _, _, true)
-        );
-
-        if can_text_diff {
-            let l = left_text.unwrap_or("");
-            let r = right_text.unwrap_or("");
-
-            aggregated.push_str(&format!("index {left_oid}..{right_oid}\n"));
-
-            let old_header = if left_present {
-                format!("a/{left_display}")
-            } else {
-                DEV_NULL.to_string()
-            };
-            let new_header = if right_bytes.is_some() {
-                format!("b/{right_display}")
-            } else {
-                DEV_NULL.to_string()
-            };
-
-            let diff = similar::TextDiff::from_lines(l, r);
-            let unified = diff
-                .unified_diff()
-                .context_radius(3)
-                .header(&old_header, &new_header)
-                .to_string();
-
-            aggregated.push_str(&unified);
-        } else {
-            aggregated.push_str(&format!("index {left_oid}..{right_oid}\n"));
-            let old_header = if left_present {
-                format!("a/{left_display}")
-            } else {
-                DEV_NULL.to_string()
-            };
-            let new_header = if right_bytes.is_some() {
-                format!("b/{right_display}")
-            } else {
-                DEV_NULL.to_string()
-            };
-            aggregated.push_str(&format!("--- {old_header}\n"));
-            aggregated.push_str(&format!("+++ {new_header}\n"));
-            aggregated.push_str("Binary files differ\n");
-        }
-        aggregated
-    }
-}
-
-/// Compute the Git SHA-1 blob object ID for the given content (bytes).
-fn git_blob_sha1_hex_bytes(data: &[u8]) -> Output<sha1::Sha1> {
-    // Git blob hash is sha1 of: "blob <len>\0<data>"
-    let header = format!("blob {}\0", data.len());
-    use sha1::Digest;
-    let mut hasher = sha1::Sha1::new();
-    hasher.update(header.as_bytes());
-    hasher.update(data);
-    hasher.finalize()
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum FileMode {
-    Regular,
-    #[cfg(unix)]
-    Executable,
-    Symlink,
-}
-
-impl FileMode {
-    fn as_str(&self) -> &'static str {
-        match self {
-            FileMode::Regular => "100644",
-            #[cfg(unix)]
-            FileMode::Executable => "100755",
-            FileMode::Symlink => "120000",
-        }
-    }
-}
-
-impl std::fmt::Display for FileMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-#[cfg(unix)]
-fn file_mode_for_path(path: &Path) -> Option<FileMode> {
-    use std::os::unix::fs::PermissionsExt;
-    let meta = fs::symlink_metadata(path).ok()?;
-    let ft = meta.file_type();
-    if ft.is_symlink() {
-        return Some(FileMode::Symlink);
-    }
-    let mode = meta.permissions().mode();
-    let is_exec = (mode & 0o111) != 0;
-    Some(if is_exec {
-        FileMode::Executable
-    } else {
-        FileMode::Regular
-    })
-}
-
-#[cfg(not(unix))]
-fn file_mode_for_path(_path: &Path) -> Option<FileMode> {
-    // Default to non-executable on non-unix.
-    Some(FileMode::Regular)
-}
-
-fn blob_bytes(path: &Path, mode: &FileMode) -> Option<Vec<u8>> {
-    if path.exists() {
-        let contents = if *mode == FileMode::Symlink {
-            symlink_blob_bytes(path)
-                .ok_or_else(|| anyhow!("failed to read symlink target for {}", path.display()))
-        } else {
-            fs::read(path)
-                .with_context(|| format!("failed to read current file for diff {}", path.display()))
-        };
-        contents.ok()
-    } else {
-        None
-    }
-}
-
-#[cfg(unix)]
-fn symlink_blob_bytes(path: &Path) -> Option<Vec<u8>> {
-    use std::os::unix::ffi::OsStrExt;
-    let target = std::fs::read_link(path).ok()?;
-    Some(target.as_os_str().as_bytes().to_vec())
-}
-
-#[cfg(not(unix))]
-fn symlink_blob_bytes(_path: &Path) -> Option<Vec<u8>> {
-    None
-}
-
-#[cfg(windows)]
-fn is_windows_drive_or_unc_root(p: &std::path::Path) -> bool {
-    use std::path::Component;
-    let mut comps = p.components();
-    matches!(
-        (comps.next(), comps.next(), comps.next()),
-        (Some(Component::Prefix(_)), Some(Component::RootDir), None)
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used)]
-    use super::*;
-    use pretty_assertions::assert_eq;
-    use tempfile::tempdir;
-
-    /// Compute the Git SHA-1 blob object ID for the given content (string).
-    /// This delegates to the bytes version to avoid UTF-8 lossy conversions here.
-    fn git_blob_sha1_hex(data: &str) -> String {
-        format!("{:x}", git_blob_sha1_hex_bytes(data.as_bytes()))
-    }
-
-    fn normalize_diff_for_test(input: &str, root: &Path) -> String {
-        let root_str = root.display().to_string().replace('\\', "/");
-        let replaced = input.replace(&root_str, "<TMP>");
-        // Split into blocks on lines starting with "diff --git ", sort blocks for determinism, and rejoin
-        let mut blocks: Vec<String> = Vec::new();
-        let mut current = String::new();
-        for line in replaced.lines() {
-            if line.starts_with("diff --git ") && !current.is_empty() {
-                blocks.push(current);
-                current = String::new();
-            }
-            if !current.is_empty() {
-                current.push('\n');
-            }
-            current.push_str(line);
-        }
-        if !current.is_empty() {
-            blocks.push(current);
-        }
-        blocks.sort();
-        let mut out = blocks.join("\n");
-        if !out.ends_with('\n') {
-            out.push('\n');
-        }
-        out
-    }
-
-    #[test]
-    fn accumulates_add_and_update() {
-        let mut acc = TurnDiffTracker::new();
-
-        let dir = tempdir().unwrap();
-        let file = dir.path().join("a.txt");
-
-        // First patch: add file (baseline should be /dev/null).
-        let add_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Add {
-                content: "foo\n".to_string(),
-            },
-        )]);
-        acc.on_patch_begin(&add_changes);
-
-        // Simulate apply: create the file on disk.
-        fs::write(&file, "foo\n").unwrap();
-        let first = acc.get_unified_diff().unwrap().unwrap();
-        let first = normalize_diff_for_test(&first, dir.path());
-        let expected_first = {
-            let mode = file_mode_for_path(&file).unwrap_or(FileMode::Regular);
-            let right_oid = git_blob_sha1_hex("foo\n");
-            format!(
-                r#"diff --git a/<TMP>/a.txt b/<TMP>/a.txt
-new file mode {mode}
-index {ZERO_OID}..{right_oid}
--- {DEV_NULL}
-+++ b/<TMP>/a.txt
-@@ -0,0 +1 @@
-+foo
-"#,
-            )
-        };
-        assert_eq!(first, expected_first);
-
-        // Second patch: update the file on disk.
-        let update_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: None,
-            },
-        )]);
-        acc.on_patch_begin(&update_changes);
-
-        // Simulate apply: append a new line.
-        fs::write(&file, "foo\nbar\n").unwrap();
-        let combined = acc.get_unified_diff().unwrap().unwrap();
-        let combined = normalize_diff_for_test(&combined, dir.path());
-        let expected_combined = {
-            let mode = file_mode_for_path(&file).unwrap_or(FileMode::Regular);
-            let right_oid = git_blob_sha1_hex("foo\nbar\n");
-            format!(
-                r#"diff --git a/<TMP>/a.txt b/<TMP>/a.txt
-new file mode {mode}
-index {ZERO_OID}..{right_oid}
--- {DEV_NULL}
-+++ b/<TMP>/a.txt
-@@ -0,0 +1,2 @@
-+foo
-+bar
-"#,
-            )
-        };
-        assert_eq!(combined, expected_combined);
-    }
-
-    #[test]
-    fn accumulates_delete() {
-        let dir = tempdir().unwrap();
-        let file = dir.path().join("b.txt");
-        fs::write(&file, "x\n").unwrap();
-
-        let mut acc = TurnDiffTracker::new();
-        let del_changes = HashMap::from([(file.clone(), FileChange::Delete)]);
-        acc.on_patch_begin(&del_changes);
-
-        // Simulate apply: delete the file from disk.
-        let baseline_mode = file_mode_for_path(&file).unwrap_or(FileMode::Regular);
-        fs::remove_file(&file).unwrap();
-        let diff = acc.get_unified_diff().unwrap().unwrap();
-        let diff = normalize_diff_for_test(&diff, dir.path());
-        let expected = {
-            let left_oid = git_blob_sha1_hex("x\n");
-            format!(
-                r#"diff --git a/<TMP>/b.txt b/<TMP>/b.txt
-deleted file mode {baseline_mode}
-index {left_oid}..{ZERO_OID}
--- a/<TMP>/b.txt
-+++ {DEV_NULL}
-@@ -1 +0,0 @@
-x
-"#,
-            )
-        };
-        assert_eq!(diff, expected);
-    }
-
-    #[test]
-    fn accumulates_move_and_update() {
-        let dir = tempdir().unwrap();
-        let src = dir.path().join("src.txt");
-        let dest = dir.path().join("dst.txt");
-        fs::write(&src, "line\n").unwrap();
-
-        let mut acc = TurnDiffTracker::new();
-        let mv_changes = HashMap::from([(
-            src.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: Some(dest.clone()),
-            },
-        )]);
-        acc.on_patch_begin(&mv_changes);
-
-        // Simulate apply: move and update content.
-        fs::rename(&src, &dest).unwrap();
-        fs::write(&dest, "line2\n").unwrap();
-
-        let out = acc.get_unified_diff().unwrap().unwrap();
-        let out = normalize_diff_for_test(&out, dir.path());
-        let expected = {
-            let left_oid = git_blob_sha1_hex("line\n");
-            let right_oid = git_blob_sha1_hex("line2\n");
-            format!(
-                r#"diff --git a/<TMP>/src.txt b/<TMP>/dst.txt
-index {left_oid}..{right_oid}
--- a/<TMP>/src.txt
-+++ b/<TMP>/dst.txt
-@@ -1 +1 @@
-line
-+line2
-"#
-            )
-        };
-        assert_eq!(out, expected);
-    }
-
-    #[test]
-    fn move_without_1change_yields_no_diff() {
-        let dir = tempdir().unwrap();
-        let src = dir.path().join("moved.txt");
-        let dest = dir.path().join("renamed.txt");
-        fs::write(&src, "same\n").unwrap();
-
-        let mut acc = TurnDiffTracker::new();
-        let mv_changes = HashMap::from([(
-            src.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: Some(dest.clone()),
-            },
-        )]);
-        acc.on_patch_begin(&mv_changes);
-
-        // Simulate apply: move only, no content change.
-        fs::rename(&src, &dest).unwrap();
-
-        let diff = acc.get_unified_diff().unwrap();
-        assert_eq!(diff, None);
-    }
-
-    #[test]
-    fn move_declared_but_file_only_appears_at_dest_is_add() {
-        let dir = tempdir().unwrap();
-        let src = dir.path().join("src.txt");
-        let dest = dir.path().join("dest.txt");
-        let mut acc = TurnDiffTracker::new();
-        let mv = HashMap::from([(
-            src.clone(),
-            FileChange::Update {
-                unified_diff: "".into(),
-                move_path: Some(dest.clone()),
-            },
-        )]);
-        acc.on_patch_begin(&mv);
-        // No file existed initially; create only dest
-        fs::write(&dest, "hello\n").unwrap();
-        let diff = acc.get_unified_diff().unwrap().unwrap();
-        let diff = normalize_diff_for_test(&diff, dir.path());
-        let expected = {
-            let mode = file_mode_for_path(&dest).unwrap_or(FileMode::Regular);
-            let right_oid = git_blob_sha1_hex("hello\n");
-            format!(
-                r#"diff --git a/<TMP>/src.txt b/<TMP>/dest.txt
-new file mode {mode}
-index {ZERO_OID}..{right_oid}
--- {DEV_NULL}
-+++ b/<TMP>/dest.txt
-@@ -0,0 +1 @@
-+hello
-"#,
-            )
-        };
-        assert_eq!(diff, expected);
-    }
-
-    #[test]
-    fn update_persists_across_new_baseline_for_new_file() {
-        let dir = tempdir().unwrap();
-        let a = dir.path().join("a.txt");
-        let b = dir.path().join("b.txt");
-        fs::write(&a, "foo\n").unwrap();
-        fs::write(&b, "z\n").unwrap();
-
-        let mut acc = TurnDiffTracker::new();
-
-        // First: update existing a.txt (baseline snapshot is created for a).
-        let update_a = HashMap::from([(
-            a.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: None,
-            },
-        )]);
-        acc.on_patch_begin(&update_a);
-        // Simulate apply: modify a.txt on disk.
-        fs::write(&a, "foo\nbar\n").unwrap();
-        let first = acc.get_unified_diff().unwrap().unwrap();
-        let first = normalize_diff_for_test(&first, dir.path());
-        let expected_first = {
-            let left_oid = git_blob_sha1_hex("foo\n");
-            let right_oid = git_blob_sha1_hex("foo\nbar\n");
-            format!(
-                r#"diff --git a/<TMP>/a.txt b/<TMP>/a.txt
-index {left_oid}..{right_oid}
--- a/<TMP>/a.txt
-+++ b/<TMP>/a.txt
-@@ -1 +1,2 @@
- foo
-+bar
-"#
-            )
-        };
-        assert_eq!(first, expected_first);
-
-        // Next: introduce a brand-new path b.txt into baseline snapshots via a delete change.
-        let del_b = HashMap::from([(b.clone(), FileChange::Delete)]);
-        acc.on_patch_begin(&del_b);
-        // Simulate apply: delete b.txt.
-        let baseline_mode = file_mode_for_path(&b).unwrap_or(FileMode::Regular);
-        fs::remove_file(&b).unwrap();
-
-        let combined = acc.get_unified_diff().unwrap().unwrap();
-        let combined = normalize_diff_for_test(&combined, dir.path());
-        let expected = {
-            let left_oid_a = git_blob_sha1_hex("foo\n");
-            let right_oid_a = git_blob_sha1_hex("foo\nbar\n");
-            let left_oid_b = git_blob_sha1_hex("z\n");
-            format!(
-                r#"diff --git a/<TMP>/a.txt b/<TMP>/a.txt
-index {left_oid_a}..{right_oid_a}
--- a/<TMP>/a.txt
-+++ b/<TMP>/a.txt
-@@ -1 +1,2 @@
- foo
-+bar
-diff --git a/<TMP>/b.txt b/<TMP>/b.txt
-deleted file mode {baseline_mode}
-index {left_oid_b}..{ZERO_OID}
--- a/<TMP>/b.txt
-+++ {DEV_NULL}
-@@ -1 +0,0 @@
-z
-"#,
-            )
-        };
-        assert_eq!(combined, expected);
-    }
-
-    #[test]
-    fn binary_files_differ_update() {
-        let dir = tempdir().unwrap();
-        let file = dir.path().join("bin.dat");
-
-        // Initial non-UTF8 bytes
-        let left_bytes: Vec<u8> = vec![0xff, 0xfe, 0xfd, 0x00];
-        // Updated non-UTF8 bytes
-        let right_bytes: Vec<u8> = vec![0x01, 0x02, 0x03, 0x00];
-
-        fs::write(&file, &left_bytes).unwrap();
-
-        let mut acc = TurnDiffTracker::new();
-        let update_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: None,
-            },
-        )]);
-        acc.on_patch_begin(&update_changes);
-
-        // Apply update on disk
-        fs::write(&file, &right_bytes).unwrap();
-
-        let diff = acc.get_unified_diff().unwrap().unwrap();
-        let diff = normalize_diff_for_test(&diff, dir.path());
-        let expected = {
-            let left_oid = format!("{:x}", git_blob_sha1_hex_bytes(&left_bytes));
-            let right_oid = format!("{:x}", git_blob_sha1_hex_bytes(&right_bytes));
-            format!(
-                r#"diff --git a/<TMP>/bin.dat b/<TMP>/bin.dat
-index {left_oid}..{right_oid}
--- a/<TMP>/bin.dat
-+++ b/<TMP>/bin.dat
-Binary files differ
-"#
-            )
-        };
-        assert_eq!(diff, expected);
-    }
-
-    #[test]
-    fn filenames_with_spaces_add_and_update() {
-        let mut acc = TurnDiffTracker::new();
-
-        let dir = tempdir().unwrap();
-        let file = dir.path().join("name with spaces.txt");
-
-        // First patch: add file (baseline should be /dev/null).
-        let add_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Add {
-                content: "foo\n".to_string(),
-            },
-        )]);
-        acc.on_patch_begin(&add_changes);
-
-        // Simulate apply: create the file on disk.
-        fs::write(&file, "foo\n").unwrap();
-        let first = acc.get_unified_diff().unwrap().unwrap();
-        let first = normalize_diff_for_test(&first, dir.path());
-        let expected_first = {
-            let mode = file_mode_for_path(&file).unwrap_or(FileMode::Regular);
-            let right_oid = git_blob_sha1_hex("foo\n");
-            format!(
-                r#"diff --git a/<TMP>/name with spaces.txt b/<TMP>/name with spaces.txt
-new file mode {mode}
-index {ZERO_OID}..{right_oid}
--- {DEV_NULL}
-+++ b/<TMP>/name with spaces.txt
-@@ -0,0 +1 @@
-+foo
-"#,
-            )
-        };
-        assert_eq!(first, expected_first);
-
-        // Second patch: update the file on disk.
-        let update_changes = HashMap::from([(
-            file.clone(),
-            FileChange::Update {
-                unified_diff: "".to_owned(),
-                move_path: None,
-            },
-        )]);
-        acc.on_patch_begin(&update_changes);
-
-        // Simulate apply: append a new line with a space.
-        fs::write(&file, "foo\nbar baz\n").unwrap();
-        let combined = acc.get_unified_diff().unwrap().unwrap();
-        let combined = normalize_diff_for_test(&combined, dir.path());
-        let expected_combined = {
-            let mode = file_mode_for_path(&file).unwrap_or(FileMode::Regular);
-            let right_oid = git_blob_sha1_hex("foo\nbar baz\n");
-            format!(
-                r#"diff --git a/<TMP>/name with spaces.txt b/<TMP>/name with spaces.txt
-new file mode {mode}
-index {ZERO_OID}..{right_oid}
--- {DEV_NULL}
-+++ b/<TMP>/name with spaces.txt
-@@ -0,0 +1,2 @@
-+foo
-+bar baz
-"#,
-            )
-        };
-        assert_eq!(combined, expected_combined);
-    }
-}
--- a/codex-rs/core/tests/exec.rs
+++ b/codex-rs/core/tests/exec.rs
@@ -1,69 +0,0 @@
-#![cfg(target_os = "macos")]
-#![expect(clippy::expect_used)]
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use codex_core::exec::ExecParams;
-use codex_core::exec::SandboxType;
-use codex_core::exec::process_exec_tool_call;
-use codex_core::protocol::SandboxPolicy;
-use codex_core::spawn::CODEX_SANDBOX_ENV_VAR;
-use tempfile::TempDir;
-use tokio::sync::Notify;
-
-use codex_core::get_platform_sandbox;
-
-async fn run_test_cmd(tmp: TempDir, cmd: Vec<&str>, should_be_ok: bool) {
-    if std::env::var(CODEX_SANDBOX_ENV_VAR) == Ok("seatbelt".to_string()) {
-        eprintln!("{CODEX_SANDBOX_ENV_VAR} is set to 'seatbelt', skipping test.");
-        return;
-    }
-
-    let sandbox_type = get_platform_sandbox().expect("should be able to get sandbox type");
-    assert_eq!(sandbox_type, SandboxType::MacosSeatbelt);
-
-    let params = ExecParams {
-        command: cmd.iter().map(|s| s.to_string()).collect(),
-        cwd: tmp.path().to_path_buf(),
-        timeout_ms: Some(1000),
-        env: HashMap::new(),
-    };
-
-    let ctrl_c = Arc::new(Notify::new());
-    let policy = SandboxPolicy::new_read_only_policy();
-
-    let result = process_exec_tool_call(params, sandbox_type, ctrl_c, &policy, &None, None).await;
-
-    assert!(result.is_ok() == should_be_ok);
-}
-
-/// Command succeeds with exit code 0 normally
-#[tokio::test]
-async fn exit_code_0_succeeds() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let cmd = vec!["echo", "hello"];
-
-    run_test_cmd(tmp, cmd, true).await
-}
-
-/// Command not found returns exit code 127, this is not considered a sandbox error
-#[tokio::test]
-async fn exit_command_not_found_is_ok() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let cmd = vec!["/bin/bash", "-c", "nonexistent_command_12345"];
-    run_test_cmd(tmp, cmd, true).await
-}
-
-/// Writing a file fails and should be considered a sandbox error
-#[tokio::test]
-async fn write_file_fails_as_sandbox_error() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let path = tmp.path().join("test.txt");
-    let cmd = vec![
-        "/user/bin/touch",
-        path.to_str().expect("should be able to get path"),
-    ];
-
-    run_test_cmd(tmp, cmd, false).await;
-}
--- a/codex-rs/core/tests/exec_stream_events.rs
+++ b/codex-rs/core/tests/exec_stream_events.rs
@@ -1,143 +0,0 @@
-#![cfg(unix)]
-
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use async_channel::Receiver;
-use codex_core::exec::ExecParams;
-use codex_core::exec::SandboxType;
-use codex_core::exec::StdoutStream;
-use codex_core::exec::process_exec_tool_call;
-use codex_core::protocol::Event;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::ExecCommandOutputDeltaEvent;
-use codex_core::protocol::ExecOutputStream;
-use codex_core::protocol::SandboxPolicy;
-use tokio::sync::Notify;
-
-fn collect_stdout_events(rx: Receiver<Event>) -> Vec<u8> {
-    let mut out = Vec::new();
-    while let Ok(ev) = rx.try_recv() {
-        if let EventMsg::ExecCommandOutputDelta(ExecCommandOutputDeltaEvent {
-            stream: ExecOutputStream::Stdout,
-            chunk,
-            ..
-        }) = ev.msg
-        {
-            out.extend_from_slice(&chunk);
-        }
-    }
-    out
-}
-
-#[tokio::test]
-async fn test_exec_stdout_stream_events_echo() {
-    let (tx, rx) = async_channel::unbounded::<Event>();
-
-    let stdout_stream = StdoutStream {
-        sub_id: "test-sub".to_string(),
-        call_id: "call-1".to_string(),
-        tx_event: tx,
-    };
-
-    let cmd = vec![
-        "/bin/sh".to_string(),
-        "-c".to_string(),
-        // Use printf for predictable behavior across shells
-        "printf 'hello-world\n'".to_string(),
-    ];
-
-    let params = ExecParams {
-        command: cmd,
-        cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
-        timeout_ms: Some(5_000),
-        env: HashMap::new(),
-    };
-
-    let ctrl_c = Arc::new(Notify::new());
-    let policy = SandboxPolicy::new_read_only_policy();
-
-    let result = process_exec_tool_call(
-        params,
-        SandboxType::None,
-        ctrl_c,
-        &policy,
-        &None,
-        Some(stdout_stream),
-    )
-    .await;
-
-    let result = match result {
-        Ok(r) => r,
-        Err(e) => panic!("process_exec_tool_call failed: {e}"),
-    };
-
-    assert_eq!(result.exit_code, 0);
-    assert_eq!(result.stdout, "hello-world\n");
-
-    let streamed = collect_stdout_events(rx);
-    // We should have received at least the same contents (possibly in one chunk)
-    assert_eq!(String::from_utf8_lossy(&streamed), "hello-world\n");
-}
-
-#[tokio::test]
-async fn test_exec_stderr_stream_events_echo() {
-    let (tx, rx) = async_channel::unbounded::<Event>();
-
-    let stdout_stream = StdoutStream {
-        sub_id: "test-sub".to_string(),
-        call_id: "call-2".to_string(),
-        tx_event: tx,
-    };
-
-    let cmd = vec![
-        "/bin/sh".to_string(),
-        "-c".to_string(),
-        // Write to stderr explicitly
-        "printf 'oops\n' 1>&2".to_string(),
-    ];
-
-    let params = ExecParams {
-        command: cmd,
-        cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
-        timeout_ms: Some(5_000),
-        env: HashMap::new(),
-    };
-
-    let ctrl_c = Arc::new(Notify::new());
-    let policy = SandboxPolicy::new_read_only_policy();
-
-    let result = process_exec_tool_call(
-        params,
-        SandboxType::None,
-        ctrl_c,
-        &policy,
-        &None,
-        Some(stdout_stream),
-    )
-    .await;
-
-    let result = match result {
-        Ok(r) => r,
-        Err(e) => panic!("process_exec_tool_call failed: {e}"),
-    };
-
-    assert_eq!(result.exit_code, 0);
-    assert_eq!(result.stdout, "");
-    assert_eq!(result.stderr, "oops\n");
-
-    // Collect only stderr delta events
-    let mut err = Vec::new();
-    while let Ok(ev) = rx.try_recv() {
-        if let EventMsg::ExecCommandOutputDelta(ExecCommandOutputDeltaEvent {
-            stream: ExecOutputStream::Stderr,
-            chunk,
-            ..
-        }) = ev.msg
-        {
-            err.extend_from_slice(&chunk);
-        }
-    }
-    assert_eq!(String::from_utf8_lossy(&err), "oops\n");
-}
--- a/codex-rs/core/tests/live_agent.rs
+++ b/codex-rs/core/tests/live_agent.rs
@@ -177,7 +177,8 @@ async fn live_shell_function_call() {
        match ev.msg {
            EventMsg::ExecCommandBegin(codex_core::protocol::ExecCommandBeginEvent {
                command,
-                ..
+                call_id: _,
+                cwd: _,
            }) => {
                assert_eq!(command, vec!["echo", MARKER]);
                saw_begin = true;
@@ -185,7 +186,8 @@ async fn live_shell_function_call() {
            EventMsg::ExecCommandEnd(codex_core::protocol::ExecCommandEndEvent {
                stdout,
                exit_code,
-                ..
+                call_id: _,
+                stderr: _,
            }) => {
                assert_eq!(exit_code, 0, "echo returned non‑zero exit code");
                assert!(stdout.contains(MARKER));
--- a/codex-rs/core/tests/sandbox.rs
+++ b/codex-rs/core/tests/sandbox.rs
@@ -1,195 +0,0 @@
-#![cfg(target_os = "macos")]
-#![expect(clippy::expect_used)]
-
-use std::collections::HashMap;
-use std::path::Path;
-use std::path::PathBuf;
-
-use codex_core::protocol::SandboxPolicy;
-use codex_core::seatbelt::spawn_command_under_seatbelt;
-use codex_core::spawn::CODEX_SANDBOX_ENV_VAR;
-use codex_core::spawn::StdioPolicy;
-use tempfile::TempDir;
-
-struct TestScenario {
-    repo_parent: PathBuf,
-    file_outside_repo: PathBuf,
-    repo_root: PathBuf,
-    file_in_repo_root: PathBuf,
-    file_in_dot_git_dir: PathBuf,
-}
-
-struct TestExpectations {
-    file_outside_repo_is_writable: bool,
-    file_in_repo_root_is_writable: bool,
-    file_in_dot_git_dir_is_writable: bool,
-}
-
-impl TestScenario {
-    async fn run_test(&self, policy: &SandboxPolicy, expectations: TestExpectations) {
-        if std::env::var(CODEX_SANDBOX_ENV_VAR) == Ok("seatbelt".to_string()) {
-            eprintln!("{CODEX_SANDBOX_ENV_VAR} is set to 'seatbelt', skipping test.");
-            return;
-        }
-
-        assert_eq!(
-            touch(&self.file_outside_repo, policy).await,
-            expectations.file_outside_repo_is_writable
-        );
-        assert_eq!(
-            self.file_outside_repo.exists(),
-            expectations.file_outside_repo_is_writable
-        );
-
-        assert_eq!(
-            touch(&self.file_in_repo_root, policy).await,
-            expectations.file_in_repo_root_is_writable
-        );
-        assert_eq!(
-            self.file_in_repo_root.exists(),
-            expectations.file_in_repo_root_is_writable
-        );
-
-        assert_eq!(
-            touch(&self.file_in_dot_git_dir, policy).await,
-            expectations.file_in_dot_git_dir_is_writable
-        );
-        assert_eq!(
-            self.file_in_dot_git_dir.exists(),
-            expectations.file_in_dot_git_dir_is_writable
-        );
-    }
-}
-
-/// If the user has added a workspace root that is not a Git repo root, then
-/// the user has to specify `--skip-git-repo-check` or go through some
-/// interstitial that indicates they are taking on some risk because Git
-/// cannot be used to backup their work before the agent begins.
-///
-/// Because the user has agreed to this risk, we do not try find all .git
-/// folders in the workspace and block them (though we could change our
-/// position on this in the future).
-#[tokio::test]
-async fn if_parent_of_repo_is_writable_then_dot_git_folder_is_writable() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let test_scenario = create_test_scenario(&tmp);
-    let policy = SandboxPolicy::WorkspaceWrite {
-        writable_roots: vec![test_scenario.repo_parent.clone()],
-        network_access: false,
-        include_default_writable_roots: false,
-    };
-
-    test_scenario
-        .run_test(
-            &policy,
-            TestExpectations {
-                file_outside_repo_is_writable: true,
-                file_in_repo_root_is_writable: true,
-                file_in_dot_git_dir_is_writable: true,
-            },
-        )
-        .await;
-}
-
-/// When the writable root is the root of a Git repository (as evidenced by the
-/// presence of a .git folder), then the .git folder should be read-only if
-/// the policy is `WorkspaceWrite`.
-#[tokio::test]
-async fn if_git_repo_is_writable_root_then_dot_git_folder_is_read_only() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let test_scenario = create_test_scenario(&tmp);
-    let policy = SandboxPolicy::WorkspaceWrite {
-        writable_roots: vec![test_scenario.repo_root.clone()],
-        network_access: false,
-        include_default_writable_roots: false,
-    };
-
-    test_scenario
-        .run_test(
-            &policy,
-            TestExpectations {
-                file_outside_repo_is_writable: false,
-                file_in_repo_root_is_writable: true,
-                file_in_dot_git_dir_is_writable: false,
-            },
-        )
-        .await;
-}
-
-/// Under DangerFullAccess, all writes should be permitted anywhere on disk,
-/// including inside the .git folder.
-#[tokio::test]
-async fn danger_full_access_allows_all_writes() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let test_scenario = create_test_scenario(&tmp);
-    let policy = SandboxPolicy::DangerFullAccess;
-
-    test_scenario
-        .run_test(
-            &policy,
-            TestExpectations {
-                file_outside_repo_is_writable: true,
-                file_in_repo_root_is_writable: true,
-                file_in_dot_git_dir_is_writable: true,
-            },
-        )
-        .await;
-}
-
-/// Under ReadOnly, writes should not be permitted anywhere on disk.
-#[tokio::test]
-async fn read_only_forbids_all_writes() {
-    let tmp = TempDir::new().expect("should be able to create temp dir");
-    let test_scenario = create_test_scenario(&tmp);
-    let policy = SandboxPolicy::ReadOnly;
-
-    test_scenario
-        .run_test(
-            &policy,
-            TestExpectations {
-                file_outside_repo_is_writable: false,
-                file_in_repo_root_is_writable: false,
-                file_in_dot_git_dir_is_writable: false,
-            },
-        )
-        .await;
-}
-
-fn create_test_scenario(tmp: &TempDir) -> TestScenario {
-    let repo_parent = tmp.path().to_path_buf();
-    let repo_root = repo_parent.join("repo");
-    let dot_git_dir = repo_root.join(".git");
-
-    std::fs::create_dir(&repo_root).expect("should be able to create repo root");
-    std::fs::create_dir(&dot_git_dir).expect("should be able to create .git dir");
-
-    TestScenario {
-        file_outside_repo: repo_parent.join("outside.txt"),
-        repo_parent,
-        file_in_repo_root: repo_root.join("repo_file.txt"),
-        repo_root,
-        file_in_dot_git_dir: dot_git_dir.join("dot_git_file.txt"),
-    }
-}
-
-/// Note that `path` must be absolute.
-async fn touch(path: &Path, policy: &SandboxPolicy) -> bool {
-    assert!(path.is_absolute(), "Path must be absolute: {path:?}");
-    let mut child = spawn_command_under_seatbelt(
-        vec![
-            "/usr/bin/touch".to_string(),
-            path.to_string_lossy().to_string(),
-        ],
-        policy,
-        std::env::current_dir().expect("should be able to get current dir"),
-        StdioPolicy::RedirectForShellTool,
-        HashMap::new(),
-    )
-    .await
-    .expect("should be able to spawn command under seatbelt");
-    child
-        .wait()
-        .await
-        .expect("should be able to wait for child process")
-        .success()
-}
--- a/codex-rs/exec/src/event_processor.rs
+++ b/codex-rs/exec/src/event_processor.rs
@@ -44,14 +44,20 @@ pub(crate) fn create_config_summary_entries(config: &Config) -> Vec<(&'static st
    entries
 }

-pub(crate) fn handle_last_message(last_agent_message: Option<&str>, output_file: &Path) {
-    let message = last_agent_message.unwrap_or_default();
-    write_last_message_file(message, Some(output_file));
-    if last_agent_message.is_none() {
-        eprintln!(
-            "Warning: no last agent message; wrote empty content to {}",
-            output_file.display()
-        );
+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."),
    }
 }

--- a/codex-rs/exec/src/event_processor_with_human_output.rs
+++ b/codex-rs/exec/src/event_processor_with_human_output.rs
@@ -4,7 +4,6 @@ use codex_core::config::Config;
 use codex_core::plan_tool::UpdatePlanArgs;
 use codex_core::protocol::AgentMessageDeltaEvent;
 use codex_core::protocol::AgentMessageEvent;
-use codex_core::protocol::AgentReasoningContentEvent;
 use codex_core::protocol::AgentReasoningDeltaEvent;
 use codex_core::protocol::BackgroundEventEvent;
 use codex_core::protocol::ErrorEvent;
@@ -21,7 +20,6 @@ use codex_core::protocol::PatchApplyEndEvent;
 use codex_core::protocol::SessionConfiguredEvent;
 use codex_core::protocol::TaskCompleteEvent;
 use codex_core::protocol::TokenUsage;
-use codex_core::protocol::TurnDiffEvent;
 use owo_colors::OwoColorize;
 use owo_colors::Style;
 use shlex::try_join;
@@ -108,6 +106,7 @@ impl EventProcessorWithHumanOutput {

 struct ExecCommandBegin {
    command: Vec<String>,
+    start_time: Instant,
 }

 struct PatchApplyBegin {
@@ -171,9 +170,10 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                // Ignore.
            }
            EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
-                if let Some(output_file) = self.last_message_path.as_deref() {
-                    handle_last_message(last_agent_message.as_deref(), output_file);
-                }
+                handle_last_message(
+                    last_agent_message.as_deref(),
+                    self.last_message_path.as_deref(),
+                );
                return CodexStatus::InitiateShutdown;
            }
            EventMsg::TokenCount(TokenUsage { total_tokens, .. }) => {
@@ -204,14 +204,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                #[allow(clippy::expect_used)]
                std::io::stdout().flush().expect("could not flush stdout");
            }
-            EventMsg::AgentReasoningContent(AgentReasoningContentEvent { text }) => {
-                if !self.show_agent_reasoning {
-                    return CodexStatus::Running;
-                }
-                print!("{text}");
-                #[allow(clippy::expect_used)]
-                std::io::stdout().flush().expect("could not flush stdout");
-            }
            EventMsg::AgentMessage(AgentMessageEvent { message }) => {
                // if answer_started is false, this means we haven't received any
                // delta. Thus, we need to print the message as a new answer.
@@ -236,6 +228,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                    call_id.clone(),
                    ExecCommandBegin {
                        command: command.clone(),
+                        start_time: Instant::now(),
                    },
                );
                ts_println!(
@@ -246,19 +239,20 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                    cwd.to_string_lossy(),
                );
            }
-            EventMsg::ExecCommandOutputDelta(_) => {}
            EventMsg::ExecCommandEnd(ExecCommandEndEvent {
                call_id,
                stdout,
                stderr,
-                duration,
                exit_code,
            }) => {
                let exec_command = self.call_id_to_command.remove(&call_id);
-                let (duration, call) = if let Some(ExecCommandBegin { command, .. }) = exec_command
+                let (duration, call) = if let Some(ExecCommandBegin {
+                    command,
+                    start_time,
+                }) = exec_command
                {
                    (
-                        format!(" in {}", format_duration(duration)),
+                        format!(" in {}", format_elapsed(start_time)),
                        format!("{}", escape_command(&command).style(self.bold)),
                    )
                } else {
@@ -408,7 +402,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                stdout,
                stderr,
                success,
-                ..
            }) => {
                let patch_begin = self.call_id_to_patch.remove(&call_id);

@@ -438,10 +431,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                    println!("{}", line.style(self.dimmed));
                }
            }
-            EventMsg::TurnDiff(TurnDiffEvent { unified_diff }) => {
-                ts_println!(self, "{}", "turn diff:".style(self.magenta));
-                println!("{unified_diff}");
-            }
            EventMsg::ExecApprovalRequest(_) => {
                // Should we exit?
            }
--- a/codex-rs/exec/src/event_processor_with_json_output.rs
+++ b/codex-rs/exec/src/event_processor_with_json_output.rs
@@ -46,9 +46,10 @@ impl EventProcessor for EventProcessorWithJsonOutput {
                CodexStatus::Running
            }
            EventMsg::TaskComplete(TaskCompleteEvent { last_agent_message }) => {
-                if let Some(output_file) = self.last_message_path.as_deref() {
-                    handle_last_message(last_agent_message.as_deref(), output_file);
-                }
+                handle_last_message(
+                    last_agent_message.as_deref(),
+                    self.last_message_path.as_deref(),
+                );
                CodexStatus::InitiateShutdown
            }
            EventMsg::ShutdownComplete => CodexStatus::Shutdown,
--- a/codex-rs/execpolicy/Cargo.toml
+++ b/codex-rs/execpolicy/Cargo.toml
@@ -26,7 +26,7 @@ multimap = "0.10.0"
 path-absolutize = "3.1.1"
 regex-lite = "0.1"
 serde = { version = "1.0.194", features = ["derive"] }
-serde_json = "1.0.142"
+serde_json = "1.0.110"
 serde_with = { version = "3", features = ["macros"] }

 [dev-dependencies]
--- a/codex-rs/file-search/Cargo.toml
+++ b/codex-rs/file-search/Cargo.toml
@@ -17,5 +17,5 @@ clap = { version = "4", features = ["derive"] }
 ignore = "0.4.23"
 nucleo-matcher = "0.3.1"
 serde = { version = "1", features = ["derive"] }
-serde_json = "1.0.142"
+serde_json = "1.0.110"
 tokio = { version = "1", features = ["full"] }
--- a/codex-rs/linux-sandbox/src/landlock.rs
+++ b/codex-rs/linux-sandbox/src/landlock.rs
@@ -36,11 +36,7 @@ pub(crate) fn apply_sandbox_policy_to_current_thread(
    }

    if !sandbox_policy.has_full_disk_write_access() {
-        let writable_roots = sandbox_policy
-            .get_writable_roots_with_cwd(cwd)
-            .into_iter()
-            .map(|writable_root| writable_root.root)
-            .collect();
+        let writable_roots = sandbox_policy.get_writable_roots_with_cwd(cwd);
        install_filesystem_landlock_rules_on_current_thread(writable_roots)?;
    }

--- a/codex-rs/linux-sandbox/tests/landlock.rs
+++ b/codex-rs/linux-sandbox/tests/landlock.rs
@@ -49,7 +49,6 @@ async fn run_cmd(cmd: &[&str], writable_roots: &[PathBuf], timeout_ms: u64) {
    let sandbox_policy = SandboxPolicy::WorkspaceWrite {
        writable_roots: writable_roots.to_vec(),
        network_access: false,
-        include_default_writable_roots: true,
    };
    let sandbox_program = env!("CARGO_BIN_EXE_codex-linux-sandbox");
    let codex_linux_sandbox_exe = Some(PathBuf::from(sandbox_program));
@@ -60,7 +59,6 @@ async fn run_cmd(cmd: &[&str], writable_roots: &[PathBuf], timeout_ms: u64) {
        ctrl_c,
        &sandbox_policy,
        &codex_linux_sandbox_exe,
-        None,
    )
    .await
    .unwrap();
@@ -151,7 +149,6 @@ async fn assert_network_blocked(cmd: &[&str]) {
        ctrl_c,
        &sandbox_policy,
        &codex_linux_sandbox_exe,
-        None,
    )
    .await;

--- a/codex-rs/login/src/login_with_chatgpt.py
+++ b/codex-rs/login/src/login_with_chatgpt.py
@@ -686,7 +686,6 @@ LOGIN_SUCCESS_HTML = """<!DOCTYPE html>
        justify-content: center;
        position: relative;
        background: white;
-
        font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
      }
      .inner-container {
@@ -704,7 +703,6 @@ LOGIN_SUCCESS_HTML = """<!DOCTYPE html>
        align-items: center;
        gap: 20px;
        display: flex;
-        margin-top: 15vh;
      }
      .svg-wrapper {
        position: relative;
@@ -712,9 +710,9 @@ LOGIN_SUCCESS_HTML = """<!DOCTYPE html>
      .title {
        text-align: center;
        color: var(--text-primary, #0D0D0D);
-        font-size: 32px;
+        font-size: 28px;
        font-weight: 400;
-        line-height: 40px;
+        line-height: 36.40px;
        word-wrap: break-word;
      }
      .setup-box {
@@ -787,26 +785,16 @@ LOGIN_SUCCESS_HTML = """<!DOCTYPE html>
        word-wrap: break-word;
        text-decoration: none;
      }
-      .logo {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        width: 4rem;
-        height: 4rem;
-        border-radius: 16px;
-        border: .5px solid rgba(0, 0, 0, 0.1);
-        box-shadow: rgba(0, 0, 0, 0.1) 0px 4px 16px 0px;
-        box-sizing: border-box;
-        background-color: rgb(255, 255, 255);
-      }
    </style>
  </head>
  <body>
    <div class="container">
      <div class="inner-container">
        <div class="content">
-          <div class="logo">
-            <svg xmlns="http://www.w3.org/2000/svg" width="32" height="32" fill="none" viewBox="0 0 32 32"><path stroke="#000" stroke-linecap="round" stroke-width="2.484" d="M22.356 19.797H17.17M9.662 12.29l1.979 3.576a.511.511 0 0 1-.005.504l-1.974 3.409M30.758 16c0 8.15-6.607 14.758-14.758 14.758-8.15 0-14.758-6.607-14.758-14.758C1.242 7.85 7.85 1.242 16 1.242c8.15 0 14.758 6.608 14.758 14.758Z"></path></svg>
+          <div data-svg-wrapper class="svg-wrapper">
+            <svg width="56" height="56" viewBox="0 0 56 56" fill="none" xmlns="http://www.w3.org/2000/svg">
+              <path d="M4.6665 28.0003C4.6665 15.1137 15.1132 4.66699 27.9998 4.66699C40.8865 4.66699 51.3332 15.1137 51.3332 28.0003C51.3332 40.887 40.8865 51.3337 27.9998 51.3337C15.1132 51.3337 4.6665 40.887 4.6665 28.0003ZM37.5093 18.5088C36.4554 17.7672 34.9999 18.0203 34.2583 19.0742L24.8508 32.4427L20.9764 28.1808C20.1095 27.2272 18.6338 27.1569 17.6803 28.0238C16.7267 28.8906 16.6565 30.3664 17.5233 31.3199L23.3566 37.7366C23.833 38.2606 24.5216 38.5399 25.2284 38.4958C25.9353 38.4517 26.5838 38.089 26.9914 37.5098L38.0747 21.7598C38.8163 20.7059 38.5632 19.2504 37.5093 18.5088Z" fill="var(--green-400, #04B84C)"/>
+            </svg>
          </div>
          <div class="title">Signed in to Codex CLI</div>
        </div>
--- a/codex-rs/mcp-server/src/codex_tool_runner.rs
+++ b/codex-rs/mcp-server/src/codex_tool_runner.rs
@@ -252,19 +252,16 @@ async fn run_codex_tool_session_inner(
                    EventMsg::AgentMessage(AgentMessageEvent { .. }) => {
                        // TODO: think how we want to support this in the MCP
                    }
-                    EventMsg::AgentReasoningContent(_)
-                    | EventMsg::TaskStarted
+                    EventMsg::TaskStarted
                    | EventMsg::TokenCount(_)
                    | EventMsg::AgentReasoning(_)
                    | EventMsg::McpToolCallBegin(_)
                    | EventMsg::McpToolCallEnd(_)
                    | EventMsg::ExecCommandBegin(_)
-                    | EventMsg::ExecCommandOutputDelta(_)
                    | EventMsg::ExecCommandEnd(_)
                    | EventMsg::BackgroundEvent(_)
                    | EventMsg::PatchApplyBegin(_)
                    | EventMsg::PatchApplyEnd(_)
-                    | EventMsg::TurnDiff(_)
                    | EventMsg::GetHistoryEntryResponse(_)
                    | EventMsg::PlanUpdate(_)
                    | EventMsg::ShutdownComplete => {
--- a/codex-rs/mcp-server/src/conversation_loop.rs
+++ b/codex-rs/mcp-server/src/conversation_loop.rs
@@ -1,123 +0,0 @@
-use std::sync::Arc;
-
-use crate::exec_approval::handle_exec_approval_request;
-use crate::outgoing_message::OutgoingMessageSender;
-use crate::outgoing_message::OutgoingNotificationMeta;
-use crate::patch_approval::handle_patch_approval_request;
-use codex_core::Codex;
-use codex_core::protocol::AgentMessageEvent;
-use codex_core::protocol::ApplyPatchApprovalRequestEvent;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::ExecApprovalRequestEvent;
-use mcp_types::RequestId;
-use tracing::error;
-
-pub async fn run_conversation_loop(
-    codex: Arc<Codex>,
-    outgoing: Arc<OutgoingMessageSender>,
-    request_id: RequestId,
-) {
-    let request_id_str = match &request_id {
-        RequestId::String(s) => s.clone(),
-        RequestId::Integer(n) => n.to_string(),
-    };
-
-    // Stream events until the task needs to pause for user interaction or
-    // completes.
-    loop {
-        match codex.next_event().await {
-            Ok(event) => {
-                outgoing
-                    .send_event_as_notification(
-                        &event,
-                        Some(OutgoingNotificationMeta::new(Some(request_id.clone()))),
-                    )
-                    .await;
-
-                match event.msg {
-                    EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
-                        command,
-                        cwd,
-                        call_id,
-                        reason: _,
-                    }) => {
-                        handle_exec_approval_request(
-                            command,
-                            cwd,
-                            outgoing.clone(),
-                            codex.clone(),
-                            request_id.clone(),
-                            request_id_str.clone(),
-                            event.id.clone(),
-                            call_id,
-                        )
-                        .await;
-                        continue;
-                    }
-                    EventMsg::Error(_) => {
-                        error!("Codex runtime error");
-                    }
-                    EventMsg::ApplyPatchApprovalRequest(ApplyPatchApprovalRequestEvent {
-                        call_id,
-                        reason,
-                        grant_root,
-                        changes,
-                    }) => {
-                        handle_patch_approval_request(
-                            call_id,
-                            reason,
-                            grant_root,
-                            changes,
-                            outgoing.clone(),
-                            codex.clone(),
-                            request_id.clone(),
-                            request_id_str.clone(),
-                            event.id.clone(),
-                        )
-                        .await;
-                        continue;
-                    }
-                    EventMsg::TaskComplete(_) => {}
-                    EventMsg::SessionConfigured(_) => {
-                        tracing::error!("unexpected SessionConfigured event");
-                    }
-                    EventMsg::AgentMessageDelta(_) => {
-                        // TODO: think how we want to support this in the MCP
-                    }
-                    EventMsg::AgentReasoningDelta(_) => {
-                        // TODO: think how we want to support this in the MCP
-                    }
-                    EventMsg::AgentMessage(AgentMessageEvent { .. }) => {
-                        // TODO: think how we want to support this in the MCP
-                    }
-                    EventMsg::AgentReasoningContent(_)
-                    | EventMsg::TaskStarted
-                    | EventMsg::TokenCount(_)
-                    | EventMsg::AgentReasoning(_)
-                    | EventMsg::McpToolCallBegin(_)
-                    | EventMsg::McpToolCallEnd(_)
-                    | EventMsg::ExecCommandBegin(_)
-                    | EventMsg::ExecCommandEnd(_)
-                    | EventMsg::TurnDiff(_)
-                    | EventMsg::BackgroundEvent(_)
-                    | EventMsg::ExecCommandOutputDelta(_)
-                    | EventMsg::PatchApplyBegin(_)
-                    | EventMsg::PatchApplyEnd(_)
-                    | EventMsg::GetHistoryEntryResponse(_)
-                    | EventMsg::PlanUpdate(_)
-                    | EventMsg::ShutdownComplete => {
-                        // For now, we do not do anything extra for these
-                        // events. Note that
-                        // send(codex_event_to_notification(&event)) above has
-                        // already dispatched these events as notifications,
-                        // though we may want to do give different treatment to
-                        // individual events in the future.
-                    }
-                }
-            }
-            Err(e) => {
-                error!("Codex runtime error: {e}");
-            }
-        }
-    }
-}
--- a/codex-rs/mcp-server/src/exec_approval.rs
+++ b/codex-rs/mcp-server/src/exec_approval.rs
@@ -18,7 +18,7 @@ use crate::codex_tool_runner::INVALID_PARAMS_ERROR_CODE;

 /// Conforms to [`mcp_types::ElicitRequestParams`] so that it can be used as the
 /// `params` field of an [`ElicitRequest`].
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Serialize)]
 pub struct ExecApprovalElicitRequestParams {
    // These fields are required so that `params`
    // conforms to ElicitRequestParams.
--- a/codex-rs/mcp-server/src/lib.rs
+++ b/codex-rs/mcp-server/src/lib.rs
@@ -17,7 +17,6 @@ use tracing_subscriber::EnvFilter;

 mod codex_tool_config;
 mod codex_tool_runner;
-mod conversation_loop;
 mod exec_approval;
 mod json_to_toml;
 pub mod mcp_protocol;
--- a/codex-rs/mcp-server/src/mcp_protocol.rs
+++ b/codex-rs/mcp-server/src/mcp_protocol.rs
@@ -172,22 +172,15 @@ pub enum ToolCallResponseResult {
 }

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ConversationCreateResult {
-    Ok {
-        conversation_id: ConversationId,
-        model: String,
-    },
-    Error {
-        message: String,
-    },
+pub struct ConversationCreateResult {
+    pub conversation_id: ConversationId,
+    pub model: String,
 }

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ConversationStreamResult {}

 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-// TODO: remove this status because we have is_error field in the response.
 #[serde(tag = "status", rename_all = "camelCase")]
 pub enum ConversationSendMessageResult {
    Ok,
@@ -498,7 +491,7 @@ mod tests {
            request_id: RequestId::Integer(1),
            is_error: None,
            result: Some(ToolCallResponseResult::ConversationCreate(
-                ConversationCreateResult::Ok {
+                ConversationCreateResult {
                    conversation_id: ConversationId(uuid!("d0f6ecbe-84a2-41c1-b23d-b20473b25eab")),
                    model: "o3".into(),
                },
@@ -522,35 +515,6 @@ mod tests {
        assert_eq!(req_id, RequestId::Integer(1));
    }

-    #[test]
-    fn response_error_conversation_create_full_schema() {
-        let env = ToolCallResponse {
-            request_id: RequestId::Integer(2),
-            is_error: Some(true),
-            result: Some(ToolCallResponseResult::ConversationCreate(
-                ConversationCreateResult::Error {
-                    message: "Failed to initialize session".into(),
-                },
-            )),
-        };
-        let req_id = env.request_id.clone();
-        let observed = to_val(&CallToolResult::from(env));
-        let expected = json!({
-            "content": [
-                { "type": "text", "text": "{\"message\":\"Failed to initialize session\"}" }
-            ],
-            "isError": true,
-            "structuredContent": {
-                "message": "Failed to initialize session"
-            }
-        });
-        assert_eq!(
-            observed, expected,
-            "error response (ConversationCreate) must match"
-        );
-        assert_eq!(req_id, RequestId::Integer(2));
-    }
-
    #[test]
    fn response_success_conversation_stream_empty_result_object() {
        let env = ToolCallResponse {
--- a/codex-rs/mcp-server/src/message_processor.rs
+++ b/codex-rs/mcp-server/src/message_processor.rs
@@ -11,7 +11,6 @@ use crate::mcp_protocol::ToolCallRequestParams;
 use crate::mcp_protocol::ToolCallResponse;
 use crate::mcp_protocol::ToolCallResponseResult;
 use crate::outgoing_message::OutgoingMessageSender;
-use crate::tool_handlers::create_conversation::handle_create_conversation;
 use crate::tool_handlers::send_message::handle_send_message;

 use codex_core::Codex;
@@ -68,10 +67,6 @@ impl MessageProcessor {
        self.session_map.clone()
    }

-    pub(crate) fn outgoing(&self) -> Arc<OutgoingMessageSender> {
-        self.outgoing.clone()
-    }
-
    pub(crate) fn running_session_ids(&self) -> Arc<Mutex<HashSet<Uuid>>> {
        self.running_session_ids.clone()
    }
@@ -354,9 +349,6 @@ impl MessageProcessor {
    }
    async fn handle_new_tool_calls(&self, request_id: RequestId, params: ToolCallRequestParams) {
        match params {
-            ToolCallRequestParams::ConversationCreate(args) => {
-                handle_create_conversation(self, request_id, args).await;
-            }
            ToolCallRequestParams::ConversationSendMessage(args) => {
                handle_send_message(self, request_id, args).await;
            }
--- a/codex-rs/mcp-server/src/tool_handlers/create_conversation.rs
+++ b/codex-rs/mcp-server/src/tool_handlers/create_conversation.rs
@@ -1,160 +0,0 @@
-use std::collections::HashMap;
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use codex_core::Codex;
-use codex_core::codex_wrapper::init_codex;
-use codex_core::config::Config as CodexConfig;
-use codex_core::config::ConfigOverrides;
-use codex_core::protocol::EventMsg;
-use codex_core::protocol::SessionConfiguredEvent;
-use mcp_types::RequestId;
-use tokio::sync::Mutex;
-use uuid::Uuid;
-
-use crate::conversation_loop::run_conversation_loop;
-use crate::json_to_toml::json_to_toml;
-use crate::mcp_protocol::ConversationCreateArgs;
-use crate::mcp_protocol::ConversationCreateResult;
-use crate::mcp_protocol::ConversationId;
-use crate::mcp_protocol::ToolCallResponseResult;
-use crate::message_processor::MessageProcessor;
-
-pub(crate) async fn handle_create_conversation(
-    message_processor: &MessageProcessor,
-    id: RequestId,
-    args: ConversationCreateArgs,
-) {
-    // Build ConfigOverrides from args
-    let ConversationCreateArgs {
-        prompt: _, // not used here; creation only establishes the session
-        model,
-        cwd,
-        approval_policy,
-        sandbox,
-        config,
-        profile,
-        base_instructions,
-    } = args;
-
-    // Convert config overrides JSON into CLI-style TOML overrides
-    let cli_overrides: Vec<(String, toml::Value)> = match config {
-        Some(v) => match v.as_object() {
-            Some(map) => map
-                .into_iter()
-                .map(|(k, v)| (k.clone(), json_to_toml(v.clone())))
-                .collect(),
-            None => Vec::new(),
-        },
-        None => Vec::new(),
-    };
-
-    let overrides = ConfigOverrides {
-        model: Some(model.clone()),
-        cwd: Some(PathBuf::from(cwd)),
-        approval_policy,
-        sandbox_mode: sandbox,
-        model_provider: None,
-        config_profile: profile,
-        codex_linux_sandbox_exe: None,
-        base_instructions,
-        include_plan_tool: None,
-    };
-
-    let cfg: CodexConfig = match CodexConfig::load_with_cli_overrides(cli_overrides, overrides) {
-        Ok(cfg) => cfg,
-        Err(e) => {
-            message_processor
-                .send_response_with_optional_error(
-                    id,
-                    Some(ToolCallResponseResult::ConversationCreate(
-                        ConversationCreateResult::Error {
-                            message: format!("Failed to load config: {e}"),
-                        },
-                    )),
-                    Some(true),
-                )
-                .await;
-            return;
-        }
-    };
-
-    // Initialize Codex session
-    let codex_conversation = match init_codex(cfg).await {
-        Ok(conv) => conv,
-        Err(e) => {
-            message_processor
-                .send_response_with_optional_error(
-                    id,
-                    Some(ToolCallResponseResult::ConversationCreate(
-                        ConversationCreateResult::Error {
-                            message: format!("Failed to initialize session: {e}"),
-                        },
-                    )),
-                    Some(true),
-                )
-                .await;
-            return;
-        }
-    };
-
-    // Expect SessionConfigured; if not, return error.
-    let EventMsg::SessionConfigured(SessionConfiguredEvent { model, .. }) =
-        &codex_conversation.session_configured.msg
-    else {
-        message_processor
-            .send_response_with_optional_error(
-                id,
-                Some(ToolCallResponseResult::ConversationCreate(
-                    ConversationCreateResult::Error {
-                        message: "Expected SessionConfigured event".to_string(),
-                    },
-                )),
-                Some(true),
-            )
-            .await;
-        return;
-    };
-
-    let effective_model = model.clone();
-
-    let session_id = codex_conversation.session_id;
-    let codex_arc = Arc::new(codex_conversation.codex);
-
-    // Store session for future calls
-    insert_session(
-        session_id,
-        codex_arc.clone(),
-        message_processor.session_map(),
-    )
-    .await;
-    // Run the conversation loop in the background so this request can return immediately.
-    let outgoing = message_processor.outgoing();
-    let spawn_id = id.clone();
-    tokio::spawn(async move {
-        run_conversation_loop(codex_arc.clone(), outgoing, spawn_id).await;
-    });
-
-    // Reply with the new conversation id and effective model
-    message_processor
-        .send_response_with_optional_error(
-            id,
-            Some(ToolCallResponseResult::ConversationCreate(
-                ConversationCreateResult::Ok {
-                    conversation_id: ConversationId(session_id),
-                    model: effective_model,
-                },
-            )),
-            Some(false),
-        )
-        .await;
-}
-
-async fn insert_session(
-    session_id: Uuid,
-    codex: Arc<Codex>,
-    session_map: Arc<Mutex<HashMap<Uuid, Arc<Codex>>>>,
-) {
-    let mut guard = session_map.lock().await;
-    guard.insert(session_id, codex);
-}
--- a/codex-rs/mcp-server/src/tool_handlers/mod.rs
+++ b/codex-rs/mcp-server/src/tool_handlers/mod.rs
@@ -1,2 +1 @@
-pub(crate) mod create_conversation;
 pub(crate) mod send_message;
--- a/codex-rs/mcp-server/tests/codex_tool.rs
+++ b/codex-rs/mcp-server/tests/codex_tool.rs
@@ -89,18 +89,14 @@ async fn shell_command_approval_triggers_elicitation() -> anyhow::Result<()> {
    // This is the first request from the server, so the id should be 0 given
    // how things are currently implemented.
    let elicitation_request_id = RequestId::Integer(0);
-    let params = serde_json::from_value::<ExecApprovalElicitRequestParams>(
-        elicitation_request
-            .params
-            .clone()
-            .ok_or_else(|| anyhow::anyhow!("elicitation_request.params must be set"))?,
-    )?;
    let expected_elicitation_request = create_expected_elicitation_request(
        elicitation_request_id.clone(),
        shell_command.clone(),
        workdir_for_shell_function_call.path(),
        codex_request_id.to_string(),
-        params.codex_event_id.clone(),
+        // Internal Codex id: empirically it is 1, but this is
+        // admittedly an internal detail that could change.
+        "1".to_string(),
    )?;
    assert_eq!(expected_elicitation_request, elicitation_request);

--- a/codex-rs/mcp-server/tests/common/mcp_process.rs
+++ b/codex-rs/mcp-server/tests/common/mcp_process.rs
@@ -14,7 +14,6 @@ use assert_cmd::prelude::*;
 use codex_core::protocol::InputItem;
 use codex_mcp_server::CodexToolCallParam;
 use codex_mcp_server::CodexToolCallReplyParam;
-use codex_mcp_server::mcp_protocol::ConversationCreateArgs;
 use codex_mcp_server::mcp_protocol::ConversationId;
 use codex_mcp_server::mcp_protocol::ConversationSendMessageArgs;
 use codex_mcp_server::mcp_protocol::ToolCallRequestParams;
@@ -201,41 +200,6 @@ impl McpProcess {
        .await
    }

-    pub async fn send_conversation_create_tool_call(
-        &mut self,
-        prompt: &str,
-        model: &str,
-        cwd: &str,
-    ) -> anyhow::Result<i64> {
-        let params = ToolCallRequestParams::ConversationCreate(ConversationCreateArgs {
-            prompt: prompt.to_string(),
-            model: model.to_string(),
-            cwd: cwd.to_string(),
-            approval_policy: None,
-            sandbox: None,
-            config: None,
-            profile: None,
-            base_instructions: None,
-        });
-        self.send_request(
-            mcp_types::CallToolRequest::METHOD,
-            Some(serde_json::to_value(params)?),
-        )
-        .await
-    }
-
-    pub async fn send_conversation_create_with_args(
-        &mut self,
-        args: ConversationCreateArgs,
-    ) -> anyhow::Result<i64> {
-        let params = ToolCallRequestParams::ConversationCreate(args);
-        self.send_request(
-            mcp_types::CallToolRequest::METHOD,
-            Some(serde_json::to_value(params)?),
-        )
-        .await
-    }
-
    async fn send_request(
        &mut self,
        method: &str,
--- a/codex-rs/mcp-server/tests/create_conversation.rs
+++ b/codex-rs/mcp-server/tests/create_conversation.rs
@@ -1,128 +0,0 @@
-#![allow(clippy::expect_used, clippy::unwrap_used)]
-
-use std::path::Path;
-
-use mcp_test_support::McpProcess;
-use mcp_test_support::create_final_assistant_message_sse_response;
-use mcp_test_support::create_mock_chat_completions_server;
-use mcp_types::JSONRPCResponse;
-use mcp_types::RequestId;
-use pretty_assertions::assert_eq;
-use serde_json::json;
-use tempfile::TempDir;
-use tokio::time::timeout;
-
-const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_conversation_create_and_send_message_ok() {
-    // Mock server – we won't strictly rely on it, but provide one to satisfy any model wiring.
-    let responses = vec![
-        create_final_assistant_message_sse_response("Done").expect("build mock assistant message"),
-    ];
-    let server = create_mock_chat_completions_server(responses).await;
-
-    // Temporary Codex home with config pointing at the mock server.
-    let codex_home = TempDir::new().expect("create temp dir");
-    create_config_toml(codex_home.path(), &server.uri()).expect("write config.toml");
-
-    // Start MCP server process and initialize.
-    let mut mcp = McpProcess::new(codex_home.path())
-        .await
-        .expect("spawn mcp process");
-    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize())
-        .await
-        .expect("init timeout")
-        .expect("init failed");
-
-    // Create a conversation via the new tool.
-    let req_id = mcp
-        .send_conversation_create_tool_call("", "o3", "/repo")
-        .await
-        .expect("send conversationCreate");
-
-    let resp: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(req_id)),
-    )
-    .await
-    .expect("create response timeout")
-    .expect("create response error");
-
-    // Structured content must include status=ok, a UUID conversation_id and the model we passed.
-    let sc = &resp.result["structuredContent"];
-    let conv_id = sc["conversation_id"].as_str().expect("uuid string");
-    assert!(!conv_id.is_empty());
-    assert_eq!(sc["model"], json!("o3"));
-
-    // Now send a message to the created conversation and expect an OK result.
-    let send_id = mcp
-        .send_user_message_tool_call("Hello", conv_id)
-        .await
-        .expect("send message");
-
-    let send_resp: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(send_id)),
-    )
-    .await
-    .expect("send response timeout")
-    .expect("send response error");
-    assert_eq!(
-        send_resp.result["structuredContent"],
-        json!({ "status": "ok" })
-    );
-
-    // avoid race condition by waiting for the mock server to receive the chat.completions request
-    let deadline = std::time::Instant::now() + DEFAULT_READ_TIMEOUT;
-    loop {
-        let requests = server.received_requests().await.unwrap_or_default();
-        if !requests.is_empty() {
-            break;
-        }
-        if std::time::Instant::now() >= deadline {
-            panic!("mock server did not receive the chat.completions request in time");
-        }
-        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
-    }
-
-    // Verify the outbound request body matches expectations for Chat Completions.
-    let request = &server.received_requests().await.unwrap()[0];
-    let body = request
-        .body_json::<serde_json::Value>()
-        .expect("parse request body as JSON");
-    assert_eq!(body["model"], json!("o3"));
-    assert!(body["stream"].as_bool().unwrap_or(false));
-    let messages = body["messages"]
-        .as_array()
-        .expect("messages should be array");
-    let last = messages.last().expect("at least one message");
-    assert_eq!(last["role"], json!("user"));
-    assert_eq!(last["content"], json!("Hello"));
-
-    drop(server);
-}
-
-// Helper to create a config.toml pointing at the mock model server.
-fn create_config_toml(codex_home: &Path, server_uri: &str) -> std::io::Result<()> {
-    let config_toml = codex_home.join("config.toml");
-    std::fs::write(
-        config_toml,
-        format!(
-            r#"
-model = "mock-model"
-approval_policy = "never"
-sandbox_mode = "danger-full-access"
-
-model_provider = "mock_provider"
-
-[model_providers.mock_provider]
-name = "Mock provider for test"
-base_url = "{server_uri}/v1"
-wire_api = "chat"
-request_max_retries = 0
-stream_max_retries = 0
-"#
-        ),
-    )
-}
--- a/codex-rs/tui/Cargo.toml
+++ b/codex-rs/tui/Cargo.toml
@@ -17,7 +17,6 @@ workspace = true
 [dependencies]
 anyhow = "1"
 base64 = "0.22.1"
-chrono = { version = "0.4", features = ["serde"] }
 clap = { version = "4", features = ["derive"] }
 codex-ansi-escape = { path = "../ansi-escape" }
 codex-arg0 = { path = "../arg0" }
@@ -42,14 +41,10 @@ ratatui = { version = "0.29.0", features = [
 ] }
 ratatui-image = "8.0.0"
 regex-lite = "0.1"
-reqwest = { version = "0.12", features = ["json"] }
-serde = { version = "1", features = ["derive"] }
 serde_json = { version = "1", features = ["preserve_order"] }
 shlex = "1.3.0"
 strum = "0.27.2"
 strum_macros = "0.27.2"
-supports-color = "3.0.2"
-textwrap = "0.16.2"
 tokio = { version = "1", features = [
    "io-std",
    "macros",
@@ -62,6 +57,7 @@ tracing-appender = "0.2.3"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 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"
@@ -71,5 +67,3 @@ uuid = "1"
 [dev-dependencies]
 insta = "1.43.1"
 pretty_assertions = "1"
-rand = "0.8"
-chrono = { version = "0.4", features = ["serde"] }
--- a/codex-rs/tui/src/app.rs
+++ b/codex-rs/tui/src/app.rs
@@ -438,15 +438,14 @@ impl App<'_> {
            );
            self.pending_history_lines.clear();
        }
-        terminal.draw(|frame| match &mut self.app_state {
+        match &mut self.app_state {
            AppState::Chat { widget } => {
-                if let Some((x, y)) = widget.cursor_pos(frame.area()) {
-                    frame.set_cursor_position((x, y));
-                }
-                frame.render_widget_ref(&**widget, frame.area())
+                terminal.draw(|frame| frame.render_widget_ref(&**widget, frame.area()))?;
            }
-            AppState::GitWarning { screen } => frame.render_widget_ref(&*screen, frame.area()),
-        })?;
+            AppState::GitWarning { screen } => {
+                terminal.draw(|frame| frame.render_widget_ref(&*screen, frame.area()))?;
+            }
+        }
        Ok(())
    }

--- a/codex-rs/tui/src/bottom_pane/chat_composer.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer.rs
--- a/codex-rs/tui/src/bottom_pane/chat_composer_history.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer_history.rs
@@ -1,5 +1,8 @@
 use std::collections::HashMap;

+use tui_textarea::CursorMove;
+use tui_textarea::TextArea;
+
 use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 use codex_core::protocol::Op;
@@ -64,52 +67,59 @@ impl ChatComposerHistory {

    /// Should Up/Down key presses be interpreted as history navigation given
    /// the current content and cursor position of `textarea`?
-    pub fn should_handle_navigation(&self, text: &str, cursor: usize) -> bool {
+    pub fn should_handle_navigation(&self, textarea: &TextArea) -> bool {
        if self.history_entry_count == 0 && self.local_history.is_empty() {
            return false;
        }

-        if text.is_empty() {
+        if textarea.is_empty() {
            return true;
        }

        // Textarea is not empty – only navigate when cursor is at start and
        // text matches last recalled history entry so regular editing is not
        // hijacked.
-        if cursor != 0 {
+        let (row, col) = textarea.cursor();
+        if row != 0 || col != 0 {
            return false;
        }

-        matches!(&self.last_history_text, Some(prev) if prev == text)
+        let lines = textarea.lines();
+        matches!(&self.last_history_text, Some(prev) if prev == &lines.join("\n"))
    }

    /// Handle <Up>. Returns true when the key was consumed and the caller
    /// should request a redraw.
-    pub fn navigate_up(&mut self, app_event_tx: &AppEventSender) -> Option<String> {
+    pub fn navigate_up(&mut self, textarea: &mut TextArea, app_event_tx: &AppEventSender) -> bool {
        let total_entries = self.history_entry_count + self.local_history.len();
        if total_entries == 0 {
-            return None;
+            return false;
        }

        let next_idx = match self.history_cursor {
            None => (total_entries as isize) - 1,
-            Some(0) => return None, // already at oldest
+            Some(0) => return true, // already at oldest
            Some(idx) => idx - 1,
        };

        self.history_cursor = Some(next_idx);
-        self.populate_history_at_index(next_idx as usize, app_event_tx)
+        self.populate_history_at_index(next_idx as usize, textarea, app_event_tx);
+        true
    }

    /// Handle <Down>.
-    pub fn navigate_down(&mut self, app_event_tx: &AppEventSender) -> Option<String> {
+    pub fn navigate_down(
+        &mut self,
+        textarea: &mut TextArea,
+        app_event_tx: &AppEventSender,
+    ) -> bool {
        let total_entries = self.history_entry_count + self.local_history.len();
        if total_entries == 0 {
-            return None;
+            return false;
        }

        let next_idx_opt = match self.history_cursor {
-            None => return None, // not browsing
+            None => return false, // not browsing
            Some(idx) if (idx as usize) + 1 >= total_entries => None,
            Some(idx) => Some(idx + 1),
        };
@@ -117,15 +127,16 @@ impl ChatComposerHistory {
        match next_idx_opt {
            Some(idx) => {
                self.history_cursor = Some(idx);
-                self.populate_history_at_index(idx as usize, app_event_tx)
+                self.populate_history_at_index(idx as usize, textarea, app_event_tx);
            }
            None => {
                // Past newest – clear and exit browsing mode.
                self.history_cursor = None;
                self.last_history_text = None;
-                Some(String::new())
+                self.replace_textarea_content(textarea, "");
            }
        }
+        true
    }

    /// Integrate a GetHistoryEntryResponse event.
@@ -134,18 +145,19 @@ impl ChatComposerHistory {
        log_id: u64,
        offset: usize,
        entry: Option<String>,
-    ) -> Option<String> {
+        textarea: &mut TextArea,
+    ) -> bool {
        if self.history_log_id != Some(log_id) {
-            return None;
+            return false;
        }
-        let text = entry?;
+        let Some(text) = entry else { return false };
        self.fetched_history.insert(offset, text.clone());

        if self.history_cursor == Some(offset as isize) {
-            self.last_history_text = Some(text.clone());
-            return Some(text);
+            self.replace_textarea_content(textarea, &text);
+            return true;
        }
-        None
+        false
    }

    // ---------------------------------------------------------------------
@@ -155,20 +167,21 @@ impl ChatComposerHistory {
    fn populate_history_at_index(
        &mut self,
        global_idx: usize,
+        textarea: &mut TextArea,
        app_event_tx: &AppEventSender,
-    ) -> Option<String> {
+    ) {
        if global_idx >= self.history_entry_count {
            // Local entry.
            if let Some(text) = self
                .local_history
                .get(global_idx - self.history_entry_count)
            {
-                self.last_history_text = Some(text.clone());
-                return Some(text.clone());
+                let t = text.clone();
+                self.replace_textarea_content(textarea, &t);
            }
        } else if let Some(text) = self.fetched_history.get(&global_idx) {
-            self.last_history_text = Some(text.clone());
-            return Some(text.clone());
+            let t = text.clone();
+            self.replace_textarea_content(textarea, &t);
        } else if let Some(log_id) = self.history_log_id {
            let op = Op::GetHistoryEntryRequest {
                offset: global_idx,
@@ -176,7 +189,14 @@ impl ChatComposerHistory {
            };
            app_event_tx.send(AppEvent::CodexOp(op));
        }
-        None
+    }
+
+    fn replace_textarea_content(&mut self, textarea: &mut TextArea, text: &str) {
+        textarea.select_all();
+        textarea.cut();
+        let _ = textarea.insert_str(text);
+        textarea.move_cursor(CursorMove::Jump(0, 0));
+        self.last_history_text = Some(text.to_string());
    }
 }

@@ -197,9 +217,11 @@ mod tests {
        // Pretend there are 3 persistent entries.
        history.set_metadata(1, 3);

+        let mut textarea = TextArea::default();
+
        // First Up should request offset 2 (latest) and await async data.
-        assert!(history.should_handle_navigation("", 0));
-        assert!(history.navigate_up(&tx).is_none()); // don't replace the text yet
+        assert!(history.should_handle_navigation(&textarea));
+        assert!(history.navigate_up(&mut textarea, &tx));

        // Verify that an AppEvent::CodexOp with the correct GetHistoryEntryRequest was sent.
        let event = rx.try_recv().expect("expected AppEvent to be sent");
@@ -213,15 +235,14 @@ mod tests {
            },
            history_request1
        );
+        assert_eq!(textarea.lines().join("\n"), ""); // still empty

        // Inject the async response.
-        assert_eq!(
-            Some("latest".into()),
-            history.on_entry_response(1, 2, Some("latest".into()))
-        );
+        assert!(history.on_entry_response(1, 2, Some("latest".into()), &mut textarea));
+        assert_eq!(textarea.lines().join("\n"), "latest");

        // Next Up should move to offset 1.
-        assert!(history.navigate_up(&tx).is_none()); // don't replace the text yet
+        assert!(history.navigate_up(&mut textarea, &tx));

        // Verify second CodexOp event for offset 1.
        let event2 = rx.try_recv().expect("expected second event");
@@ -236,9 +257,7 @@ mod tests {
            history_request_2
        );

-        assert_eq!(
-            Some("older".into()),
-            history.on_entry_response(1, 1, Some("older".into()))
-        );
+        history.on_entry_response(1, 1, Some("older".into()), &mut textarea);
+        assert_eq!(textarea.lines().join("\n"), "older");
    }
 }
--- a/codex-rs/tui/src/bottom_pane/command_popup.rs
+++ b/codex-rs/tui/src/bottom_pane/command_popup.rs
@@ -25,6 +25,8 @@ pub(crate) struct CommandPopup {
    command_filter: String,
    all_commands: Vec<(&'static str, SlashCommand)>,
    selected_idx: Option<usize>,
+    // Index of the first visible row in the filtered list.
+    scroll_top: usize,
 }

 impl CommandPopup {
@@ -33,6 +35,7 @@ impl CommandPopup {
            command_filter: String::new(),
            all_commands: built_in_slash_commands(),
            selected_idx: None,
+            scroll_top: 0,
        }
    }

@@ -66,26 +69,28 @@ impl CommandPopup {
            0 => None,
            _ => Some(self.selected_idx.unwrap_or(0).min(matches_len - 1)),
        };
+
+        self.adjust_scroll(matches_len);
    }

    /// Determine the preferred height of the popup. This is the number of
-    /// rows required to show **at most** `MAX_POPUP_ROWS` commands plus the
-    /// table/border overhead (one line at the top and one at the bottom).
+    /// rows required to show at most MAX_POPUP_ROWS commands.
    pub(crate) fn calculate_required_height(&self) -> u16 {
        self.filtered_commands().len().clamp(1, MAX_POPUP_ROWS) as u16
    }

    /// Return the list of commands that match the current filter. Matching is
-    /// performed using a *prefix* comparison on the command name.
+    /// performed using a case-insensitive prefix comparison on the command name.
    fn filtered_commands(&self) -> Vec<&SlashCommand> {
+        let filter = self.command_filter.as_str();
        self.all_commands
            .iter()
            .filter_map(|(_name, cmd)| {
-                if self.command_filter.is_empty()
-                    || cmd
-                        .command()
-                        .starts_with(&self.command_filter.to_ascii_lowercase())
-                {
+                if filter.is_empty() {
+                    return Some(cmd);
+                }
+                let name = cmd.command();
+                if name.len() >= filter.len() && name[..filter.len()].eq_ignore_ascii_case(filter) {
                    Some(cmd)
                } else {
                    None
@@ -96,26 +101,30 @@ impl CommandPopup {

    /// Move the selection cursor one step up.
    pub(crate) fn move_up(&mut self) {
-        if let Some(len) = self.filtered_commands().len().checked_sub(1) {
-            if len == usize::MAX {
-                return;
-            }
+        let matches = self.filtered_commands();
+        let len = matches.len();
+        if len == 0 {
+            self.selected_idx = None;
+            self.scroll_top = 0;
+            return;
        }

-        if let Some(idx) = self.selected_idx {
-            if idx > 0 {
-                self.selected_idx = Some(idx - 1);
-            }
-        } else if !self.filtered_commands().is_empty() {
-            self.selected_idx = Some(0);
+        match self.selected_idx {
+            Some(idx) if idx > 0 => self.selected_idx = Some(idx - 1),
+            Some(_) => self.selected_idx = Some(len - 1), // wrap to last
+            None => self.selected_idx = Some(0),
        }
+
+        self.adjust_scroll(len);
    }

    /// Move the selection cursor one step down.
    pub(crate) fn move_down(&mut self) {
-        let matches_len = self.filtered_commands().len();
+        let matches = self.filtered_commands();
+        let matches_len = matches.len();
        if matches_len == 0 {
            self.selected_idx = None;
+            self.scroll_top = 0;
            return;
        }

@@ -123,11 +132,15 @@ impl CommandPopup {
            Some(idx) if idx + 1 < matches_len => {
                self.selected_idx = Some(idx + 1);
            }
+            Some(_idx_last) => {
+                self.selected_idx = Some(0);
+            }
            None => {
                self.selected_idx = Some(0);
            }
-            _ => {}
        }
+
+        self.adjust_scroll(matches_len);
    }

    /// Return currently selected command, if any.
@@ -135,6 +148,26 @@ impl CommandPopup {
        let matches = self.filtered_commands();
        self.selected_idx.and_then(|idx| matches.get(idx).copied())
    }
+
+    fn adjust_scroll(&mut self, matches_len: usize) {
+        if matches_len == 0 {
+            self.scroll_top = 0;
+            return;
+        }
+        let visible_rows = MAX_POPUP_ROWS.min(matches_len);
+        if let Some(sel) = self.selected_idx {
+            if sel < self.scroll_top {
+                self.scroll_top = sel;
+            } else {
+                let bottom = self.scroll_top + visible_rows - 1;
+                if sel > bottom {
+                    self.scroll_top = sel + 1 - visible_rows;
+                }
+            }
+        } else {
+            self.scroll_top = 0;
+        }
+    }
 }

 impl WidgetRef for CommandPopup {
@@ -142,10 +175,8 @@ impl WidgetRef for CommandPopup {
        let matches = self.filtered_commands();

        let mut rows: Vec<Row> = Vec::new();
-        let visible_matches: Vec<&SlashCommand> =
-            matches.into_iter().take(MAX_POPUP_ROWS).collect();

-        if visible_matches.is_empty() {
+        if matches.is_empty() {
            rows.push(Row::new(vec![
                Cell::from(""),
                Cell::from("No matching commands").add_modifier(Modifier::ITALIC),
@@ -153,10 +184,32 @@ impl WidgetRef for CommandPopup {
        } else {
            let default_style = Style::default();
            let command_style = Style::default().fg(Color::LightBlue);
-            for (idx, cmd) in visible_matches.iter().enumerate() {
+            let max_rows_from_area = area.height as usize;
+            let visible_rows = MAX_POPUP_ROWS
+                .min(matches.len())
+                .min(max_rows_from_area.max(1));
+
+            let mut start_idx = self.scroll_top.min(matches.len().saturating_sub(1));
+            if let Some(sel) = self.selected_idx {
+                if sel < start_idx {
+                    start_idx = sel;
+                } else if visible_rows > 0 {
+                    let bottom = start_idx + visible_rows - 1;
+                    if sel > bottom {
+                        start_idx = sel + 1 - visible_rows;
+                    }
+                }
+            }
+
+            for (global_idx, cmd) in matches
+                .iter()
+                .enumerate()
+                .skip(start_idx)
+                .take(visible_rows)
+            {
                rows.push(Row::new(vec![
                    Cell::from(Line::from(vec![
-                        if Some(idx) == self.selected_idx {
+                        if Some(global_idx) == self.selected_idx {
                            Span::styled(
                                "›",
                                Style::default().bg(Color::DarkGray).fg(Color::LightCyan),
@@ -188,3 +241,67 @@ impl WidgetRef for CommandPopup {
        table.render(area, buf);
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::layout::Rect;
+
+    #[test]
+    fn move_down_wraps_to_top() {
+        let mut popup = CommandPopup::new();
+        // Show all commands by simulating composer input starting with '/'.
+        popup.on_composer_text_change("/".to_string());
+        let len = popup.filtered_commands().len();
+        assert!(len > 0);
+
+        // Move to last item.
+        for _ in 0..len.saturating_sub(1) {
+            popup.move_down();
+        }
+        // Next move_down should wrap to index 0.
+        popup.move_down();
+        assert_eq!(popup.selected_idx, Some(0));
+    }
+
+    #[test]
+    fn move_up_wraps_to_bottom() {
+        let mut popup = CommandPopup::new();
+        popup.on_composer_text_change("/".to_string());
+        let len = popup.filtered_commands().len();
+        assert!(len > 0);
+
+        // Initial selection is 0; moving up should wrap to last.
+        popup.move_up();
+        assert_eq!(popup.selected_idx, Some(len - 1));
+    }
+
+    #[test]
+    fn respects_tiny_terminal_height_when_rendering() {
+        let mut popup = CommandPopup::new();
+        popup.on_composer_text_change("/".to_string());
+        assert!(popup.filtered_commands().len() >= 3);
+
+        let area = Rect::new(0, 0, 50, 2);
+        let mut buf = Buffer::empty(area);
+        popup.render(area, &mut buf);
+
+        let mut non_empty_rows = 0u16;
+        for y in 0..area.height {
+            let mut row_has_content = false;
+            for x in 0..area.width {
+                let c = buf[(x, y)].symbol();
+                if !c.trim().is_empty() {
+                    row_has_content = true;
+                    break;
+                }
+            }
+            if row_has_content {
+                non_empty_rows += 1;
+            }
+        }
+
+        assert_eq!(non_empty_rows, 2);
+    }
+}
--- a/codex-rs/tui/src/bottom_pane/file_search_popup.rs
+++ b/codex-rs/tui/src/bottom_pane/file_search_popup.rs
@@ -108,7 +108,6 @@ impl FileSearchPopup {
            .map(|file_match| file_match.path.as_str())
    }

-    /// Preferred height (rows) including border.
    pub(crate) fn calculate_required_height(&self) -> u16 {
        // Row count depends on whether we already have matches. If no matches
        // yet (e.g. initial search or query with no results) reserve a single
--- a/codex-rs/tui/src/bottom_pane/mod.rs
+++ b/codex-rs/tui/src/bottom_pane/mod.rs
@@ -19,7 +19,6 @@ mod chat_composer_history;
 mod command_popup;
 mod file_search_popup;
 mod status_indicator_view;
-mod textarea;

 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CancellationEvent {
@@ -37,7 +36,7 @@ use status_indicator_view::StatusIndicatorView;
 pub(crate) struct BottomPane<'a> {
    /// Composer is retained even when a BottomPaneView is displayed so the
    /// input state is retained when the view is closed.
-    composer: ChatComposer,
+    composer: ChatComposer<'a>,

    /// If present, this is displayed instead of the `composer`.
    active_view: Option<Box<dyn BottomPaneView<'a> + 'a>>,
@@ -75,19 +74,7 @@ impl BottomPane<'_> {
        self.active_view
            .as_ref()
            .map(|v| v.desired_height(width))
-            .unwrap_or(self.composer.desired_height(width))
-    }
-
-    pub fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
-        // Hide the cursor whenever an overlay view is active (e.g. the
-        // status indicator shown while a task is running, or approval modal).
-        // In these states the textarea is not interactable, so we should not
-        // show its caret.
-        if self.active_view.is_some() {
-            None
-        } else {
-            self.composer.cursor_pos(area)
-        }
+            .unwrap_or(self.composer.desired_height())
    }

    /// Forward a key event to the active view or the composer.
--- a/codex-rs/tui/src/bottom_pane/textarea.rs
+++ b/codex-rs/tui/src/bottom_pane/textarea.rs
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::time::Duration;

 use codex_core::codex_wrapper::CodexConversation;
 use codex_core::codex_wrapper::init_codex;
@@ -373,7 +374,6 @@ impl ChatWidget<'_> {
                );
                self.add_to_history(HistoryCell::new_active_exec_command(command));
            }
-            EventMsg::ExecCommandOutputDelta(_) => {}
            EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
                call_id: _,
                auto_approved,
@@ -389,7 +389,6 @@ impl ChatWidget<'_> {
            EventMsg::ExecCommandEnd(ExecCommandEndEvent {
                call_id,
                exit_code,
-                duration,
                stdout,
                stderr,
            }) => {
@@ -400,7 +399,7 @@ impl ChatWidget<'_> {
                        exit_code,
                        stdout,
                        stderr,
-                        duration,
+                        duration: Duration::from_secs(0),
                    },
                ));
            }
@@ -509,10 +508,6 @@ impl ChatWidget<'_> {
        self.bottom_pane
            .set_token_usage(self.token_usage.clone(), self.config.model_context_window);
    }
-
-    pub fn cursor_pos(&self, area: Rect) -> Option<(u16, u16)> {
-        self.bottom_pane.cursor_pos(area)
-    }
 }

 impl WidgetRef for &ChatWidget<'_> {
--- a/codex-rs/tui/src/history_cell.rs
+++ b/codex-rs/tui/src/history_cell.rs
@@ -545,17 +545,24 @@ impl HistoryCell {
        } else {
            for (idx, PlanItemArg { step, status }) in plan.into_iter().enumerate() {
                let num = idx + 1;
-                let icon_span: Span = match status {
-                    StepStatus::Completed => Span::from("✓").fg(Color::Green),
-                    StepStatus::InProgress => Span::from("▶").fg(Color::Yellow).bold(),
-                    StepStatus::Pending => Span::from("○").fg(Color::Gray),
+                let (icon, style): (&str, Style) = match status {
+                    StepStatus::Completed => ("✓", Style::default().fg(Color::Green)),
+                    StepStatus::InProgress => (
+                        "▶",
+                        Style::default()
+                            .fg(Color::Yellow)
+                            .add_modifier(Modifier::BOLD),
+                    ),
+                    StepStatus::Pending => ("○", Style::default().fg(Color::Gray)),
                };
-                lines.push(Line::from(vec![
-                    format!("{num:>2}. [").into(),
-                    icon_span,
-                    "] ".into(),
-                    step.into(),
-                ]));
+                let prefix = vec![
+                    Span::raw(format!("{num:>2}. [")),
+                    Span::styled(icon.to_string(), style),
+                    Span::raw("] "),
+                ];
+                let mut spans = prefix;
+                spans.push(Span::raw(step));
+                lines.push(Line::from(spans));
            }
        }

--- a/codex-rs/tui/src/insert_history.rs
+++ b/codex-rs/tui/src/insert_history.rs
@@ -216,18 +216,18 @@ where
 {
    let mut fg = Color::Reset;
    let mut bg = Color::Reset;
-    let mut last_modifier = Modifier::empty();
+    let mut modifier = Modifier::empty();
    for span in content {
-        let mut modifier = Modifier::empty();
-        modifier.insert(span.style.add_modifier);
-        modifier.remove(span.style.sub_modifier);
-        if modifier != last_modifier {
+        let mut next_modifier = modifier;
+        next_modifier.insert(span.style.add_modifier);
+        next_modifier.remove(span.style.sub_modifier);
+        if next_modifier != modifier {
            let diff = ModifierDiff {
-                from: last_modifier,
-                to: modifier,
+                from: modifier,
+                to: next_modifier,
            };
            diff.queue(&mut writer)?;
-            last_modifier = modifier;
+            modifier = next_modifier;
        }
        let next_fg = span.style.fg.unwrap_or(Color::Reset);
        let next_bg = span.style.bg.unwrap_or(Color::Reset);
@@ -250,37 +250,3 @@ where
        SetAttribute(crossterm::style::Attribute::Reset),
    )
 }
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::unwrap_used)]
-    use super::*;
-
-    #[test]
-    fn writes_bold_then_regular_spans() {
-        use ratatui::style::Stylize;
-
-        let spans = ["A".bold(), "B".into()];
-
-        let mut actual: Vec<u8> = Vec::new();
-        write_spans(&mut actual, spans.iter()).unwrap();
-
-        let mut expected: Vec<u8> = Vec::new();
-        queue!(
-            expected,
-            SetAttribute(crossterm::style::Attribute::Bold),
-            Print("A"),
-            SetAttribute(crossterm::style::Attribute::NormalIntensity),
-            Print("B"),
-            SetForegroundColor(CColor::Reset),
-            SetBackgroundColor(CColor::Reset),
-            SetAttribute(crossterm::style::Attribute::Reset),
-        )
-        .unwrap();
-
-        assert_eq!(
-            String::from_utf8(actual).unwrap(),
-            String::from_utf8(expected).unwrap()
-        );
-    }
-}
--- a/codex-rs/tui/src/lib.rs
+++ b/codex-rs/tui/src/lib.rs
@@ -41,11 +41,6 @@ mod text_formatting;
 mod tui;
 mod user_approval_widget;

-#[cfg(not(debug_assertions))]
-mod updates;
-#[cfg(not(debug_assertions))]
-use color_eyre::owo_colors::OwoColorize;
-
 pub use cli::Cli;

 pub async fn run_main(
@@ -144,38 +139,6 @@ pub async fn run_main(
        .with(tui_layer)
        .try_init();

-    #[allow(clippy::print_stderr)]
-    #[cfg(not(debug_assertions))]
-    if let Some(latest_version) = updates::get_upgrade_version(&config) {
-        let current_version = env!("CARGO_PKG_VERSION");
-        let exe = std::env::current_exe()?;
-        let managed_by_npm = std::env::var_os("CODEX_MANAGED_BY_NPM").is_some();
-
-        eprintln!(
-            "{} {current_version} -> {latest_version}.",
-            "✨⬆️ Update available!".bold().cyan()
-        );
-
-        if managed_by_npm {
-            let npm_cmd = "npm install -g @openai/codex@latest";
-            eprintln!("Run {} to update.", npm_cmd.cyan().on_black());
-        } else if cfg!(target_os = "macos")
-            && (exe.starts_with("/opt/homebrew") || exe.starts_with("/usr/local"))
-        {
-            let brew_cmd = "brew upgrade codex";
-            eprintln!("Run {} to update.", brew_cmd.cyan().on_black());
-        } else {
-            eprintln!(
-                "See {} for the latest releases and installation options.",
-                "https://github.com/openai/codex/releases/latest"
-                    .cyan()
-                    .on_black()
-            );
-        }
-
-        eprintln!("");
-    }
-
    let show_login_screen = should_show_login_screen(&config);
    if show_login_screen {
        std::io::stdout()
--- a/codex-rs/tui/src/status_indicator_widget.rs
+++ b/codex-rs/tui/src/status_indicator_widget.rs
@@ -57,7 +57,7 @@ impl StatusIndicatorWidget {
            thread::spawn(move || {
                let mut counter = 0usize;
                while running_clone.load(Ordering::Relaxed) {
-                    std::thread::sleep(Duration::from_millis(100));
+                    std::thread::sleep(Duration::from_millis(200));
                    counter = counter.wrapping_add(1);
                    frame_idx_clone.store(counter, Ordering::Relaxed);
                    app_event_tx_clone.send(AppEvent::RequestRedraw);
@@ -98,51 +98,46 @@ impl WidgetRef for StatusIndicatorWidget {
            .borders(Borders::LEFT)
            .border_type(BorderType::QuadrantOutside)
            .border_style(widget_style.dim());
+        // Animated 3‑dot pattern inside brackets. The *active* dot is bold
+        // white, the others are dim.
+        const DOT_COUNT: usize = 3;
        let idx = self.frame_idx.load(std::sync::atomic::Ordering::Relaxed);
-        let header_text = "Working";
-        let header_chars: Vec<char> = header_text.chars().collect();
-
-        let padding = 4usize; // virtual padding around the word for smoother loop
-        let period = header_chars.len() + padding * 2;
-        let pos = idx % period;
-
-        let has_true_color = supports_color::on_cached(supports_color::Stream::Stdout)
-            .map(|level| level.has_16m)
-            .unwrap_or(false);
-
-        // Width of the bright band (in characters).
-        let band_half_width = 2.0;
+        let phase = idx % (DOT_COUNT * 2 - 2);
+        let active = if phase < DOT_COUNT {
+            phase
+        } else {
+            (DOT_COUNT * 2 - 2) - phase
+        };

        let mut header_spans: Vec<Span<'static>> = Vec::new();
-        for (i, ch) in header_chars.iter().enumerate() {
-            let i_pos = i as isize + padding as isize;
-            let pos = pos as isize;
-            let dist = (i_pos - pos).abs() as f32;

-            let t = if dist <= band_half_width {
-                let x = std::f32::consts::PI * (dist / band_half_width);
-                0.5 * (1.0 + x.cos())
-            } else {
-                0.0
-            };
+        header_spans.push(Span::styled(
+            "Working ",
+            Style::default()
+                .fg(Color::White)
+                .add_modifier(Modifier::BOLD),
+        ));

-            let brightness = 0.4 + 0.6 * t;
-            let level = (brightness * 255.0).clamp(0.0, 255.0) as u8;
-            let style = if has_true_color {
+        header_spans.push(Span::styled(
+            "[",
+            Style::default()
+                .fg(Color::White)
+                .add_modifier(Modifier::BOLD),
+        ));
+
+        for i in 0..DOT_COUNT {
+            let style = if i == active {
                Style::default()
-                    .fg(Color::Rgb(level, level, level))
+                    .fg(Color::White)
                    .add_modifier(Modifier::BOLD)
            } else {
-                // Bold makes dark gray and gray look the same, so don't use it
-                // when true color is not supported.
-                Style::default().fg(color_for_level(level))
+                Style::default().dim()
            };
-
-            header_spans.push(Span::styled(ch.to_string(), style));
+            header_spans.push(Span::styled(".", style));
        }

        header_spans.push(Span::styled(
-            " ",
+            "] ",
            Style::default()
                .fg(Color::White)
                .add_modifier(Modifier::BOLD),
@@ -194,13 +189,3 @@ impl WidgetRef for StatusIndicatorWidget {
        paragraph.render_ref(area, buf);
    }
 }
-
-fn color_for_level(level: u8) -> Color {
-    if level < 128 {
-        Color::DarkGray
-    } else if level < 192 {
-        Color::Gray
-    } else {
-        Color::White
-    }
-}
--- a/codex-rs/tui/src/updates.rs
+++ b/codex-rs/tui/src/updates.rs
@@ -1,137 +0,0 @@
-#![cfg(any(not(debug_assertions), test))]
-
-use chrono::DateTime;
-use chrono::Duration;
-use chrono::Utc;
-use serde::Deserialize;
-use serde::Serialize;
-use std::path::Path;
-use std::path::PathBuf;
-
-use codex_core::config::Config;
-
-pub fn get_upgrade_version(config: &Config) -> Option<String> {
-    let version_file = version_filepath(config);
-    let info = read_version_info(&version_file).ok();
-
-    if match &info {
-        None => true,
-        Some(info) => info.last_checked_at < Utc::now() - Duration::hours(20),
-    } {
-        // Refresh the cached latest version in the background so TUI startup
-        // isn’t blocked by a network call. The UI reads the previously cached
-        // value (if any) for this run; the next run shows the banner if needed.
-        tokio::spawn(async move {
-            check_for_update(&version_file)
-                .await
-                .inspect_err(|e| tracing::error!("Failed to update version: {e}"))
-        });
-    }
-
-    info.and_then(|info| {
-        let current_version = env!("CARGO_PKG_VERSION");
-        if is_newer(&info.latest_version, current_version).unwrap_or(false) {
-            Some(info.latest_version)
-        } else {
-            None
-        }
-    })
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-struct VersionInfo {
-    latest_version: String,
-    // ISO-8601 timestamp (RFC3339)
-    last_checked_at: DateTime<Utc>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-struct ReleaseInfo {
-    tag_name: String,
-}
-
-const VERSION_FILENAME: &str = "version.json";
-const LATEST_RELEASE_URL: &str = "https://api.github.com/repos/openai/codex/releases/latest";
-
-fn version_filepath(config: &Config) -> PathBuf {
-    config.codex_home.join(VERSION_FILENAME)
-}
-
-fn read_version_info(version_file: &Path) -> anyhow::Result<VersionInfo> {
-    let contents = std::fs::read_to_string(version_file)?;
-    Ok(serde_json::from_str(&contents)?)
-}
-
-async fn check_for_update(version_file: &Path) -> anyhow::Result<()> {
-    let ReleaseInfo {
-        tag_name: latest_tag_name,
-    } = reqwest::Client::new()
-        .get(LATEST_RELEASE_URL)
-        .header(
-            "User-Agent",
-            format!(
-                "codex/{} (+https://github.com/openai/codex)",
-                env!("CARGO_PKG_VERSION")
-            ),
-        )
-        .send()
-        .await?
-        .error_for_status()?
-        .json::<ReleaseInfo>()
-        .await?;
-
-    let info = VersionInfo {
-        latest_version: latest_tag_name
-            .strip_prefix("rust-v")
-            .ok_or_else(|| anyhow::anyhow!("Failed to parse latest tag name '{latest_tag_name}'"))?
-            .into(),
-        last_checked_at: Utc::now(),
-    };
-
-    let json_line = format!("{}\n", serde_json::to_string(&info)?);
-    if let Some(parent) = version_file.parent() {
-        tokio::fs::create_dir_all(parent).await?;
-    }
-    tokio::fs::write(version_file, json_line).await?;
-    Ok(())
-}
-
-fn is_newer(latest: &str, current: &str) -> Option<bool> {
-    match (parse_version(latest), parse_version(current)) {
-        (Some(l), Some(c)) => Some(l > c),
-        _ => None,
-    }
-}
-
-fn parse_version(v: &str) -> Option<(u64, u64, u64)> {
-    let mut iter = v.trim().split('.');
-    let maj = iter.next()?.parse::<u64>().ok()?;
-    let min = iter.next()?.parse::<u64>().ok()?;
-    let pat = iter.next()?.parse::<u64>().ok()?;
-    Some((maj, min, pat))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn prerelease_version_is_not_considered_newer() {
-        assert_eq!(is_newer("0.11.0-beta.1", "0.11.0"), None);
-        assert_eq!(is_newer("1.0.0-rc.1", "1.0.0"), None);
-    }
-
-    #[test]
-    fn plain_semver_comparisons_work() {
-        assert_eq!(is_newer("0.11.1", "0.11.0"), Some(true));
-        assert_eq!(is_newer("0.11.0", "0.11.1"), Some(false));
-        assert_eq!(is_newer("1.0.0", "0.9.9"), Some(true));
-        assert_eq!(is_newer("0.9.9", "1.0.0"), Some(false));
-    }
-
-    #[test]
-    fn whitespace_is_ignored() {
-        assert_eq!(parse_version(" 1.2.3 \n"), Some((1, 2, 3)));
-        assert_eq!(is_newer(" 1.2.3 ", "1.2.2"), Some(true));
-    }
-}
Author	SHA1	Message	Date
easong-openai	f0d9f24fc0	improvements, more dry	2025-08-01 20:01:49 -07:00
easong-openai	60e9eb683c	tests	2025-08-01 17:38:30 -07:00
easong-openai	f7f43f1b5b	Merge remote-tracking branch 'origin/main' into scrollable-slash-menu	2025-08-01 10:15:54 -07:00
easong-openai	9c0f8a50b6	comments	2025-08-01 10:15:07 -07:00
easong-openai	53c19b4d07	tests, scroll to bottom from top	2025-08-01 05:00:45 -07:00
easong-openai	9f45d477e5	comments	2025-08-01 04:34:40 -07:00
easong-openai	1aad659eba	scrollable slash menu, esc to exit	2025-08-01 04:33:01 -07:00