Merge branch 'main' into codex-concurrent-simple

.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=="],
 

.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"
     }
 }

.github/actions/codex/src/process-label.ts

@@ -91,38 +91,7 @@ async function processLabel(
   labelConfig: LabelConfig,
 ): Promise<void> {
   const template = labelConfig.getPromptTemplate();
-
-  // If this is a review label, prepend explicit PR-diff scoping guidance to
-  // reduce out-of-scope feedback. Do this before rendering so placeholders in
-  // the guidance (e.g., {CODEX_ACTION_GITHUB_EVENT_PATH}) are substituted.
-  const isReview = label.toLowerCase().includes("review");
-  const reviewScopeGuidance = `
-PR Diff Scope
-- Only review changes between the PR's merge-base and head; do not comment on commits or files outside this range.
-- Derive the base/head SHAs from the event JSON at {CODEX_ACTION_GITHUB_EVENT_PATH}, then compute and use the PR diff for all analysis and comments.
-
-Commands to determine scope
-- Resolve SHAs:
-  - BASE_SHA=$(jq -r '.pull_request.base.sha // .pull_request.base.ref' "{CODEX_ACTION_GITHUB_EVENT_PATH}")
-  - HEAD_SHA=$(jq -r '.pull_request.head.sha // .pull_request.head.ref' "{CODEX_ACTION_GITHUB_EVENT_PATH}")
-  - BASE_SHA=$(git rev-parse "$BASE_SHA")
-  - HEAD_SHA=$(git rev-parse "$HEAD_SHA")
-- Prefer triple-dot (merge-base) semantics for PR diffs:
-  - Changed commits: git log --oneline "$BASE_SHA...$HEAD_SHA"
-  - Changed files: git diff --name-status "$BASE_SHA...$HEAD_SHA"
-  - Review hunks: git diff -U0 "$BASE_SHA...$HEAD_SHA"
-
-Review rules
-- Anchor every comment to a file and hunk present in git diff "$BASE_SHA...$HEAD_SHA".
-- If you mention context outside the diff, label it as "Follow-up (outside this PR scope)" and keep it brief (<=2 bullets).
-- Do not critique commits or files not reachable in the PR range (merge-base(base, head) → head).
-`.trim();
-
-  const effectiveTemplate = isReview
-    ? `${reviewScopeGuidance}\n\n${template}`
-    : template;
-
-  const populatedTemplate = await renderPromptTemplate(effectiveTemplate, ctx);
+  const populatedTemplate = await renderPromptTemplate(template, ctx);
 
   // Always run Codex and post the resulting message as a comment.
   let commentBody = await runCodex(populatedTemplate, ctx);

.github/codex/labels/codex-rust-review.md

@@ -6,134 +6,18 @@ Then provide the **review** (1-2 sentences plus bullet points, friendly tone).
 
 Things to look out for when doing the review:
 
-## General Principles
-
 - **Make sure the pull request body explains the motivation behind the change.** If the author has failed to do this, call it out, and if you think you can deduce the motivation behind the change, propose copy.
 - Ideally, the PR body also contains a small summary of the change. For small changes, the PR title may be sufficient.
 - Each PR should ideally do one conceptual thing. For example, if a PR does a refactoring as well as introducing a new feature, push back and suggest the refactoring be done in a separate PR. This makes things easier for the reviewer, as refactoring changes can often be far-reaching, yet quick to review.
+- If the nature of the change seems to have a visual component (which is often the case for changes to `codex-rs/tui`), recommend including a screenshot or video to demonstrate the change, if appropriate.
+- Rust files should generally be organized such that the public parts of the API appear near the top of the file and helper functions go below. This is analagous to the "inverted pyramid" structure that is favored in journalism.
+- Encourage the use of small enums or the newtype pattern in Rust if it helps readability without adding significant cognitive load or lines of code.
+- Be wary of large files and offer suggestions for how to break things into more reasonably-sized files.
+- When modifying a `Cargo.toml` file, make sure that dependency lists stay alphabetically sorted. Also consider whether a new dependency is added to the appropriate place (e.g., `[dependencies]` versus `[dev-dependencies]`)
+- If you see opportunities for the changes in a diff to use more idiomatic Rust, please make specific recommendations. For example, favor the use of expressions over `return`.
 - When introducing new code, be on the lookout for code that duplicates existing code. When found, propose a way to refactor the existing code such that it should be reused.
-
-## Code Organization
-
 - Each create in the Cargo workspace in `codex-rs` has a specific purpose: make a note if you believe new code is not introduced in the correct crate.
 - When possible, try to keep the `core` crate as small as possible. Non-core but shared logic is often a good candidate for `codex-rs/common`.
-- Be wary of large files and offer suggestions for how to break things into more reasonably-sized files.
-- Rust files should generally be organized such that the public parts of the API appear near the top of the file and helper functions go below. This is analagous to the "inverted pyramid" structure that is favored in journalism.
-
-## Assertions in Tests
-
-Assert the equality of the entire objects instead of doing "piecemeal comparisons," performing `assert_eq!()` on individual fields.
-
-Note that unit tests also function as "executable documentation." As shown in the following example, "piecemeal comparisons" are often more verbose, provide less coverage, and are not as useful as executable documentation.
-
-For example, suppose you have the following enum:
-
-```rust
-#[derive(Debug, PartialEq)]
-enum Message {
-    Request {
-        id: String,
-        method: String,
-        params: Option<serde_json::Value>,
-    },
-    Notification {
-        method: String,
-        params: Option<serde_json::Value>,
-    },
-}
-```
-
-This is an example of a _piecemeal_ comparison:
-
-```rust
-// BAD: Piecemeal Comparison
-
-#[test]
-fn test_get_latest_messages() {
-    let messages = get_latest_messages();
-    assert_eq!(messages.len(), 2);
-
-    let m0 = &messages[0];
-    match m0 {
-        Message::Request { id, method, params } => {
-            assert_eq!(id, "123");
-            assert_eq!(method, "subscribe");
-            assert_eq!(
-                *params,
-                Some(json!({
-                    "conversation_id": "x42z86"
-                }))
-            )
-        }
-        Message::Notification { .. } => {
-            panic!("expected Request");
-        }
-    }
-
-    let m1 = &messages[1];
-    match m1 {
-        Message::Request { .. } => {
-            panic!("expected Notification");
-        }
-        Message::Notification { method, params } => {
-            assert_eq!(method, "log");
-            assert_eq!(
-                *params,
-                Some(json!({
-                    "level": "info",
-                    "message": "subscribed"
-                }))
-            )
-        }
-    }
-}
-```
-
-This is a _deep_ comparison:
-
-```rust
-// GOOD: Verify the entire structure with a single assert_eq!().
-
-use pretty_assertions::assert_eq;
-
-#[test]
-fn test_get_latest_messages() {
-    let messages = get_latest_messages();
-
-    assert_eq!(
-        vec![
-            Message::Request {
-                id: "123".to_string(),
-                method: "subscribe".to_string(),
-                params: Some(json!({
-                    "conversation_id": "x42z86"
-                })),
-            },
-            Message::Notification {
-                method: "log".to_string(),
-                params: Some(json!({
-                    "level": "info",
-                    "message": "subscribed"
-                })),
-            },
-        ],
-        messages,
-    );
-}
-```
-
-## More Tactical Rust Things To Look Out For
-
-- Do not use `unsafe` (unless you have a really, really good reason like using an operating system API directly and no safe wrapper exists). For example, there are cases where it is tempting to use `unsafe` in order to use `std::env::set_var()`, but this indeed `unsafe` and has led to race conditions on multiple occasions. (When this happens, find a mechanism other than environment variables to use for configuration.)
-- Encourage the use of small enums or the newtype pattern in Rust if it helps readability without adding significant cognitive load or lines of code.
-- If you see opportunities for the changes in a diff to use more idiomatic Rust, please make specific recommendations. For example, favor the use of expressions over `return`.
-- When modifying a `Cargo.toml` file, make sure that dependency lists stay alphabetically sorted. Also consider whether a new dependency is added to the appropriate place (e.g., `[dependencies]` versus `[dev-dependencies]`)
-
-## Pull Request Body
-
-- If the nature of the change seems to have a visual component (which is often the case for changes to `codex-rs/tui`), recommend including a screenshot or video to demonstrate the change, if appropriate.
 - References to existing GitHub issues and PRs are encouraged, where appropriate, though you likely do not have network access, so may not be able to help here.
 
-# PR Information
-
 {CODEX_ACTION_GITHUB_EVENT_PATH} contains the JSON that triggered this GitHub workflow. It contains the `base` and `head` refs that define this PR. Both refs are available locally.

.github/workflows/rust-release.yml

@@ -181,9 +181,9 @@ jobs:
           name: ${{ steps.release_name.outputs.name }}
           tag_name: ${{ github.ref_name }}
           files: dist/**
-          # Mark as prerelease only when the version has a suffix after x.y.z
-          # (e.g. -alpha, -beta). Otherwise publish a normal release.
-          prerelease: ${{ contains(steps.release_name.outputs.name, '-') }}
+          # For now, tag releases as "prerelease" because we are not claiming
+          # the Rust CLI is stable yet.
+          prerelease: true
 
       - uses: facebook/dotslash-publish-release@v2
         env:

.vscode/settings.json

@@ -11,8 +11,6 @@
         "editor.defaultFormatter": "tamasfe.even-better-toml",
         "editor.formatOnSave": true,
     },
-    // Array order for options in ~/.codex/config.toml such as `notify` and the
-    // `args` for an MCP server is significant, so we disable reordering.
-    "evenBetterToml.formatter.reorderArrays": false,
+    "evenBetterToml.formatter.reorderArrays": true,
     "evenBetterToml.formatter.reorderKeys": true,
 }

README.md

@@ -18,7 +18,6 @@ This is the home of the **Codex CLI**, which is a coding agent from OpenAI that
 - [Quickstart](#quickstart)
   - [OpenAI API Users](#openai-api-users)
   - [OpenAI Plus/Pro Users](#openai-pluspro-users)
-- [Using Open Source Models](#using-open-source-models)
 - [Why Codex?](#why-codex)
 - [Security model & permissions](#security-model--permissions)
   - [Platform sandboxing details](#platform-sandboxing-details)
@@ -187,41 +186,6 @@ they'll be committed to your working directory.
 
 ---
 
-## Using Open Source Models
-
-Codex can run fully locally against an OpenAI-compatible OSS host (like Ollama) using the `--oss` flag:
-
-- Interactive UI:
-  - codex --oss
-- Non-interactive (programmatic) mode:
-  - echo "Refactor utils" | codex exec --oss
-
-Model selection when using `--oss`:
-
-- If you omit `-m/--model`, Codex defaults to -m gpt-oss:20b and will verify it exists locally (downloading if needed).
-- To pick a different size, pass one of:
-  - -m "gpt-oss:20b"
-  - -m "gpt-oss:120b"
-
-Point Codex at your own OSS host:
-
-- By default, `--oss` talks to http://localhost:11434/v1.
-- To use a different host, set one of these environment variables before running Codex:
-  - CODEX_OSS_BASE_URL, for example:
-    - CODEX_OSS_BASE_URL="http://my-ollama.example.com:11434/v1" codex --oss -m gpt-oss:20b
-  - or CODEX_OSS_PORT (when the host is localhost):
-    - CODEX_OSS_PORT=11434 codex --oss
-
-Advanced: you can persist this in your config instead of environment variables by overriding the built-in `oss` provider in `~/.codex/config.toml`:
-
-```toml
-[model_providers.oss]
-name = "Open Source"
-base_url = "http://my-ollama.example.com:11434/v1"
-```
-
----
-
 ## Why Codex?
 
 Codex CLI is built for developers who already **live in the terminal** and want

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();

codex-rs/Cargo.lock

@@ -661,7 +661,7 @@ dependencies = [
  "clap",
  "codex-core",
  "serde",
- "toml 0.9.4",
+ "toml 0.9.2",
 ]
 
 [[package]]
@@ -699,7 +699,6 @@ dependencies = [
  "serde_json",
  "sha1",
  "shlex",
- "similar",
  "strum_macros 0.27.2",
  "tempfile",
  "thiserror 2.0.12",
@@ -707,7 +706,7 @@ dependencies = [
  "tokio",
  "tokio-test",
  "tokio-util",
- "toml 0.9.4",
+ "toml 0.9.2",
  "tracing",
  "tree-sitter",
  "tree-sitter-bash",
@@ -729,7 +728,6 @@ dependencies = [
  "codex-arg0",
  "codex-common",
  "codex-core",
- "codex-ollama",
  "owo-colors",
  "predicates",
  "serde_json",
@@ -832,30 +830,13 @@ dependencies = [
  "tempfile",
  "tokio",
  "tokio-test",
- "toml 0.9.4",
+ "toml 0.9.2",
  "tracing",
  "tracing-subscriber",
  "uuid",
  "wiremock",
 ]
 
-[[package]]
-name = "codex-ollama"
-version = "0.0.0"
-dependencies = [
- "async-stream",
- "bytes",
- "codex-core",
- "futures",
- "reqwest",
- "serde_json",
- "tempfile",
- "tokio",
- "toml 0.9.4",
- "tracing",
- "wiremock",
-]
-
 [[package]]
 name = "codex-tui"
 version = "0.0.0"
@@ -870,7 +851,6 @@ dependencies = [
  "codex-core",
  "codex-file-search",
  "codex-login",
- "codex-ollama",
  "color-eyre",
  "crossterm",
  "image",
@@ -879,7 +859,6 @@ dependencies = [
  "mcp-types",
  "path-clean",
  "pretty_assertions",
- "rand 0.8.5",
  "ratatui",
  "ratatui-image",
  "regex-lite",
@@ -889,18 +868,16 @@ dependencies = [
  "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",
- "vt100",
 ]
 
 [[package]]
@@ -1493,7 +1470,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "778e2ac28f6c47af28e4907f13ffd1e1ddbd400980a9abd7c8df189bf578a5ad"
 dependencies = [
  "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -1573,7 +1550,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
  "cfg-if",
  "rustix 1.0.8",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1776,7 +1753,7 @@ version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cba6ae63eb948698e300f645f87c70f76630d505f23b8907cf1e193ee85048c1"
 dependencies = [
- "unicode-width 0.2.1",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
@@ -2037,7 +2014,7 @@ dependencies = [
  "libc",
  "percent-encoding",
  "pin-project-lite",
- "socket2",
+ "socket2 0.6.0",
  "system-configuration",
  "tokio",
  "tower-service",
@@ -2356,15 +2333,9 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
  "hermit-abi",
  "libc",
- "windows-sys 0.52.0",
+ "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"
@@ -3412,7 +3383,7 @@ dependencies = [
 [[package]]
 name = "ratatui"
 version = "0.29.0"
-source = "git+https://github.com/nornagon/ratatui?branch=nornagon-v0.29.0-patch#9b2ad1298408c45918ee9f8241a6f95498cdbed2"
+source = "git+https://github.com/nornagon/ratatui?branch=nornagon-v0.29.0-patch#bca287ddc5d38fe088c79e2eda22422b96226f2e"
 dependencies = [
  "bitflags 2.9.1",
  "cassowary",
@@ -3426,7 +3397,7 @@ dependencies = [
  "strum 0.26.3",
  "unicode-segmentation",
  "unicode-truncate",
- "unicode-width 0.2.1",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
@@ -3740,7 +3711,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -3753,7 +3724,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.9.4",
- "windows-sys 0.52.0",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
@@ -4017,9 +3988,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",
@@ -4203,10 +4174,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"
@@ -4260,7 +4235,7 @@ dependencies = [
  "starlark_syntax",
  "static_assertions",
  "strsim 0.10.0",
- "textwrap 0.11.0",
+ "textwrap",
  "thiserror 1.0.69",
 ]
 
@@ -4396,15 +4371,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"
@@ -4519,7 +4485,7 @@ dependencies = [
  "getrandom 0.3.3",
  "once_cell",
  "rustix 1.0.8",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4558,17 +4524,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.1",
-]
-
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -4683,9 +4638,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",
@@ -4696,9 +4651,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]]
@@ -4783,9 +4738,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",
@@ -5014,7 +4969,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "911e93158bf80bbc94bad533b2b16e3d711e1132d69a6a6980c3920a63422c19"
 dependencies = [
  "ratatui",
- "unicode-width 0.2.1",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
@@ -5033,6 +4988,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"
@@ -5051,12 +5017,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"
@@ -5082,9 +5042,9 @@ checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
 [[package]]
 name = "unicode-width"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a1a07cc7db3810833284e8d372ccdc6da29741639ecc70c9ec107df0fa6154c"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
 name = "unicode-xid"
@@ -5169,27 +5129,6 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
-[[package]]
-name = "vt100"
-version = "0.16.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "054ff75fb8fa83e609e685106df4faeffdf3a735d3c74ebce97ec557d5d36fd9"
-dependencies = [
- "itoa",
- "unicode-width 0.2.1",
- "vte",
-]
-
-[[package]]
-name = "vte"
-version = "0.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5924018406ce0063cd67f8e008104968b74b563ee1b85dde3ed1f7cb87d3dbd"
-dependencies = [
- "arrayvec",
- "memchr",
-]
-
 [[package]]
 name = "wait-timeout"
 version = "0.2.1"
@@ -5378,7 +5317,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]

codex-rs/Cargo.toml

@@ -14,7 +14,6 @@ members = [
     "mcp-client",
     "mcp-server",
     "mcp-types",
-    "ollama",
     "tui",
 ]
 resolver = "2"

codex-rs/apply-patch/src/lib.rs

@@ -42,15 +42,6 @@ impl From<std::io::Error> for ApplyPatchError {
     }
 }
 
-impl From<&std::io::Error> for ApplyPatchError {
-    fn from(err: &std::io::Error) -> Self {
-        ApplyPatchError::IoError(IoError {
-            context: "I/O error".to_string(),
-            source: std::io::Error::new(err.kind(), err.to_string()),
-        })
-    }
-}
-
 #[derive(Debug, Error)]
 #[error("{context}: {source}")]
 pub struct IoError {
@@ -375,21 +366,13 @@ pub fn apply_hunks(
     match apply_hunks_to_files(hunks) {
         Ok(affected) => {
             print_summary(&affected, stdout).map_err(ApplyPatchError::from)?;
-            Ok(())
         }
         Err(err) => {
-            let msg = err.to_string();
-            writeln!(stderr, "{msg}").map_err(ApplyPatchError::from)?;
-            if let Some(io) = err.downcast_ref::<std::io::Error>() {
-                Err(ApplyPatchError::from(io))
-            } else {
-                Err(ApplyPatchError::IoError(IoError {
-                    context: msg,
-                    source: std::io::Error::other(err),
-                }))
-            }
+            writeln!(stderr, "{err:?}").map_err(ApplyPatchError::from)?;
         }
     }
+
+    Ok(())
 }
 
 /// Applies each parsed patch hunk to the filesystem.
@@ -1255,24 +1238,4 @@ g
             })
         );
     }
-
-    #[test]
-    fn test_apply_patch_fails_on_write_error() {
-        let dir = tempdir().unwrap();
-        let path = dir.path().join("readonly.txt");
-        fs::write(&path, "before\n").unwrap();
-        let mut perms = fs::metadata(&path).unwrap().permissions();
-        perms.set_readonly(true);
-        fs::set_permissions(&path, perms).unwrap();
-
-        let patch = wrap_patch(&format!(
-            "*** Update File: {}\n@@\n-before\n+after\n*** End Patch",
-            path.display()
-        ));
-
-        let mut stdout = Vec::new();
-        let mut stderr = Vec::new();
-        let result = apply_patch(&patch, &mut stdout, &mut stderr);
-        assert!(result.is_err());
-    }
 }

codex-rs/cli/src/concurrent/mod.rs

@@ -0,0 +1,584 @@
+use std::fs::File;
+use std::io::Write;
+use std::path::Path;
+use std::path::PathBuf;
+use std::process::Command;
+use std::process::Stdio;
+use std::sync::OnceLock;
+
+use tokio::process::Command as TokioCommand;
+use tokio::sync::Semaphore;
+
+use anyhow::Context;
+use codex_common::CliConfigOverrides;
+use codex_exec::Cli as ExecCli;
+
+// Serialize git worktree add operations across tasks to avoid repository lock contention.
+static GIT_WORKTREE_ADD_SEMAPHORE: OnceLock<Semaphore> = OnceLock::new();
+
+#[derive(Debug, Clone)]
+pub struct ConcurrentRunResult {
+    pub branch: String,
+    pub worktree_dir: PathBuf,
+    pub log_file: Option<PathBuf>,
+    pub exec_exit_code: Option<i32>,
+    pub _had_changes: bool,
+    pub _applied_changes: Option<usize>,
+}
+
+fn compute_codex_home() -> PathBuf {
+    if let Ok(val) = std::env::var("CODEX_HOME") {
+        if !val.is_empty() {
+            return PathBuf::from(val);
+        }
+    }
+    // Fallback to default (~/.codex) without requiring it to already exist.
+    codex_core::config::find_codex_home().unwrap_or_else(|_| {
+        let mut p = std::env::var_os("HOME")
+            .map(PathBuf::from)
+            .unwrap_or_default();
+        if p.as_os_str().is_empty() {
+            return PathBuf::from(".codex");
+        }
+        p.push(".codex");
+        p
+    })
+}
+
+fn slugify_prompt(prompt: &str, max_len: usize) -> String {
+    let mut out = String::with_capacity(prompt.len());
+    let mut prev_hyphen = false;
+    for ch in prompt.chars() {
+        let c = ch.to_ascii_lowercase();
+        let keep = matches!(c, 'a'..='z' | '0'..='9');
+        if keep {
+            out.push(c);
+            prev_hyphen = false;
+        } else if c.is_ascii_whitespace() || matches!(c, '-' | '_' | '+') {
+            if !prev_hyphen && !out.is_empty() {
+                out.push('-');
+                prev_hyphen = true;
+            }
+        } else {
+            // skip other punctuation/symbols
+        }
+        if out.len() >= max_len {
+            break;
+        }
+    }
+    // Trim trailing hyphens
+    while out.ends_with('-') {
+        out.pop();
+    }
+    if out.is_empty() {
+        "task".to_string()
+    } else {
+        out
+    }
+}
+
+fn git_output(repo_dir: &Path, args: &[&str]) -> anyhow::Result<String> {
+    let out = Command::new("git")
+        .args(args)
+        .current_dir(repo_dir)
+        .output()
+        .with_context(|| format!("running git {args:?}"))?;
+    if !out.status.success() {
+        anyhow::bail!(
+            "git {:?} failed with status {}: {}",
+            args,
+            out.status,
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+    Ok(String::from_utf8_lossy(&out.stdout).trim().to_string())
+}
+
+fn git_capture_stdout(repo_dir: &Path, args: &[&str]) -> anyhow::Result<Vec<u8>> {
+    let out = Command::new("git")
+        .args(args)
+        .current_dir(repo_dir)
+        .output()
+        .with_context(|| format!("running git {args:?}"))?;
+    if !out.status.success() {
+        anyhow::bail!(
+            "git {:?} failed with status {}: {}",
+            args,
+            out.status,
+            String::from_utf8_lossy(&out.stderr)
+        );
+    }
+    Ok(out.stdout)
+}
+
+fn count_files_in_patch(diff: &[u8]) -> usize {
+    // Count occurrences of lines starting with "diff --git ", which mark file boundaries.
+    // This works for text and binary patches produced by `git diff --binary`.
+    let mut count = 0usize;
+    for line in diff.split(|&b| b == b'\n') {
+        if line.starts_with(b"diff --git ") {
+            count += 1;
+        }
+    }
+    count
+}
+
+pub async fn run_concurrent_flow(
+    prompt: String,
+    cli_config_overrides: CliConfigOverrides,
+    codex_linux_sandbox_exe: Option<PathBuf>,
+    automerge: bool,
+    quiet: bool,
+) -> anyhow::Result<ConcurrentRunResult> {
+    let cwd = std::env::current_dir()?;
+
+    // Ensure we are in a git repo and find repo root.
+    let repo_root_str = git_output(&cwd, &["rev-parse", "--show-toplevel"]);
+    let repo_root = match repo_root_str {
+        Ok(p) => PathBuf::from(p),
+        Err(err) => {
+            eprintln!("Not inside a Git repo: {err}");
+            std::process::exit(1);
+        }
+    };
+
+    // Determine current branch and original head commit.
+    let current_branch = git_output(&repo_root, &["rev-parse", "--abbrev-ref", "HEAD"])
+        .unwrap_or_else(|_| "HEAD".to_string());
+    let original_head =
+        git_output(&repo_root, &["rev-parse", "HEAD"]).context("finding original HEAD commit")?;
+
+    // Build worktree target path under $CODEX_HOME/worktrees/<repo>/<branch>
+    let mut codex_home = compute_codex_home();
+    codex_home.push("worktrees");
+    // repo name = last component of repo_root
+    let repo_name = repo_root
+        .file_name()
+        .map(|s| s.to_string_lossy().to_string())
+        .unwrap_or_else(|| "repo".to_string());
+    codex_home.push(repo_name.clone());
+
+    // Prepare branch name: codex/<slug>, retrying with a numeric suffix to avoid races.
+    let slug = slugify_prompt(&prompt, 64);
+    let mut branch: String;
+    let worktree_dir: PathBuf;
+    let mut attempt: u32 = 1;
+    loop {
+        branch = if attempt == 1 {
+            format!("codex/{slug}")
+        } else {
+            format!("codex/{slug}-{attempt}")
+        };
+
+        let mut candidate_dir = codex_home.clone();
+        candidate_dir.push(&branch);
+
+        // Create parent directories for candidate path.
+        if let Some(parent) = candidate_dir.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+
+        if !quiet {
+            println!(
+                "Creating worktree at {} with branch {}",
+                candidate_dir.display(),
+                branch
+            );
+        }
+
+        // Try to add worktree with new branch from current HEAD
+        let worktree_path_str = candidate_dir.to_string_lossy().to_string();
+        let add_status = Command::new("git")
+            .arg("worktree")
+            .arg("add")
+            .arg("-b")
+            .arg(&branch)
+            .arg(&worktree_path_str)
+            .current_dir(&repo_root)
+            .status()?;
+        if add_status.success() {
+            worktree_dir = candidate_dir;
+            break;
+        }
+
+        attempt += 1;
+        if attempt > 50 {
+            anyhow::bail!("Failed to create git worktree after multiple attempts");
+        }
+        // Retry with a new branch name.
+    }
+
+    // Either run codex exec inline (verbose) or as a subprocess with logs redirected.
+    let mut log_file: Option<PathBuf> = None;
+    let mut exec_exit_code: Option<i32> = None;
+    if quiet {
+        let exe = std::env::current_exe()
+            .map_err(|e| anyhow::anyhow!("failed to locate current executable: {e}"))?;
+
+        // Prepare logs directory: $CODEX_HOME/logs/<repo_name>
+        let mut logs_dir = compute_codex_home();
+        logs_dir.push("logs");
+        logs_dir.push(&repo_name);
+        std::fs::create_dir_all(&logs_dir)?;
+
+        let sanitized_branch = branch.replace('/', "_");
+        let log_path = logs_dir.join(format!("{sanitized_branch}.log"));
+        let log_f = File::create(&log_path)?;
+        log_file = Some(log_path.clone());
+
+        let mut cmd = Command::new(exe);
+        cmd.arg("exec")
+            .arg("--full-auto")
+            .arg("--cd")
+            .arg(worktree_dir.as_os_str())
+            .stdout(Stdio::from(log_f.try_clone()?))
+            .stderr(Stdio::from(log_f));
+
+        // Forward any root-level config overrides.
+        for ov in cli_config_overrides.raw_overrides.iter() {
+            cmd.arg("-c").arg(ov);
+        }
+
+        // Append the prompt last (positional argument).
+        cmd.arg(&prompt);
+
+        let status = cmd.status()?;
+        exec_exit_code = status.code();
+        if !status.success() && !quiet {
+            eprintln!("codex exec failed with exit code {exec_exit_code:?}");
+        }
+    } else {
+        // Build an ExecCli to run in full-auto mode at the worktree directory.
+        let mut exec_cli = ExecCli {
+            images: vec![],
+            model: None,
+            sandbox_mode: None,
+            config_profile: None,
+            full_auto: true,
+            dangerously_bypass_approvals_and_sandbox: false,
+            cwd: Some(worktree_dir.clone()),
+            skip_git_repo_check: false,
+            config_overrides: CliConfigOverrides::default(),
+            color: Default::default(),
+            json: false,
+            last_message_file: None,
+            prompt: Some(prompt.clone()),
+        };
+
+        // Prepend any root-level config overrides.
+        super::prepend_config_flags(&mut exec_cli.config_overrides, cli_config_overrides);
+
+        // Run codex exec
+        if let Err(e) = codex_exec::run_main(exec_cli, codex_linux_sandbox_exe).await {
+            eprintln!("codex exec failed: {e}");
+            // Do not attempt to bring changes on failure; leave worktree for inspection.
+            return Err(e);
+        }
+    }
+
+    // Auto-commit changes in the worktree if any
+    let status_out = Command::new("git")
+        .args(["status", "--porcelain"])
+        .current_dir(&worktree_dir)
+        .output()?;
+    let status_text = String::from_utf8_lossy(&status_out.stdout);
+    let had_changes = !status_text.trim().is_empty();
+    if had_changes {
+        // Stage and commit
+        if !Command::new("git")
+            .args(["add", "-A"])
+            .current_dir(&worktree_dir)
+            .status()?
+            .success()
+        {
+            anyhow::bail!("git add failed in worktree");
+        }
+        let commit_message = format!("Codex concurrent: {prompt}");
+        if !Command::new("git")
+            .args(["commit", "-m", &commit_message])
+            .current_dir(&worktree_dir)
+            .status()?
+            .success()
+        {
+            if !quiet {
+                eprintln!("No commit created (maybe no changes)");
+            }
+        } else if !quiet {
+            println!("Committed changes in worktree branch {branch}");
+        }
+    } else if !quiet {
+        println!("No changes detected in worktree; skipping commit.");
+    }
+
+    if !automerge {
+        if !quiet {
+            println!(
+                "Auto-merge disabled; leaving changes in worktree {} on branch {}.",
+                worktree_dir.display(),
+                branch
+            );
+            println!(
+                "You can review and manually merge from that branch into {current_branch} when ready."
+            );
+            println!("Summary: Auto-merge disabled.");
+        }
+        return Ok(ConcurrentRunResult {
+            branch,
+            worktree_dir,
+            log_file,
+            exec_exit_code,
+            _had_changes: had_changes,
+            _applied_changes: None,
+        });
+    }
+
+    // Bring the changes into the main working tree as UNSTAGED modifications.
+    // We generate a patch from the original HEAD to the worktree branch tip, then apply with 3-way merge.
+    if !quiet {
+        println!("Applying changes from {branch} onto {current_branch} as unstaged modifications");
+    }
+    let range = format!("{original_head}..{branch}");
+    let mut diff_bytes =
+        git_capture_stdout(&repo_root, &["diff", "--binary", "--full-index", &range])?;
+
+    // Fallback: if there is nothing in the commit range (e.g., commit didn't happen),
+    // try to capture uncommitted changes from the worktree working tree.
+    if diff_bytes.is_empty() && had_changes {
+        // If we saw changes earlier but no commit diff was produced, fall back to working tree diff.
+        // This captures unstaged changes relative to HEAD in the worktree.
+        diff_bytes =
+            git_capture_stdout(&worktree_dir, &["diff", "--binary", "--full-index", "HEAD"])?;
+    }
+
+    if diff_bytes.is_empty() {
+        if !quiet {
+            println!("Summary: 0 changes detected.");
+        }
+        return Ok(ConcurrentRunResult {
+            branch,
+            worktree_dir,
+            log_file,
+            exec_exit_code,
+            _had_changes: had_changes,
+            _applied_changes: Some(0),
+        });
+    }
+
+    let changed_files = count_files_in_patch(&diff_bytes);
+
+    let mut child = Command::new("git")
+        .arg("apply")
+        .arg("-3")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .current_dir(&repo_root)
+        .spawn()
+        .context("spawning git apply")?;
+    if let Some(stdin) = child.stdin.as_mut() {
+        stdin
+            .write_all(&diff_bytes)
+            .context("writing patch to git apply stdin")?;
+    }
+    let status = child.wait().context("waiting for git apply")?;
+    if !status.success() {
+        if !quiet {
+            eprintln!(
+                "Applying changes failed. You can manually inspect {} and apply diffs.",
+                worktree_dir.display()
+            );
+            println!("Summary: Apply failed.");
+        }
+    } else {
+        if !quiet {
+            println!("Changes applied to working tree (unstaged).");
+            println!("Summary: Applied {changed_files} files changed.");
+        }
+
+        // Cleanup: remove the worktree and delete the temporary branch.
+        if !quiet {
+            println!(
+                "Cleaning up worktree {} and branch {}",
+                worktree_dir.display(),
+                branch
+            );
+        }
+        let worktree_path_str = worktree_dir.to_string_lossy().to_string();
+        let remove_status = Command::new("git")
+            .args(["worktree", "remove", &worktree_path_str])
+            .current_dir(&repo_root)
+            .status();
+        match remove_status {
+            Ok(s) if s.success() => {
+                // removed
+            }
+            _ => {
+                if !quiet {
+                    eprintln!("git worktree remove failed; retrying with --force");
+                }
+                let _ = Command::new("git")
+                    .args(["worktree", "remove", "--force", &worktree_path_str])
+                    .current_dir(&repo_root)
+                    .status();
+            }
+        }
+
+        let del_status = Command::new("git")
+            .args(["branch", "-D", &branch])
+            .current_dir(&repo_root)
+            .status();
+        if let Ok(s) = del_status {
+            if !s.success() && !quiet {
+                eprintln!("Failed to delete branch {branch}");
+            }
+        } else if !quiet {
+            eprintln!("Error running git branch -D {branch}");
+        }
+    }
+
+    Ok(ConcurrentRunResult {
+        branch,
+        worktree_dir,
+        log_file,
+        exec_exit_code,
+        _had_changes: had_changes,
+        _applied_changes: Some(changed_files),
+    })
+}
+
+/// A Send-friendly variant used for best-of-n: run quietly (logs redirected) and do not auto-merge.
+/// This intentionally avoids referencing non-Send types from codex-exec.
+pub async fn run_concurrent_flow_quiet_no_automerge(
+    prompt: String,
+    cli_config_overrides: CliConfigOverrides,
+    _codex_linux_sandbox_exe: Option<PathBuf>,
+) -> anyhow::Result<ConcurrentRunResult> {
+    let cwd = std::env::current_dir()?;
+
+    let repo_root_str = git_output(&cwd, &["rev-parse", "--show-toplevel"]);
+    let repo_root = match repo_root_str {
+        Ok(p) => PathBuf::from(p),
+        Err(err) => {
+            eprintln!("Not inside a Git repo: {err}");
+            std::process::exit(1);
+        }
+    };
+
+    // Capture basic repo info (not used further in quiet/no-automerge flow).
+
+    let mut codex_home = compute_codex_home();
+    codex_home.push("worktrees");
+    let repo_name = repo_root
+        .file_name()
+        .map(|s| s.to_string_lossy().to_string())
+        .unwrap_or_else(|| "repo".to_string());
+    codex_home.push(repo_name.clone());
+
+    let slug = slugify_prompt(&prompt, 64);
+    let mut branch: String;
+    let worktree_dir: PathBuf;
+    // Serialize worktree creation to avoid git repo lock contention across tasks.
+    {
+        let semaphore = GIT_WORKTREE_ADD_SEMAPHORE.get_or_init(|| Semaphore::new(1));
+        let _permit = semaphore.acquire().await.expect("semaphore closed");
+
+        let mut attempt: u32 = 1;
+        loop {
+            branch = if attempt == 1 {
+                format!("codex/{slug}")
+            } else {
+                format!("codex/{slug}-{attempt}")
+            };
+
+            let mut candidate_dir = codex_home.clone();
+            candidate_dir.push(&branch);
+
+            if let Some(parent) = candidate_dir.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+
+            let worktree_path_str = candidate_dir.to_string_lossy().to_string();
+            let add_status = TokioCommand::new("git")
+                .arg("worktree")
+                .arg("add")
+                .arg("-b")
+                .arg(&branch)
+                .arg(&worktree_path_str)
+                .current_dir(&repo_root)
+                .status()
+                .await?;
+            if add_status.success() {
+                worktree_dir = candidate_dir;
+                break;
+            }
+            attempt += 1;
+            if attempt > 50 {
+                anyhow::bail!("Failed to create git worktree after multiple attempts");
+            }
+        }
+    }
+
+    // Run the CLI in quiet mode (logs redirected).
+    let exe = std::env::current_exe()
+        .map_err(|e| anyhow::anyhow!("failed to locate current executable: {e}"))?;
+
+    let mut logs_dir = compute_codex_home();
+    logs_dir.push("logs");
+    logs_dir.push(&repo_name);
+    std::fs::create_dir_all(&logs_dir)?;
+
+    let sanitized_branch = branch.replace('/', "_");
+    let log_path = logs_dir.join(format!("{sanitized_branch}.log"));
+    let log_f = File::create(&log_path)?;
+    let log_file = Some(log_path.clone());
+
+    let mut cmd = TokioCommand::new(exe);
+    cmd.arg("exec")
+        .arg("--full-auto")
+        .arg("--cd")
+        .arg(worktree_dir.as_os_str())
+        .stdout(Stdio::from(log_f.try_clone()?))
+        .stderr(Stdio::from(log_f));
+    for ov in cli_config_overrides.raw_overrides.iter() {
+        cmd.arg("-c").arg(ov);
+    }
+    cmd.arg(&prompt);
+
+    let status = cmd.status().await?;
+    let exec_exit_code = status.code();
+
+    // Auto-commit changes in the worktree if any
+    let status_out = TokioCommand::new("git")
+        .args(["status", "--porcelain"])
+        .current_dir(&worktree_dir)
+        .output()
+        .await?;
+    let status_text = String::from_utf8_lossy(&status_out.stdout);
+    let had_changes = !status_text.trim().is_empty();
+    if had_changes {
+        if !TokioCommand::new("git")
+            .args(["add", "-A"])
+            .current_dir(&worktree_dir)
+            .status()
+            .await?
+            .success()
+        {
+            anyhow::bail!("git add failed in worktree");
+        }
+        let commit_message = format!("Codex concurrent: {prompt}");
+        let _ = TokioCommand::new("git")
+            .args(["commit", "-m", &commit_message])
+            .current_dir(&worktree_dir)
+            .status()
+            .await?;
+    }
+
+    Ok(ConcurrentRunResult {
+        branch,
+        worktree_dir,
+        log_file,
+        exec_exit_code,
+        _had_changes: had_changes,
+        _applied_changes: None,
+    })
+}

codex-rs/cli/src/main.rs

@@ -17,6 +17,7 @@ use codex_tui::Cli as TuiCli;
 use std::path::PathBuf;
 
 use crate::proto::ProtoCli;
+mod concurrent;
 
 /// Codex CLI
 ///
@@ -32,6 +33,22 @@ struct MultitoolCli {
     #[clap(flatten)]
     pub config_overrides: CliConfigOverrides,
 
+    /// Experimental:Launch a concurrent task in a separate Git worktree using the given prompt.
+    /// Creates worktree under $CODEX_HOME/worktrees/<repo>/codex/<slug> and runs `codex exec` in full-auto mode.
+    #[arg(long = "concurrent", value_name = "PROMPT")]
+    pub concurrent: Option<String>,
+
+    /// When using --concurrent, also attempt to auto-merge the resulting changes
+    /// back into the current working tree as unstaged modifications via
+    /// a 3-way git apply. Disable with --automerge=false.
+    #[arg(long = "automerge", default_value_t = true, action = clap::ArgAction::Set)]
+    pub automerge: bool,
+
+    /// Run the same --concurrent prompt N times in separate worktrees and keep them all.
+    /// Intended to generate multiple candidate solutions without auto-merging.
+    #[arg(long = "best-of-n", value_name = "N", default_value_t = 1)]
+    pub best_of_n: usize,
+
     #[clap(flatten)]
     interactive: TuiCli,
 
@@ -116,14 +133,93 @@ fn main() -> anyhow::Result<()> {
 async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()> {
     let cli = MultitoolCli::parse();
 
+    // Handle --concurrent at the root level.
+    if let Some(prompt) = cli.concurrent.clone() {
+        if cli.subcommand.is_some() {
+            eprintln!("--concurrent cannot be used together with a subcommand");
+            std::process::exit(2);
+        }
+        let runs = if cli.best_of_n == 0 { 1 } else { cli.best_of_n };
+        if runs > 1 {
+            println!(
+                "Running best-of-n with {runs} runs; auto-merge will be disabled and worktrees kept."
+            );
+
+            // Launch all runs concurrently and collect results as they finish.
+            let mut join_set = tokio::task::JoinSet::new();
+            for _ in 0..runs {
+                let prompt = prompt.clone();
+                let overrides = cli.config_overrides.clone();
+                let sandbox = codex_linux_sandbox_exe.clone();
+                join_set.spawn(async move {
+                    concurrent::run_concurrent_flow_quiet_no_automerge(prompt, overrides, sandbox)
+                        .await
+                });
+            }
+
+            let mut results: Vec<concurrent::ConcurrentRunResult> = Vec::with_capacity(runs);
+            while let Some(join_result) = join_set.join_next().await {
+                match join_result {
+                    Ok(Ok(res)) => {
+                        println!(
+                            "task finished for branch: {}\n, directory: {}",
+                            res.branch,
+                            res.worktree_dir.display()
+                        );
+                        results.push(res);
+                    }
+                    Ok(Err(err)) => {
+                        eprintln!("concurrent task failed: {err}");
+                    }
+                    Err(join_err) => {
+                        eprintln!("failed to join concurrent task: {join_err}");
+                    }
+                }
+            }
+
+            println!("\nBest-of-n summary:");
+            for r in &results {
+                let status = match r.exec_exit_code {
+                    Some(0) => "OK",
+                    Some(_code) => "FAIL",
+                    None => "OK",
+                };
+                let log = r
+                    .log_file
+                    .as_ref()
+                    .map(|p| p.to_string_lossy().to_string())
+                    .unwrap_or_else(|| "<no log>".to_string());
+                println!(
+                    "[{status}] branch={} worktree={} log={}",
+                    r.branch,
+                    r.worktree_dir.display(),
+                    log
+                );
+            }
+        } else {
+            concurrent::run_concurrent_flow(
+                prompt,
+                cli.config_overrides,
+                codex_linux_sandbox_exe,
+                cli.automerge,
+                false,
+            )
+            .await?;
+        }
+        return Ok(());
+    }
+
+    if cli.best_of_n > 1 {
+        eprintln!("--best-of-n requires --concurrent <PROMPT>");
+        std::process::exit(2);
+    }
+
     match cli.subcommand {
         None => {
             let mut tui_cli = cli.interactive;
             prepend_config_flags(&mut tui_cli.config_overrides, cli.config_overrides);
             let usage = codex_tui::run_main(tui_cli, codex_linux_sandbox_exe).await?;
-            if !usage.is_zero() {
-                println!("{}", codex_core::protocol::FinalOutput::from(usage));
-            }
+            println!("{}", codex_core::protocol::FinalOutput::from(usage));
         }
         Some(Subcommand::Exec(mut exec_cli)) => {
             prepend_config_flags(&mut exec_cli.config_overrides, cli.config_overrides);

codex-rs/common/src/approval_mode_cli_arg.rs

@@ -18,9 +18,6 @@ pub enum ApprovalModeCliArg {
     /// will escalate to the user to ask for un-sandboxed execution.
     OnFailure,
 
-    /// The model decides when to ask the user for approval.
-    OnRequest,
-
     /// Never ask for user approval
     /// Execution failures are immediately returned to the model.
     Never,
@@ -31,7 +28,6 @@ impl From<ApprovalModeCliArg> for AskForApproval {
         match value {
             ApprovalModeCliArg::Untrusted => AskForApproval::UnlessTrusted,
             ApprovalModeCliArg::OnFailure => AskForApproval::OnFailure,
-            ApprovalModeCliArg::OnRequest => AskForApproval::OnRequest,
             ApprovalModeCliArg::Never => AskForApproval::Never,
         }
     }

codex-rs/common/src/config_summary.rs

@@ -1,29 +0,0 @@
-use codex_core::WireApi;
-use codex_core::config::Config;
-
-use crate::sandbox_summary::summarize_sandbox_policy;
-
-/// Build a list of key/value pairs summarizing the effective configuration.
-pub fn create_config_summary_entries(config: &Config) -> Vec<(&'static str, String)> {
-    let mut entries = vec![
-        ("workdir", config.cwd.display().to_string()),
-        ("model", config.model.clone()),
-        ("provider", config.model_provider_id.clone()),
-        ("approval", config.approval_policy.to_string()),
-        ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
-    ];
-    if config.model_provider.wire_api == WireApi::Responses
-        && config.model_family.supports_reasoning_summaries
-    {
-        entries.push((
-            "reasoning effort",
-            config.model_reasoning_effort.to_string(),
-        ));
-        entries.push((
-            "reasoning summaries",
-            config.model_reasoning_summary.to_string(),
-        ));
-    }
-
-    entries
-}

codex-rs/common/src/lib.rs

@@ -23,7 +23,3 @@ mod sandbox_summary;
 
 #[cfg(feature = "sandbox_summary")]
 pub use sandbox_summary::summarize_sandbox_policy;
-
-mod config_summary;
-
-pub use config_summary::create_config_summary_entries;

codex-rs/config.md

@@ -148,20 +148,12 @@ Determines when the user should be prompted to approve whether Codex can execute
 approval_policy = "untrusted"
 ```
 
-If you want to be notified whenever a command fails, use "on-failure":
 ```toml
 # If the command fails when run in the sandbox, Codex asks for permission to
 # retry the command outside the sandbox.
 approval_policy = "on-failure"
 ```
 
-If you want the model to run until it decides that it needs to ask you for escalated permissions, use "on-request":
-```toml
-# The model decides when to escalate
-approval_policy = "on-request"
-```
-
-Alternatively, you can have the model run until it is done, and never ask to run a command with escalated permissions:
 ```toml
 # User is never prompted: if the command fails, Codex will automatically try
 # something out. Note the `exec` subcommand always uses this mode.
@@ -491,19 +483,6 @@ Setting `hide_agent_reasoning` to `true` suppresses these events in **both** the
 hide_agent_reasoning = true   # defaults to false
 ```
 
-## show_raw_agent_reasoning
-
-Surfaces the model’s raw chain-of-thought ("raw reasoning content") when available.
-
-Notes:
-- Only takes effect if the selected model/provider actually emits raw reasoning content. Many models do not. When unsupported, this option has no visible effect.
-- Raw reasoning may include intermediate thoughts or sensitive context. Enable only if acceptable for your workflow.
-
-Example:
-```toml
-show_raw_agent_reasoning = true  # defaults to false
-```
-
 ## model_context_window
 
 The size of the context window for the model, in tokens.

codex-rs/core/Cargo.toml

@@ -34,7 +34,6 @@ 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 +45,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"

codex-rs/core/prompt.md

@@ -1,31 +1,16 @@
-You are operating as and within the Codex CLI, an open-source, terminal-based agentic coding assistant built by OpenAI. It wraps OpenAI models to enable natural language interaction with a local codebase. You are expected to be precise, safe, and helpful.
+Please resolve the user's task by editing and testing the code files in your current code execution session.
+You are a deployed coding agent.
+Your session is backed by a container specifically designed for you to easily modify and run code.
+The repo(s) are already cloned in your working directory, and you must fully solve the problem for your answer to be considered correct.
 
-Your capabilities:
-- Receive user prompts, project context, and files.
-- Stream responses and emit function calls (e.g., shell commands, code edits).
-- Run commands, like apply_patch, and manage user approvals based on policy.
-- Work inside a workspace with sandboxing instructions specified by the policy described in (## Sandbox environment and approval instructions)
-
-Within this context, Codex refers to the open-source agentic coding interface (not the old Codex language model built by OpenAI).
-
-## General guidelines
-As a deployed coding agent, please continue working on the user's task until their query is resolved, before ending your turn and yielding back to the user. Only terminate your turn when you are sure that the task is solved. If you are not sure about file content or codebase structure pertaining to the user's request, use your tools to read files and gather the relevant information. Do NOT guess or make up an answer.
-
-After a user sends their first message, you should immediately provide a brief message acknowledging their request to set the tone and expectation of future work to be done (no more than 8-10 words). This should be done before performing work like exploring the codebase, writing or reading files, or other tool calls needed to complete the task. Use a natural, collaborative tone similar to how a teammate would receive a task during a pair programming session.
-
-Please resolve the user's task by editing the code files in your current code execution session. Your session allows for you to modify and run code. The repo(s) are already cloned in your working directory, and you must fully solve the problem for your answer to be considered correct.
-
-### Task execution
 You MUST adhere to the following criteria when executing the task:
 
 - Working on the repo(s) in the current environment is allowed, even if they are proprietary.
 - Analyzing code for vulnerabilities is allowed.
 - Showing user code and tool call details is allowed.
 - User instructions may overwrite the _CODING GUIDELINES_ section in this developer message.
-- `user_instructions` are not part of the user's request, but guidance for how to complete the task.
-- Do not cite `user_instructions` back to the user unless a specific piece is relevant.
 - Do not use \`ls -R\`, \`find\`, or \`grep\` - these are slow in large repos. Use \`rg\` and \`rg --files\`.
-- Use the \`apply_patch\` shell command 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.
@@ -48,22 +33,23 @@ You MUST adhere to the following criteria when executing the task:
 - If completing the user's task DOES NOT require writing or modifying files (e.g., the user asks a question about the code base):
   - Respond in a friendly tune as a remote teammate, who is knowledgeable, capable and eager to help with coding.
 - When your task involves writing or modifying files:
-  - Do NOT tell the user to "save the file" or "copy the code into a file" if you already created or modified the file using the `apply_patch` shell command. Instead, reference the file as already saved.
+  - Do NOT tell the user to "save the file" or "copy the code into a file" if you already created or modified the file using \`apply_patch\`. Instead, reference the file as already saved.
   - Do NOT show the full contents of large files you have already written, unless the user explicitly asks for them.
 
-## Using the shell command `apply_patch` to edit files
-`apply_patch` is a shell command for editing files. 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:
+§ `apply-patch` Specification
 
-*** Begin Patch
+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
 [ 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.
@@ -77,60 +63,45 @@ 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:
 
 - You must include a header with your intended action (Add/Delete/Update)
 - You must prefix new lines with `+` even when creating a new file
-- You must follow this schema exactly when providing a patch
 
-You can invoke apply_patch with the following shell command:
+You can invoke apply_patch like:
 
 ```
 shell {"command":["apply_patch","*** Begin Patch\n*** Add File: hello.txt\n+Hello, world!\n*** End Patch\n"]}
 ```
 
-## Sandbox environment and approval instructions
-
-You are running in a sandboxed workspace backed by version control. The sandbox might be configured by the user to restrict certain behaviors, like accessing the internet or writing to files outside the current directory.
-
-Commands that are blocked by sandbox settings will be automatically sent to the user for approval. The result of the request will be returned (i.e. the command result, or the request denial).
-The user also has an opportunity to approve the same command for the rest of the session.
-
-Guidance on running within the sandbox:
-- When running commands that will likely require approval, attempt to use simple, precise commands, to reduce frequency of approval requests.
-- When approval is denied or a command fails due to a permission error, do not retry the exact command in a different way. Move on and continue trying to address the user's request.
-
-
-## Tools available
-### Plan updates
+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`.
-

codex-rs/core/src/chat_completions.rs

@@ -21,9 +21,7 @@ use crate::client_common::ResponseEvent;
 use crate::client_common::ResponseStream;
 use crate::error::CodexErr;
 use crate::error::Result;
-use crate::model_family::ModelFamily;
 use crate::models::ContentItem;
-use crate::models::ReasoningItemContent;
 use crate::models::ResponseItem;
 use crate::openai_tools::create_tools_json_for_chat_completions_api;
 use crate::util::backoff;
@@ -31,19 +29,22 @@ use crate::util::backoff;
 /// Implementation for the classic Chat Completions API.
 pub(crate) async fn stream_chat_completions(
     prompt: &Prompt,
-    model_family: &ModelFamily,
+    model: &str,
+    include_plan_tool: bool,
     client: &reqwest::Client,
     provider: &ModelProviderInfo,
 ) -> Result<ResponseStream> {
     // Build messages array
     let mut messages = Vec::<serde_json::Value>::new();
 
-    let full_instructions = prompt.get_full_instructions(model_family);
+    let full_instructions = prompt.get_full_instructions(model);
     messages.push(json!({"role": "system", "content": full_instructions}));
 
-    let input = prompt.get_formatted_input();
+    if let Some(instr) = &prompt.user_instructions {
+        messages.push(json!({"role": "user", "content": instr}));
+    }
 
-    for item in &input {
+    for item in &prompt.input {
         match item {
             ResponseItem::Message { role, content, .. } => {
                 let mut text = String::new();
@@ -109,9 +110,9 @@ pub(crate) async fn stream_chat_completions(
         }
     }
 
-    let tools_json = create_tools_json_for_chat_completions_api(&prompt.tools)?;
+    let tools_json = create_tools_json_for_chat_completions_api(prompt, model, include_plan_tool)?;
     let payload = json!({
-        "model": model_family.slug,
+        "model": model,
         "messages": messages,
         "stream": true,
         "tools": tools_json,
@@ -119,7 +120,7 @@ pub(crate) async fn stream_chat_completions(
 
     debug!(
         "POST to {}: {}",
-        provider.get_full_url(&None),
+        provider.get_full_url(),
         serde_json::to_string_pretty(&payload).unwrap_or_default()
     );
 
@@ -128,7 +129,7 @@ pub(crate) async fn stream_chat_completions(
     loop {
         attempt += 1;
 
-        let req_builder = provider.create_request_builder(client, &None).await?;
+        let req_builder = provider.create_request_builder(client)?;
 
         let res = req_builder
             .header(reqwest::header::ACCEPT, "text/event-stream")
@@ -206,8 +207,6 @@ async fn process_chat_sse<S>(
     }
 
     let mut fn_call_state = FunctionCallState::default();
-    let mut assistant_text = String::new();
-    let mut reasoning_text = String::new();
 
     loop {
         let sse = match timeout(idle_timeout, stream.next()).await {
@@ -236,31 +235,6 @@ async fn process_chat_sse<S>(
 
         // OpenAI Chat streaming sends a literal string "[DONE]" when finished.
         if sse.data.trim() == "[DONE]" {
-            // Emit any finalized items before closing so downstream consumers receive
-            // terminal events for both assistant content and raw reasoning.
-            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;
-            }
-
-            if !reasoning_text.is_empty() {
-                let item = ResponseItem::Reasoning {
-                    id: String::new(),
-                    summary: Vec::new(),
-                    content: Some(vec![ReasoningItemContent::ReasoningText {
-                        text: std::mem::take(&mut reasoning_text),
-                    }]),
-                    encrypted_content: None,
-                };
-                let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
-            }
-
             let _ = tx_event
                 .send(Ok(ResponseEvent::Completed {
                     response_id: String::new(),
@@ -280,47 +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.
-            // Some providers stream `reasoning` as a plain string while others
-            // nest the text under an object (e.g. `{ "reasoning": { "text": "…" } }`).
-            if let Some(reasoning_val) = choice.get("delta").and_then(|d| d.get("reasoning")) {
-                let mut maybe_text = reasoning_val.as_str().map(|s| s.to_string());
-
-                if maybe_text.is_none() && reasoning_val.is_object() {
-                    if let Some(s) = reasoning_val
-                        .get("text")
-                        .and_then(|t| t.as_str())
-                        .filter(|s| !s.is_empty())
-                    {
-                        maybe_text = Some(s.to_string());
-                    } else if let Some(s) = reasoning_val
-                        .get("content")
-                        .and_then(|t| t.as_str())
-                        .filter(|s| !s.is_empty())
-                    {
-                        maybe_text = Some(s.to_string());
-                    }
-                }
-
-                if let Some(reasoning) = maybe_text {
-                    let _ = tx_event
-                        .send(Ok(ResponseEvent::ReasoningContentDelta(reasoning)))
-                        .await;
-                }
+                let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
             }
 
             // Handle streaming function / tool calls.
@@ -357,21 +305,7 @@ async fn process_chat_sse<S>(
             if let Some(finish_reason) = choice.get("finish_reason").and_then(|v| v.as_str()) {
                 match finish_reason {
                     "tool_calls" if fn_call_state.active => {
-                        // First, flush the terminal raw reasoning so UIs can finalize
-                        // the reasoning stream before any exec/tool events begin.
-                        if !reasoning_text.is_empty() {
-                            let item = ResponseItem::Reasoning {
-                                id: String::new(),
-                                summary: Vec::new(),
-                                content: Some(vec![ReasoningItemContent::ReasoningText {
-                                    text: std::mem::take(&mut reasoning_text),
-                                }]),
-                                encrypted_content: None,
-                            };
-                            let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
-                        }
-
-                        // Then emit the FunctionCall response item.
+                        // Build the FunctionCall response item.
                         let item = ResponseItem::FunctionCall {
                             id: None,
                             name: fn_call_state.name.clone().unwrap_or_else(|| "".to_string()),
@@ -379,33 +313,11 @@ async fn process_chat_sse<S>(
                             call_id: fn_call_state.call_id.clone().unwrap_or_else(String::new),
                         };
 
+                        // Emit it downstream.
                         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;
-                        }
-                        // Also emit a terminal Reasoning item so UIs can finalize raw reasoning.
-                        if !reasoning_text.is_empty() {
-                            let item = ResponseItem::Reasoning {
-                                id: String::new(),
-                                summary: Vec::new(),
-                                content: Some(vec![ReasoningItemContent::ReasoningText {
-                                    text: std::mem::take(&mut reasoning_text),
-                                }]),
-                                encrypted_content: None,
-                            };
-                            let _ = tx_event.send(Ok(ResponseEvent::OutputItemDone(item))).await;
-                        }
+                        // Regular turn without tool-call.
                     }
                     _ => {}
                 }
@@ -443,17 +355,10 @@ async fn process_chat_sse<S>(
 /// The adapter is intentionally *lossless*: callers who do **not** opt in via
 /// [`AggregateStreamExt::aggregate()`] keep receiving the original unmodified
 /// events.
-#[derive(Copy, Clone, Eq, PartialEq)]
-enum AggregateMode {
-    AggregatedOnly,
-    Streaming,
-}
 pub(crate) struct AggregatedChatStream<S> {
     inner: S,
     cumulative: String,
-    cumulative_reasoning: String,
-    pending: std::collections::VecDeque<ResponseEvent>,
-    mode: AggregateMode,
+    pending_completed: Option<ResponseEvent>,
 }
 
 impl<S> Stream for AggregatedChatStream<S>
@@ -465,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)));
         }
 
@@ -483,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;
                     }
 
@@ -508,50 +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()
-                        && matches!(this.mode, AggregateMode::AggregatedOnly)
-                    {
-                        let aggregated_reasoning = crate::models::ResponseItem::Reasoning {
-                            id: String::new(),
-                            summary: Vec::new(),
-                            content: Some(vec![
-                                crate::models::ReasoningItemContent::ReasoningText {
-                                    text: std::mem::take(&mut this.cumulative_reasoning),
-                                },
-                            ]),
-                            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.
@@ -565,27 +439,10 @@ 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 matches!(this.mode, AggregateMode::Streaming) {
-                        // In streaming mode, also forward the delta immediately.
-                        return Poll::Ready(Some(Ok(ResponseEvent::OutputTextDelta(delta))));
-                    } else {
-                        continue;
-                    }
-                }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta)))) => {
-                    // Always accumulate reasoning deltas so we can emit a final Reasoning item at Completed.
-                    this.cumulative_reasoning.push_str(&delta);
-                    if matches!(this.mode, AggregateMode::Streaming) {
-                        // In streaming mode, also forward the delta immediately.
-                        return Poll::Ready(Some(Ok(ResponseEvent::ReasoningContentDelta(delta))));
-                    } else {
-                        continue;
-                    }
-                }
-                Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(_)))) => {
+                Poll::Ready(Some(Ok(ResponseEvent::OutputTextDelta(_))))
+                | Poll::Ready(Some(Ok(ResponseEvent::ReasoningSummaryDelta(_)))) => {
+                    // Deltas are ignored here since aggregation waits for the
+                    // final OutputItemDone.
                     continue;
                 }
             }
@@ -615,24 +472,12 @@ pub(crate) trait AggregateStreamExt: Stream<Item = Result<ResponseEvent>> + Size
     /// }
     /// ```
     fn aggregate(self) -> AggregatedChatStream<Self> {
-        AggregatedChatStream::new(self, AggregateMode::AggregatedOnly)
+        AggregatedChatStream {
+            inner: self,
+            cumulative: String::new(),
+            pending_completed: None,
+        }
     }
 }
 
 impl<T> AggregateStreamExt for T where T: Stream<Item = Result<ResponseEvent>> + Sized {}
-
-impl<S> AggregatedChatStream<S> {
-    fn new(inner: S, mode: AggregateMode) -> Self {
-        AggregatedChatStream {
-            inner,
-            cumulative: String::new(),
-            cumulative_reasoning: String::new(),
-            pending: std::collections::VecDeque::new(),
-            mode,
-        }
-    }
-
-    pub(crate) fn streaming_mode(inner: S) -> Self {
-        Self::new(inner, AggregateMode::Streaming)
-    }
-}

codex-rs/core/src/client.rs

@@ -30,10 +30,12 @@ use crate::config::Config;
 use crate::config_types::ReasoningEffort as ReasoningEffortConfig;
 use crate::config_types::ReasoningSummary as ReasoningSummaryConfig;
 use crate::error::CodexErr;
+use crate::error::EnvVarError;
 use crate::error::Result;
 use crate::flags::CODEX_RS_SSE_FIXTURE;
 use crate::model_provider_info::ModelProviderInfo;
 use crate::model_provider_info::WireApi;
+use crate::models::ContentItem;
 use crate::models::ResponseItem;
 use crate::openai_tools::create_tools_json_for_responses_api;
 use crate::protocol::TokenUsage;
@@ -81,7 +83,8 @@ impl ModelClient {
                 // Create the raw streaming connection first.
                 let response_stream = stream_chat_completions(
                     prompt,
-                    &self.config.model_family,
+                    &self.config.model,
+                    self.config.include_plan_tool,
                     &self.client,
                     &self.provider,
                 )
@@ -90,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.show_raw_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.
@@ -123,29 +122,32 @@ impl ModelClient {
             return stream_from_fixture(path, self.provider.clone()).await;
         }
 
-        let auth = self.auth.clone();
+        let auth = self.auth.as_ref().ok_or_else(|| {
+            CodexErr::EnvVar(EnvVarError {
+                var: "OPENAI_API_KEY".to_string(),
+                instructions: Some("Create an API key (https://platform.openai.com) and export it as an environment variable.".to_string()),
+            })
+        })?;
 
-        let auth_mode = auth.as_ref().map(|a| a.mode);
+        let store = prompt.store && auth.mode != AuthMode::ChatGPT;
 
-        if self.config.model_family.requires_chatgpt_auth && auth_mode != Some(AuthMode::ChatGPT) {
-            return Err(CodexErr::UnexpectedStatus(
-                StatusCode::BAD_REQUEST,
-                format!(
-                    "{slug} is only supported with ChatGPT auth, run `codex login status` to check your auth status and `codex login` to login with ChatGPT",
-                    slug = self.config.model_family.slug
-                ),
-            ));
-        }
+        let base_url = match self.provider.base_url.clone() {
+            Some(url) => url,
+            None => match auth.mode {
+                AuthMode::ChatGPT => "https://chatgpt.com/backend-api/codex".to_string(),
+                AuthMode::ApiKey => "https://api.openai.com/v1".to_string(),
+            },
+        };
 
-        let store = prompt.store && auth_mode != Some(AuthMode::ChatGPT);
+        let token = auth.get_token().await?;
 
-        let full_instructions = prompt.get_full_instructions(&self.config.model_family);
-        let tools_json = create_tools_json_for_responses_api(&prompt.tools)?;
-        let reasoning = create_reasoning_param_for_request(
-            &self.config.model_family,
-            self.effort,
-            self.summary,
-        );
+        let full_instructions = prompt.get_full_instructions(&self.config.model);
+        let tools_json = create_tools_json_for_responses_api(
+            prompt,
+            &self.config.model,
+            self.config.include_plan_tool,
+        )?;
+        let reasoning = create_reasoning_param_for_request(&self.config, self.effort, self.summary);
 
         // Request encrypted COT if we are not storing responses,
         // otherwise reasoning items will be referenced by ID
@@ -155,7 +157,15 @@ impl ModelClient {
             vec![]
         };
 
-        let input_with_instructions = prompt.get_formatted_input();
+        let mut input_with_instructions = Vec::with_capacity(prompt.input.len() + 1);
+        if let Some(ui) = &prompt.user_instructions {
+            input_with_instructions.push(ResponseItem::Message {
+                id: None,
+                role: "user".to_string(),
+                content: vec![ContentItem::InputText { text: ui.clone() }],
+            });
+        }
+        input_with_instructions.extend(prompt.input.clone());
 
         let payload = ResponsesApiRequest {
             model: &self.config.model,
@@ -170,36 +180,35 @@ impl ModelClient {
             include,
         };
 
-        let mut attempt = 0;
-        let max_retries = self.provider.request_max_retries();
-
         trace!(
             "POST to {}: {}",
-            self.provider.get_full_url(&auth),
+            self.provider.get_full_url(),
             serde_json::to_string(&payload)?
         );
 
+        let mut attempt = 0;
+        let max_retries = self.provider.request_max_retries();
+
         loop {
             attempt += 1;
 
             let mut req_builder = self
-                .provider
-                .create_request_builder(&self.client, &auth)
-                .await?;
-
-            req_builder = req_builder
+                .client
+                .post(format!("{base_url}/responses"))
                 .header("OpenAI-Beta", "responses=experimental")
                 .header("session_id", self.session_id.to_string())
+                .bearer_auth(&token)
                 .header(reqwest::header::ACCEPT, "text/event-stream")
                 .json(&payload);
 
-            if let Some(auth) = auth.as_ref()
-                && auth.mode == AuthMode::ChatGPT
-                && let Some(account_id) = auth.get_account_id().await
-            {
-                req_builder = req_builder.header("chatgpt-account-id", account_id);
+            if auth.mode == AuthMode::ChatGPT {
+                if let Some(account_id) = auth.get_account_id().await {
+                    req_builder = req_builder.header("chatgpt-account-id", account_id);
+                }
             }
 
+            req_builder = self.provider.apply_http_headers(req_builder);
+
             let originator = self
                 .config
                 .internal_originator
@@ -437,14 +446,6 @@ async fn process_sse<S>(
                     }
                 }
             }
-            "response.reasoning_text.delta" => {
-                if let Some(delta) = event.delta {
-                    let event = ResponseEvent::ReasoningContentDelta(delta);
-                    if tx_event.send(Ok(event)).await.is_err() {
-                        return;
-                    }
-                }
-            }
             "response.created" => {
                 if event.response.is_some() {
                     let _ = tx_event.send(Ok(ResponseEvent::Created {})).await;
@@ -633,7 +634,7 @@ mod tests {
             request_max_retries: Some(0),
             stream_max_retries: Some(0),
             stream_idle_timeout_ms: Some(1000),
-            requires_openai_auth: false,
+            requires_auth: false,
         };
 
         let events = collect_events(
@@ -693,7 +694,7 @@ mod tests {
             request_max_retries: Some(0),
             stream_max_retries: Some(0),
             stream_idle_timeout_ms: Some(1000),
-            requires_openai_auth: false,
+            requires_auth: false,
         };
 
         let events = collect_events(&[sse1.as_bytes()], provider).await;
@@ -796,7 +797,7 @@ mod tests {
                 request_max_retries: Some(0),
                 stream_max_retries: Some(0),
                 stream_idle_timeout_ms: Some(1000),
-                requires_openai_auth: false,
+                requires_auth: false,
             };
 
             let out = run_sse(evs, provider).await;

codex-rs/core/src/client_common.rs

@@ -1,19 +1,13 @@
 use crate::config_types::ReasoningEffort as ReasoningEffortConfig;
 use crate::config_types::ReasoningSummary as ReasoningSummaryConfig;
 use crate::error::Result;
-use crate::model_family::ModelFamily;
-use crate::models::ContentItem;
 use crate::models::ResponseItem;
-use crate::openai_tools::OpenAiTool;
-use crate::protocol::AskForApproval;
-use crate::protocol::SandboxPolicy;
 use crate::protocol::TokenUsage;
 use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
 use futures::Stream;
 use serde::Serialize;
 use std::borrow::Cow;
-use std::fmt::Display;
-use std::path::PathBuf;
+use std::collections::HashMap;
 use std::pin::Pin;
 use std::task::Context;
 use std::task::Poll;
@@ -23,47 +17,6 @@ use tokio::sync::mpsc;
 /// with this content.
 const BASE_INSTRUCTIONS: &str = include_str!("../prompt.md");
 
-/// wraps environment context message in a tag for the model to parse more easily.
-const ENVIRONMENT_CONTEXT_START: &str = "<environment_context>\n\n";
-const ENVIRONMENT_CONTEXT_END: &str = "\n\n</environment_context>";
-
-/// wraps user instructions message in a tag for the model to parse more easily.
-const USER_INSTRUCTIONS_START: &str = "<user_instructions>\n\n";
-const USER_INSTRUCTIONS_END: &str = "\n\n</user_instructions>";
-
-#[derive(Debug, Clone)]
-pub(crate) struct EnvironmentContext {
-    pub cwd: PathBuf,
-    pub approval_policy: AskForApproval,
-    pub sandbox_policy: SandboxPolicy,
-}
-
-impl Display for EnvironmentContext {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(
-            f,
-            "Current working directory: {}",
-            self.cwd.to_string_lossy()
-        )?;
-        writeln!(f, "Approval policy: {}", self.approval_policy)?;
-        writeln!(f, "Sandbox policy: {}", self.sandbox_policy)?;
-
-        let network_access = match self.sandbox_policy.clone() {
-            SandboxPolicy::DangerFullAccess => "enabled",
-            SandboxPolicy::ReadOnly => "restricted",
-            SandboxPolicy::WorkspaceWrite { network_access, .. } => {
-                if network_access {
-                    "enabled"
-                } else {
-                    "restricted"
-                }
-            }
-        };
-        writeln!(f, "Network access: {network_access}")?;
-        Ok(())
-    }
-}
-
 /// API request payload for a single model turn.
 #[derive(Default, Debug, Clone)]
 pub struct Prompt {
@@ -75,62 +28,27 @@ pub struct Prompt {
     /// Whether to store response on server side (disable_response_storage = !store).
     pub store: bool,
 
-    /// A list of key-value pairs that will be added as a developer message
-    /// for the model to use
-    pub environment_context: Option<EnvironmentContext>,
-
-    /// Tools available to the model, including additional tools sourced from
-    /// external MCP servers.
-    pub tools: Vec<OpenAiTool>,
+    /// Additional tools sourced from external MCP servers. Note each key is
+    /// the "fully qualified" tool name (i.e., prefixed with the server name),
+    /// which should be reported to the model in place of Tool::name.
+    pub extra_tools: HashMap<String, mcp_types::Tool>,
 
     /// Optional override for the built-in BASE_INSTRUCTIONS.
     pub base_instructions_override: Option<String>,
 }
 
 impl Prompt {
-    pub(crate) fn get_full_instructions(&self, model: &ModelFamily) -> Cow<'_, str> {
+    pub(crate) fn get_full_instructions(&self, model: &str) -> Cow<'_, str> {
         let base = self
             .base_instructions_override
             .as_deref()
             .unwrap_or(BASE_INSTRUCTIONS);
         let mut sections: Vec<&str> = vec![base];
-        if model.needs_special_apply_patch_instructions {
+        if model.starts_with("gpt-4.1") {
             sections.push(APPLY_PATCH_TOOL_INSTRUCTIONS);
         }
         Cow::Owned(sections.join("\n"))
     }
-
-    fn get_formatted_user_instructions(&self) -> Option<String> {
-        self.user_instructions
-            .as_ref()
-            .map(|ui| format!("{USER_INSTRUCTIONS_START}{ui}{USER_INSTRUCTIONS_END}"))
-    }
-
-    fn get_formatted_environment_context(&self) -> Option<String> {
-        self.environment_context
-            .as_ref()
-            .map(|ec| format!("{ENVIRONMENT_CONTEXT_START}{ec}{ENVIRONMENT_CONTEXT_END}"))
-    }
-
-    pub(crate) fn get_formatted_input(&self) -> Vec<ResponseItem> {
-        let mut input_with_instructions = Vec::with_capacity(self.input.len() + 2);
-        if let Some(ec) = self.get_formatted_environment_context() {
-            input_with_instructions.push(ResponseItem::Message {
-                id: None,
-                role: "user".to_string(),
-                content: vec![ContentItem::InputText { text: ec }],
-            });
-        }
-        if let Some(ui) = self.get_formatted_user_instructions() {
-            input_with_instructions.push(ResponseItem::Message {
-                id: None,
-                role: "user".to_string(),
-                content: vec![ContentItem::InputText { text: ui }],
-            });
-        }
-        input_with_instructions.extend(self.input.clone());
-        input_with_instructions
-    }
 }
 
 #[derive(Debug)]
@@ -143,7 +61,6 @@ pub enum ResponseEvent {
     },
     OutputTextDelta(String),
     ReasoningSummaryDelta(String),
-    ReasoningContentDelta(String),
 }
 
 #[derive(Debug, Serialize)]
@@ -217,12 +134,14 @@ pub(crate) struct ResponsesApiRequest<'a> {
     pub(crate) include: Vec<String>,
 }
 
+use crate::config::Config;
+
 pub(crate) fn create_reasoning_param_for_request(
-    model_family: &ModelFamily,
+    config: &Config,
     effort: ReasoningEffortConfig,
     summary: ReasoningSummaryConfig,
 ) -> Option<Reasoning> {
-    if model_family.supports_reasoning_summaries {
+    if model_supports_reasoning_summaries(config) {
         let effort: Option<OpenAiReasoningEffort> = effort.into();
         let effort = effort?;
         Some(Reasoning {
@@ -234,6 +153,27 @@ pub(crate) fn create_reasoning_param_for_request(
     }
 }
 
+pub fn model_supports_reasoning_summaries(config: &Config) -> bool {
+    // Currently, we hardcode this rule to decide whether to enable reasoning.
+    // We expect reasoning to apply only to OpenAI models, but we do not want
+    // users to have to mess with their config to disable reasoning for models
+    // that do not support it, such as `gpt-4.1`.
+    //
+    // Though if a user is using Codex with non-OpenAI models that, say, happen
+    // to start with "o", then they can set `model_reasoning_effort = "none"` in
+    // config.toml to disable reasoning.
+    //
+    // Converseley, if a user has a non-OpenAI provider that supports reasoning,
+    // they can set the top-level `model_supports_reasoning_summaries = true`
+    // config option to enable reasoning.
+    if config.model_supports_reasoning_summaries {
+        return true;
+    }
+
+    let model = &config.model;
+    model.starts_with("o") || model.starts_with("codex")
+}
+
 pub(crate) struct ResponseStream {
     pub(crate) rx_event: mpsc::Receiver<Result<ResponseEvent>>,
 }
@@ -248,9 +188,6 @@ impl Stream for ResponseStream {
 
 #[cfg(test)]
 mod tests {
-    #![allow(clippy::expect_used)]
-    use crate::model_family::find_family_for_model;
-
     use super::*;
 
     #[test]
@@ -260,8 +197,7 @@ mod tests {
             ..Default::default()
         };
         let expected = format!("{BASE_INSTRUCTIONS}\n{APPLY_PATCH_TOOL_INSTRUCTIONS}");
-        let model_family = find_family_for_model("gpt-4.1").expect("known model slug");
-        let full = prompt.get_full_instructions(&model_family);
+        let full = prompt.get_full_instructions("gpt-4.1");
         assert_eq!(full, expected);
     }
 }

codex-rs/core/src/codex.rs

@@ -37,7 +37,6 @@ use crate::apply_patch::convert_apply_patch_to_protocol;
 use crate::apply_patch::get_writable_roots;
 use crate::apply_patch::{self};
 use crate::client::ModelClient;
-use crate::client_common::EnvironmentContext;
 use crate::client_common::Prompt;
 use crate::client_common::ResponseEvent;
 use crate::config::Config;
@@ -57,21 +56,16 @@ 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;
 use crate::models::ShellToolCallParams;
-use crate::openai_tools::ToolsConfig;
-use crate::openai_tools::get_openai_tools;
 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::AgentReasoningDeltaEvent;
 use crate::protocol::AgentReasoningEvent;
-use crate::protocol::AgentReasoningRawContentDeltaEvent;
-use crate::protocol::AgentReasoningRawContentEvent;
 use crate::protocol::ApplyPatchApprovalRequestEvent;
 use crate::protocol::AskForApproval;
 use crate::protocol::BackgroundEventEvent;
@@ -91,13 +85,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;
 
@@ -129,7 +121,7 @@ impl Codex {
         let resume_path = config.experimental_resume.clone();
         info!("resume_path: {resume_path:?}");
         let (tx_sub, rx_sub) = async_channel::bounded(64);
-        let (tx_event, rx_event) = async_channel::unbounded();
+        let (tx_event, rx_event) = async_channel::bounded(1600);
 
         let user_instructions = get_user_instructions(&config).await;
 
@@ -219,7 +211,6 @@ pub(crate) struct Session {
     shell_environment_policy: ShellEnvironmentPolicy,
     pub(crate) writable_roots: Mutex<Vec<PathBuf>>,
     disable_response_storage: bool,
-    tools_config: ToolsConfig,
 
     /// Manager for external MCP servers/tools.
     mcp_connection_manager: McpConnectionManager,
@@ -234,7 +225,6 @@ pub(crate) struct Session {
     state: Mutex<State>,
     codex_linux_sandbox_exe: Option<PathBuf>,
     user_shell: shell::Shell,
-    show_raw_agent_reasoning: bool,
 }
 
 impl Session {
@@ -372,11 +362,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,
@@ -388,15 +374,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(),
@@ -410,21 +392,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
@@ -436,15 +412,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,
             })
         };
 
@@ -453,20 +428,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
@@ -709,7 +670,7 @@ async fn submission_loop(
                 cwd,
                 resume_path,
             } => {
-                debug!(
+                info!(
                     "Configuring session: model={model}; provider={provider:?}; resume={resume_path:?}"
                 );
                 if !cwd.is_absolute() {
@@ -814,12 +775,6 @@ async fn submission_loop(
                 let default_shell = shell::default_user_shell().await;
                 sess = Some(Arc::new(Session {
                     client,
-                    tools_config: ToolsConfig::new(
-                        &config.model_family,
-                        approval_policy,
-                        sandbox_policy.clone(),
-                        config.include_plan_tool,
-                    ),
                     tx_event: tx_event.clone(),
                     ctrl_c: Arc::clone(&ctrl_c),
                     user_instructions,
@@ -836,7 +791,6 @@ async fn submission_loop(
                     codex_linux_sandbox_exe: config.codex_linux_sandbox_exe.clone(),
                     disable_response_storage,
                     user_shell: default_shell,
-                    show_raw_agent_reasoning: config.show_raw_agent_reasoning,
                 }));
 
                 // Patch restored state into the newly created session.
@@ -1047,10 +1001,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
@@ -1082,7 +1032,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();
@@ -1147,7 +1097,6 @@ async fn run_task(sess: Arc<Session>, sub_id: String, input: Vec<InputItem>) {
                             ResponseItem::Reasoning {
                                 id,
                                 summary,
-                                content,
                                 encrypted_content,
                             },
                             None,
@@ -1155,7 +1104,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(),
                             });
                         }
@@ -1210,31 +1158,21 @@ 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>> {
-    let tools = get_openai_tools(
-        &sess.tools_config,
-        Some(sess.mcp_connection_manager.list_all_tools()),
-    );
-
+    let extra_tools = sess.mcp_connection_manager.list_all_tools();
     let prompt = Prompt {
         input,
         user_instructions: sess.user_instructions.clone(),
         store: !sess.disable_response_storage,
-        tools,
+        extra_tools,
         base_instructions_override: sess.base_instructions.clone(),
-        environment_context: Some(EnvironmentContext {
-            cwd: sess.cwd.clone(),
-            approval_policy: sess.approval_policy,
-            sandbox_policy: sess.sandbox_policy.clone(),
-        }),
     };
 
     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)),
@@ -1280,7 +1218,6 @@ struct ProcessedResponseItem {
 
 async fn try_run_turn(
     sess: &Session,
-    turn_diff_tracker: &mut TurnDiffTracker,
     sub_id: &str,
     prompt: &Prompt,
 ) -> CodexResult<Vec<ProcessedResponseItem>> {
@@ -1368,8 +1305,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 });
             }
@@ -1387,24 +1323,9 @@ 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) => {
-                {
-                    let mut st = sess.state.lock().unwrap();
-                    st.history.append_assistant_text(&delta);
-                }
-
                 let event = Event {
                     id: sub_id.to_string(),
                     msg: EventMsg::AgentMessageDelta(AgentMessageDeltaEvent { delta }),
@@ -1418,17 +1339,6 @@ async fn try_run_turn(
                 };
                 sess.tx_event.send(event).await.ok();
             }
-            ResponseEvent::ReasoningContentDelta(delta) => {
-                if sess.show_raw_agent_reasoning {
-                    let event = Event {
-                        id: sub_id.to_string(),
-                        msg: EventMsg::AgentReasoningRawContentDelta(
-                            AgentReasoningRawContentDeltaEvent { delta },
-                        ),
-                    };
-                    sess.tx_event.send(event).await.ok();
-                }
-            }
         }
     }
 }
@@ -1455,8 +1365,7 @@ async fn run_compact_task(
         input: turn_input,
         user_instructions: None,
         store: !sess.disable_response_storage,
-        environment_context: None,
-        tools: Vec::new(),
+        extra_tools: HashMap::new(),
         base_instructions_override: Some(compact_instructions.clone()),
     };
 
@@ -1518,7 +1427,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>> {
@@ -1536,12 +1444,7 @@ async fn handle_response_item(
             }
             None
         }
-        ResponseItem::Reasoning {
-            id: _,
-            summary,
-            content,
-            encrypted_content: _,
-        } => {
+        ResponseItem::Reasoning { summary, .. } => {
             for item in summary {
                 let text = match item {
                     ReasoningItemReasoningSummary::SummaryText { text } => text,
@@ -1552,21 +1455,6 @@ async fn handle_response_item(
                 };
                 sess.tx_event.send(event).await.ok();
             }
-            if sess.show_raw_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::AgentReasoningRawContent(AgentReasoningRawContentEvent {
-                            text,
-                        }),
-                    };
-                    sess.tx_event.send(event).await.ok();
-                }
-            }
             None
         }
         ResponseItem::FunctionCall {
@@ -1576,17 +1464,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,
@@ -1600,8 +1478,6 @@ async fn handle_response_item(
                 command: action.command,
                 workdir: action.working_directory,
                 timeout_ms: action.timeout_ms,
-                with_escalated_permissions: None,
-                justification: None,
             };
             let effective_call_id = match (call_id, id) {
                 (Some(call_id), _) => call_id,
@@ -1623,7 +1499,6 @@ async fn handle_response_item(
                 handle_container_exec_with_params(
                     exec_params,
                     sess,
-                    turn_diff_tracker,
                     sub_id.to_string(),
                     effective_call_id,
                 )
@@ -1641,7 +1516,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,
@@ -1655,8 +1529,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,
         _ => {
@@ -1690,8 +1563,6 @@ fn to_exec_params(params: ShellToolCallParams, sess: &Session) -> ExecParams {
         cwd: sess.resolve_path(params.workdir.clone()),
         timeout_ms: params.timeout_ms,
         env: create_env(&sess.shell_environment_policy),
-        with_escalated_permissions: params.with_escalated_permissions,
-        justification: params.justification,
     }
 }
 
@@ -1732,7 +1603,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 {
@@ -1792,19 +1662,13 @@ async fn handle_container_exec_with_params(
                 cwd: cwd.clone(),
                 timeout_ms: params.timeout_ms,
                 env: HashMap::new(),
-                with_escalated_permissions: params.with_escalated_permissions,
-                justification: params.justification.clone(),
             };
             let safety = if *user_explicitly_approved_this_action {
                 SafetyCheck::AutoApprove {
                     sandbox_type: SandboxType::None,
                 }
             } else {
-                assess_safety_for_untrusted_command(
-                    sess.approval_policy,
-                    &sess.sandbox_policy,
-                    params.with_escalated_permissions.unwrap_or(false),
-                )
+                assess_safety_for_untrusted_command(sess.approval_policy, &sess.sandbox_policy)
             };
             (
                 params,
@@ -1820,7 +1684,6 @@ async fn handle_container_exec_with_params(
                     sess.approval_policy,
                     &sess.sandbox_policy,
                     &state.approved_commands,
-                    params.with_escalated_permissions.unwrap_or(false),
                 )
             };
             let command_for_display = params.command.clone();
@@ -1837,7 +1700,7 @@ async fn handle_container_exec_with_params(
                     call_id.clone(),
                     params.command.clone(),
                     params.cwd.clone(),
-                    params.justification.clone(),
+                    None,
                 )
                 .await;
             match rx_approve.await.unwrap_or_default() {
@@ -1887,7 +1750,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);
@@ -1912,22 +1775,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 {
@@ -1939,15 +1803,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
@@ -1963,7 +1819,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,
@@ -1975,31 +1830,13 @@ async fn handle_sandbox_error(
     let cwd = exec_command_context.cwd.clone();
     let is_apply_patch = exec_command_context.apply_patch.is_some();
 
-    // Early out if either the user never wants to be asked for approval, or
-    // we're letting the model manage escalation requests. Otherwise, continue
-    match sess.approval_policy {
-        AskForApproval::Never | AskForApproval::OnRequest => {
-            return ResponseInputItem::FunctionCallOutput {
-                call_id,
-                output: FunctionCallOutputPayload {
-                    content: format!(
-                        "failed in sandbox {sandbox_type:?} with execution error: {error}"
-                    ),
-                    success: Some(false),
-                },
-            };
-        }
-        AskForApproval::UnlessTrusted | AskForApproval::OnFailure => (),
-    }
-
-    // similarly, if the command timed out, we can simply return this failure to the model
-    if matches!(error, SandboxErr::Timeout) {
+    // Early out if the user never wants to be asked for approval; just return to the model immediately
+    if sess.approval_policy == AskForApproval::Never {
         return ResponseInputItem::FunctionCallOutput {
             call_id,
             output: FunctionCallOutputPayload {
                 content: format!(
-                    "command timed out after {} milliseconds",
-                    params.timeout_duration().as_millis()
+                    "failed in sandbox {sandbox_type:?} with execution error: {error}"
                 ),
                 success: Some(false),
             },
@@ -2013,8 +1850,7 @@ async fn handle_sandbox_error(
     // include additional metadata on the command to indicate whether non-zero
     // exit codes merit a retry.
 
-    // For now, we categorically ask the user to retry without sandbox and
-    // emit the raw error as a background event.
+    // For now, we categorically ask the user to retry without sandbox.
     sess.notify_background_event(&sub_id, format!("Execution failed: {error}"))
         .await;
 
@@ -2039,8 +1875,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`.
@@ -2065,22 +1900,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 {

codex-rs/core/src/config.rs

@@ -10,8 +10,6 @@ use crate::config_types::ShellEnvironmentPolicyToml;
 use crate::config_types::Tui;
 use crate::config_types::UriBasedFileOpener;
 use crate::flags::OPENAI_DEFAULT_MODEL;
-use crate::model_family::ModelFamily;
-use crate::model_family::find_family_for_model;
 use crate::model_provider_info::ModelProviderInfo;
 use crate::model_provider_info::built_in_model_providers;
 use crate::openai_model_info::get_model_info;
@@ -35,8 +33,6 @@ pub struct Config {
     /// Optional override of model selection.
     pub model: String,
 
-    pub model_family: ModelFamily,
-
     /// Size of the context window for the model, in tokens.
     pub model_context_window: Option<u64>,
 
@@ -61,16 +57,12 @@ pub struct Config {
     /// users are only interested in the final agent responses.
     pub hide_agent_reasoning: bool,
 
-    /// When set to `true`, `AgentReasoningRawContentEvent` events will be shown in the UI/output.
-    /// Defaults to `false`.
-    pub show_raw_agent_reasoning: bool,
-
     /// Disable server-side response storage (sends the full conversation
     /// context with every request). Currently necessary for OpenAI customers
     /// who have opted into Zero Data Retention (ZDR).
     pub disable_response_storage: bool,
 
-    /// User-provided instructions from AGENTS.md.
+    /// User-provided instructions from instructions.md.
     pub user_instructions: Option<String>,
 
     /// Base instructions override.
@@ -142,6 +134,10 @@ pub struct Config {
     /// request using the Responses API.
     pub model_reasoning_summary: ReasoningSummary,
 
+    /// When set to `true`, overrides the default heuristic and forces
+    /// `model_supports_reasoning_summaries()` to return `true`.
+    pub model_supports_reasoning_summaries: bool,
+
     /// Base URL for requests to ChatGPT (as opposed to the OpenAI API).
     pub chatgpt_base_url: String,
 
@@ -329,10 +325,6 @@ pub struct ConfigToml {
     /// UI/output. Defaults to `false`.
     pub hide_agent_reasoning: Option<bool>,
 
-    /// When set to `true`, `AgentReasoningRawContentEvent` events will be shown in the UI/output.
-    /// Defaults to `false`.
-    pub show_raw_agent_reasoning: Option<bool>,
-
     pub model_reasoning_effort: Option<ReasoningEffort>,
     pub model_reasoning_summary: Option<ReasoningSummary>,
 
@@ -385,8 +377,6 @@ pub struct ConfigOverrides {
     pub codex_linux_sandbox_exe: Option<PathBuf>,
     pub base_instructions: Option<String>,
     pub include_plan_tool: Option<bool>,
-    pub disable_response_storage: Option<bool>,
-    pub show_raw_agent_reasoning: Option<bool>,
 }
 
 impl Config {
@@ -410,8 +400,6 @@ impl Config {
             codex_linux_sandbox_exe,
             base_instructions,
             include_plan_tool,
-            disable_response_storage,
-            show_raw_agent_reasoning,
         } = overrides;
 
         let config_profile = match config_profile_key.as_ref().or(cfg.profile.as_ref()) {
@@ -477,20 +465,7 @@ impl Config {
             .or(config_profile.model)
             .or(cfg.model)
             .unwrap_or_else(default_model);
-        let model_family = find_family_for_model(&model).unwrap_or_else(|| {
-            let supports_reasoning_summaries =
-                cfg.model_supports_reasoning_summaries.unwrap_or(false);
-            ModelFamily {
-                slug: model.clone(),
-                family: model.clone(),
-                needs_special_apply_patch_instructions: false,
-                supports_reasoning_summaries,
-                uses_local_shell_tool: false,
-                requires_chatgpt_auth: false,
-            }
-        });
-
-        let openai_model_info = get_model_info(&model_family);
+        let openai_model_info = get_model_info(&model);
         let model_context_window = cfg
             .model_context_window
             .or_else(|| openai_model_info.as_ref().map(|info| info.context_window));
@@ -505,17 +480,14 @@ 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);
 
         let config = Self {
             model,
-            model_family,
             model_context_window,
             model_max_output_tokens,
             model_provider_id,
@@ -530,7 +502,6 @@ impl Config {
             disable_response_storage: config_profile
                 .disable_response_storage
                 .or(cfg.disable_response_storage)
-                .or(disable_response_storage)
                 .unwrap_or(false),
             notify: cfg.notify,
             user_instructions,
@@ -545,10 +516,6 @@ impl Config {
             codex_linux_sandbox_exe,
 
             hide_agent_reasoning: cfg.hide_agent_reasoning.unwrap_or(false),
-            show_raw_agent_reasoning: cfg
-                .show_raw_agent_reasoning
-                .or(show_raw_agent_reasoning)
-                .unwrap_or(false),
             model_reasoning_effort: config_profile
                 .model_reasoning_effort
                 .or(cfg.model_reasoning_effort)
@@ -558,6 +525,10 @@ impl Config {
                 .or(cfg.model_reasoning_summary)
                 .unwrap_or_default(),
 
+            model_supports_reasoning_summaries: cfg
+                .model_supports_reasoning_summaries
+                .unwrap_or(false),
+
             chatgpt_base_url: config_profile
                 .chatgpt_base_url
                 .or(cfg.chatgpt_base_url)
@@ -576,7 +547,7 @@ impl Config {
             None => return None,
         };
 
-        p.push("AGENTS.md");
+        p.push("instructions.md");
         std::fs::read_to_string(&p).ok().and_then(|s| {
             let s = s.trim();
             if s.is_empty() {
@@ -843,7 +814,7 @@ disable_response_storage = true
             request_max_retries: Some(4),
             stream_max_retries: Some(10),
             stream_idle_timeout_ms: Some(300_000),
-            requires_openai_auth: false,
+            requires_auth: false,
         };
         let model_provider_map = {
             let mut model_provider_map = built_in_model_providers();
@@ -898,7 +869,6 @@ disable_response_storage = true
         assert_eq!(
             Config {
                 model: "o3".to_string(),
-                model_family: find_family_for_model("o3").expect("known model slug"),
                 model_context_window: Some(200_000),
                 model_max_output_tokens: Some(100_000),
                 model_provider_id: "openai".to_string(),
@@ -919,9 +889,9 @@ disable_response_storage = true
                 tui: Tui::default(),
                 codex_linux_sandbox_exe: None,
                 hide_agent_reasoning: false,
-                show_raw_agent_reasoning: false,
                 model_reasoning_effort: ReasoningEffort::High,
                 model_reasoning_summary: ReasoningSummary::Detailed,
+                model_supports_reasoning_summaries: false,
                 chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
                 experimental_resume: None,
                 base_instructions: None,
@@ -949,7 +919,6 @@ disable_response_storage = true
         )?;
         let expected_gpt3_profile_config = Config {
             model: "gpt-3.5-turbo".to_string(),
-            model_family: find_family_for_model("gpt-3.5-turbo").expect("known model slug"),
             model_context_window: Some(16_385),
             model_max_output_tokens: Some(4_096),
             model_provider_id: "openai-chat-completions".to_string(),
@@ -970,9 +939,9 @@ disable_response_storage = true
             tui: Tui::default(),
             codex_linux_sandbox_exe: None,
             hide_agent_reasoning: false,
-            show_raw_agent_reasoning: false,
             model_reasoning_effort: ReasoningEffort::default(),
             model_reasoning_summary: ReasoningSummary::default(),
+            model_supports_reasoning_summaries: false,
             chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
             experimental_resume: None,
             base_instructions: None,
@@ -1015,7 +984,6 @@ disable_response_storage = true
         )?;
         let expected_zdr_profile_config = Config {
             model: "o3".to_string(),
-            model_family: find_family_for_model("o3").expect("known model slug"),
             model_context_window: Some(200_000),
             model_max_output_tokens: Some(100_000),
             model_provider_id: "openai".to_string(),
@@ -1036,9 +1004,9 @@ disable_response_storage = true
             tui: Tui::default(),
             codex_linux_sandbox_exe: None,
             hide_agent_reasoning: false,
-            show_raw_agent_reasoning: false,
             model_reasoning_effort: ReasoningEffort::default(),
             model_reasoning_summary: ReasoningSummary::default(),
+            model_supports_reasoning_summaries: false,
             chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
             experimental_resume: None,
             base_instructions: None,

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>,
 }

codex-rs/core/src/conversation_history.rs

@@ -24,52 +24,9 @@ impl ConversationHistory {
         I::Item: std::ops::Deref<Target = ResponseItem>,
     {
         for item in items {
-            if !is_api_message(&item) {
-                continue;
-            }
-
-            // Merge adjacent assistant messages into a single history entry.
-            // This prevents duplicates when a partial assistant message was
-            // streamed into history earlier in the turn and the final full
-            // message is recorded at turn end.
-            match (&*item, self.items.last_mut()) {
-                (
-                    ResponseItem::Message {
-                        role: new_role,
-                        content: new_content,
-                        ..
-                    },
-                    Some(ResponseItem::Message {
-                        role: last_role,
-                        content: last_content,
-                        ..
-                    }),
-                ) if new_role == "assistant" && last_role == "assistant" => {
-                    append_text_content(last_content, new_content);
-                }
-                _ => {
-                    self.items.push(item.clone());
-                }
-            }
-        }
-    }
-
-    /// Append a text `delta` to the latest assistant message, creating a new
-    /// assistant entry if none exists yet (e.g. first delta for this turn).
-    pub(crate) fn append_assistant_text(&mut self, delta: &str) {
-        match self.items.last_mut() {
-            Some(ResponseItem::Message { role, content, .. }) if role == "assistant" => {
-                append_text_delta(content, delta);
-            }
-            _ => {
-                // Start a new assistant message with the delta.
-                self.items.push(ResponseItem::Message {
-                    id: None,
-                    role: "assistant".to_string(),
-                    content: vec![crate::models::ContentItem::OutputText {
-                        text: delta.to_string(),
-                    }],
-                });
+            if is_api_message(&item) {
+                // Note agent-loop.ts also does filtering on some of the fields.
+                self.items.push(item.clone());
             }
         }
     }
@@ -115,140 +72,3 @@ fn is_api_message(message: &ResponseItem) -> bool {
         ResponseItem::Other => false,
     }
 }
-
-/// Helper to append the textual content from `src` into `dst` in place.
-fn append_text_content(
-    dst: &mut Vec<crate::models::ContentItem>,
-    src: &Vec<crate::models::ContentItem>,
-) {
-    for c in src {
-        if let crate::models::ContentItem::OutputText { text } = c {
-            append_text_delta(dst, text);
-        }
-    }
-}
-
-/// Append a single text delta to the last OutputText item in `content`, or
-/// push a new OutputText item if none exists.
-fn append_text_delta(content: &mut Vec<crate::models::ContentItem>, delta: &str) {
-    if let Some(crate::models::ContentItem::OutputText { text }) = content
-        .iter_mut()
-        .rev()
-        .find(|c| matches!(c, crate::models::ContentItem::OutputText { .. }))
-    {
-        text.push_str(delta);
-    } else {
-        content.push(crate::models::ContentItem::OutputText {
-            text: delta.to_string(),
-        });
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::models::ContentItem;
-
-    fn assistant_msg(text: &str) -> ResponseItem {
-        ResponseItem::Message {
-            id: None,
-            role: "assistant".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: text.to_string(),
-            }],
-        }
-    }
-
-    fn user_msg(text: &str) -> ResponseItem {
-        ResponseItem::Message {
-            id: None,
-            role: "user".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: text.to_string(),
-            }],
-        }
-    }
-
-    #[test]
-    fn merges_adjacent_assistant_messages() {
-        let mut h = ConversationHistory::default();
-        let a1 = assistant_msg("Hello");
-        let a2 = assistant_msg(", world!");
-        h.record_items([&a1, &a2]);
-
-        let items = h.contents();
-        assert_eq!(
-            items,
-            vec![ResponseItem::Message {
-                id: None,
-                role: "assistant".to_string(),
-                content: vec![ContentItem::OutputText {
-                    text: "Hello, world!".to_string()
-                }]
-            }]
-        );
-    }
-
-    #[test]
-    fn append_assistant_text_creates_and_appends() {
-        let mut h = ConversationHistory::default();
-        h.append_assistant_text("Hello");
-        h.append_assistant_text(", world");
-
-        // Now record a final full assistant message and verify it merges.
-        let final_msg = assistant_msg("!");
-        h.record_items([&final_msg]);
-
-        let items = h.contents();
-        assert_eq!(
-            items,
-            vec![ResponseItem::Message {
-                id: None,
-                role: "assistant".to_string(),
-                content: vec![ContentItem::OutputText {
-                    text: "Hello, world!".to_string()
-                }]
-            }]
-        );
-    }
-
-    #[test]
-    fn filters_non_api_messages() {
-        let mut h = ConversationHistory::default();
-        // System message is not an API message; Other is ignored.
-        let system = ResponseItem::Message {
-            id: None,
-            role: "system".to_string(),
-            content: vec![ContentItem::OutputText {
-                text: "ignored".to_string(),
-            }],
-        };
-        h.record_items([&system, &ResponseItem::Other]);
-
-        // User and assistant should be retained.
-        let u = user_msg("hi");
-        let a = assistant_msg("hello");
-        h.record_items([&u, &a]);
-
-        let items = h.contents();
-        assert_eq!(
-            items,
-            vec![
-                ResponseItem::Message {
-                    id: None,
-                    role: "user".to_string(),
-                    content: vec![ContentItem::OutputText {
-                        text: "hi".to_string()
-                    }]
-                },
-                ResponseItem::Message {
-                    id: None,
-                    role: "assistant".to_string(),
-                    content: vec![ContentItem::OutputText {
-                        text: "hello".to_string()
-                    }]
-                }
-            ]
-        );
-    }
-}

codex-rs/core/src/exec.rs

@@ -49,14 +49,6 @@ pub struct ExecParams {
     pub cwd: PathBuf,
     pub timeout_ms: Option<u64>,
     pub env: HashMap<String, String>,
-    pub with_escalated_permissions: Option<bool>,
-    pub justification: Option<String>,
-}
-
-impl ExecParams {
-    pub fn timeout_duration(&self) -> Duration {
-        Duration::from_millis(self.timeout_ms.unwrap_or(DEFAULT_TIMEOUT_MS))
-    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -91,9 +83,11 @@ pub async fn process_exec_tool_call(
     {
         SandboxType::None => exec(params, sandbox_policy, ctrl_c, stdout_stream.clone()).await,
         SandboxType::MacosSeatbelt => {
-            let timeout = params.timeout_duration();
             let ExecParams {
-                command, cwd, env, ..
+                command,
+                cwd,
+                timeout_ms,
+                env,
             } = params;
             let child = spawn_command_under_seatbelt(
                 command,
@@ -103,12 +97,14 @@ pub async fn process_exec_tool_call(
                 env,
             )
             .await?;
-            consume_truncated_output(child, ctrl_c, timeout, stdout_stream.clone()).await
+            consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream.clone()).await
         }
         SandboxType::LinuxSeccomp => {
-            let timeout = params.timeout_duration();
             let ExecParams {
-                command, cwd, env, ..
+                command,
+                cwd,
+                timeout_ms,
+                env,
             } = params;
 
             let codex_linux_sandbox_exe = codex_linux_sandbox_exe
@@ -124,7 +120,7 @@ pub async fn process_exec_tool_call(
             )
             .await?;
 
-            consume_truncated_output(child, ctrl_c, timeout, stdout_stream).await
+            consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream).await
         }
     };
     let duration = start.elapsed();
@@ -144,7 +140,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,
                 )));
@@ -223,26 +223,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,
@@ -259,16 +239,16 @@ pub struct ExecToolCallOutput {
 }
 
 async fn exec(
-    params: ExecParams,
+    ExecParams {
+        command,
+        cwd,
+        timeout_ms,
+        env,
+    }: ExecParams,
     sandbox_policy: &SandboxPolicy,
     ctrl_c: Arc<Notify>,
     stdout_stream: Option<StdoutStream>,
 ) -> Result<RawExecToolCallOutput> {
-    let timeout = params.timeout_duration();
-    let ExecParams {
-        command, cwd, env, ..
-    } = params;
-
     let (program, args) = command.split_first().ok_or_else(|| {
         CodexErr::Io(io::Error::new(
             io::ErrorKind::InvalidInput,
@@ -286,7 +266,7 @@ async fn exec(
         env,
     )
     .await?;
-    consume_truncated_output(child, ctrl_c, timeout, stdout_stream).await
+    consume_truncated_output(child, ctrl_c, timeout_ms, stdout_stream).await
 }
 
 /// Consumes the output of a child process, truncating it so it is suitable for
@@ -294,7 +274,7 @@ async fn exec(
 pub(crate) async fn consume_truncated_output(
     mut child: Child,
     ctrl_c: Arc<Notify>,
-    timeout: Duration,
+    timeout_ms: Option<u64>,
     stdout_stream: Option<StdoutStream>,
 ) -> Result<RawExecToolCallOutput> {
     // Both stdout and stderr were configured with `Stdio::piped()`
@@ -328,6 +308,7 @@ pub(crate) async fn consume_truncated_output(
     ));
 
     let interrupted = ctrl_c.notified();
+    let timeout = Duration::from_millis(timeout_ms.unwrap_or(DEFAULT_TIMEOUT_MS));
     let exit_status = tokio::select! {
         result = tokio::time::timeout(timeout, child.wait()) => {
             match result {

codex-rs/core/src/git_info.rs

@@ -9,7 +9,7 @@ use tokio::time::timeout;
 /// Timeout for git commands to prevent freezing on large repositories
 const GIT_COMMAND_TIMEOUT: TokioDuration = TokioDuration::from_secs(5);
 
-#[derive(Serialize, Deserialize, Clone, Debug)]
+#[derive(Serialize, Deserialize, Clone)]
 pub struct GitInfo {
     /// Current commit hash (SHA)
     #[serde(skip_serializing_if = "Option::is_none")]

codex-rs/core/src/lib.rs

@@ -28,12 +28,9 @@ mod mcp_connection_manager;
 mod mcp_tool_call;
 mod message_history;
 mod model_provider_info;
-pub use model_provider_info::BUILT_IN_OSS_MODEL_PROVIDER_ID;
 pub use model_provider_info::ModelProviderInfo;
 pub use model_provider_info::WireApi;
 pub use model_provider_info::built_in_model_providers;
-pub use model_provider_info::create_oss_provider_with_base_url;
-pub mod model_family;
 mod models;
 mod openai_model_info;
 mod openai_tools;
@@ -41,12 +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 safety::get_platform_sandbox;
+pub use client_common::model_supports_reasoning_summaries;

codex-rs/core/src/model_family.rs

@@ -1,105 +0,0 @@
-/// A model family is a group of models that share certain characteristics.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ModelFamily {
-    /// The full model slug used to derive this model family, e.g.
-    /// "gpt-4.1-2025-04-14".
-    pub slug: String,
-
-    /// The model family name, e.g. "gpt-4.1". Note this should able to be used
-    /// with [`crate::openai_model_info::get_model_info`].
-    pub family: String,
-
-    /// True if the model needs additional instructions on how to use the
-    /// "virtual" `apply_patch` CLI.
-    pub needs_special_apply_patch_instructions: bool,
-
-    // Whether the `reasoning` field can be set when making a request to this
-    // model family. Note it has `effort` and `summary` subfields (though
-    // `summary` is optional).
-    pub supports_reasoning_summaries: bool,
-
-    // This should be set to true when the model expects a tool named
-    // "local_shell" to be provided. Its contract must be understood natively by
-    // the model such that its description can be omitted.
-    // See https://platform.openai.com/docs/guides/tools-local-shell
-    pub uses_local_shell_tool: bool,
-
-    pub requires_chatgpt_auth: bool,
-}
-
-macro_rules! model_family {
-    (
-        $slug:expr, $family:expr $(, $key:ident : $value:expr )* $(,)?
-    ) => {{
-        // defaults
-        let mut mf = ModelFamily {
-            slug: $slug.to_string(),
-            family: $family.to_string(),
-            needs_special_apply_patch_instructions: false,
-            supports_reasoning_summaries: false,
-            uses_local_shell_tool: false,
-            requires_chatgpt_auth: false,
-        };
-        // apply overrides
-        $(
-            mf.$key = $value;
-        )*
-        Some(mf)
-    }};
-}
-
-macro_rules! simple_model_family {
-    (
-        $slug:expr, $family:expr
-    ) => {{
-        Some(ModelFamily {
-            slug: $slug.to_string(),
-            family: $family.to_string(),
-            needs_special_apply_patch_instructions: false,
-            supports_reasoning_summaries: false,
-            uses_local_shell_tool: false,
-            requires_chatgpt_auth: false,
-        })
-    }};
-}
-
-/// Returns a `ModelFamily` for the given model slug, or `None` if the slug
-/// does not match any known model family.
-pub fn find_family_for_model(slug: &str) -> Option<ModelFamily> {
-    if slug.starts_with("o3") {
-        model_family!(
-            slug, "o3",
-            supports_reasoning_summaries: true,
-        )
-    } else if slug.starts_with("o4-mini") {
-        model_family!(
-            slug, "o4-mini",
-            supports_reasoning_summaries: true,
-        )
-    } else if slug.starts_with("codex-mini-latest") {
-        model_family!(
-            slug, "codex-mini-latest",
-            supports_reasoning_summaries: true,
-            uses_local_shell_tool: true,
-        )
-    } else if slug.starts_with("gpt-4.1") {
-        model_family!(
-            slug, "gpt-4.1",
-            needs_special_apply_patch_instructions: true,
-        )
-    } else if slug.starts_with("gpt-4o") {
-        simple_model_family!(slug, "gpt-4o")
-    } else if slug.starts_with("gpt-oss") {
-        simple_model_family!(slug, "gpt-oss")
-    } else if slug.starts_with("gpt-3.5") {
-        simple_model_family!(slug, "gpt-3.5")
-    } else if slug.starts_with("2025-08-06-model") {
-        model_family!(
-            slug, "2025-08-06-model",
-            supports_reasoning_summaries: true,
-            requires_chatgpt_auth: true,
-        )
-    } else {
-        None
-    }
-}

codex-rs/core/src/model_provider_info.rs

@@ -5,8 +5,6 @@
 //!   2. User-defined entries inside `~/.codex/config.toml` under the `model_providers`
 //!      key. These override or extend the defaults at runtime.
 
-use codex_login::AuthMode;
-use codex_login::CodexAuth;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::HashMap;
@@ -78,7 +76,7 @@ pub struct ModelProviderInfo {
 
     /// Whether this provider requires some form of standard authentication (API key, ChatGPT token).
     #[serde(default)]
-    pub requires_openai_auth: bool,
+    pub requires_auth: bool,
 }
 
 impl ModelProviderInfo {
@@ -86,40 +84,29 @@ impl ModelProviderInfo {
     /// reqwest Client applying:
     ///   • provider-specific headers (static + env based)
     ///   • Bearer auth header when an API key is available.
-    ///   • Auth token for OAuth.
     ///
-    /// If the provider declares an `env_key` but the variable is missing/empty, returns an [`Err`] identical to the
+    /// When `require_api_key` is true and the provider declares an `env_key`
+    /// but the variable is missing/empty, returns an [`Err`] identical to the
     /// one produced by [`ModelProviderInfo::api_key`].
-    pub async fn create_request_builder<'a>(
+    pub fn create_request_builder<'a>(
         &'a self,
         client: &'a reqwest::Client,
-        auth: &Option<CodexAuth>,
     ) -> crate::error::Result<reqwest::RequestBuilder> {
-        let effective_auth = match self.api_key() {
-            Ok(Some(key)) => Some(CodexAuth::from_api_key(key)),
-            Ok(None) => auth.clone(),
-            Err(err) => {
-                if auth.is_some() {
-                    auth.clone()
-                } else {
-                    return Err(err);
-                }
-            }
-        };
-
-        let url = self.get_full_url(&effective_auth);
+        let url = self.get_full_url();
 
         let mut builder = client.post(url);
 
-        if let Some(auth) = effective_auth.as_ref() {
-            builder = builder.bearer_auth(auth.get_token().await?);
+        let api_key = self.api_key()?;
+        if let Some(key) = api_key {
+            builder = builder.bearer_auth(key);
         }
 
         Ok(self.apply_http_headers(builder))
     }
 
-    fn get_query_string(&self) -> String {
-        self.query_params
+    pub(crate) fn get_full_url(&self) -> String {
+        let query_string = self
+            .query_params
             .as_ref()
             .map_or_else(String::new, |params| {
                 let full_params = params
@@ -128,29 +115,16 @@ impl ModelProviderInfo {
                     .collect::<Vec<_>>()
                     .join("&");
                 format!("?{full_params}")
-            })
-    }
-
-    pub(crate) fn get_full_url(&self, auth: &Option<CodexAuth>) -> String {
-        let default_base_url = if matches!(
-            auth,
-            Some(CodexAuth {
-                mode: AuthMode::ChatGPT,
-                ..
-            })
-        ) {
-            "https://chatgpt.com/backend-api/codex"
-        } else {
-            "https://api.openai.com/v1"
-        };
-        let query_string = self.get_query_string();
+            });
         let base_url = self
             .base_url
             .clone()
-            .unwrap_or(default_base_url.to_string());
+            .unwrap_or("https://api.openai.com/v1".to_string());
 
         match self.wire_api {
-            WireApi::Responses => format!("{base_url}/responses{query_string}"),
+            WireApi::Responses => {
+                format!("{base_url}/responses{query_string}")
+            }
             WireApi::Chat => format!("{base_url}/chat/completions{query_string}"),
         }
     }
@@ -158,7 +132,10 @@ impl ModelProviderInfo {
     /// Apply provider-specific HTTP headers (both static and environment-based)
     /// onto an existing `reqwest::RequestBuilder` and return the updated
     /// builder.
-    fn apply_http_headers(&self, mut builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    pub fn apply_http_headers(
+        &self,
+        mut builder: reqwest::RequestBuilder,
+    ) -> reqwest::RequestBuilder {
         if let Some(extra) = &self.http_headers {
             for (k, v) in extra {
                 builder = builder.header(k, v);
@@ -180,7 +157,7 @@ impl ModelProviderInfo {
     /// If `env_key` is Some, returns the API key for this provider if present
     /// (and non-empty) in the environment. If `env_key` is required but
     /// cannot be found, returns an error.
-    pub fn api_key(&self) -> crate::error::Result<Option<String>> {
+    fn api_key(&self) -> crate::error::Result<Option<String>> {
         match &self.env_key {
             Some(env_key) => {
                 let env_value = std::env::var(env_key);
@@ -223,103 +200,58 @@ impl ModelProviderInfo {
     }
 }
 
-const DEFAULT_OLLAMA_PORT: u32 = 11434;
-
-pub const BUILT_IN_OSS_MODEL_PROVIDER_ID: &str = "oss";
-
 /// Built-in default provider list.
 pub fn built_in_model_providers() -> HashMap<String, ModelProviderInfo> {
     use ModelProviderInfo as P;
 
     // We do not want to be in the business of adjucating which third-party
-    // providers are bundled with Codex CLI, so we only include the OpenAI and
-    // open source ("oss") providers by default. Users are encouraged to add to
-    // `model_providers` in config.toml to add their own providers.
-    [
-        (
-            "openai",
-            P {
-                name: "OpenAI".into(),
-                // Allow users to override the default OpenAI endpoint by
-                // exporting `OPENAI_BASE_URL`. This is useful when pointing
-                // Codex at a proxy, mock server, or Azure-style deployment
-                // without requiring a full TOML override for the built-in
-                // OpenAI provider.
-                base_url: std::env::var("OPENAI_BASE_URL")
-                    .ok()
-                    .filter(|v| !v.trim().is_empty()),
-                env_key: None,
-                env_key_instructions: None,
-                wire_api: WireApi::Responses,
-                query_params: None,
-                http_headers: Some(
-                    [("version".to_string(), env!("CARGO_PKG_VERSION").to_string())]
-                        .into_iter()
-                        .collect(),
-                ),
-                env_http_headers: Some(
-                    [
-                        (
-                            "OpenAI-Organization".to_string(),
-                            "OPENAI_ORGANIZATION".to_string(),
-                        ),
-                        ("OpenAI-Project".to_string(), "OPENAI_PROJECT".to_string()),
-                    ]
+    // providers are bundled with Codex CLI, so we only include the OpenAI
+    // provider by default. Users are encouraged to add to `model_providers`
+    // in config.toml to add their own providers.
+    [(
+        "openai",
+        P {
+            name: "OpenAI".into(),
+            // Allow users to override the default OpenAI endpoint by
+            // exporting `OPENAI_BASE_URL`. This is useful when pointing
+            // Codex at a proxy, mock server, or Azure-style deployment
+            // without requiring a full TOML override for the built-in
+            // OpenAI provider.
+            base_url: std::env::var("OPENAI_BASE_URL")
+                .ok()
+                .filter(|v| !v.trim().is_empty()),
+            env_key: None,
+            env_key_instructions: None,
+            wire_api: WireApi::Responses,
+            query_params: None,
+            http_headers: Some(
+                [("version".to_string(), env!("CARGO_PKG_VERSION").to_string())]
                     .into_iter()
                     .collect(),
-                ),
-                // Use global defaults for retry/timeout unless overridden in config.toml.
-                request_max_retries: None,
-                stream_max_retries: None,
-                stream_idle_timeout_ms: None,
-                requires_openai_auth: true,
-            },
-        ),
-        (BUILT_IN_OSS_MODEL_PROVIDER_ID, create_oss_provider()),
-    ]
+            ),
+            env_http_headers: Some(
+                [
+                    (
+                        "OpenAI-Organization".to_string(),
+                        "OPENAI_ORGANIZATION".to_string(),
+                    ),
+                    ("OpenAI-Project".to_string(), "OPENAI_PROJECT".to_string()),
+                ]
+                .into_iter()
+                .collect(),
+            ),
+            // Use global defaults for retry/timeout unless overridden in config.toml.
+            request_max_retries: None,
+            stream_max_retries: None,
+            stream_idle_timeout_ms: None,
+            requires_auth: true,
+        },
+    )]
     .into_iter()
     .map(|(k, v)| (k.to_string(), v))
     .collect()
 }
 
-pub fn create_oss_provider() -> ModelProviderInfo {
-    // These CODEX_OSS_ environment variables are experimental: we may
-    // switch to reading values from config.toml instead.
-    let codex_oss_base_url = match std::env::var("CODEX_OSS_BASE_URL")
-        .ok()
-        .filter(|v| !v.trim().is_empty())
-    {
-        Some(url) => url,
-        None => format!(
-            "http://localhost:{port}/v1",
-            port = std::env::var("CODEX_OSS_PORT")
-                .ok()
-                .filter(|v| !v.trim().is_empty())
-                .and_then(|v| v.parse::<u32>().ok())
-                .unwrap_or(DEFAULT_OLLAMA_PORT)
-        ),
-    };
-
-    create_oss_provider_with_base_url(&codex_oss_base_url)
-}
-
-pub fn create_oss_provider_with_base_url(base_url: &str) -> ModelProviderInfo {
-    ModelProviderInfo {
-        name: "gpt-oss".into(),
-        base_url: Some(base_url.into()),
-        env_key: None,
-        env_key_instructions: None,
-        wire_api: WireApi::Chat,
-        query_params: None,
-        http_headers: None,
-        env_http_headers: None,
-        request_max_retries: None,
-        stream_max_retries: None,
-        stream_idle_timeout_ms: None,
-        requires_openai_auth: false,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used)]
@@ -344,7 +276,7 @@ base_url = "http://localhost:11434/v1"
             request_max_retries: None,
             stream_max_retries: None,
             stream_idle_timeout_ms: None,
-            requires_openai_auth: false,
+            requires_auth: false,
         };
 
         let provider: ModelProviderInfo = toml::from_str(azure_provider_toml).unwrap();
@@ -373,7 +305,7 @@ query_params = { api-version = "2025-04-01-preview" }
             request_max_retries: None,
             stream_max_retries: None,
             stream_idle_timeout_ms: None,
-            requires_openai_auth: false,
+            requires_auth: false,
         };
 
         let provider: ModelProviderInfo = toml::from_str(azure_provider_toml).unwrap();
@@ -405,7 +337,7 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
             request_max_retries: None,
             stream_max_retries: None,
             stream_idle_timeout_ms: None,
-            requires_openai_auth: false,
+            requires_auth: false,
         };
 
         let provider: ModelProviderInfo = toml::from_str(azure_provider_toml).unwrap();

codex-rs/core/src/models.rs

@@ -9,7 +9,7 @@ use serde::ser::Serializer;
 
 use crate::protocol::InputItem;
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ResponseInputItem {
     Message {
@@ -26,7 +26,7 @@ pub enum ResponseInputItem {
     },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ContentItem {
     InputText { text: String },
@@ -34,7 +34,7 @@ pub enum ContentItem {
     OutputText { text: String },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ResponseItem {
     Message {
@@ -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 {
@@ -109,7 +107,7 @@ impl From<ResponseInputItem> for ResponseItem {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LocalShellStatus {
     Completed,
@@ -117,13 +115,13 @@ pub enum LocalShellStatus {
     Incomplete,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum LocalShellAction {
     Exec(LocalShellExecAction),
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LocalShellExecAction {
     pub command: Vec<String>,
     pub timeout_ms: Option<u64>,
@@ -132,18 +130,12 @@ pub struct LocalShellExecAction {
     pub user: Option<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ReasoningItemReasoningSummary {
     SummaryText { text: String },
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[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 {
@@ -191,15 +183,12 @@ pub struct ShellToolCallParams {
     // The wire format uses `timeout`, which has ambiguous units, so we use
     // `timeout_ms` as the field name so it is clear in code.
     pub timeout_ms: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub with_escalated_permissions: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub justification: Option<String>,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub struct FunctionCallOutputPayload {
     pub content: String,
+    #[expect(dead_code)]
     pub success: Option<bool>,
 }
 
@@ -306,8 +295,6 @@ mod tests {
                 command: vec!["ls".to_string(), "-l".to_string()],
                 workdir: Some("/tmp".to_string()),
                 timeout_ms: Some(1000),
-                with_escalated_permissions: None,
-                justification: None,
             },
             params
         );

codex-rs/core/src/openai_model_info.rs

@@ -1,5 +1,3 @@
-use crate::model_family::ModelFamily;
-
 /// Metadata about a model, particularly OpenAI models.
 /// We may want to consider including details like the pricing for
 /// input tokens, output tokens, etc., though users will need to be able to
@@ -14,19 +12,10 @@ pub(crate) struct ModelInfo {
     pub(crate) max_output_tokens: u64,
 }
 
-pub(crate) fn get_model_info(model_family: &ModelFamily) -> Option<ModelInfo> {
-    match model_family.slug.as_str() {
-        // OSS models have a 128k shared token pool.
-        // Arbitrarily splitting it: 3/4 input context, 1/4 output.
-        // https://openai.com/index/gpt-oss-model-card/
-        "gpt-oss-20b" => Some(ModelInfo {
-            context_window: 96_000,
-            max_output_tokens: 32_000,
-        }),
-        "gpt-oss-120b" => Some(ModelInfo {
-            context_window: 96_000,
-            max_output_tokens: 32_000,
-        }),
+/// Note details such as what a model like gpt-4o is aliased to may be out of
+/// date.
+pub(crate) fn get_model_info(name: &str) -> Option<ModelInfo> {
+    match name {
         // https://platform.openai.com/docs/models/o3
         "o3" => Some(ModelInfo {
             context_window: 200_000,
@@ -77,11 +66,6 @@ pub(crate) fn get_model_info(model_family: &ModelFamily) -> Option<ModelInfo> {
             max_output_tokens: 4_096,
         }),
 
-        "2025-08-06-model" => Some(ModelInfo {
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-        }),
-
         _ => None,
     }
 }

codex-rs/core/src/openai_tools.rs

@@ -1,28 +1,22 @@
-use serde::Deserialize;
 use serde::Serialize;
 use serde_json::json;
 use std::collections::BTreeMap;
-use std::collections::HashMap;
+use std::sync::LazyLock;
 
-use crate::model_family::ModelFamily;
+use crate::client_common::Prompt;
 use crate::plan_tool::PLAN_TOOL;
-use crate::protocol::AskForApproval;
-use crate::protocol::SandboxPolicy;
 
-#[derive(Debug, Clone, Serialize, PartialEq)]
-pub struct ResponsesApiTool {
-    pub(crate) name: String,
-    pub(crate) description: String,
-    /// TODO: Validation. When strict is set to true, the JSON schema,
-    /// `required` and `additional_properties` must be present. All fields in
-    /// `properties` must be present in `required`.
+#[derive(Debug, Clone, Serialize)]
+pub(crate) struct ResponsesApiTool {
+    pub(crate) name: &'static str,
+    pub(crate) description: &'static str,
     pub(crate) strict: bool,
     pub(crate) parameters: JsonSchema,
 }
 
 /// When serialized as JSON, this produces a valid "Tool" in the OpenAI
 /// Responses API.
-#[derive(Debug, Clone, Serialize, PartialEq)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type")]
 pub(crate) enum OpenAiTool {
     #[serde(rename = "function")]
@@ -31,217 +25,78 @@ pub(crate) enum OpenAiTool {
     LocalShell {},
 }
 
-#[derive(Debug, Clone)]
-pub enum ConfigShellToolType {
-    DefaultShell,
-    ShellWithRequest { sandbox_policy: SandboxPolicy },
-    LocalShell,
-}
-
-#[derive(Debug, Clone)]
-pub struct ToolsConfig {
-    pub shell_type: ConfigShellToolType,
-    pub plan_tool: bool,
-}
-
-impl ToolsConfig {
-    pub fn new(
-        model_family: &ModelFamily,
-        approval_policy: AskForApproval,
-        sandbox_policy: SandboxPolicy,
-        include_plan_tool: bool,
-    ) -> Self {
-        let mut shell_type = if model_family.uses_local_shell_tool {
-            ConfigShellToolType::LocalShell
-        } else {
-            ConfigShellToolType::DefaultShell
-        };
-        if matches!(approval_policy, AskForApproval::OnRequest) {
-            shell_type = ConfigShellToolType::ShellWithRequest {
-                sandbox_policy: sandbox_policy.clone(),
-            }
-        }
-
-        Self {
-            shell_type,
-            plan_tool: include_plan_tool,
-        }
-    }
-}
-
 /// Generic JSON‑Schema subset needed for our tool definitions
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub(crate) enum JsonSchema {
-    Boolean {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        description: Option<String>,
-    },
-    String {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        description: Option<String>,
-    },
-    Number {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        description: Option<String>,
-    },
+    String,
+    Number,
     Array {
         items: Box<JsonSchema>,
-
-        #[serde(skip_serializing_if = "Option::is_none")]
-        description: Option<String>,
     },
     Object {
         properties: BTreeMap<String, JsonSchema>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        required: Option<Vec<String>>,
-        #[serde(
-            rename = "additionalProperties",
-            skip_serializing_if = "Option::is_none"
-        )]
-        additional_properties: Option<bool>,
+        required: &'static [&'static str],
+        #[serde(rename = "additionalProperties")]
+        additional_properties: bool,
     },
 }
 
-fn create_shell_tool() -> OpenAiTool {
+/// Tool usage specification
+static DEFAULT_TOOLS: LazyLock<Vec<OpenAiTool>> = LazyLock::new(|| {
     let mut properties = BTreeMap::new();
     properties.insert(
         "command".to_string(),
         JsonSchema::Array {
-            items: Box::new(JsonSchema::String { description: None }),
-            description: None,
+            items: Box::new(JsonSchema::String),
         },
     );
-    properties.insert(
-        "workdir".to_string(),
-        JsonSchema::String { description: None },
-    );
-    properties.insert(
-        "timeout".to_string(),
-        JsonSchema::Number { description: None },
-    );
+    properties.insert("workdir".to_string(), JsonSchema::String);
+    properties.insert("timeout".to_string(), JsonSchema::Number);
 
-    OpenAiTool::Function(ResponsesApiTool {
-        name: "shell".to_string(),
-        description: "Runs a shell command and returns its output".to_string(),
+    vec![OpenAiTool::Function(ResponsesApiTool {
+        name: "shell",
+        description: "Runs a shell command, and returns its output.",
         strict: false,
         parameters: JsonSchema::Object {
             properties,
-            required: Some(vec!["command".to_string()]),
-            additional_properties: Some(false),
+            required: &["command"],
+            additional_properties: false,
         },
-    })
-}
+    })]
+});
 
-fn create_shell_tool_for_sandbox(sandbox_policy: &SandboxPolicy) -> OpenAiTool {
-    let mut properties = BTreeMap::new();
-    properties.insert(
-        "command".to_string(),
-        JsonSchema::Array {
-            items: Box::new(JsonSchema::String { description: None }),
-            description: Some("The command to execute".to_string()),
-        },
-    );
-    properties.insert(
-        "workdir".to_string(),
-        JsonSchema::String {
-            description: Some("The working directory to execute the command in".to_string()),
-        },
-    );
-    properties.insert(
-        "timeout".to_string(),
-        JsonSchema::Number {
-            description: Some("The timeout for the command in milliseconds".to_string()),
-        },
-    );
-
-    if matches!(sandbox_policy, SandboxPolicy::WorkspaceWrite { .. }) {
-        properties.insert(
-        "with_escalated_permissions".to_string(),
-        JsonSchema::Boolean {
-            description: Some("Whether to request escalated permissions. Set to true if command needs to be run without sandbox restrictions".to_string()),
-        },
-    );
-        properties.insert(
-        "justification".to_string(),
-        JsonSchema::String {
-            description: Some("Only set if ask_for_escalated_permissions is true. 1-sentence explanation of why we want to run this command.".to_string()),
-        },
-    );
-    }
-
-    let description = match sandbox_policy {
-        SandboxPolicy::WorkspaceWrite {
-            network_access,
-            ..
-        } => {
-            format!(
-                r#"
-The shell tool is used to execute shell commands.
-- When invoking the shell tool, your call will be running in a landlock sandbox, and some shell commands will require escalated privileges:
-  - Types of actions that require escalated privileges:
-    - Reading files outside the current directory
-    - Writing files outside the current directory, and protected folders like .git or .env{}
-  - Examples of commands that require escalated privileges:
-    - git commit
-    - npm install or pnpm install
-    - cargo build
-    - cargo test
-- When invoking a command that will require escalated privileges:
-  - Provide the with_escalated_permissions parameter with the boolean value true
-  - Include a short, 1 sentence explanation for why we need to run with_escalated_permissions in the justification parameter."#,
-                if !network_access {
-                    "\n  - Commands that require network access\n"
-                } else {
-                    ""
-                }
-            )
-        }
-        SandboxPolicy::DangerFullAccess => {
-            "Runs a shell command and returns its output.".to_string()
-        }
-        SandboxPolicy::ReadOnly => {
-            r#"
-The shell tool is used to execute shell commands.
-- When invoking the shell tool, your call will be running in a landlock sandbox, and some shell commands (including apply_patch) will require escalated permissions:
-  - Types of actions that require escalated privileges:
-    - Reading files outside the current directory
-    - Writing files
-    - Applying patches
-  - Examples of commands that require escalated privileges:
-    - apply_patch
-    - git commit
-    - npm install or pnpm install
-    - cargo build
-    - cargo test
-- When invoking a command that will require escalated privileges:
-  - Provide the with_escalated_permissions parameter with the boolean value true
-  - Include a short, 1 sentence explanation for why we need to run with_escalated_permissions in the justification parameter"#.to_string()
-        }
-    };
-
-    OpenAiTool::Function(ResponsesApiTool {
-        name: "shell".to_string(),
-        description,
-        strict: false,
-        parameters: JsonSchema::Object {
-            properties,
-            required: Some(vec!["command".to_string()]),
-            additional_properties: Some(false),
-        },
-    })
-}
+static DEFAULT_CODEX_MODEL_TOOLS: LazyLock<Vec<OpenAiTool>> =
+    LazyLock::new(|| vec![OpenAiTool::LocalShell {}]);
 
 /// Returns JSON values that are compatible with Function Calling in the
 /// Responses API:
 /// https://platform.openai.com/docs/guides/function-calling?api-mode=responses
 pub(crate) fn create_tools_json_for_responses_api(
-    tools: &Vec<OpenAiTool>,
+    prompt: &Prompt,
+    model: &str,
+    include_plan_tool: bool,
 ) -> crate::error::Result<Vec<serde_json::Value>> {
-    let mut tools_json = Vec::new();
+    // Assemble tool list: built-in tools + any extra tools from the prompt.
+    let default_tools = if model.starts_with("codex") {
+        &DEFAULT_CODEX_MODEL_TOOLS
+    } else {
+        &DEFAULT_TOOLS
+    };
+    let mut tools_json = Vec::with_capacity(default_tools.len() + prompt.extra_tools.len());
+    for t in default_tools.iter() {
+        tools_json.push(serde_json::to_value(t)?);
+    }
+    tools_json.extend(
+        prompt
+            .extra_tools
+            .clone()
+            .into_iter()
+            .map(|(name, tool)| mcp_tool_to_openai_tool(name, tool)),
+    );
 
-    for tool in tools {
-        tools_json.push(serde_json::to_value(tool)?);
+    if include_plan_tool {
+        tools_json.push(serde_json::to_value(PLAN_TOOL.clone())?);
     }
 
     Ok(tools_json)
@@ -251,11 +106,14 @@ pub(crate) fn create_tools_json_for_responses_api(
 /// Chat Completions API:
 /// https://platform.openai.com/docs/guides/function-calling?api-mode=chat
 pub(crate) fn create_tools_json_for_chat_completions_api(
-    tools: &Vec<OpenAiTool>,
+    prompt: &Prompt,
+    model: &str,
+    include_plan_tool: bool,
 ) -> crate::error::Result<Vec<serde_json::Value>> {
     // We start with the JSON for the Responses API and than rewrite it to match
     // the chat completions tool call format.
-    let responses_api_tools_json = create_tools_json_for_responses_api(tools)?;
+    let responses_api_tools_json =
+        create_tools_json_for_responses_api(prompt, model, include_plan_tool)?;
     let tools_json = responses_api_tools_json
         .into_iter()
         .filter_map(|mut tool| {
@@ -278,10 +136,10 @@ pub(crate) fn create_tools_json_for_chat_completions_api(
     Ok(tools_json)
 }
 
-pub(crate) fn mcp_tool_to_openai_tool(
+fn mcp_tool_to_openai_tool(
     fully_qualified_name: String,
     tool: mcp_types::Tool,
-) -> Result<ResponsesApiTool, serde_json::Error> {
+) -> serde_json::Value {
     let mcp_types::Tool {
         description,
         mut input_schema,
@@ -296,205 +154,12 @@ pub(crate) fn mcp_tool_to_openai_tool(
         input_schema.properties = Some(serde_json::Value::Object(serde_json::Map::new()));
     }
 
-    let serialized_input_schema = serde_json::to_value(input_schema)?;
-    let input_schema = serde_json::from_value::<JsonSchema>(serialized_input_schema)?;
-
-    Ok(ResponsesApiTool {
-        name: fully_qualified_name,
-        description: description.unwrap_or_default(),
-        strict: false,
-        parameters: input_schema,
+    // TODO(mbolin): Change the contract of this function to return
+    // ResponsesApiTool.
+    json!({
+        "name": fully_qualified_name,
+        "description": description,
+        "parameters": input_schema,
+        "type": "function",
     })
 }
-
-/// Returns a list of OpenAiTools based on the provided config and MCP tools.
-/// Note that the keys of mcp_tools should be fully qualified names. See
-/// [`McpConnectionManager`] for more details.
-pub(crate) fn get_openai_tools(
-    config: &ToolsConfig,
-    mcp_tools: Option<HashMap<String, mcp_types::Tool>>,
-) -> Vec<OpenAiTool> {
-    let mut tools: Vec<OpenAiTool> = Vec::new();
-
-    match &config.shell_type {
-        ConfigShellToolType::DefaultShell => {
-            tools.push(create_shell_tool());
-        }
-        ConfigShellToolType::ShellWithRequest { sandbox_policy } => {
-            tools.push(create_shell_tool_for_sandbox(sandbox_policy));
-        }
-        ConfigShellToolType::LocalShell => {
-            tools.push(OpenAiTool::LocalShell {});
-        }
-    }
-
-    if config.plan_tool {
-        tools.push(PLAN_TOOL.clone());
-    }
-
-    if let Some(mcp_tools) = mcp_tools {
-        for (name, tool) in mcp_tools {
-            match mcp_tool_to_openai_tool(name.clone(), tool.clone()) {
-                Ok(converted_tool) => tools.push(OpenAiTool::Function(converted_tool)),
-                Err(e) => {
-                    tracing::error!("Failed to convert {name:?} MCP tool to OpenAI tool: {e:?}");
-                }
-            }
-        }
-    }
-
-    tools
-}
-
-#[cfg(test)]
-#[allow(clippy::expect_used)]
-mod tests {
-    use crate::model_family::find_family_for_model;
-    use mcp_types::ToolInputSchema;
-
-    use super::*;
-
-    fn assert_eq_tool_names(tools: &[OpenAiTool], expected_names: &[&str]) {
-        let tool_names = tools
-            .iter()
-            .map(|tool| match tool {
-                OpenAiTool::Function(ResponsesApiTool { name, .. }) => name,
-                OpenAiTool::LocalShell {} => "local_shell",
-            })
-            .collect::<Vec<_>>();
-
-        assert_eq!(
-            tool_names.len(),
-            expected_names.len(),
-            "tool_name mismatch, {tool_names:?}, {expected_names:?}",
-        );
-        for (name, expected_name) in tool_names.iter().zip(expected_names.iter()) {
-            assert_eq!(
-                name, expected_name,
-                "tool_name mismatch, {name:?}, {expected_name:?}"
-            );
-        }
-    }
-
-    #[test]
-    fn test_get_openai_tools() {
-        let model_family = find_family_for_model("codex-mini-latest")
-            .expect("codex-mini-latest should be a valid model family");
-        let config = ToolsConfig::new(
-            &model_family,
-            AskForApproval::Never,
-            SandboxPolicy::ReadOnly,
-            true,
-        );
-        let tools = get_openai_tools(&config, Some(HashMap::new()));
-
-        assert_eq_tool_names(&tools, &["local_shell", "update_plan"]);
-    }
-
-    #[test]
-    fn test_get_openai_tools_default_shell() {
-        let model_family = find_family_for_model("o3").expect("o3 should be a valid model family");
-        let config = ToolsConfig::new(
-            &model_family,
-            AskForApproval::Never,
-            SandboxPolicy::ReadOnly,
-            true,
-        );
-        let tools = get_openai_tools(&config, Some(HashMap::new()));
-
-        assert_eq_tool_names(&tools, &["shell", "update_plan"]);
-    }
-
-    #[test]
-    fn test_get_openai_tools_mcp_tools() {
-        let model_family = find_family_for_model("o3").expect("o3 should be a valid model family");
-        let config = ToolsConfig::new(
-            &model_family,
-            AskForApproval::Never,
-            SandboxPolicy::ReadOnly,
-            false,
-        );
-        let tools = get_openai_tools(
-            &config,
-            Some(HashMap::from([(
-                "test_server/do_something_cool".to_string(),
-                mcp_types::Tool {
-                    name: "do_something_cool".to_string(),
-                    input_schema: ToolInputSchema {
-                        properties: Some(serde_json::json!({
-                            "string_argument": {
-                                "type": "string",
-                            },
-                            "number_argument": {
-                                "type": "number",
-                            },
-                            "object_argument": {
-                                "type": "object",
-                                "properties": {
-                                    "string_property": { "type": "string" },
-                                    "number_property": { "type": "number" },
-                                },
-                                "required": [
-                                    "string_property",
-                                    "number_property"
-                                ],
-                                "additionalProperties": Some(false),
-                            },
-                        })),
-                        required: None,
-                        r#type: "object".to_string(),
-                    },
-                    output_schema: None,
-                    title: None,
-                    annotations: None,
-                    description: Some("Do something cool".to_string()),
-                },
-            )])),
-        );
-
-        assert_eq_tool_names(&tools, &["shell", "test_server/do_something_cool"]);
-
-        assert_eq!(
-            tools[1],
-            OpenAiTool::Function(ResponsesApiTool {
-                name: "test_server/do_something_cool".to_string(),
-                parameters: JsonSchema::Object {
-                    properties: BTreeMap::from([
-                        (
-                            "string_argument".to_string(),
-                            JsonSchema::String { description: None }
-                        ),
-                        (
-                            "number_argument".to_string(),
-                            JsonSchema::Number { description: None }
-                        ),
-                        (
-                            "object_argument".to_string(),
-                            JsonSchema::Object {
-                                properties: BTreeMap::from([
-                                    (
-                                        "string_property".to_string(),
-                                        JsonSchema::String { description: None }
-                                    ),
-                                    (
-                                        "number_property".to_string(),
-                                        JsonSchema::Number { description: None }
-                                    ),
-                                ]),
-                                required: Some(vec![
-                                    "string_property".to_string(),
-                                    "number_property".to_string(),
-                                ]),
-                                additional_properties: Some(false),
-                            },
-                        ),
-                    ]),
-                    required: None,
-                    additional_properties: None,
-                },
-                description: "Do something cool".to_string(),
-                strict: false,
-            })
-        );
-    }
-}

codex-rs/core/src/plan_tool.rs

@@ -39,30 +39,23 @@ pub struct UpdatePlanArgs {
 
 pub(crate) static PLAN_TOOL: LazyLock<OpenAiTool> = LazyLock::new(|| {
     let mut plan_item_props = BTreeMap::new();
-    plan_item_props.insert("step".to_string(), JsonSchema::String { description: None });
-    plan_item_props.insert(
-        "status".to_string(),
-        JsonSchema::String { description: None },
-    );
+    plan_item_props.insert("step".to_string(), JsonSchema::String);
+    plan_item_props.insert("status".to_string(), JsonSchema::String);
 
     let plan_items_schema = JsonSchema::Array {
-        description: Some("The list of steps".to_string()),
         items: Box::new(JsonSchema::Object {
             properties: plan_item_props,
-            required: Some(vec!["step".to_string(), "status".to_string()]),
-            additional_properties: Some(false),
+            required: &["step", "status"],
+            additional_properties: false,
         }),
     };
 
     let mut properties = BTreeMap::new();
-    properties.insert(
-        "explanation".to_string(),
-        JsonSchema::String { description: None },
-    );
+    properties.insert("explanation".to_string(), JsonSchema::String);
     properties.insert("plan".to_string(), plan_items_schema);
 
     OpenAiTool::Function(ResponsesApiTool {
-        name: "update_plan".to_string(),
+        name: "update_plan",
         description: r#"Use the update_plan tool to keep the user updated on the current plan for the task.
 After understanding the user's task, call the update_plan tool with an initial plan. An example of a plan:
 1. Explore the codebase to find relevant files (status: in_progress)
@@ -73,12 +66,12 @@ Until all the steps are finished, there should always be exactly one in_progress
 Call the update_plan tool whenever you finish a step, marking the completed step as `completed` and marking the next step as `in_progress`.
 Before running a command, consider whether or not you have completed the previous step, and make sure to mark it as completed before moving on to the next step.
 Sometimes, you may need to change plans in the middle of a task: call `update_plan` with the updated plan and make sure to provide an `explanation` of the rationale when doing so.
-When all steps are completed, call update_plan one last time with all steps marked as `completed`."#.to_string(),
+When all steps are completed, call update_plan one last time with all steps marked as `completed`."#,
         strict: false,
         parameters: JsonSchema::Object {
             properties,
-            required: Some(vec!["plan".to_string()]),
-            additional_properties: Some(false),
+            required: &["plan"],
+            additional_properties: false,
         },
     })
 });

codex-rs/core/src/protocol.rs

@@ -150,17 +150,13 @@ pub enum AskForApproval {
     /// the user to approve execution without a sandbox.
     OnFailure,
 
-    /// The model decides when to ask the user for approval.
-    OnRequest,
-
     /// Never ask the user to approve commands. Failures are immediately returned
     /// to the model, and never escalated to the user for approval.
     Never,
 }
 
 /// Determines execution restrictions for model shell commands.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Display)]
-#[strum(serialize_all = "kebab-case")]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "mode", rename_all = "kebab-case")]
 pub enum SandboxPolicy {
     /// No restrictions whatsoever. Use with caution.
@@ -363,12 +359,6 @@ pub enum EventMsg {
     /// Agent reasoning delta event from agent.
     AgentReasoningDelta(AgentReasoningDeltaEvent),
 
-    /// Raw chain-of-thought from agent.
-    AgentReasoningRawContent(AgentReasoningRawContentEvent),
-
-    /// Agent reasoning content delta event from agent.
-    AgentReasoningRawContentDelta(AgentReasoningRawContentDeltaEvent),
-
     /// Ack the client's configure message.
     SessionConfigured(SessionConfiguredEvent),
 
@@ -397,8 +387,6 @@ pub enum EventMsg {
     /// Notification that a patch application has finished.
     PatchApplyEnd(PatchApplyEndEvent),
 
-    TurnDiff(TurnDiffEvent),
-
     /// Response to GetHistoryEntryRequest.
     GetHistoryEntryResponse(GetHistoryEntryResponseEvent),
 
@@ -429,12 +417,6 @@ pub struct TokenUsage {
     pub total_tokens: u64,
 }
 
-impl TokenUsage {
-    pub fn is_zero(&self) -> bool {
-        self.total_tokens == 0
-    }
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct FinalOutput {
     pub token_usage: TokenUsage,
@@ -480,16 +462,6 @@ pub struct AgentReasoningEvent {
     pub text: String,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AgentReasoningRawContentEvent {
-    pub text: String,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct AgentReasoningRawContentDeltaEvent {
-    pub delta: String,
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct AgentReasoningDeltaEvent {
     pub delta: String,
@@ -551,8 +523,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)]
@@ -626,11 +596,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,

codex-rs/core/src/safety.rs

@@ -11,7 +11,7 @@ use crate::is_safe_command::is_known_safe_command;
 use crate::protocol::AskForApproval;
 use crate::protocol::SandboxPolicy;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub enum SafetyCheck {
     AutoApprove { sandbox_type: SandboxType },
     AskUser,
@@ -31,7 +31,7 @@ pub fn assess_patch_safety(
     }
 
     match policy {
-        AskForApproval::OnFailure | AskForApproval::Never | AskForApproval::OnRequest => {
+        AskForApproval::OnFailure | AskForApproval::Never => {
             // Continue to see if this can be auto-approved.
         }
         // TODO(ragona): I'm not sure this is actually correct? I believe in this case
@@ -76,7 +76,6 @@ pub fn assess_command_safety(
     approval_policy: AskForApproval,
     sandbox_policy: &SandboxPolicy,
     approved: &HashSet<Vec<String>>,
-    with_escalated_permissions: bool,
 ) -> SafetyCheck {
     // A command is "trusted" because either:
     // - it belongs to a set of commands we consider "safe" by default, or
@@ -97,13 +96,12 @@ pub fn assess_command_safety(
         };
     }
 
-    assess_safety_for_untrusted_command(approval_policy, sandbox_policy, with_escalated_permissions)
+    assess_safety_for_untrusted_command(approval_policy, sandbox_policy)
 }
 
 pub(crate) fn assess_safety_for_untrusted_command(
     approval_policy: AskForApproval,
     sandbox_policy: &SandboxPolicy,
-    with_escalated_permissions: bool,
 ) -> SafetyCheck {
     use AskForApproval::*;
     use SandboxPolicy::*;
@@ -115,23 +113,9 @@ pub(crate) fn assess_safety_for_untrusted_command(
             // commands.
             SafetyCheck::AskUser
         }
-        (OnFailure, DangerFullAccess)
-        | (Never, DangerFullAccess)
-        | (OnRequest, DangerFullAccess) => SafetyCheck::AutoApprove {
+        (OnFailure, DangerFullAccess) | (Never, DangerFullAccess) => SafetyCheck::AutoApprove {
             sandbox_type: SandboxType::None,
         },
-        (OnRequest, ReadOnly) | (OnRequest, WorkspaceWrite { .. }) => {
-            if with_escalated_permissions {
-                SafetyCheck::AskUser
-            } else {
-                match get_platform_sandbox() {
-                    Some(sandbox_type) => SafetyCheck::AutoApprove { sandbox_type },
-                    // Fall back to asking since the command is untrusted and
-                    // we do not have a sandbox available
-                    None => SafetyCheck::AskUser,
-                }
-            }
-        }
         (Never, ReadOnly)
         | (Never, WorkspaceWrite { .. })
         | (OnFailure, ReadOnly)
@@ -280,47 +264,4 @@ mod tests {
             &cwd,
         ))
     }
-
-    #[test]
-    fn test_request_escalated_privileges() {
-        // Should not be a trusted command
-        let command = vec!["git commit".to_string()];
-        let approval_policy = AskForApproval::OnRequest;
-        let sandbox_policy = SandboxPolicy::ReadOnly;
-        let approved: HashSet<Vec<String>> = HashSet::new();
-        let request_escalated_privileges = true;
-
-        let safety_check = assess_command_safety(
-            &command,
-            approval_policy,
-            &sandbox_policy,
-            &approved,
-            request_escalated_privileges,
-        );
-
-        assert_eq!(safety_check, SafetyCheck::AskUser);
-    }
-
-    #[test]
-    fn test_request_escalated_privileges_no_sandbox_fallback() {
-        let command = vec!["git".to_string(), "commit".to_string()];
-        let approval_policy = AskForApproval::OnRequest;
-        let sandbox_policy = SandboxPolicy::ReadOnly;
-        let approved: HashSet<Vec<String>> = HashSet::new();
-        let request_escalated_privileges = false;
-
-        let safety_check = assess_command_safety(
-            &command,
-            approval_policy,
-            &sandbox_policy,
-            &approved,
-            request_escalated_privileges,
-        );
-
-        let expected = match get_platform_sandbox() {
-            Some(sandbox_type) => SafetyCheck::AutoApprove { sandbox_type },
-            None => SafetyCheck::AskUser,
-        };
-        assert_eq!(safety_check, expected);
-    }
 }

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)

codex-rs/core/src/shell.rs

@@ -215,8 +215,6 @@ mod tests {
                         "HOME".to_string(),
                         temp_home.path().to_str().unwrap().to_string(),
                     )]),
-                    with_escalated_permissions: None,
-                    justification: None,
                 },
                 SandboxType::None,
                 Arc::new(Notify::new()),

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);
-    }
-}

codex-rs/core/tests/client.rs

@@ -1,12 +1,9 @@
-#![allow(clippy::expect_used)]
-#![allow(clippy::unwrap_used)]
 use std::path::PathBuf;
 
 use chrono::Utc;
 use codex_core::Codex;
 use codex_core::CodexSpawnOk;
 use codex_core::ModelProviderInfo;
-use codex_core::WireApi;
 use codex_core::built_in_model_providers;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::InputItem;
@@ -24,42 +21,14 @@ use tempfile::TempDir;
 use wiremock::Mock;
 use wiremock::MockServer;
 use wiremock::ResponseTemplate;
-use wiremock::matchers::header_regex;
 use wiremock::matchers::method;
 use wiremock::matchers::path;
-use wiremock::matchers::query_param;
 
 /// Build minimal SSE stream with completed marker using the JSON fixture.
 fn sse_completed(id: &str) -> String {
     load_sse_fixture_with_id("tests/fixtures/completed_template.json", id)
 }
 
-fn assert_message_role(request_body: &serde_json::Value, role: &str) {
-    assert_eq!(request_body["role"].as_str().unwrap(), role);
-}
-
-fn assert_message_starts_with(request_body: &serde_json::Value, text: &str) {
-    let content = request_body["content"][0]["text"]
-        .as_str()
-        .expect("invalid message content");
-
-    assert!(
-        content.starts_with(text),
-        "expected message content '{content}' to start with '{text}'"
-    );
-}
-
-fn assert_message_ends_with(request_body: &serde_json::Value, text: &str) {
-    let content = request_body["content"][0]["text"]
-        .as_str()
-        .expect("invalid message content");
-
-    assert!(
-        content.ends_with(text),
-        "expected message content '{content}' to end with '{text}'"
-    );
-}
-
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn includes_session_id_and_model_headers_in_request() {
     #![allow(clippy::unwrap_used)]
@@ -399,168 +368,14 @@ async fn includes_user_instructions_message_in_request() {
             .unwrap()
             .contains("be nice")
     );
-    assert_message_role(&request_body["input"][0], "user");
-    assert_message_starts_with(&request_body["input"][0], "<environment_context>\n\n");
-    assert_message_ends_with(&request_body["input"][0], "</environment_context>");
-    assert_message_role(&request_body["input"][1], "user");
-    assert_message_starts_with(&request_body["input"][1], "<user_instructions>\n\n");
-    assert_message_ends_with(&request_body["input"][1], "</user_instructions>");
+    assert_eq!(request_body["input"][0]["role"], "user");
+    assert!(
+        request_body["input"][0]["content"][0]["text"]
+            .as_str()
+            .unwrap()
+            .starts_with("be nice")
+    );
 }
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn azure_overrides_assign_properties_used_for_responses_url() {
-    #![allow(clippy::unwrap_used)]
-
-    let existing_env_var_with_random_value = if cfg!(windows) { "USERNAME" } else { "USER" };
-
-    // Mock server
-    let server = MockServer::start().await;
-
-    // First request – must NOT include `previous_response_id`.
-    let first = ResponseTemplate::new(200)
-        .insert_header("content-type", "text/event-stream")
-        .set_body_raw(sse_completed("resp1"), "text/event-stream");
-
-    // Expect POST to /openai/responses with api-version query param
-    Mock::given(method("POST"))
-        .and(path("/openai/responses"))
-        .and(query_param("api-version", "2025-04-01-preview"))
-        .and(header_regex("Custom-Header", "Value"))
-        .and(header_regex(
-            "Authorization",
-            format!(
-                "Bearer {}",
-                std::env::var(existing_env_var_with_random_value).unwrap()
-            )
-            .as_str(),
-        ))
-        .respond_with(first)
-        .expect(1)
-        .mount(&server)
-        .await;
-
-    let provider = ModelProviderInfo {
-        name: "custom".to_string(),
-        base_url: Some(format!("{}/openai", server.uri())),
-        // Reuse the existing environment variable to avoid using unsafe code
-        env_key: Some(existing_env_var_with_random_value.to_string()),
-        query_params: Some(std::collections::HashMap::from([(
-            "api-version".to_string(),
-            "2025-04-01-preview".to_string(),
-        )])),
-        env_key_instructions: None,
-        wire_api: WireApi::Responses,
-        http_headers: Some(std::collections::HashMap::from([(
-            "Custom-Header".to_string(),
-            "Value".to_string(),
-        )])),
-        env_http_headers: None,
-        request_max_retries: None,
-        stream_max_retries: None,
-        stream_idle_timeout_ms: None,
-        requires_openai_auth: false,
-    };
-
-    // Init session
-    let codex_home = TempDir::new().unwrap();
-    let mut config = load_default_config_for_test(&codex_home);
-    config.model_provider = provider;
-
-    let ctrl_c = std::sync::Arc::new(tokio::sync::Notify::new());
-    let CodexSpawnOk { codex, .. } = Codex::spawn(config, None, ctrl_c.clone()).await.unwrap();
-
-    codex
-        .submit(Op::UserInput {
-            items: vec![InputItem::Text {
-                text: "hello".into(),
-            }],
-        })
-        .await
-        .unwrap();
-
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn env_var_overrides_loaded_auth() {
-    #![allow(clippy::unwrap_used)]
-
-    let existing_env_var_with_random_value = if cfg!(windows) { "USERNAME" } else { "USER" };
-
-    // Mock server
-    let server = MockServer::start().await;
-
-    // First request – must NOT include `previous_response_id`.
-    let first = ResponseTemplate::new(200)
-        .insert_header("content-type", "text/event-stream")
-        .set_body_raw(sse_completed("resp1"), "text/event-stream");
-
-    // Expect POST to /openai/responses with api-version query param
-    Mock::given(method("POST"))
-        .and(path("/openai/responses"))
-        .and(query_param("api-version", "2025-04-01-preview"))
-        .and(header_regex("Custom-Header", "Value"))
-        .and(header_regex(
-            "Authorization",
-            format!(
-                "Bearer {}",
-                std::env::var(existing_env_var_with_random_value).unwrap()
-            )
-            .as_str(),
-        ))
-        .respond_with(first)
-        .expect(1)
-        .mount(&server)
-        .await;
-
-    let provider = ModelProviderInfo {
-        name: "custom".to_string(),
-        base_url: Some(format!("{}/openai", server.uri())),
-        // Reuse the existing environment variable to avoid using unsafe code
-        env_key: Some(existing_env_var_with_random_value.to_string()),
-        query_params: Some(std::collections::HashMap::from([(
-            "api-version".to_string(),
-            "2025-04-01-preview".to_string(),
-        )])),
-        env_key_instructions: None,
-        wire_api: WireApi::Responses,
-        http_headers: Some(std::collections::HashMap::from([(
-            "Custom-Header".to_string(),
-            "Value".to_string(),
-        )])),
-        env_http_headers: None,
-        request_max_retries: None,
-        stream_max_retries: None,
-        stream_idle_timeout_ms: None,
-        requires_openai_auth: false,
-    };
-
-    // Init session
-    let codex_home = TempDir::new().unwrap();
-    let mut config = load_default_config_for_test(&codex_home);
-    config.model_provider = provider;
-
-    let ctrl_c = std::sync::Arc::new(tokio::sync::Notify::new());
-    let CodexSpawnOk { codex, .. } = Codex::spawn(
-        config,
-        Some(auth_from_token("Default Access Token".to_string())),
-        ctrl_c.clone(),
-    )
-    .await
-    .unwrap();
-
-    codex
-        .submit(Op::UserInput {
-            items: vec![InputItem::Text {
-                text: "hello".into(),
-            }],
-        })
-        .await
-        .unwrap();
-
-    wait_for_event(&codex, |ev| matches!(ev, EventMsg::TaskComplete(_))).await;
-}
-
 fn auth_from_token(id_token: String) -> CodexAuth {
     CodexAuth::new(
         None,

codex-rs/core/tests/exec.rs

@@ -1,71 +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(),
-        with_escalated_permissions: None,
-        justification: None,
-    };
-
-    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;
-}

codex-rs/core/tests/exec_stream_events.rs

@@ -53,8 +53,6 @@ async fn test_exec_stdout_stream_events_echo() {
         cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
         timeout_ms: Some(5_000),
         env: HashMap::new(),
-        with_escalated_permissions: None,
-        justification: None,
     };
 
     let ctrl_c = Arc::new(Notify::new());
@@ -105,8 +103,6 @@ async fn test_exec_stderr_stream_events_echo() {
         cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
         timeout_ms: Some(5_000),
         env: HashMap::new(),
-        with_escalated_permissions: None,
-        justification: None,
     };
 
     let ctrl_c = Arc::new(Notify::new());

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));

codex-rs/core/tests/stream_no_completed.rs

@@ -90,7 +90,7 @@ async fn retries_on_early_close() {
         request_max_retries: Some(0),
         stream_max_retries: Some(1),
         stream_idle_timeout_ms: Some(2000),
-        requires_openai_auth: false,
+        requires_auth: false,
     };
 
     let ctrl_c = std::sync::Arc::new(tokio::sync::Notify::new());

codex-rs/exec/Cargo.toml

@@ -25,7 +25,6 @@ codex-common = { path = "../common", features = [
     "sandbox_summary",
 ] }
 codex-core = { path = "../core" }
-codex-ollama = { path = "../ollama" }
 owo-colors = "4.2.0"
 serde_json = "1"
 shlex = "1.3.0"

codex-rs/exec/src/cli.rs

@@ -14,9 +14,6 @@ pub struct Cli {
     #[arg(long, short = 'm')]
     pub model: Option<String>,
 
-    #[arg(long = "oss", default_value_t = false)]
-    pub oss: bool,
-
     /// Select the sandbox policy to use when executing model-generated shell
     /// commands.
     #[arg(long = "sandbox", short = 's')]

codex-rs/exec/src/event_processor.rs

@@ -1,6 +1,9 @@
 use std::path::Path;
 
+use codex_common::summarize_sandbox_policy;
+use codex_core::WireApi;
 use codex_core::config::Config;
+use codex_core::model_supports_reasoning_summaries;
 use codex_core::protocol::Event;
 
 pub(crate) enum CodexStatus {
@@ -17,14 +20,44 @@ pub(crate) trait EventProcessor {
     fn process_event(&mut self, event: Event) -> CodexStatus;
 }
 
-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 create_config_summary_entries(config: &Config) -> Vec<(&'static str, String)> {
+    let mut entries = vec![
+        ("workdir", config.cwd.display().to_string()),
+        ("model", config.model.clone()),
+        ("provider", config.model_provider_id.clone()),
+        ("approval", config.approval_policy.to_string()),
+        ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
+    ];
+    if config.model_provider.wire_api == WireApi::Responses
+        && model_supports_reasoning_summaries(config)
+    {
+        entries.push((
+            "reasoning effort",
+            config.model_reasoning_effort.to_string(),
+        ));
+        entries.push((
+            "reasoning summaries",
+            config.model_reasoning_summary.to_string(),
+        ));
+    }
+
+    entries
+}
+
+pub(crate) fn handle_last_message(
+    last_agent_message: Option<&str>,
+    last_message_path: Option<&Path>,
+) {
+    match (last_message_path, last_agent_message) {
+        (Some(path), Some(msg)) => write_last_message_file(msg, Some(path)),
+        (Some(path), None) => {
+            write_last_message_file("", Some(path));
+            eprintln!(
+                "Warning: no last agent message; wrote empty content to {}",
+                path.display()
+            );
+        }
+        (None, _) => eprintln!("Warning: no file to write last message to."),
     }
 }
 

codex-rs/exec/src/event_processor_with_human_output.rs

@@ -5,8 +5,6 @@ use codex_core::plan_tool::UpdatePlanArgs;
 use codex_core::protocol::AgentMessageDeltaEvent;
 use codex_core::protocol::AgentMessageEvent;
 use codex_core::protocol::AgentReasoningDeltaEvent;
-use codex_core::protocol::AgentReasoningRawContentDeltaEvent;
-use codex_core::protocol::AgentReasoningRawContentEvent;
 use codex_core::protocol::BackgroundEventEvent;
 use codex_core::protocol::ErrorEvent;
 use codex_core::protocol::Event;
@@ -22,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;
@@ -33,8 +30,8 @@ use std::time::Instant;
 
 use crate::event_processor::CodexStatus;
 use crate::event_processor::EventProcessor;
+use crate::event_processor::create_config_summary_entries;
 use crate::event_processor::handle_last_message;
-use codex_common::create_config_summary_entries;
 
 /// This should be configurable. When used in CI, users may not want to impose
 /// a limit so they can see the full transcript.
@@ -57,10 +54,8 @@ pub(crate) struct EventProcessorWithHumanOutput {
 
     /// Whether to include `AgentReasoning` events in the output.
     show_agent_reasoning: bool,
-    show_raw_agent_reasoning: bool,
     answer_started: bool,
     reasoning_started: bool,
-    raw_reasoning_started: bool,
     last_message_path: Option<PathBuf>,
 }
 
@@ -85,10 +80,8 @@ impl EventProcessorWithHumanOutput {
                 green: Style::new().green(),
                 cyan: Style::new().cyan(),
                 show_agent_reasoning: !config.hide_agent_reasoning,
-                show_raw_agent_reasoning: config.show_raw_agent_reasoning,
                 answer_started: false,
                 reasoning_started: false,
-                raw_reasoning_started: false,
                 last_message_path,
             }
         } else {
@@ -103,10 +96,8 @@ impl EventProcessorWithHumanOutput {
                 green: Style::new(),
                 cyan: Style::new(),
                 show_agent_reasoning: !config.hide_agent_reasoning,
-                show_raw_agent_reasoning: config.show_raw_agent_reasoning,
                 answer_started: false,
                 reasoning_started: false,
-                raw_reasoning_started: false,
                 last_message_path,
             }
         }
@@ -115,6 +106,7 @@ impl EventProcessorWithHumanOutput {
 
 struct ExecCommandBegin {
     command: Vec<String>,
+    start_time: Instant,
 }
 
 struct PatchApplyBegin {
@@ -178,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, .. }) => {
@@ -211,32 +204,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 #[allow(clippy::expect_used)]
                 std::io::stdout().flush().expect("could not flush stdout");
             }
-            EventMsg::AgentReasoningRawContent(AgentReasoningRawContentEvent { text }) => {
-                if !self.show_raw_agent_reasoning {
-                    return CodexStatus::Running;
-                }
-                if !self.raw_reasoning_started {
-                    print!("{text}");
-                    #[allow(clippy::expect_used)]
-                    std::io::stdout().flush().expect("could not flush stdout");
-                } else {
-                    println!();
-                    self.raw_reasoning_started = false;
-                }
-            }
-            EventMsg::AgentReasoningRawContentDelta(AgentReasoningRawContentDeltaEvent {
-                delta,
-            }) => {
-                if !self.show_raw_agent_reasoning {
-                    return CodexStatus::Running;
-                }
-                if !self.raw_reasoning_started {
-                    self.raw_reasoning_started = true;
-                }
-                print!("{delta}");
-                #[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.
@@ -261,6 +228,7 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                     call_id.clone(),
                     ExecCommandBegin {
                         command: command.clone(),
+                        start_time: Instant::now(),
                     },
                 );
                 ts_println!(
@@ -276,14 +244,16 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 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 {
@@ -433,7 +403,6 @@ impl EventProcessor for EventProcessorWithHumanOutput {
                 stdout,
                 stderr,
                 success,
-                ..
             }) => {
                 let patch_begin = self.call_id_to_patch.remove(&call_id);
 
@@ -463,10 +432,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?
             }

codex-rs/exec/src/event_processor_with_json_output.rs

@@ -9,8 +9,8 @@ use serde_json::json;
 
 use crate::event_processor::CodexStatus;
 use crate::event_processor::EventProcessor;
+use crate::event_processor::create_config_summary_entries;
 use crate::event_processor::handle_last_message;
-use codex_common::create_config_summary_entries;
 
 pub(crate) struct EventProcessorWithJsonOutput {
     last_message_path: Option<PathBuf>,
@@ -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,

codex-rs/exec/src/lib.rs

@@ -9,7 +9,6 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 pub use cli::Cli;
-use codex_core::BUILT_IN_OSS_MODEL_PROVIDER_ID;
 use codex_core::codex_wrapper::CodexConversation;
 use codex_core::codex_wrapper::{self};
 use codex_core::config::Config;
@@ -22,7 +21,6 @@ use codex_core::protocol::InputItem;
 use codex_core::protocol::Op;
 use codex_core::protocol::TaskCompleteEvent;
 use codex_core::util::is_inside_git_repo;
-use codex_ollama::DEFAULT_OSS_MODEL;
 use event_processor_with_human_output::EventProcessorWithHumanOutput;
 use event_processor_with_json_output::EventProcessorWithJsonOutput;
 use tracing::debug;
@@ -36,8 +34,7 @@ use crate::event_processor::EventProcessor;
 pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()> {
     let Cli {
         images,
-        model: model_cli_arg,
-        oss,
+        model,
         config_profile,
         full_auto,
         dangerously_bypass_approvals_and_sandbox,
@@ -117,23 +114,6 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         sandbox_mode_cli_arg.map(Into::<SandboxMode>::into)
     };
 
-    // When using `--oss`, let the bootstrapper pick the model (defaulting to
-    // gpt-oss:20b) and ensure it is present locally. Also, force the built‑in
-    // `oss` model provider.
-    let model = if let Some(model) = model_cli_arg {
-        Some(model)
-    } else if oss {
-        Some(DEFAULT_OSS_MODEL.to_owned())
-    } else {
-        None // No model specified, will use the default.
-    };
-
-    let model_provider = if oss {
-        Some(BUILT_IN_OSS_MODEL_PROVIDER_ID.to_string())
-    } else {
-        None // No specific model provider override.
-    };
-
     // Load configuration and determine approval policy
     let overrides = ConfigOverrides {
         model,
@@ -143,12 +123,10 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         approval_policy: Some(AskForApproval::Never),
         sandbox_mode,
         cwd: cwd.map(|p| p.canonicalize().unwrap_or(p)),
-        model_provider,
+        model_provider: None,
         codex_linux_sandbox_exe,
         base_instructions: None,
         include_plan_tool: None,
-        disable_response_storage: oss.then_some(true),
-        show_raw_agent_reasoning: oss.then_some(true),
     };
     // Parse `-c` overrides.
     let cli_kv_overrides = match config_overrides.parse_overrides() {
@@ -170,12 +148,6 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
         ))
     };
 
-    if oss {
-        codex_ollama::ensure_oss_ready(&config)
-            .await
-            .map_err(|e| anyhow::anyhow!("OSS setup failed: {e}"))?;
-    }
-
     // Print the effective configuration and prompt so users can see what Codex
     // is using.
     event_processor.print_config_summary(&config, &prompt);
@@ -216,16 +188,10 @@ pub async fn run_main(cli: Cli, codex_linux_sandbox_exe: Option<PathBuf>) -> any
                     res = codex.next_event() => match res {
                         Ok(event) => {
                             debug!("Received event: {event:?}");
-
-                            let is_shutdown_complete = matches!(event.msg, EventMsg::ShutdownComplete);
                             if let Err(e) = tx.send(event) {
                                 error!("Error sending event: {e:?}");
                                 break;
                             }
-                            if is_shutdown_complete {
-                                info!("Received shutdown event, exiting event loop.");
-                                break;
-                            }
                         },
                         Err(e) => {
                             error!("Error receiving event: {e:?}");

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]

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"] }

codex-rs/linux-sandbox/tests/landlock.rs

@@ -44,8 +44,6 @@ async fn run_cmd(cmd: &[&str], writable_roots: &[PathBuf], timeout_ms: u64) {
         cwd: std::env::current_dir().expect("cwd should exist"),
         timeout_ms: Some(timeout_ms),
         env: create_env_from_core_vars(),
-        with_escalated_permissions: None,
-        justification: None,
     };
 
     let sandbox_policy = SandboxPolicy::WorkspaceWrite {
@@ -141,8 +139,6 @@ async fn assert_network_blocked(cmd: &[&str]) {
         // do not stall the suite.
         timeout_ms: Some(NETWORK_TIMEOUT_MS),
         env: create_env_from_core_vars(),
-        with_escalated_permissions: None,
-        justification: None,
     };
 
     let sandbox_policy = SandboxPolicy::new_read_only_policy();

codex-rs/login/src/lib.rs

@@ -4,7 +4,6 @@ use chrono::Utc;
 use serde::Deserialize;
 use serde::Serialize;
 use std::env;
-use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::Read;
 use std::io::Write;
@@ -12,7 +11,6 @@ use std::io::Write;
 use std::os::unix::fs::OpenOptionsExt;
 use std::path::Path;
 use std::path::PathBuf;
-use std::process::Child;
 use std::process::Stdio;
 use std::sync::Arc;
 use std::sync::Mutex;
@@ -24,7 +22,7 @@ const SOURCE_FOR_PYTHON_SERVER: &str = include_str!("./login_with_chatgpt.py");
 const CLIENT_ID: &str = "app_EMoamEEZ73f0CkXaXp7hrann";
 pub const OPENAI_API_KEY_ENV_VAR: &str = "OPENAI_API_KEY";
 
-#[derive(Clone, Debug, PartialEq, Copy)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum AuthMode {
     ApiKey,
     ChatGPT,
@@ -185,59 +183,6 @@ fn get_auth_file(codex_home: &Path) -> PathBuf {
     codex_home.join("auth.json")
 }
 
-/// Represents a running login subprocess. The child can be killed by holding
-/// the mutex and calling `kill()`.
-#[derive(Debug, Clone)]
-pub struct SpawnedLogin {
-    pub child: Arc<Mutex<Child>>,
-    pub stdout: Arc<Mutex<Vec<u8>>>,
-    pub stderr: Arc<Mutex<Vec<u8>>>,
-}
-
-/// Spawn the ChatGPT login Python server as a child process and return a handle to its process.
-pub fn spawn_login_with_chatgpt(codex_home: &Path) -> std::io::Result<SpawnedLogin> {
-    let mut cmd = std::process::Command::new("python3");
-    cmd.arg("-c")
-        .arg(SOURCE_FOR_PYTHON_SERVER)
-        .env("CODEX_HOME", codex_home)
-        .env("CODEX_CLIENT_ID", CLIENT_ID)
-        .stdin(Stdio::null())
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped());
-
-    let mut child = cmd.spawn()?;
-
-    let stdout_buf = Arc::new(Mutex::new(Vec::new()));
-    let stderr_buf = Arc::new(Mutex::new(Vec::new()));
-
-    if let Some(mut out) = child.stdout.take() {
-        let buf = stdout_buf.clone();
-        std::thread::spawn(move || {
-            let mut tmp = Vec::new();
-            let _ = std::io::copy(&mut out, &mut tmp);
-            if let Ok(mut b) = buf.lock() {
-                b.extend_from_slice(&tmp);
-            }
-        });
-    }
-    if let Some(mut err) = child.stderr.take() {
-        let buf = stderr_buf.clone();
-        std::thread::spawn(move || {
-            let mut tmp = Vec::new();
-            let _ = std::io::copy(&mut err, &mut tmp);
-            if let Ok(mut b) = buf.lock() {
-                b.extend_from_slice(&tmp);
-            }
-        });
-    }
-
-    Ok(SpawnedLogin {
-        child: Arc::new(Mutex::new(child)),
-        stdout: stdout_buf,
-        stderr: stderr_buf,
-    })
-}
-
 /// Run `python3 -c {{SOURCE_FOR_PYTHON_SERVER}}` with the CODEX_HOME
 /// environment variable set to the provided `codex_home` path. If the
 /// subprocess exits 0, read the OPENAI_API_KEY property out of
@@ -289,7 +234,7 @@ pub fn login_with_api_key(codex_home: &Path, api_key: &str) -> std::io::Result<(
 /// Attempt to read and refresh the `auth.json` file in the given `CODEX_HOME` directory.
 /// Returns the full AuthDotJson structure after refreshing if necessary.
 pub fn try_read_auth_json(auth_file: &Path) -> std::io::Result<AuthDotJson> {
-    let mut file = File::open(auth_file)?;
+    let mut file = std::fs::File::open(auth_file)?;
     let mut contents = String::new();
     file.read_to_string(&mut contents)?;
     let auth_dot_json: AuthDotJson = serde_json::from_str(&contents)?;

codex-rs/login/src/login_with_chatgpt.py

@@ -110,7 +110,7 @@ def main() -> None:
                 eprint(f"Failed to open browser: {e}")
 
         eprint(
-            f". If your browser did not open, navigate to this URL to authenticate: \n\n{auth_url}"
+            f"If your browser did not open, navigate to this URL to authenticate:\n\n{auth_url}"
         )
 
         # Run the server in the main thread until `shutdown()` is called by the
@@ -458,7 +458,6 @@ class _ApiKeyHTTPServer(http.server.HTTPServer):
             "code_challenge": self.pkce.code_challenge,
             "code_challenge_method": "S256",
             "id_token_add_organizations": "true",
-            "codex_cli_simplified_flow": "true",
             "state": self.state,
         }
         return f"{self.issuer}/oauth/authorize?" + urllib.parse.urlencode(params)

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

@@ -158,8 +158,6 @@ impl CodexToolCallParam {
             codex_linux_sandbox_exe,
             base_instructions,
             include_plan_tool,
-            disable_response_storage: None,
-            show_raw_agent_reasoning: None,
         };
 
         let cli_overrides = cli_overrides

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

@@ -252,9 +252,7 @@ async fn run_codex_tool_session_inner(
                     EventMsg::AgentMessage(AgentMessageEvent { .. }) => {
                         // TODO: think how we want to support this in the MCP
                     }
-                    EventMsg::AgentReasoningRawContent(_)
-                    | EventMsg::AgentReasoningRawContentDelta(_)
-                    | EventMsg::TaskStarted
+                    EventMsg::TaskStarted
                     | EventMsg::TokenCount(_)
                     | EventMsg::AgentReasoning(_)
                     | EventMsg::McpToolCallBegin(_)
@@ -265,7 +263,6 @@ async fn run_codex_tool_session_inner(
                     | EventMsg::BackgroundEvent(_)
                     | EventMsg::PatchApplyBegin(_)
                     | EventMsg::PatchApplyEnd(_)
-                    | EventMsg::TurnDiff(_)
                     | EventMsg::GetHistoryEntryResponse(_)
                     | EventMsg::PlanUpdate(_)
                     | EventMsg::ShutdownComplete => {

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

@@ -90,16 +90,13 @@ pub async fn run_conversation_loop(
                     EventMsg::AgentMessage(AgentMessageEvent { .. }) => {
                         // TODO: think how we want to support this in the MCP
                     }
-                    EventMsg::AgentReasoningRawContent(_)
-                    | EventMsg::AgentReasoningRawContentDelta(_)
-                    | EventMsg::TaskStarted
+                    EventMsg::TaskStarted
                     | EventMsg::TokenCount(_)
                     | EventMsg::AgentReasoning(_)
                     | EventMsg::McpToolCallBegin(_)
                     | EventMsg::McpToolCallEnd(_)
                     | EventMsg::ExecCommandBegin(_)
                     | EventMsg::ExecCommandEnd(_)
-                    | EventMsg::TurnDiff(_)
                     | EventMsg::BackgroundEvent(_)
                     | EventMsg::ExecCommandOutputDelta(_)
                     | EventMsg::PatchApplyBegin(_)

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.

codex-rs/mcp-server/src/tool_handlers/create_conversation.rs

@@ -59,8 +59,6 @@ pub(crate) async fn handle_create_conversation(
         codex_linux_sandbox_exe: None,
         base_instructions,
         include_plan_tool: None,
-        disable_response_storage: None,
-        show_raw_agent_reasoning: None,
     };
 
     let cfg: CodexConfig = match CodexConfig::load_with_cli_overrides(cli_overrides, overrides) {

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);
 

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

@@ -18,7 +18,7 @@ use tokio::time::timeout;
 
 const DEFAULT_READ_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(10);
 
-#[tokio::test]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_send_message_success() {
     // Spin up a mock completions server that immediately ends the Codex turn.
     // Two Codex turns hit the mock model (session start + send-user-message). Provide two SSE responses.
@@ -99,13 +99,13 @@ async fn test_send_message_success() {
         response
     );
     // wait for the server to hear the user message
-    sleep(Duration::from_secs(5));
+    sleep(Duration::from_secs(1));
 
     // Ensure the server and tempdir live until end of test
     drop(server);
 }
 
-#[tokio::test]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_send_message_session_not_found() {
     // Start MCP without creating a Codex session
     let codex_home = TempDir::new().expect("tempdir");

codex-rs/ollama/Cargo.toml

@@ -1,32 +0,0 @@
-[package]
-edition = "2024"
-name = "codex-ollama"
-version = { workspace = true }
-
-[lib]
-name = "codex_ollama"
-path = "src/lib.rs"
-
-[lints]
-workspace = true
-
-[dependencies]
-async-stream = "0.3"
-bytes = "1.10.1"
-codex-core = { path = "../core" }
-futures = "0.3"
-reqwest = { version = "0.12", features = ["json", "stream"] }
-serde_json = "1"
-tokio = { version = "1", features = [
-    "io-std",
-    "macros",
-    "process",
-    "rt-multi-thread",
-    "signal",
-] }
-toml = "0.9.2"
-tracing = { version = "0.1.41", features = ["log"] }
-wiremock = "0.6"
-
-[dev-dependencies]
-tempfile = "3"

codex-rs/ollama/src/client.rs

@@ -1,351 +0,0 @@
-use bytes::BytesMut;
-use futures::StreamExt;
-use futures::stream::BoxStream;
-use serde_json::Value as JsonValue;
-use std::collections::VecDeque;
-use std::io;
-
-use crate::parser::pull_events_from_value;
-use crate::pull::PullEvent;
-use crate::pull::PullProgressReporter;
-use crate::url::base_url_to_host_root;
-use crate::url::is_openai_compatible_base_url;
-use codex_core::BUILT_IN_OSS_MODEL_PROVIDER_ID;
-use codex_core::ModelProviderInfo;
-use codex_core::WireApi;
-use codex_core::config::Config;
-
-const OLLAMA_CONNECTION_ERROR: &str = "No running Ollama server detected. Start it with: `ollama serve` (after installing). Install instructions: https://github.com/ollama/ollama?tab=readme-ov-file#ollama";
-
-/// Client for interacting with a local Ollama instance.
-pub struct OllamaClient {
-    client: reqwest::Client,
-    host_root: String,
-    uses_openai_compat: bool,
-}
-
-impl OllamaClient {
-    /// Construct a client for the built‑in open‑source ("oss") model provider
-    /// and verify that a local Ollama server is reachable. If no server is
-    /// detected, returns an error with helpful installation/run instructions.
-    pub async fn try_from_oss_provider(config: &Config) -> io::Result<Self> {
-        // Note that we must look up the provider from the Config to ensure that
-        // any overrides the user has in their config.toml are taken into
-        // account.
-        let provider = config
-            .model_providers
-            .get(BUILT_IN_OSS_MODEL_PROVIDER_ID)
-            .ok_or_else(|| {
-                io::Error::new(
-                    io::ErrorKind::NotFound,
-                    format!("Built-in provider {BUILT_IN_OSS_MODEL_PROVIDER_ID} not found",),
-                )
-            })?;
-
-        Self::try_from_provider(provider).await
-    }
-
-    #[cfg(test)]
-    async fn try_from_provider_with_base_url(base_url: &str) -> io::Result<Self> {
-        let provider = codex_core::create_oss_provider_with_base_url(base_url);
-        Self::try_from_provider(&provider).await
-    }
-
-    /// Build a client from a provider definition and verify the server is reachable.
-    async fn try_from_provider(provider: &ModelProviderInfo) -> io::Result<Self> {
-        #![allow(clippy::expect_used)]
-        let base_url = provider
-            .base_url
-            .as_ref()
-            .expect("oss provider must have a base_url");
-        let uses_openai_compat = is_openai_compatible_base_url(base_url)
-            || matches!(provider.wire_api, WireApi::Chat)
-                && is_openai_compatible_base_url(base_url);
-        let host_root = base_url_to_host_root(base_url);
-        let client = reqwest::Client::builder()
-            .connect_timeout(std::time::Duration::from_secs(5))
-            .build()
-            .unwrap_or_else(|_| reqwest::Client::new());
-        let client = Self {
-            client,
-            host_root,
-            uses_openai_compat,
-        };
-        client.probe_server().await?;
-        Ok(client)
-    }
-
-    /// Probe whether the server is reachable by hitting the appropriate health endpoint.
-    async fn probe_server(&self) -> io::Result<()> {
-        let url = if self.uses_openai_compat {
-            format!("{}/v1/models", self.host_root.trim_end_matches('/'))
-        } else {
-            format!("{}/api/tags", self.host_root.trim_end_matches('/'))
-        };
-        let resp = self.client.get(url).send().await.map_err(|err| {
-            tracing::warn!("Failed to connect to Ollama server: {err:?}");
-            io::Error::other(OLLAMA_CONNECTION_ERROR)
-        })?;
-        if resp.status().is_success() {
-            Ok(())
-        } else {
-            tracing::warn!(
-                "Failed to probe server at {}: HTTP {}",
-                self.host_root,
-                resp.status()
-            );
-            Err(io::Error::other(OLLAMA_CONNECTION_ERROR))
-        }
-    }
-
-    /// Return the list of model names known to the local Ollama instance.
-    pub async fn fetch_models(&self) -> io::Result<Vec<String>> {
-        let tags_url = format!("{}/api/tags", self.host_root.trim_end_matches('/'));
-        let resp = self
-            .client
-            .get(tags_url)
-            .send()
-            .await
-            .map_err(io::Error::other)?;
-        if !resp.status().is_success() {
-            return Ok(Vec::new());
-        }
-        let val = resp.json::<JsonValue>().await.map_err(io::Error::other)?;
-        let names = val
-            .get("models")
-            .and_then(|m| m.as_array())
-            .map(|arr| {
-                arr.iter()
-                    .filter_map(|v| v.get("name").and_then(|n| n.as_str()))
-                    .map(|s| s.to_string())
-                    .collect::<Vec<_>>()
-            })
-            .unwrap_or_default();
-        Ok(names)
-    }
-
-    /// Start a model pull and emit streaming events. The returned stream ends when
-    /// a Success event is observed or the server closes the connection.
-    pub async fn pull_model_stream(
-        &self,
-        model: &str,
-    ) -> io::Result<BoxStream<'static, PullEvent>> {
-        let url = format!("{}/api/pull", self.host_root.trim_end_matches('/'));
-        let resp = self
-            .client
-            .post(url)
-            .json(&serde_json::json!({"model": model, "stream": true}))
-            .send()
-            .await
-            .map_err(io::Error::other)?;
-        if !resp.status().is_success() {
-            return Err(io::Error::other(format!(
-                "failed to start pull: HTTP {}",
-                resp.status()
-            )));
-        }
-
-        let mut stream = resp.bytes_stream();
-        let mut buf = BytesMut::new();
-        let _pending: VecDeque<PullEvent> = VecDeque::new();
-
-        // Using an async stream adaptor backed by unfold-like manual loop.
-        let s = async_stream::stream! {
-            while let Some(chunk) = stream.next().await {
-                match chunk {
-                    Ok(bytes) => {
-                        buf.extend_from_slice(&bytes);
-                        while let Some(pos) = buf.iter().position(|b| *b == b'\n') {
-                            let line = buf.split_to(pos + 1);
-                            if let Ok(text) = std::str::from_utf8(&line) {
-                                let text = text.trim();
-                                if text.is_empty() { continue; }
-                                if let Ok(value) = serde_json::from_str::<JsonValue>(text) {
-                                    for ev in pull_events_from_value(&value) { yield ev; }
-                                    if let Some(err_msg) = value.get("error").and_then(|e| e.as_str()) {
-                                        yield PullEvent::Error(err_msg.to_string());
-                                        return;
-                                    }
-                                    if let Some(status) = value.get("status").and_then(|s| s.as_str()) {
-                                        if status == "success" { yield PullEvent::Success; return; }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    Err(_) => {
-                        // Connection error: end the stream.
-                        return;
-                    }
-                }
-            }
-        };
-
-        Ok(Box::pin(s))
-    }
-
-    /// High-level helper to pull a model and drive a progress reporter.
-    pub async fn pull_with_reporter(
-        &self,
-        model: &str,
-        reporter: &mut dyn PullProgressReporter,
-    ) -> io::Result<()> {
-        reporter.on_event(&PullEvent::Status(format!("Pulling model {model}...")))?;
-        let mut stream = self.pull_model_stream(model).await?;
-        while let Some(event) = stream.next().await {
-            reporter.on_event(&event)?;
-            match event {
-                PullEvent::Success => {
-                    return Ok(());
-                }
-                PullEvent::Error(err) => {
-                    // Empirically, ollama returns a 200 OK response even when
-                    // the output stream includes an error message. Verify with:
-                    //
-                    // `curl -i http://localhost:11434/api/pull -d '{ "model": "foobarbaz" }'`
-                    //
-                    // As such, we have to check the event stream, not the
-                    // HTTP response status, to determine whether to return Err.
-                    return Err(io::Error::other(format!("Pull failed: {err}")));
-                }
-                PullEvent::ChunkProgress { .. } | PullEvent::Status(_) => {
-                    continue;
-                }
-            }
-        }
-        Err(io::Error::other(
-            "Pull stream ended unexpectedly without success.",
-        ))
-    }
-
-    /// Low-level constructor given a raw host root, e.g. "http://localhost:11434".
-    #[cfg(test)]
-    fn from_host_root(host_root: impl Into<String>) -> Self {
-        let client = reqwest::Client::builder()
-            .connect_timeout(std::time::Duration::from_secs(5))
-            .build()
-            .unwrap_or_else(|_| reqwest::Client::new());
-        Self {
-            client,
-            host_root: host_root.into(),
-            uses_openai_compat: false,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::expect_used, clippy::unwrap_used)]
-    use super::*;
-
-    // Happy-path tests using a mock HTTP server; skip if sandbox network is disabled.
-    #[tokio::test]
-    async fn test_fetch_models_happy_path() {
-        if std::env::var(codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
-            tracing::info!(
-                "{} is set; skipping test_fetch_models_happy_path",
-                codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
-            );
-            return;
-        }
-
-        let server = wiremock::MockServer::start().await;
-        wiremock::Mock::given(wiremock::matchers::method("GET"))
-            .and(wiremock::matchers::path("/api/tags"))
-            .respond_with(
-                wiremock::ResponseTemplate::new(200).set_body_raw(
-                    serde_json::json!({
-                        "models": [ {"name": "llama3.2:3b"}, {"name":"mistral"} ]
-                    })
-                    .to_string(),
-                    "application/json",
-                ),
-            )
-            .mount(&server)
-            .await;
-
-        let client = OllamaClient::from_host_root(server.uri());
-        let models = client.fetch_models().await.expect("fetch models");
-        assert!(models.contains(&"llama3.2:3b".to_string()));
-        assert!(models.contains(&"mistral".to_string()));
-    }
-
-    #[tokio::test]
-    async fn test_probe_server_happy_path_openai_compat_and_native() {
-        if std::env::var(codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
-            tracing::info!(
-                "{} set; skipping test_probe_server_happy_path_openai_compat_and_native",
-                codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
-            );
-            return;
-        }
-
-        let server = wiremock::MockServer::start().await;
-
-        // Native endpoint
-        wiremock::Mock::given(wiremock::matchers::method("GET"))
-            .and(wiremock::matchers::path("/api/tags"))
-            .respond_with(wiremock::ResponseTemplate::new(200))
-            .mount(&server)
-            .await;
-        let native = OllamaClient::from_host_root(server.uri());
-        native.probe_server().await.expect("probe native");
-
-        // OpenAI compatibility endpoint
-        wiremock::Mock::given(wiremock::matchers::method("GET"))
-            .and(wiremock::matchers::path("/v1/models"))
-            .respond_with(wiremock::ResponseTemplate::new(200))
-            .mount(&server)
-            .await;
-        let ollama_client =
-            OllamaClient::try_from_provider_with_base_url(&format!("{}/v1", server.uri()))
-                .await
-                .expect("probe OpenAI compat");
-        ollama_client
-            .probe_server()
-            .await
-            .expect("probe OpenAI compat");
-    }
-
-    #[tokio::test]
-    async fn test_try_from_oss_provider_ok_when_server_running() {
-        if std::env::var(codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
-            tracing::info!(
-                "{} set; skipping test_try_from_oss_provider_ok_when_server_running",
-                codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
-            );
-            return;
-        }
-
-        let server = wiremock::MockServer::start().await;
-
-        // OpenAI‑compat models endpoint responds OK.
-        wiremock::Mock::given(wiremock::matchers::method("GET"))
-            .and(wiremock::matchers::path("/v1/models"))
-            .respond_with(wiremock::ResponseTemplate::new(200))
-            .mount(&server)
-            .await;
-
-        OllamaClient::try_from_provider_with_base_url(&format!("{}/v1", server.uri()))
-            .await
-            .expect("client should be created when probe succeeds");
-    }
-
-    #[tokio::test]
-    async fn test_try_from_oss_provider_err_when_server_missing() {
-        if std::env::var(codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {
-            tracing::info!(
-                "{} set; skipping test_try_from_oss_provider_err_when_server_missing",
-                codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR
-            );
-            return;
-        }
-
-        let server = wiremock::MockServer::start().await;
-        let err = OllamaClient::try_from_provider_with_base_url(&format!("{}/v1", server.uri()))
-            .await
-            .err()
-            .expect("expected error");
-        assert_eq!(OLLAMA_CONNECTION_ERROR, err.to_string());
-    }
-}

codex-rs/ollama/src/lib.rs

@@ -1,44 +0,0 @@
-mod client;
-mod parser;
-mod pull;
-mod url;
-
-pub use client::OllamaClient;
-use codex_core::config::Config;
-pub use pull::CliProgressReporter;
-pub use pull::PullEvent;
-pub use pull::PullProgressReporter;
-pub use pull::TuiProgressReporter;
-
-/// Default OSS model to use when `--oss` is passed without an explicit `-m`.
-pub const DEFAULT_OSS_MODEL: &str = "gpt-oss:20b";
-
-/// Prepare the local OSS environment when `--oss` is selected.
-///
-/// - Ensures a local Ollama server is reachable.
-/// - Checks if the model exists locally and pulls it if missing.
-pub async fn ensure_oss_ready(config: &Config) -> std::io::Result<()> {
-    // Only download when the requested model is the default OSS model (or when -m is not provided).
-    let model = config.model.as_ref();
-
-    // Verify local Ollama is reachable.
-    let ollama_client = crate::OllamaClient::try_from_oss_provider(config).await?;
-
-    // If the model is not present locally, pull it.
-    match ollama_client.fetch_models().await {
-        Ok(models) => {
-            if !models.iter().any(|m| m == model) {
-                let mut reporter = crate::CliProgressReporter::new();
-                ollama_client
-                    .pull_with_reporter(model, &mut reporter)
-                    .await?;
-            }
-        }
-        Err(err) => {
-            // Not fatal; higher layers may still proceed and surface errors later.
-            tracing::warn!("Failed to query local models from Ollama: {}.", err);
-        }
-    }
-
-    Ok(())
-}

codex-rs/ollama/src/parser.rs

@@ -1,82 +0,0 @@
-use serde_json::Value as JsonValue;
-
-use crate::pull::PullEvent;
-
-// Convert a single JSON object representing a pull update into one or more events.
-pub(crate) fn pull_events_from_value(value: &JsonValue) -> Vec<PullEvent> {
-    let mut events = Vec::new();
-    if let Some(status) = value.get("status").and_then(|s| s.as_str()) {
-        events.push(PullEvent::Status(status.to_string()));
-        if status == "success" {
-            events.push(PullEvent::Success);
-        }
-    }
-    let digest = value
-        .get("digest")
-        .and_then(|d| d.as_str())
-        .unwrap_or("")
-        .to_string();
-    let total = value.get("total").and_then(|t| t.as_u64());
-    let completed = value.get("completed").and_then(|t| t.as_u64());
-    if total.is_some() || completed.is_some() {
-        events.push(PullEvent::ChunkProgress {
-            digest,
-            total,
-            completed,
-        });
-    }
-    events
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_pull_events_decoder_status_and_success() {
-        let v: JsonValue = serde_json::json!({"status":"verifying"});
-        let events = pull_events_from_value(&v);
-        assert!(matches!(events.as_slice(), [PullEvent::Status(s)] if s == "verifying"));
-
-        let v2: JsonValue = serde_json::json!({"status":"success"});
-        let events2 = pull_events_from_value(&v2);
-        assert_eq!(events2.len(), 2);
-        assert!(matches!(events2[0], PullEvent::Status(ref s) if s == "success"));
-        assert!(matches!(events2[1], PullEvent::Success));
-    }
-
-    #[test]
-    fn test_pull_events_decoder_progress() {
-        let v: JsonValue = serde_json::json!({"digest":"sha256:abc","total":100});
-        let events = pull_events_from_value(&v);
-        assert_eq!(events.len(), 1);
-        match &events[0] {
-            PullEvent::ChunkProgress {
-                digest,
-                total,
-                completed,
-            } => {
-                assert_eq!(digest, "sha256:abc");
-                assert_eq!(*total, Some(100));
-                assert_eq!(*completed, None);
-            }
-            _ => panic!("expected ChunkProgress"),
-        }
-
-        let v2: JsonValue = serde_json::json!({"digest":"sha256:def","completed":42});
-        let events2 = pull_events_from_value(&v2);
-        assert_eq!(events2.len(), 1);
-        match &events2[0] {
-            PullEvent::ChunkProgress {
-                digest,
-                total,
-                completed,
-            } => {
-                assert_eq!(digest, "sha256:def");
-                assert_eq!(*total, None);
-                assert_eq!(*completed, Some(42));
-            }
-            _ => panic!("expected ChunkProgress"),
-        }
-    }
-}

codex-rs/ollama/src/pull.rs

@@ -1,147 +0,0 @@
-use std::collections::HashMap;
-use std::io;
-use std::io::Write;
-
-/// Events emitted while pulling a model from Ollama.
-#[derive(Debug, Clone)]
-pub enum PullEvent {
-    /// A human-readable status message (e.g., "verifying", "writing").
-    Status(String),
-    /// Byte-level progress update for a specific layer digest.
-    ChunkProgress {
-        digest: String,
-        total: Option<u64>,
-        completed: Option<u64>,
-    },
-    /// The pull finished successfully.
-    Success,
-
-    /// Error event with a message.
-    Error(String),
-}
-
-/// A simple observer for pull progress events. Implementations decide how to
-/// render progress (CLI, TUI, logs, ...).
-pub trait PullProgressReporter {
-    fn on_event(&mut self, event: &PullEvent) -> io::Result<()>;
-}
-
-/// A minimal CLI reporter that writes inline progress to stderr.
-pub struct CliProgressReporter {
-    printed_header: bool,
-    last_line_len: usize,
-    last_completed_sum: u64,
-    last_instant: std::time::Instant,
-    totals_by_digest: HashMap<String, (u64, u64)>,
-}
-
-impl Default for CliProgressReporter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl CliProgressReporter {
-    pub fn new() -> Self {
-        Self {
-            printed_header: false,
-            last_line_len: 0,
-            last_completed_sum: 0,
-            last_instant: std::time::Instant::now(),
-            totals_by_digest: HashMap::new(),
-        }
-    }
-}
-
-impl PullProgressReporter for CliProgressReporter {
-    fn on_event(&mut self, event: &PullEvent) -> io::Result<()> {
-        let mut out = std::io::stderr();
-        match event {
-            PullEvent::Status(status) => {
-                // Avoid noisy manifest messages; otherwise show status inline.
-                if status.eq_ignore_ascii_case("pulling manifest") {
-                    return Ok(());
-                }
-                let pad = self.last_line_len.saturating_sub(status.len());
-                let line = format!("\r{status}{}", " ".repeat(pad));
-                self.last_line_len = status.len();
-                out.write_all(line.as_bytes())?;
-                out.flush()
-            }
-            PullEvent::ChunkProgress {
-                digest,
-                total,
-                completed,
-            } => {
-                if let Some(t) = *total {
-                    self.totals_by_digest
-                        .entry(digest.clone())
-                        .or_insert((0, 0))
-                        .0 = t;
-                }
-                if let Some(c) = *completed {
-                    self.totals_by_digest
-                        .entry(digest.clone())
-                        .or_insert((0, 0))
-                        .1 = c;
-                }
-
-                let (sum_total, sum_completed) = self
-                    .totals_by_digest
-                    .values()
-                    .fold((0u64, 0u64), |acc, (t, c)| (acc.0 + *t, acc.1 + *c));
-                if sum_total > 0 {
-                    if !self.printed_header {
-                        let gb = (sum_total as f64) / (1024.0 * 1024.0 * 1024.0);
-                        let header = format!("Downloading model: total {gb:.2} GB\n");
-                        out.write_all(b"\r\x1b[2K")?;
-                        out.write_all(header.as_bytes())?;
-                        self.printed_header = true;
-                    }
-                    let now = std::time::Instant::now();
-                    let dt = now
-                        .duration_since(self.last_instant)
-                        .as_secs_f64()
-                        .max(0.001);
-                    let dbytes = sum_completed.saturating_sub(self.last_completed_sum) as f64;
-                    let speed_mb_s = dbytes / (1024.0 * 1024.0) / dt;
-                    self.last_completed_sum = sum_completed;
-                    self.last_instant = now;
-
-                    let done_gb = (sum_completed as f64) / (1024.0 * 1024.0 * 1024.0);
-                    let total_gb = (sum_total as f64) / (1024.0 * 1024.0 * 1024.0);
-                    let pct = (sum_completed as f64) * 100.0 / (sum_total as f64);
-                    let text =
-                        format!("{done_gb:.2}/{total_gb:.2} GB ({pct:.1}%) {speed_mb_s:.1} MB/s");
-                    let pad = self.last_line_len.saturating_sub(text.len());
-                    let line = format!("\r{text}{}", " ".repeat(pad));
-                    self.last_line_len = text.len();
-                    out.write_all(line.as_bytes())?;
-                    out.flush()
-                } else {
-                    Ok(())
-                }
-            }
-            PullEvent::Error(_) => {
-                // This will be handled by the caller, so we don't do anything
-                // here or the error will be printed twice.
-                Ok(())
-            }
-            PullEvent::Success => {
-                out.write_all(b"\n")?;
-                out.flush()
-            }
-        }
-    }
-}
-
-/// For now the TUI reporter delegates to the CLI reporter. This keeps UI and
-/// CLI behavior aligned until a dedicated TUI integration is implemented.
-#[derive(Default)]
-pub struct TuiProgressReporter(CliProgressReporter);
-
-impl PullProgressReporter for TuiProgressReporter {
-    fn on_event(&mut self, event: &PullEvent) -> io::Result<()> {
-        self.0.on_event(event)
-    }
-}

codex-rs/ollama/src/url.rs

@@ -1,39 +0,0 @@
-/// Identify whether a base_url points at an OpenAI-compatible root (".../v1").
-pub(crate) fn is_openai_compatible_base_url(base_url: &str) -> bool {
-    base_url.trim_end_matches('/').ends_with("/v1")
-}
-
-/// Convert a provider base_url into the native Ollama host root.
-/// For example, "http://localhost:11434/v1" -> "http://localhost:11434".
-pub fn base_url_to_host_root(base_url: &str) -> String {
-    let trimmed = base_url.trim_end_matches('/');
-    if trimmed.ends_with("/v1") {
-        trimmed
-            .trim_end_matches("/v1")
-            .trim_end_matches('/')
-            .to_string()
-    } else {
-        trimmed.to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_base_url_to_host_root() {
-        assert_eq!(
-            base_url_to_host_root("http://localhost:11434/v1"),
-            "http://localhost:11434"
-        );
-        assert_eq!(
-            base_url_to_host_root("http://localhost:11434"),
-            "http://localhost:11434"
-        );
-        assert_eq!(
-            base_url_to_host_root("http://localhost:11434/"),
-            "http://localhost:11434"
-        );
-    }
-}

codex-rs/scripts/create_github_release.sh

@@ -19,33 +19,7 @@ if ! git diff --quiet || ! git diff --cached --quiet || [ -n "$(git ls-files --o
 fi
 
 # Fail if in a detached HEAD state.
-CURRENT_BRANCH=$(git symbolic-ref --short -q HEAD 2>/dev/null || true)
-if [ -z "${CURRENT_BRANCH:-}" ]; then
-  echo "ERROR: Could not determine the current branch (detached HEAD?)." >&2
-  echo "       Please run this script from a checked-out branch." >&2
-  exit 1
-fi
-
-# Ensure we are on the 'main' branch before proceeding.
-if [ "${CURRENT_BRANCH}" != "main" ]; then
-  echo "ERROR: Releases must be created from the 'main' branch (current: '${CURRENT_BRANCH}')." >&2
-  echo "       Please switch to 'main' and try again." >&2
-  exit 1
-fi
-
-# Ensure the current local commit on 'main' is present on 'origin/main'.
-# This guarantees we only create releases from commits that are already on
-# the canonical repository (https://github.com/openai/codex).
-if ! git fetch --quiet origin main; then
-  echo "ERROR: Failed to fetch 'origin/main'. Ensure the 'origin' remote is configured and reachable." >&2
-  exit 1
-fi
-
-if ! git merge-base --is-ancestor HEAD origin/main; then
-  echo "ERROR: Your local 'main' HEAD commit is not present on 'origin/main'." >&2
-  echo "       Please push your commits first (git push origin main) or check out a commit on 'origin/main'." >&2
-  exit 1
-fi
+CURRENT_BRANCH=$(git symbolic-ref --short -q HEAD)
 
 # Create a new branch for the release and make a commit with the new version.
 if [ $# -ge 1 ]; then

codex-rs/tui/Cargo.toml

@@ -11,10 +11,6 @@ path = "src/main.rs"
 name = "codex_tui"
 path = "src/lib.rs"
 
-[features]
-# Enable vt100-based tests (emulator) when running with `--features vt100-tests`.
-vt100-tests = []
-
 [lints]
 workspace = true
 
@@ -33,7 +29,6 @@ codex-common = { path = "../common", features = [
 codex-core = { path = "../core" }
 codex-file-search = { path = "../file-search" }
 codex-login = { path = "../login" }
-codex-ollama = { path = "../ollama" }
 color-eyre = "0.6.3"
 crossterm = { version = "0.28.1", features = ["bracketed-paste"] }
 image = { version = "^0.25.6", default-features = false, features = ["jpeg"] }
@@ -53,8 +48,6 @@ 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",
@@ -67,6 +60,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"
@@ -76,6 +70,3 @@ uuid = "1"
 [dev-dependencies]
 insta = "1.43.1"
 pretty_assertions = "1"
-rand = "0.8"
-chrono = { version = "0.4", features = ["serde"] }
-vt100 = "0.16.2"

codex-rs/tui/prompt_for_init_command.md

@@ -1,40 +0,0 @@
-Generate a file named AGENTS.md that serves as a contributor guide for this repository.
-Your goal is to produce a clear, concise, and well-structured document with descriptive headings and actionable explanations for each section.
-Follow the outline below, but adapt as needed — add sections if relevant, and omit those that do not apply to this project.
-
-Document Requirements
-
-- Title the document "Repository Guidelines".
-- Use Markdown headings (#, ##, etc.) for structure.
-- Keep the document concise. 200-400 words is optimal.
-- Keep explanations short, direct, and specific to this repository.
-- Provide examples where helpful (commands, directory paths, naming patterns).
-- Maintain a professional, instructional tone.
-
-Recommended Sections
-
-Project Structure & Module Organization
-
-- Outline the project structure, including where the source code, tests, and assets are located.
-
-Build, Test, and Development Commands
-
-- List key commands for building, testing, and running locally (e.g., npm test, make build).
-- Briefly explain what each command does.
-
-Coding Style & Naming Conventions
-
-- Specify indentation rules, language-specific style preferences, and naming patterns.
-- Include any formatting or linting tools used.
-
-Testing Guidelines
-
-- Identify testing frameworks and coverage requirements.
-- State test naming conventions and how to run tests.
-
-Commit & Pull Request Guidelines
-
-- Summarize commit message conventions found in the project’s Git history.
-- Outline pull request requirements (descriptions, linked issues, screenshots, etc.).
-
-(Optional) Add other sections if relevant, such as Security & Configuration Tips, Architecture Overview, or Agent-Specific Instructions.

codex-rs/tui/src/app.rs

@@ -5,10 +5,6 @@ use crate::file_search::FileSearchManager;
 use crate::get_git_diff::get_git_diff;
 use crate::git_warning_screen::GitWarningOutcome;
 use crate::git_warning_screen::GitWarningScreen;
-use crate::onboarding::onboarding_screen::KeyEventResult;
-use crate::onboarding::onboarding_screen::KeyboardHandler;
-use crate::onboarding::onboarding_screen::OnboardingScreen;
-use crate::should_show_login_screen;
 use crate::slash_command::SlashCommand;
 use crate::tui;
 use codex_core::config::Config;
@@ -39,9 +35,6 @@ const REDRAW_DEBOUNCE: Duration = Duration::from_millis(10);
 /// Top-level application state: which full-screen view is currently active.
 #[allow(clippy::large_enum_variant)]
 enum AppState<'a> {
-    Onboarding {
-        screen: OnboardingScreen,
-    },
     /// The main chat UI is visible.
     Chat {
         /// Boxed to avoid a large enum variant and reduce the overall size of
@@ -49,9 +42,7 @@ enum AppState<'a> {
         widget: Box<ChatWidget<'a>>,
     },
     /// The start-up warning that recommends running codex inside a Git repo.
-    GitWarning {
-        screen: GitWarningScreen,
-    },
+    GitWarning { screen: GitWarningScreen },
 }
 
 pub(crate) struct App<'a> {
@@ -142,20 +133,7 @@ impl App<'_> {
             });
         }
 
-        let show_login_screen = should_show_login_screen(&config);
-        let (app_state, chat_args) = if show_login_screen {
-            (
-                AppState::Onboarding {
-                    screen: OnboardingScreen::new(app_event_tx.clone(), config.codex_home.clone()),
-                },
-                Some(ChatWidgetArgs {
-                    config: config.clone(),
-                    initial_prompt,
-                    initial_images,
-                    enhanced_keys_supported,
-                }),
-            )
-        } else if show_git_warning {
+        let (app_state, chat_args) = if show_git_warning {
             (
                 AppState::GitWarning {
                     screen: GitWarningScreen::new(),
@@ -254,25 +232,11 @@ impl App<'_> {
                                 AppState::Chat { widget } => {
                                     widget.on_ctrl_c();
                                 }
-                                AppState::Onboarding { .. } => {
-                                    self.app_event_tx.send(AppEvent::ExitRequest);
-                                }
                                 AppState::GitWarning { .. } => {
-                                    // Allow exiting the app with Ctrl+C from the warning screen.
-                                    self.app_event_tx.send(AppEvent::ExitRequest);
+                                    // No-op.
                                 }
                             }
                         }
-                        KeyEvent {
-                            code: KeyCode::Char('z'),
-                            modifiers: crossterm::event::KeyModifiers::CONTROL,
-                            kind: KeyEventKind::Press,
-                            ..
-                        } => {
-                            if let AppState::Chat { widget } = &mut self.app_state {
-                                widget.on_ctrl_z();
-                            }
-                        }
                         KeyEvent {
                             code: KeyCode::Char('d'),
                             modifiers: crossterm::event::KeyModifiers::CONTROL,
@@ -290,9 +254,6 @@ impl App<'_> {
                                         self.dispatch_key_event(key_event);
                                     }
                                 }
-                                AppState::Onboarding { .. } => {
-                                    self.app_event_tx.send(AppEvent::ExitRequest);
-                                }
                                 AppState::GitWarning { .. } => {
                                     self.app_event_tx.send(AppEvent::ExitRequest);
                                 }
@@ -320,12 +281,10 @@ impl App<'_> {
                 }
                 AppEvent::CodexOp(op) => match &mut self.app_state {
                     AppState::Chat { widget } => widget.submit_op(op),
-                    AppState::Onboarding { .. } => {}
                     AppState::GitWarning { .. } => {}
                 },
                 AppEvent::LatestLog(line) => match &mut self.app_state {
                     AppState::Chat { widget } => widget.update_latest_log(line),
-                    AppState::Onboarding { .. } => {}
                     AppState::GitWarning { .. } => {}
                 },
                 AppEvent::DispatchCommand(command) => match command {
@@ -340,13 +299,6 @@ impl App<'_> {
                         self.app_state = AppState::Chat { widget: new_widget };
                         self.app_event_tx.send(AppEvent::RequestRedraw);
                     }
-                    SlashCommand::Init => {
-                        // Guard: do not run if a task is active.
-                        if let AppState::Chat { widget } = &mut self.app_state {
-                            const INIT_PROMPT: &str = include_str!("../prompt_for_init_command.md");
-                            widget.submit_text_message(INIT_PROMPT.to_string());
-                        }
-                    }
                     SlashCommand::Compact => {
                         if let AppState::Chat { widget } = &mut self.app_state {
                             widget.clear_token_usage();
@@ -377,11 +329,6 @@ impl App<'_> {
                             widget.add_diff_output(text);
                         }
                     }
-                    SlashCommand::Status => {
-                        if let AppState::Chat { widget } = &mut self.app_state {
-                            widget.add_status_output();
-                        }
-                    }
                     #[cfg(debug_assertions)]
                     SlashCommand::TestApproval => {
                         use std::collections::HashMap;
@@ -422,12 +369,6 @@ impl App<'_> {
                         }));
                     }
                 },
-                AppEvent::OnboardingAuthComplete(result) => {
-                    if let AppState::Onboarding { screen } = &mut self.app_state {
-                        // Let the onboarding screen handle success/failure and emit follow-up events.
-                        let _ = screen.on_auth_complete(result);
-                    }
-                }
                 AppEvent::StartFileSearch(query) => {
                     self.file_search.on_user_query(query);
                 }
@@ -446,7 +387,6 @@ impl App<'_> {
     pub(crate) fn token_usage(&self) -> codex_core::protocol::TokenUsage {
         match &self.app_state {
             AppState::Chat { widget } => widget.token_usage().clone(),
-            AppState::Onboarding { .. } => codex_core::protocol::TokenUsage::default(),
             AppState::GitWarning { .. } => codex_core::protocol::TokenUsage::default(),
         }
     }
@@ -475,8 +415,7 @@ impl App<'_> {
         let size = terminal.size()?;
         let desired_height = match &self.app_state {
             AppState::Chat { widget } => widget.desired_height(size.width),
-            AppState::Onboarding { .. } => size.height,
-            AppState::GitWarning { .. } => size.height,
+            AppState::GitWarning { .. } => 10,
         };
 
         let mut area = terminal.viewport_area;
@@ -499,16 +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::Onboarding { screen } => frame.render_widget_ref(&*screen, 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(())
     }
 
@@ -519,25 +456,6 @@ impl App<'_> {
             AppState::Chat { widget } => {
                 widget.handle_key_event(key_event);
             }
-            AppState::Onboarding { screen } => match screen.handle_key_event(key_event) {
-                KeyEventResult::Continue => {
-                    self.app_state = AppState::Chat {
-                        widget: Box::new(ChatWidget::new(
-                            self.config.clone(),
-                            self.app_event_tx.clone(),
-                            None,
-                            Vec::new(),
-                            self.enhanced_keys_supported,
-                        )),
-                    };
-                }
-                KeyEventResult::Quit => {
-                    self.app_event_tx.send(AppEvent::ExitRequest);
-                }
-                KeyEventResult::None => {
-                    // do nothing
-                }
-            },
             AppState::GitWarning { screen } => match screen.handle_key_event(key_event) {
                 GitWarningOutcome::Continue => {
                     // User accepted – switch to chat view.
@@ -569,7 +487,6 @@ impl App<'_> {
     fn dispatch_paste_event(&mut self, pasted: String) {
         match &mut self.app_state {
             AppState::Chat { widget } => widget.handle_paste(pasted),
-            AppState::Onboarding { .. } => {}
             AppState::GitWarning { .. } => {}
         }
     }
@@ -577,7 +494,6 @@ impl App<'_> {
     fn dispatch_codex_event(&mut self, event: Event) {
         match &mut self.app_state {
             AppState::Chat { widget } => widget.handle_codex_event(event),
-            AppState::Onboarding { .. } => {}
             AppState::GitWarning { .. } => {}
         }
     }

codex-rs/tui/src/app_event.rs

@@ -48,7 +48,4 @@ pub(crate) enum AppEvent {
     },
 
     InsertHistory(Vec<Line<'static>>),
-
-    /// Onboarding: result of login_with_chatgpt.
-    OnboardingAuthComplete(Result<(), String>),
 }

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");
     }
 }

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

@@ -188,38 +188,3 @@ impl WidgetRef for CommandPopup {
         table.render(area, buf);
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn filter_includes_init_when_typing_prefix() {
-        let mut popup = CommandPopup::new();
-        // Simulate the composer line starting with '/in' so the popup filters
-        // matching commands by prefix.
-        popup.on_composer_text_change("/in".to_string());
-
-        // Access the filtered list via the selected command and ensure that
-        // one of the matches is the new "init" command.
-        let matches = popup.filtered_commands();
-        assert!(
-            matches.iter().any(|cmd| cmd.command() == "init"),
-            "expected '/init' to appear among filtered commands"
-        );
-    }
-
-    #[test]
-    fn selecting_init_by_exact_match() {
-        let mut popup = CommandPopup::new();
-        popup.on_composer_text_change("/init".to_string());
-
-        // When an exact match exists, the selected command should be that
-        // command by default.
-        let selected = popup.selected_command();
-        match selected {
-            Some(cmd) => assert_eq!(cmd.command(), "init"),
-            None => panic!("expected a selected command for exact match"),
-        }
-    }
-}

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

@@ -1,45 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::text::Line;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::WidgetRef;
-
-/// Minimal rendering-only widget for the transient ring rows.
-pub(crate) struct LiveRingWidget {
-    max_rows: u16,
-    rows: Vec<Line<'static>>, // newest at the end
-}
-
-impl LiveRingWidget {
-    pub fn new() -> Self {
-        Self {
-            max_rows: 3,
-            rows: Vec::new(),
-        }
-    }
-
-    pub fn set_max_rows(&mut self, n: u16) {
-        self.max_rows = n.max(1);
-    }
-
-    pub fn set_rows(&mut self, rows: Vec<Line<'static>>) {
-        self.rows = rows;
-    }
-
-    pub fn desired_height(&self, _width: u16) -> u16 {
-        let len = self.rows.len() as u16;
-        len.min(self.max_rows)
-    }
-}
-
-impl WidgetRef for LiveRingWidget {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        if area.height == 0 {
-            return;
-        }
-        let visible = self.rows.len().saturating_sub(self.max_rows as usize);
-        let slice = &self.rows[visible..];
-        let para = Paragraph::new(slice.to_vec());
-        para.render_ref(area, buf);
-    }
-}

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

@@ -4,12 +4,12 @@ use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 use crate::user_approval_widget::ApprovalRequest;
 use bottom_pane_view::BottomPaneView;
+use bottom_pane_view::ConditionalUpdate;
 use codex_core::protocol::TokenUsage;
 use codex_file_search::FileMatch;
 use crossterm::event::KeyEvent;
 use ratatui::buffer::Buffer;
 use ratatui::layout::Rect;
-use ratatui::text::Line;
 use ratatui::widgets::WidgetRef;
 
 mod approval_modal_view;
@@ -18,9 +18,7 @@ mod chat_composer;
 mod chat_composer_history;
 mod command_popup;
 mod file_search_popup;
-mod live_ring_widget;
 mod status_indicator_view;
-mod textarea;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CancellationEvent {
@@ -31,7 +29,6 @@ pub(crate) enum CancellationEvent {
 pub(crate) use chat_composer::ChatComposer;
 pub(crate) use chat_composer::InputResult;
 
-use crate::status_indicator_widget::StatusIndicatorWidget;
 use approval_modal_view::ApprovalModalView;
 use status_indicator_view::StatusIndicatorView;
 
@@ -39,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>>,
@@ -48,19 +45,6 @@ pub(crate) struct BottomPane<'a> {
     has_input_focus: bool,
     is_task_running: bool,
     ctrl_c_quit_hint: bool,
-
-    /// Optional live, multi‑line status/"live cell" rendered directly above
-    /// the composer while a task is running. Unlike `active_view`, this does
-    /// not replace the composer; it augments it.
-    live_status: Option<StatusIndicatorWidget>,
-
-    /// Optional transient ring shown above the composer. This is a rendering-only
-    /// container used during development before we wire it to ChatWidget events.
-    live_ring: Option<live_ring_widget::LiveRingWidget>,
-
-    /// True if the active view is the StatusIndicatorView that replaces the
-    /// composer during a running task.
-    status_view_active: bool,
 }
 
 pub(crate) struct BottomPaneParams {
@@ -70,7 +54,6 @@ pub(crate) struct BottomPaneParams {
 }
 
 impl BottomPane<'_> {
-    const BOTTOM_PAD_LINES: u16 = 2;
     pub fn new(params: BottomPaneParams) -> Self {
         let enhanced_keys_supported = params.enhanced_keys_supported;
         Self {
@@ -84,52 +67,14 @@ impl BottomPane<'_> {
             has_input_focus: params.has_input_focus,
             is_task_running: false,
             ctrl_c_quit_hint: false,
-            live_status: None,
-            live_ring: None,
-            status_view_active: false,
         }
     }
 
     pub fn desired_height(&self, width: u16) -> u16 {
-        let overlay_status_h = self
-            .live_status
+        self.active_view
             .as_ref()
-            .map(|s| s.desired_height(width))
-            .unwrap_or(0);
-        let ring_h = self
-            .live_ring
-            .as_ref()
-            .map(|r| r.desired_height(width))
-            .unwrap_or(0);
-
-        let view_height = if let Some(view) = self.active_view.as_ref() {
-            // Add a single blank spacer line between live ring and status view when active.
-            let spacer = if self.live_ring.is_some() && self.status_view_active {
-                1
-            } else {
-                0
-            };
-            spacer + view.desired_height(width)
-        } else {
-            self.composer.desired_height(width)
-        };
-
-        overlay_status_h
-            .saturating_add(ring_h)
-            .saturating_add(view_height)
-            .saturating_add(Self::BOTTOM_PAD_LINES)
-    }
-
-    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)
-        }
+            .map(|v| v.desired_height(width))
+            .unwrap_or(self.composer.desired_height())
     }
 
     /// Forward a key event to the active view or the composer.
@@ -139,10 +84,9 @@ impl BottomPane<'_> {
             if !view.is_complete() {
                 self.active_view = Some(view);
             } else if self.is_task_running {
-                let mut v = StatusIndicatorView::new(self.app_event_tx.clone());
-                v.update_text("waiting for model".to_string());
-                self.active_view = Some(Box::new(v));
-                self.status_view_active = true;
+                self.active_view = Some(Box::new(StatusIndicatorView::new(
+                    self.app_event_tx.clone(),
+                )));
             }
             self.request_redraw();
             InputResult::None
@@ -169,11 +113,9 @@ impl BottomPane<'_> {
                 if !view.is_complete() {
                     self.active_view = Some(view);
                 } else if self.is_task_running {
-                    // Modal aborted but task still running – restore status indicator.
-                    let mut v = StatusIndicatorView::new(self.app_event_tx.clone());
-                    v.update_text("waiting for model".to_string());
-                    self.active_view = Some(Box::new(v));
-                    self.status_view_active = true;
+                    self.active_view = Some(Box::new(StatusIndicatorView::new(
+                        self.app_event_tx.clone(),
+                    )));
                 }
                 self.show_ctrl_c_quit_hint();
             }
@@ -193,42 +135,19 @@ impl BottomPane<'_> {
         }
     }
 
-    /// Update the status indicator text. Prefer replacing the composer with
-    /// the StatusIndicatorView so the input pane shows a single-line status
-    /// like: `▌ Working waiting for model`.
+    /// Update the status indicator text (only when the `StatusIndicatorView` is
+    /// active).
     pub(crate) fn update_status_text(&mut self, text: String) {
-        let mut handled_by_view = false;
-        if let Some(view) = self.active_view.as_mut() {
-            if matches!(
-                view.update_status_text(text.clone()),
-                bottom_pane_view::ConditionalUpdate::NeedsRedraw
-            ) {
-                handled_by_view = true;
+        if let Some(view) = &mut self.active_view {
+            match view.update_status_text(text) {
+                ConditionalUpdate::NeedsRedraw => {
+                    self.request_redraw();
+                }
+                ConditionalUpdate::NoRedraw => {
+                    // No redraw needed.
+                }
             }
-        } else {
-            let mut v = StatusIndicatorView::new(self.app_event_tx.clone());
-            v.update_text(text.clone());
-            self.active_view = Some(Box::new(v));
-            self.status_view_active = true;
-            handled_by_view = true;
         }
-
-        // Fallback: if the current active view did not consume status updates
-        // and no modal view is active, present an overlay above the composer.
-        // If a modal is active, do NOT render the overlay to avoid drawing
-        // over the dialog.
-        if !handled_by_view && self.active_view.is_none() {
-            if self.live_status.is_none() {
-                self.live_status = Some(StatusIndicatorWidget::new(self.app_event_tx.clone()));
-            }
-            if let Some(status) = &mut self.live_status {
-                status.update_text(text);
-            }
-        } else if !handled_by_view {
-            // Ensure any previous overlay is cleared when a modal becomes active.
-            self.live_status = None;
-        }
-        self.request_redraw();
     }
 
     pub(crate) fn show_ctrl_c_quit_hint(&mut self) {
@@ -254,23 +173,27 @@ impl BottomPane<'_> {
     pub fn set_task_running(&mut self, running: bool) {
         self.is_task_running = running;
 
-        if running {
-            if self.active_view.is_none() {
+        match (running, self.active_view.is_some()) {
+            (true, false) => {
+                // Show status indicator overlay.
                 self.active_view = Some(Box::new(StatusIndicatorView::new(
                     self.app_event_tx.clone(),
                 )));
-                self.status_view_active = true;
+                self.request_redraw();
             }
-            self.request_redraw();
-        } else {
-            self.live_status = None;
-            // Drop the status view when a task completes, but keep other
-            // modal views (e.g. approval dialogs).
-            if let Some(mut view) = self.active_view.take() {
-                if !view.should_hide_when_task_is_done() {
-                    self.active_view = Some(view);
+            (false, true) => {
+                if let Some(mut view) = self.active_view.take() {
+                    if view.should_hide_when_task_is_done() {
+                        // Leave self.active_view as None.
+                        self.request_redraw();
+                    } else {
+                        // Preserve the view.
+                        self.active_view = Some(view);
+                    }
                 }
-                self.status_view_active = false;
+            }
+            _ => {
+                // No change.
             }
         }
     }
@@ -312,9 +235,6 @@ impl BottomPane<'_> {
         // Otherwise create a new approval modal overlay.
         let modal = ApprovalModalView::new(request, self.app_event_tx.clone());
         self.active_view = Some(Box::new(modal));
-        // Hide any overlay status while a modal is visible.
-        self.live_status = None;
-        self.status_view_active = false;
         self.request_redraw()
     }
 
@@ -348,82 +268,15 @@ impl BottomPane<'_> {
         self.composer.on_file_search_result(query, matches);
         self.request_redraw();
     }
-
-    /// Set the rows and cap for the transient live ring overlay.
-    pub(crate) fn set_live_ring_rows(&mut self, max_rows: u16, rows: Vec<Line<'static>>) {
-        let mut w = live_ring_widget::LiveRingWidget::new();
-        w.set_max_rows(max_rows);
-        w.set_rows(rows);
-        self.live_ring = Some(w);
-    }
-
-    pub(crate) fn clear_live_ring(&mut self) {
-        self.live_ring = None;
-    }
-
-    // Removed restart_live_status_with_text – no longer used by the current streaming UI.
 }
 
 impl WidgetRef for &BottomPane<'_> {
     fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        let mut y_offset = 0u16;
-        if let Some(ring) = &self.live_ring {
-            let live_h = ring.desired_height(area.width).min(area.height);
-            if live_h > 0 {
-                let live_rect = Rect {
-                    x: area.x,
-                    y: area.y,
-                    width: area.width,
-                    height: live_h,
-                };
-                ring.render_ref(live_rect, buf);
-                y_offset = live_h;
-            }
-        }
-        // Spacer between live ring and status view when active
-        if self.live_ring.is_some() && self.status_view_active && y_offset < area.height {
-            // Leave one empty line
-            y_offset = y_offset.saturating_add(1);
-        }
-        if let Some(status) = &self.live_status {
-            let live_h = status
-                .desired_height(area.width)
-                .min(area.height.saturating_sub(y_offset));
-            if live_h > 0 {
-                let live_rect = Rect {
-                    x: area.x,
-                    y: area.y + y_offset,
-                    width: area.width,
-                    height: live_h,
-                };
-                status.render_ref(live_rect, buf);
-                y_offset = y_offset.saturating_add(live_h);
-            }
-        }
-
-        if let Some(view) = &self.active_view {
-            if y_offset < area.height {
-                // Reserve bottom padding lines; keep at least 1 line for the view.
-                let avail = area.height - y_offset;
-                let pad = BottomPane::BOTTOM_PAD_LINES.min(avail.saturating_sub(1));
-                let view_rect = Rect {
-                    x: area.x,
-                    y: area.y + y_offset,
-                    width: area.width,
-                    height: avail - pad,
-                };
-                view.render(view_rect, buf);
-            }
-        } else if y_offset < area.height {
-            let composer_rect = Rect {
-                x: area.x,
-                y: area.y + y_offset,
-                width: area.width,
-                // Reserve bottom padding
-                height: (area.height - y_offset)
-                    - BottomPane::BOTTOM_PAD_LINES.min((area.height - y_offset).saturating_sub(1)),
-            };
-            (&self.composer).render_ref(composer_rect, buf);
+        // Show BottomPaneView if present.
+        if let Some(ov) = &self.active_view {
+            ov.render(area, buf);
+        } else {
+            (&self.composer).render_ref(area, buf);
         }
     }
 }
@@ -432,9 +285,6 @@ impl WidgetRef for &BottomPane<'_> {
 mod tests {
     use super::*;
     use crate::app_event::AppEvent;
-    use ratatui::buffer::Buffer;
-    use ratatui::layout::Rect;
-    use ratatui::text::Line;
     use std::path::PathBuf;
     use std::sync::mpsc::channel;
 
@@ -461,316 +311,4 @@ mod tests {
         assert!(pane.ctrl_c_quit_hint_visible());
         assert_eq!(CancellationEvent::Ignored, pane.on_ctrl_c());
     }
-
-    #[test]
-    fn live_ring_renders_above_composer() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Provide 4 rows with max_rows=3; only the last 3 should be visible.
-        pane.set_live_ring_rows(
-            3,
-            vec![
-                Line::from("one".to_string()),
-                Line::from("two".to_string()),
-                Line::from("three".to_string()),
-                Line::from("four".to_string()),
-            ],
-        );
-
-        let area = Rect::new(0, 0, 10, 5);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-
-        // Extract the first 3 rows and assert they contain the last three lines.
-        let mut lines: Vec<String> = Vec::new();
-        for y in 0..3 {
-            let mut s = String::new();
-            for x in 0..area.width {
-                s.push(buf[(x, y)].symbol().chars().next().unwrap_or(' '));
-            }
-            lines.push(s.trim_end().to_string());
-        }
-        assert_eq!(lines, vec!["two", "three", "four"]);
-    }
-
-    #[test]
-    fn status_indicator_visible_with_live_ring() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Simulate task running which replaces composer with the status indicator.
-        pane.set_task_running(true);
-        pane.update_status_text("waiting for model".to_string());
-
-        // Provide 2 rows in the live ring (e.g., streaming CoT) and ensure the
-        // status indicator remains visible below them.
-        pane.set_live_ring_rows(
-            2,
-            vec![
-                Line::from("cot1".to_string()),
-                Line::from("cot2".to_string()),
-            ],
-        );
-
-        // Allow some frames so the dot animation is present.
-        std::thread::sleep(std::time::Duration::from_millis(120));
-
-        // Height should include both ring rows, 1 spacer, and the 1-line status.
-        let area = Rect::new(0, 0, 30, 4);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-
-        // Top two rows are the live ring.
-        let mut r0 = String::new();
-        let mut r1 = String::new();
-        for x in 0..area.width {
-            r0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-            r1.push(buf[(x, 1)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(r0.contains("cot1"), "expected first live row: {r0:?}");
-        assert!(r1.contains("cot2"), "expected second live row: {r1:?}");
-
-        // Row 2 is the spacer (blank)
-        let mut r2 = String::new();
-        for x in 0..area.width {
-            r2.push(buf[(x, 2)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(r2.trim().is_empty(), "expected blank spacer line: {r2:?}");
-
-        // Bottom row is the status line; it should contain the left bar and "Working".
-        let mut r3 = String::new();
-        for x in 0..area.width {
-            r3.push(buf[(x, 3)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert_eq!(buf[(0, 3)].symbol().chars().next().unwrap_or(' '), '▌');
-        assert!(
-            r3.contains("Working"),
-            "expected Working header in status line: {r3:?}"
-        );
-    }
-
-    #[test]
-    fn overlay_not_shown_above_approval_modal() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Create an approval modal (active view).
-        pane.push_approval_request(exec_request());
-        // Attempt to update status; this should NOT create an overlay while modal is visible.
-        pane.update_status_text("running command".to_string());
-
-        // Render and verify the top row does not include the Working header overlay.
-        let area = Rect::new(0, 0, 60, 6);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-
-        let mut r0 = String::new();
-        for x in 0..area.width {
-            r0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            !r0.contains("Working"),
-            "overlay Working header should not render above modal"
-        );
-    }
-
-    #[test]
-    fn composer_not_shown_after_denied_if_task_running() {
-        let (tx_raw, rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx.clone(),
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Start a running task so the status indicator replaces the composer.
-        pane.set_task_running(true);
-        pane.update_status_text("waiting for model".to_string());
-
-        // Push an approval modal (e.g., command approval) which should hide the status view.
-        pane.push_approval_request(exec_request());
-
-        // Simulate pressing 'n' (deny) on the modal.
-        use crossterm::event::KeyCode;
-        use crossterm::event::KeyEvent;
-        use crossterm::event::KeyModifiers;
-        pane.handle_key_event(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE));
-
-        // After denial, since the task is still running, the status indicator
-        // should be restored as the active view; the composer should NOT be visible.
-        assert!(
-            pane.status_view_active,
-            "status view should be active after denial"
-        );
-        assert!(pane.active_view.is_some(), "active view should be present");
-
-        // Render and ensure the top row includes the Working header instead of the composer.
-        // Give the animation thread a moment to tick.
-        std::thread::sleep(std::time::Duration::from_millis(120));
-        let area = Rect::new(0, 0, 40, 3);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-        let mut row0 = String::new();
-        for x in 0..area.width {
-            row0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            row0.contains("Working"),
-            "expected Working header after denial: {row0:?}"
-        );
-
-        // Drain the channel to avoid unused warnings.
-        drop(rx);
-    }
-
-    #[test]
-    fn status_indicator_visible_during_command_execution() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Begin a task: show initial status.
-        pane.set_task_running(true);
-        pane.update_status_text("waiting for model".to_string());
-
-        // As a long-running command begins (post-approval), ensure the status
-        // indicator is visible while we wait for the command to run.
-        pane.update_status_text("running command".to_string());
-
-        // Allow some frames so the animation thread ticks.
-        std::thread::sleep(std::time::Duration::from_millis(120));
-
-        // Render and confirm the line contains the "Working" header.
-        let area = Rect::new(0, 0, 40, 3);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-
-        let mut row0 = String::new();
-        for x in 0..area.width {
-            row0.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            row0.contains("Working"),
-            "expected Working header: {row0:?}"
-        );
-    }
-
-    #[test]
-    fn bottom_padding_present_for_status_view() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        // Activate spinner (status view replaces composer) with no live ring.
-        pane.set_task_running(true);
-        pane.update_status_text("waiting for model".to_string());
-
-        // Use height == desired_height; expect 1 status row at top and 2 bottom padding rows.
-        let height = pane.desired_height(30);
-        assert!(
-            height >= 3,
-            "expected at least 3 rows with bottom padding; got {height}"
-        );
-        let area = Rect::new(0, 0, 30, height);
-        let mut buf = Buffer::empty(area);
-        (&pane).render_ref(area, &mut buf);
-
-        // Top row contains the status header
-        let mut top = String::new();
-        for x in 0..area.width {
-            top.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert_eq!(buf[(0, 0)].symbol().chars().next().unwrap_or(' '), '▌');
-        assert!(
-            top.contains("Working"),
-            "expected Working header on top row: {top:?}"
-        );
-
-        // Bottom two rows are blank padding
-        let mut r_last = String::new();
-        let mut r_last2 = String::new();
-        for x in 0..area.width {
-            r_last.push(buf[(x, height - 1)].symbol().chars().next().unwrap_or(' '));
-            r_last2.push(buf[(x, height - 2)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            r_last.trim().is_empty(),
-            "expected last row blank: {r_last:?}"
-        );
-        assert!(
-            r_last2.trim().is_empty(),
-            "expected second-to-last row blank: {r_last2:?}"
-        );
-    }
-
-    #[test]
-    fn bottom_padding_shrinks_when_tiny() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut pane = BottomPane::new(BottomPaneParams {
-            app_event_tx: tx,
-            has_input_focus: true,
-            enhanced_keys_supported: false,
-        });
-
-        pane.set_task_running(true);
-        pane.update_status_text("waiting for model".to_string());
-
-        // Height=2 → pad shrinks to 1; bottom row is blank, top row has spinner.
-        let area2 = Rect::new(0, 0, 20, 2);
-        let mut buf2 = Buffer::empty(area2);
-        (&pane).render_ref(area2, &mut buf2);
-        let mut row0 = String::new();
-        let mut row1 = String::new();
-        for x in 0..area2.width {
-            row0.push(buf2[(x, 0)].symbol().chars().next().unwrap_or(' '));
-            row1.push(buf2[(x, 1)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            row0.contains("Working"),
-            "expected Working header on row 0: {row0:?}"
-        );
-        assert!(
-            row1.trim().is_empty(),
-            "expected bottom padding on row 1: {row1:?}"
-        );
-
-        // Height=1 → no padding; single row is the spinner.
-        let area1 = Rect::new(0, 0, 20, 1);
-        let mut buf1 = Buffer::empty(area1);
-        (&pane).render_ref(area1, &mut buf1);
-        let mut only = String::new();
-        for x in 0..area1.width {
-            only.push(buf1[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(
-            only.contains("Working"),
-            "expected Working header with no padding: {only:?}"
-        );
-    }
 }

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;
@@ -9,10 +10,7 @@ use codex_core::protocol::AgentMessageDeltaEvent;
 use codex_core::protocol::AgentMessageEvent;
 use codex_core::protocol::AgentReasoningDeltaEvent;
 use codex_core::protocol::AgentReasoningEvent;
-use codex_core::protocol::AgentReasoningRawContentDeltaEvent;
-use codex_core::protocol::AgentReasoningRawContentEvent;
 use codex_core::protocol::ApplyPatchApprovalRequestEvent;
-use codex_core::protocol::BackgroundEventEvent;
 use codex_core::protocol::ErrorEvent;
 use codex_core::protocol::Event;
 use codex_core::protocol::EventMsg;
@@ -26,18 +24,14 @@ use codex_core::protocol::Op;
 use codex_core::protocol::PatchApplyBeginEvent;
 use codex_core::protocol::TaskCompleteEvent;
 use codex_core::protocol::TokenUsage;
-use codex_core::protocol::TurnDiffEvent;
 use crossterm::event::KeyEvent;
 use crossterm::event::KeyEventKind;
 use ratatui::buffer::Buffer;
-use ratatui::layout::Constraint;
-use ratatui::layout::Layout;
 use ratatui::layout::Rect;
 use ratatui::widgets::Widget;
 use ratatui::widgets::WidgetRef;
 use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::mpsc::unbounded_channel;
-use tracing::info;
 
 use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
@@ -49,10 +43,8 @@ use crate::exec_command::strip_bash_lc_and_escape;
 use crate::history_cell::CommandOutput;
 use crate::history_cell::HistoryCell;
 use crate::history_cell::PatchEventType;
-use crate::live_wrap::RowBuilder;
 use crate::user_approval_widget::ApprovalRequest;
 use codex_file_search::FileMatch;
-use ratatui::style::Stylize;
 
 struct RunningCommand {
     command: Vec<String>,
@@ -64,21 +56,15 @@ pub(crate) struct ChatWidget<'a> {
     app_event_tx: AppEventSender,
     codex_op_tx: UnboundedSender<Op>,
     bottom_pane: BottomPane<'a>,
-    active_history_cell: Option<HistoryCell>,
     config: Config,
     initial_user_message: Option<UserMessage>,
     token_usage: TokenUsage,
     reasoning_buffer: String,
-    content_buffer: String,
     // Buffer for streaming assistant answer text; we do not surface partial
     // We wait for the final AgentMessage event and then emit the full text
     // at once into scrollback so the history contains a single message.
     answer_buffer: String,
     running_commands: HashMap<String, RunningCommand>,
-    live_builder: RowBuilder,
-    current_stream: Option<StreamKind>,
-    stream_header_emitted: bool,
-    live_max_rows: u16,
 }
 
 struct UserMessage {
@@ -86,12 +72,6 @@ struct UserMessage {
     image_paths: Vec<PathBuf>,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum StreamKind {
-    Answer,
-    Reasoning,
-}
-
 impl From<String> for UserMessage {
     fn from(text: String) -> Self {
         Self {
@@ -110,51 +90,6 @@ fn create_initial_user_message(text: String, image_paths: Vec<PathBuf>) -> Optio
 }
 
 impl ChatWidget<'_> {
-    fn interrupt_running_task(&mut self) {
-        if self.bottom_pane.is_task_running() {
-            self.active_history_cell = None;
-            self.bottom_pane.clear_ctrl_c_quit_hint();
-            self.submit_op(Op::Interrupt);
-            self.bottom_pane.set_task_running(false);
-            self.bottom_pane.clear_live_ring();
-            self.live_builder = RowBuilder::new(self.live_builder.width());
-            self.current_stream = None;
-            self.stream_header_emitted = false;
-            self.answer_buffer.clear();
-            self.reasoning_buffer.clear();
-            self.content_buffer.clear();
-            self.request_redraw();
-        }
-    }
-    fn layout_areas(&self, area: Rect) -> [Rect; 2] {
-        Layout::vertical([
-            Constraint::Max(
-                self.active_history_cell
-                    .as_ref()
-                    .map_or(0, |c| c.desired_height(area.width)),
-            ),
-            Constraint::Min(self.bottom_pane.desired_height(area.width)),
-        ])
-        .areas(area)
-    }
-    fn emit_stream_header(&mut self, kind: StreamKind) {
-        use ratatui::text::Line as RLine;
-        if self.stream_header_emitted {
-            return;
-        }
-        let header = match kind {
-            StreamKind::Reasoning => RLine::from("thinking".magenta().italic()),
-            StreamKind::Answer => RLine::from("codex".magenta().bold()),
-        };
-        self.app_event_tx
-            .send(AppEvent::InsertHistory(vec![header]));
-        self.stream_header_emitted = true;
-    }
-    fn finalize_active_stream(&mut self) {
-        if let Some(kind) = self.current_stream {
-            self.finalize_stream(kind);
-        }
-    }
     pub(crate) fn new(
         config: Config,
         app_event_tx: AppEventSender,
@@ -208,7 +143,6 @@ impl ChatWidget<'_> {
                 has_input_focus: true,
                 enhanced_keys_supported,
             }),
-            active_history_cell: None,
             config,
             initial_user_message: create_initial_user_message(
                 initial_prompt.unwrap_or_default(),
@@ -216,22 +150,13 @@ impl ChatWidget<'_> {
             ),
             token_usage: TokenUsage::default(),
             reasoning_buffer: String::new(),
-            content_buffer: String::new(),
             answer_buffer: String::new(),
             running_commands: HashMap::new(),
-            live_builder: RowBuilder::new(80),
-            current_stream: None,
-            stream_header_emitted: false,
-            live_max_rows: 3,
         }
     }
 
     pub fn desired_height(&self, width: u16) -> u16 {
         self.bottom_pane.desired_height(width)
-            + self
-                .active_history_cell
-                .as_ref()
-                .map_or(0, |c| c.desired_height(width))
     }
 
     pub(crate) fn handle_key_event(&mut self, key_event: KeyEvent) {
@@ -310,59 +235,58 @@ impl ChatWidget<'_> {
 
                 self.request_redraw();
             }
-            EventMsg::AgentMessage(AgentMessageEvent { message: _ }) => {
-                // Final assistant answer: commit all remaining rows and close with
-                // a blank line. Use the final text if provided, otherwise rely on
-                // streamed deltas already in the builder.
-                self.finalize_stream(StreamKind::Answer);
+            EventMsg::AgentMessage(AgentMessageEvent { message }) => {
+                // Final assistant answer. Prefer the fully provided message
+                // from the event; if it is empty fall back to any accumulated
+                // delta buffer (some providers may only stream deltas and send
+                // an empty final message).
+                let full = if message.is_empty() {
+                    std::mem::take(&mut self.answer_buffer)
+                } else {
+                    self.answer_buffer.clear();
+                    message
+                };
+                if !full.is_empty() {
+                    self.add_to_history(HistoryCell::new_agent_message(&self.config, full));
+                }
                 self.request_redraw();
             }
             EventMsg::AgentMessageDelta(AgentMessageDeltaEvent { delta }) => {
-                self.begin_stream(StreamKind::Answer);
+                // Buffer only – do not emit partial lines. This avoids cases
+                // where long responses appear truncated if the terminal
+                // wrapped early. The full message is emitted on
+                // AgentMessage.
                 self.answer_buffer.push_str(&delta);
-                self.stream_push_and_maybe_commit(&delta);
-                self.request_redraw();
             }
             EventMsg::AgentReasoningDelta(AgentReasoningDeltaEvent { delta }) => {
-                // Stream CoT into the live pane; keep input visible and commit
-                // overflow rows incrementally to scrollback.
-                self.begin_stream(StreamKind::Reasoning);
+                // Buffer only – disable incremental reasoning streaming so we
+                // avoid truncated intermediate lines. Full text emitted on
+                // AgentReasoning.
                 self.reasoning_buffer.push_str(&delta);
-                self.stream_push_and_maybe_commit(&delta);
-                self.request_redraw();
             }
-            EventMsg::AgentReasoning(AgentReasoningEvent { text: _ }) => {
-                // Final reasoning: commit remaining rows and close with a blank.
-                self.finalize_stream(StreamKind::Reasoning);
-                self.request_redraw();
-            }
-            EventMsg::AgentReasoningRawContentDelta(AgentReasoningRawContentDeltaEvent {
-                delta,
-            }) => {
-                // Treat raw reasoning content the same as summarized reasoning for UI flow.
-                self.begin_stream(StreamKind::Reasoning);
-                self.reasoning_buffer.push_str(&delta);
-                self.stream_push_and_maybe_commit(&delta);
-                self.request_redraw();
-            }
-            EventMsg::AgentReasoningRawContent(AgentReasoningRawContentEvent { text: _ }) => {
-                // Finalize the raw reasoning stream just like the summarized reasoning event.
-                self.finalize_stream(StreamKind::Reasoning);
+            EventMsg::AgentReasoning(AgentReasoningEvent { text }) => {
+                // Emit full reasoning text once. Some providers might send
+                // final event with empty text if only deltas were used.
+                let full = if text.is_empty() {
+                    std::mem::take(&mut self.reasoning_buffer)
+                } else {
+                    self.reasoning_buffer.clear();
+                    text
+                };
+                if !full.is_empty() {
+                    self.add_to_history(HistoryCell::new_agent_reasoning(&self.config, full));
+                }
                 self.request_redraw();
             }
             EventMsg::TaskStarted => {
                 self.bottom_pane.clear_ctrl_c_quit_hint();
                 self.bottom_pane.set_task_running(true);
-                // Replace composer with single-line spinner while waiting.
-                self.bottom_pane
-                    .update_status_text("waiting for model".to_string());
                 self.request_redraw();
             }
             EventMsg::TaskComplete(TaskCompleteEvent {
                 last_agent_message: _,
             }) => {
                 self.bottom_pane.set_task_running(false);
-                self.bottom_pane.clear_live_ring();
                 self.request_redraw();
             }
             EventMsg::TokenCount(token_usage) => {
@@ -373,18 +297,10 @@ impl ChatWidget<'_> {
             EventMsg::Error(ErrorEvent { message }) => {
                 self.add_to_history(HistoryCell::new_error_event(message.clone()));
                 self.bottom_pane.set_task_running(false);
-                self.bottom_pane.clear_live_ring();
-                self.live_builder = RowBuilder::new(self.live_builder.width());
-                self.current_stream = None;
-                self.stream_header_emitted = false;
-                self.answer_buffer.clear();
-                self.reasoning_buffer.clear();
-                self.content_buffer.clear();
-                self.request_redraw();
             }
             EventMsg::PlanUpdate(update) => {
-                // Commit plan updates directly to history (no status-line preview).
                 self.add_to_history(HistoryCell::new_plan_update(update));
+                self.request_redraw();
             }
             EventMsg::ExecApprovalRequest(ExecApprovalRequestEvent {
                 call_id: _,
@@ -392,8 +308,8 @@ impl ChatWidget<'_> {
                 cwd,
                 reason,
             }) => {
-                self.finalize_active_stream();
-                // Log a background summary immediately so the history is chronological.
+                // Print the command to the history so it is visible in the
+                // transcript *before* the modal asks for approval.
                 let cmdline = strip_bash_lc_and_escape(&command);
                 let text = format!(
                     "command requires approval:\n$ {cmdline}{reason}",
@@ -419,7 +335,6 @@ impl ChatWidget<'_> {
                 reason,
                 grant_root,
             }) => {
-                self.finalize_active_stream();
                 // ------------------------------------------------------------------
                 // Before we even prompt the user for approval we surface the patch
                 // summary in the main conversation so that the dialog appears in a
@@ -430,6 +345,7 @@ impl ChatWidget<'_> {
                 // approval dialog) and avoids surprising the user with a modal
                 // prompt before they have seen *what* is being requested.
                 // ------------------------------------------------------------------
+
                 self.add_to_history(HistoryCell::new_patch_event(
                     PatchEventType::ApprovalRequest,
                     changes,
@@ -449,10 +365,6 @@ impl ChatWidget<'_> {
                 command,
                 cwd,
             }) => {
-                self.finalize_active_stream();
-                // Ensure the status indicator is visible while the command runs.
-                self.bottom_pane
-                    .update_status_text("running command".to_string());
                 self.running_commands.insert(
                     call_id,
                     RunningCommand {
@@ -460,45 +372,35 @@ impl ChatWidget<'_> {
                         cwd: cwd.clone(),
                     },
                 );
-                self.active_history_cell = Some(HistoryCell::new_active_exec_command(command));
-            }
-            EventMsg::ExecCommandOutputDelta(_) => {
-                // TODO
+                self.add_to_history(HistoryCell::new_active_exec_command(command));
             }
+            EventMsg::ExecCommandOutputDelta(_) => {}
             EventMsg::PatchApplyBegin(PatchApplyBeginEvent {
                 call_id: _,
                 auto_approved,
                 changes,
             }) => {
+                // Even when a patch is auto‑approved we still display the
+                // summary so the user can follow along.
                 self.add_to_history(HistoryCell::new_patch_event(
                     PatchEventType::ApplyBegin { auto_approved },
                     changes,
                 ));
             }
-            EventMsg::PatchApplyEnd(event) => {
-                self.add_to_history(HistoryCell::new_patch_apply_end(
-                    event.stdout,
-                    event.stderr,
-                    event.success,
-                ));
-            }
             EventMsg::ExecCommandEnd(ExecCommandEndEvent {
                 call_id,
                 exit_code,
-                duration,
                 stdout,
                 stderr,
             }) => {
-                // Compute summary before moving stdout into the history cell.
                 let cmd = self.running_commands.remove(&call_id);
-                self.active_history_cell = None;
                 self.add_to_history(HistoryCell::new_completed_exec_command(
                     cmd.map(|cmd| cmd.command).unwrap_or_else(|| vec![call_id]),
                     CommandOutput {
                         exit_code,
                         stdout,
                         stderr,
-                        duration,
+                        duration: Duration::from_secs(0),
                     },
                 ));
             }
@@ -506,7 +408,6 @@ impl ChatWidget<'_> {
                 call_id: _,
                 invocation,
             }) => {
-                self.finalize_active_stream();
                 self.add_to_history(HistoryCell::new_active_mcp_tool_call(invocation));
             }
             EventMsg::McpToolCallEnd(McpToolCallEndEvent {
@@ -540,20 +441,16 @@ impl ChatWidget<'_> {
             EventMsg::ShutdownComplete => {
                 self.app_event_tx.send(AppEvent::ExitRequest);
             }
-            EventMsg::TurnDiff(TurnDiffEvent { unified_diff }) => {
-                info!("TurnDiffEvent: {unified_diff}");
-            }
-            EventMsg::BackgroundEvent(BackgroundEventEvent { message }) => {
-                info!("BackgroundEvent: {message}");
+            event => {
+                self.add_to_history(HistoryCell::new_background_event(format!("{event:?}")));
             }
         }
     }
 
     /// Update the live log preview while a task is running.
     pub(crate) fn update_latest_log(&mut self, line: String) {
-        if self.bottom_pane.is_task_running() {
-            self.bottom_pane.update_status_text(line);
-        }
+        // Forward only if we are currently showing the status indicator.
+        self.bottom_pane.update_status_text(line);
     }
 
     fn request_redraw(&mut self) {
@@ -564,13 +461,6 @@ impl ChatWidget<'_> {
         self.add_to_history(HistoryCell::new_diff_output(diff_output.clone()));
     }
 
-    pub(crate) fn add_status_output(&mut self) {
-        self.add_to_history(HistoryCell::new_status_output(
-            &self.config,
-            &self.token_usage,
-        ));
-    }
-
     /// Forward file-search results to the bottom pane.
     pub(crate) fn apply_file_search_result(&mut self, query: String, matches: Vec<FileMatch>) {
         self.bottom_pane.on_file_search_result(query, matches);
@@ -585,7 +475,10 @@ impl ChatWidget<'_> {
             CancellationEvent::Ignored => {}
         }
         if self.bottom_pane.is_task_running() {
-            self.interrupt_running_task();
+            self.bottom_pane.clear_ctrl_c_quit_hint();
+            self.submit_op(Op::Interrupt);
+            self.answer_buffer.clear();
+            self.reasoning_buffer.clear();
             CancellationEvent::Ignored
         } else if self.bottom_pane.ctrl_c_quit_hint_visible() {
             self.submit_op(Op::Shutdown);
@@ -596,10 +489,6 @@ impl ChatWidget<'_> {
         }
     }
 
-    pub(crate) fn on_ctrl_z(&mut self) {
-        self.interrupt_running_task();
-    }
-
     pub(crate) fn composer_is_empty(&self) -> bool {
         self.bottom_pane.composer_is_empty()
     }
@@ -611,16 +500,6 @@ impl ChatWidget<'_> {
         }
     }
 
-    /// Programmatically submit a user text message as if typed in the
-    /// composer. The text will be added to conversation history and sent to
-    /// the agent.
-    pub(crate) fn submit_text_message(&mut self, text: String) {
-        if text.is_empty() {
-            return;
-        }
-        self.submit_user_message(text.into());
-    }
-
     pub(crate) fn token_usage(&self) -> &TokenUsage {
         &self.token_usage
     }
@@ -630,118 +509,14 @@ 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)> {
-        let [_, bottom_pane_area] = self.layout_areas(area);
-        self.bottom_pane.cursor_pos(bottom_pane_area)
-    }
-}
-
-impl ChatWidget<'_> {
-    fn begin_stream(&mut self, kind: StreamKind) {
-        if let Some(current) = self.current_stream {
-            if current != kind {
-                self.finalize_stream(current);
-            }
-        }
-
-        if self.current_stream != Some(kind) {
-            self.current_stream = Some(kind);
-            self.stream_header_emitted = false;
-            // Clear any previous live content; we're starting a new stream.
-            self.live_builder = RowBuilder::new(self.live_builder.width());
-            // Ensure the waiting status is visible (composer replaced).
-            self.bottom_pane
-                .update_status_text("waiting for model".to_string());
-            self.emit_stream_header(kind);
-        }
-    }
-
-    fn stream_push_and_maybe_commit(&mut self, delta: &str) {
-        self.live_builder.push_fragment(delta);
-
-        // Commit overflow rows (small batches) while keeping the last N rows visible.
-        let drained = self
-            .live_builder
-            .drain_commit_ready(self.live_max_rows as usize);
-        if !drained.is_empty() {
-            let mut lines: Vec<ratatui::text::Line<'static>> = Vec::new();
-            if !self.stream_header_emitted {
-                match self.current_stream {
-                    Some(StreamKind::Reasoning) => {
-                        lines.push(ratatui::text::Line::from("thinking".magenta().italic()));
-                    }
-                    Some(StreamKind::Answer) => {
-                        lines.push(ratatui::text::Line::from("codex".magenta().bold()));
-                    }
-                    None => {}
-                }
-                self.stream_header_emitted = true;
-            }
-            for r in drained {
-                lines.push(ratatui::text::Line::from(r.text));
-            }
-            self.app_event_tx.send(AppEvent::InsertHistory(lines));
-        }
-
-        // Update the live ring overlay lines (text-only, newest at bottom).
-        let rows = self
-            .live_builder
-            .display_rows()
-            .into_iter()
-            .map(|r| ratatui::text::Line::from(r.text))
-            .collect::<Vec<_>>();
-        self.bottom_pane
-            .set_live_ring_rows(self.live_max_rows, rows);
-    }
-
-    fn finalize_stream(&mut self, kind: StreamKind) {
-        if self.current_stream != Some(kind) {
-            // Nothing to do; either already finalized or not the active stream.
-            return;
-        }
-        // Flush any partial line as a full row, then drain all remaining rows.
-        self.live_builder.end_line();
-        let remaining = self.live_builder.drain_rows();
-        // TODO: Re-add markdown rendering for assistant answers and reasoning.
-        // When finalizing, pass the accumulated text through `markdown::append_markdown`
-        // to build styled `Line<'static>` entries instead of raw plain text lines.
-        if !remaining.is_empty() || !self.stream_header_emitted {
-            let mut lines: Vec<ratatui::text::Line<'static>> = Vec::new();
-            if !self.stream_header_emitted {
-                match kind {
-                    StreamKind::Reasoning => {
-                        lines.push(ratatui::text::Line::from("thinking".magenta().italic()));
-                    }
-                    StreamKind::Answer => {
-                        lines.push(ratatui::text::Line::from("codex".magenta().bold()));
-                    }
-                }
-                self.stream_header_emitted = true;
-            }
-            for r in remaining {
-                lines.push(ratatui::text::Line::from(r.text));
-            }
-            // Close the block with a blank line for readability.
-            lines.push(ratatui::text::Line::from(""));
-            self.app_event_tx.send(AppEvent::InsertHistory(lines));
-        }
-
-        // Clear the live overlay and reset state for the next stream.
-        self.live_builder = RowBuilder::new(self.live_builder.width());
-        self.bottom_pane.clear_live_ring();
-        self.current_stream = None;
-        self.stream_header_emitted = false;
-    }
 }
 
 impl WidgetRef for &ChatWidget<'_> {
     fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        let [active_cell_area, bottom_pane_area] = self.layout_areas(area);
-        (&self.bottom_pane).render(bottom_pane_area, buf);
-        if let Some(cell) = &self.active_history_cell {
-            cell.render_ref(active_cell_area, buf);
-        }
+        // In the hybrid inline viewport mode we only draw the interactive
+        // bottom pane; history entries are injected directly into scrollback
+        // via `Terminal::insert_before`.
+        (&self.bottom_pane).render(area, buf);
     }
 }
 

codex-rs/tui/src/cli.rs

@@ -17,12 +17,6 @@ pub struct Cli {
     #[arg(long, short = 'm')]
     pub model: Option<String>,
 
-    /// Convenience flag to select the local open source model provider.
-    /// Equivalent to -c model_provider=oss; verifies a local Ollama server is
-    /// running.
-    #[arg(long = "oss", default_value_t = false)]
-    pub oss: bool,
-
     /// Configuration profile from config.toml to specify default options.
     #[arg(long = "profile", short = 'p')]
     pub config_profile: Option<String>,

codex-rs/tui/src/colors.rs

@@ -1,4 +0,0 @@
-use ratatui::style::Color;
-
-pub(crate) const LIGHT_BLUE: Color = Color::Rgb(134, 238, 255);
-pub(crate) const SUCCESS_GREEN: Color = Color::Rgb(169, 230, 158);

codex-rs/tui/src/history_cell.rs

@@ -1,20 +1,20 @@
-use crate::exec_command::relativize_to_home;
 use crate::exec_command::strip_bash_lc_and_escape;
-use crate::slash_command::SlashCommand;
+use crate::markdown::append_markdown;
 use crate::text_block::TextBlock;
 use crate::text_formatting::format_and_truncate_tool_result;
 use base64::Engine;
 use codex_ansi_escape::ansi_escape_line;
-use codex_common::create_config_summary_entries;
 use codex_common::elapsed::format_duration;
+use codex_common::summarize_sandbox_policy;
+use codex_core::WireApi;
 use codex_core::config::Config;
+use codex_core::model_supports_reasoning_summaries;
 use codex_core::plan_tool::PlanItemArg;
 use codex_core::plan_tool::StepStatus;
 use codex_core::plan_tool::UpdatePlanArgs;
 use codex_core::protocol::FileChange;
 use codex_core::protocol::McpInvocation;
 use codex_core::protocol::SessionConfiguredEvent;
-use codex_core::protocol::TokenUsage;
 use image::DynamicImage;
 use image::ImageReader;
 use mcp_types::EmbeddedResourceResource;
@@ -25,9 +25,6 @@ use ratatui::style::Modifier;
 use ratatui::style::Style;
 use ratatui::text::Line as RtLine;
 use ratatui::text::Span as RtSpan;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::WidgetRef;
-use ratatui::widgets::Wrap;
 use std::collections::HashMap;
 use std::io::Cursor;
 use std::path::PathBuf;
@@ -71,7 +68,12 @@ pub(crate) enum HistoryCell {
     /// Message from the user.
     UserPrompt { view: TextBlock },
 
-    // AgentMessage and AgentReasoning variants were unused and have been removed.
+    /// Message from the agent.
+    AgentMessage { view: TextBlock },
+
+    /// Reasoning event from the agent.
+    AgentReasoning { view: TextBlock },
+
     /// An exec tool call that has not finished yet.
     ActiveExecCommand { view: TextBlock },
 
@@ -100,9 +102,6 @@ pub(crate) enum HistoryCell {
     /// Output from the `/diff` command.
     GitDiffOutput { view: TextBlock },
 
-    /// Output from the `/status` command.
-    StatusOutput { view: TextBlock },
-
     /// Error event from the backend.
     ErrorEvent { view: TextBlock },
 
@@ -117,9 +116,6 @@ pub(crate) enum HistoryCell {
     /// A human‑friendly rendering of the model's current plan and step
     /// statuses provided via the `update_plan` tool.
     PlanUpdate { view: TextBlock },
-
-    /// Result of applying a patch (success or failure) with optional output.
-    PatchApplyResult { view: TextBlock },
 }
 
 const TOOL_CALL_MAX_LINES: usize = 5;
@@ -132,16 +128,16 @@ impl HistoryCell {
         match self {
             HistoryCell::WelcomeMessage { view }
             | HistoryCell::UserPrompt { view }
+            | HistoryCell::AgentMessage { view }
+            | HistoryCell::AgentReasoning { view }
             | HistoryCell::BackgroundEvent { view }
             | HistoryCell::GitDiffOutput { view }
-            | HistoryCell::StatusOutput { view }
             | HistoryCell::ErrorEvent { view }
             | HistoryCell::SessionInfo { view }
             | HistoryCell::CompletedExecCommand { view }
             | HistoryCell::CompletedMcpToolCall { view }
             | HistoryCell::PendingPatch { view }
             | HistoryCell::PlanUpdate { view }
-            | HistoryCell::PatchApplyResult { view }
             | HistoryCell::ActiveExecCommand { view, .. }
             | HistoryCell::ActiveMcpToolCall { view, .. } => {
                 view.lines.iter().map(line_to_static).collect()
@@ -152,15 +148,6 @@ impl HistoryCell {
             ],
         }
     }
-
-    pub(crate) fn desired_height(&self, width: u16) -> u16 {
-        Paragraph::new(Text::from(self.plain_lines()))
-            .wrap(Wrap { trim: false })
-            .line_count(width)
-            .try_into()
-            .unwrap_or(0)
-    }
-
     pub(crate) fn new_session_info(
         config: &Config,
         event: SessionConfiguredEvent,
@@ -168,35 +155,51 @@ impl HistoryCell {
     ) -> Self {
         let SessionConfiguredEvent {
             model,
-            session_id: _,
+            session_id,
             history_log_id: _,
             history_entry_count: _,
         } = event;
         if is_first_event {
-            let cwd_str = match relativize_to_home(&config.cwd) {
-                Some(rel) if !rel.as_os_str().is_empty() => format!("~/{}", rel.display()),
-                Some(_) => "~".to_string(),
-                None => config.cwd.display().to_string(),
-            };
+            const VERSION: &str = env!("CARGO_PKG_VERSION");
 
-            let lines: Vec<Line<'static>> = vec![
+            let mut lines: Vec<Line<'static>> = vec![
                 Line::from(vec![
-                    Span::raw(">_ ").dim(),
-                    Span::styled(
-                        "You are using OpenAI Codex in",
-                        Style::default().add_modifier(Modifier::BOLD),
-                    ),
-                    Span::raw(format!(" {cwd_str}")).dim(),
+                    "OpenAI ".into(),
+                    "Codex".bold(),
+                    format!(" v{VERSION}").into(),
+                    " (research preview)".dim(),
+                ]),
+                Line::from(""),
+                Line::from(vec![
+                    "codex session".magenta().bold(),
+                    " ".into(),
+                    session_id.to_string().dim(),
                 ]),
-                Line::from("".dim()),
-                Line::from(" Try one of the following commands to get started:".dim()),
-                Line::from("".dim()),
-                Line::from(format!(" 1. /init - {}", SlashCommand::Init.description()).dim()),
-                Line::from(format!(" 2. /status - {}", SlashCommand::Status.description()).dim()),
-                Line::from(format!(" 3. /compact - {}", SlashCommand::Compact.description()).dim()),
-                Line::from(format!(" 4. /new - {}", SlashCommand::New.description()).dim()),
-                Line::from("".dim()),
             ];
+
+            let mut entries = vec![
+                ("workdir", config.cwd.display().to_string()),
+                ("model", config.model.clone()),
+                ("provider", config.model_provider_id.clone()),
+                ("approval", config.approval_policy.to_string()),
+                ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
+            ];
+            if config.model_provider.wire_api == WireApi::Responses
+                && model_supports_reasoning_summaries(config)
+            {
+                entries.push((
+                    "reasoning effort",
+                    config.model_reasoning_effort.to_string(),
+                ));
+                entries.push((
+                    "reasoning summaries",
+                    config.model_reasoning_summary.to_string(),
+                ));
+            }
+            for (key, value) in entries {
+                lines.push(Line::from(vec![format!("{key}: ").bold(), value.into()]));
+            }
+            lines.push(Line::from(""));
             HistoryCell::WelcomeMessage {
                 view: TextBlock::new(lines),
             }
@@ -228,6 +231,28 @@ impl HistoryCell {
         }
     }
 
+    pub(crate) fn new_agent_message(config: &Config, message: String) -> Self {
+        let mut lines: Vec<Line<'static>> = Vec::new();
+        lines.push(Line::from("codex".magenta().bold()));
+        append_markdown(&message, &mut lines, config);
+        lines.push(Line::from(""));
+
+        HistoryCell::AgentMessage {
+            view: TextBlock::new(lines),
+        }
+    }
+
+    pub(crate) fn new_agent_reasoning(config: &Config, text: String) -> Self {
+        let mut lines: Vec<Line<'static>> = Vec::new();
+        lines.push(Line::from("thinking".magenta().italic()));
+        append_markdown(&text, &mut lines, config);
+        lines.push(Line::from(""));
+
+        HistoryCell::AgentReasoning {
+            view: TextBlock::new(lines),
+        }
+    }
+
     pub(crate) fn new_active_exec_command(command: Vec<String>) -> Self {
         let command_escaped = strip_bash_lc_and_escape(&command);
 
@@ -450,49 +475,6 @@ impl HistoryCell {
         }
     }
 
-    pub(crate) fn new_status_output(config: &Config, usage: &TokenUsage) -> Self {
-        let mut lines: Vec<Line<'static>> = Vec::new();
-        lines.push(Line::from("/status".magenta()));
-
-        // Config
-        for (key, value) in create_config_summary_entries(config) {
-            lines.push(Line::from(vec![format!("{key}: ").bold(), value.into()]));
-        }
-
-        // Token usage
-        lines.push(Line::from(""));
-        lines.push(Line::from("token usage".bold()));
-        lines.push(Line::from(vec![
-            "  input: ".bold(),
-            usage.input_tokens.to_string().into(),
-        ]));
-        lines.push(Line::from(vec![
-            "  cached input: ".bold(),
-            usage.cached_input_tokens.unwrap_or(0).to_string().into(),
-        ]));
-        lines.push(Line::from(vec![
-            "  output: ".bold(),
-            usage.output_tokens.to_string().into(),
-        ]));
-        lines.push(Line::from(vec![
-            "  reasoning output: ".bold(),
-            usage
-                .reasoning_output_tokens
-                .unwrap_or(0)
-                .to_string()
-                .into(),
-        ]));
-        lines.push(Line::from(vec![
-            "  total: ".bold(),
-            usage.total_tokens.to_string().into(),
-        ]));
-
-        lines.push(Line::from(""));
-        HistoryCell::StatusOutput {
-            view: TextBlock::new(lines),
-        }
-    }
-
     pub(crate) fn new_error_event(message: String) -> Self {
         let lines: Vec<Line<'static>> = vec![
             vec!["ERROR: ".red().bold(), message.into()].into(),
@@ -599,10 +581,7 @@ impl HistoryCell {
             PatchEventType::ApplyBegin {
                 auto_approved: false,
             } => {
-                let lines: Vec<Line<'static>> = vec![
-                    Line::from("applying patch".magenta().bold()),
-                    Line::from(""),
-                ];
+                let lines = vec![Line::from("patch applied".magenta().bold())];
                 return Self::PendingPatch {
                     view: TextBlock::new(lines),
                 };
@@ -650,62 +629,6 @@ impl HistoryCell {
             view: TextBlock::new(lines),
         }
     }
-
-    pub(crate) fn new_patch_apply_end(stdout: String, stderr: String, success: bool) -> Self {
-        let mut lines: Vec<Line<'static>> = Vec::new();
-
-        let status = if success {
-            RtSpan::styled("patch applied", Style::default().fg(Color::Green))
-        } else {
-            RtSpan::styled(
-                "patch failed",
-                Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
-            )
-        };
-        lines.push(RtLine::from(vec![
-            "patch".magenta().bold(),
-            " ".into(),
-            status,
-        ]));
-
-        let src = if success {
-            if stdout.trim().is_empty() {
-                &stderr
-            } else {
-                &stdout
-            }
-        } else if stderr.trim().is_empty() {
-            &stdout
-        } else {
-            &stderr
-        };
-
-        if !src.trim().is_empty() {
-            lines.push(Line::from(""));
-            let mut iter = src.lines();
-            for raw in iter.by_ref().take(TOOL_CALL_MAX_LINES) {
-                lines.push(ansi_escape_line(raw).dim());
-            }
-            let remaining = iter.count();
-            if remaining > 0 {
-                lines.push(Line::from(format!("... {remaining} additional lines")).dim());
-            }
-        }
-
-        lines.push(Line::from(""));
-
-        HistoryCell::PatchApplyResult {
-            view: TextBlock::new(lines),
-        }
-    }
-}
-
-impl WidgetRef for &HistoryCell {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        Paragraph::new(Text::from(self.plain_lines()))
-            .wrap(Wrap { trim: false })
-            .render(area, buf);
-    }
 }
 
 fn create_diff_summary(changes: HashMap<PathBuf, FileChange>) -> Vec<String> {

codex-rs/tui/src/insert_history.rs

@@ -14,6 +14,7 @@ use crossterm::style::SetBackgroundColor;
 use crossterm::style::SetColors;
 use crossterm::style::SetForegroundColor;
 use ratatui::layout::Size;
+use ratatui::prelude::Backend;
 use ratatui::style::Color;
 use ratatui::style::Modifier;
 use ratatui::text::Line;
@@ -21,20 +22,6 @@ use ratatui::text::Span;
 
 /// Insert `lines` above the viewport.
 pub(crate) fn insert_history_lines(terminal: &mut tui::Tui, lines: Vec<Line>) {
-    let mut out = std::io::stdout();
-    insert_history_lines_to_writer(terminal, &mut out, lines);
-}
-
-/// Like `insert_history_lines`, but writes ANSI to the provided writer. This
-/// is intended for testing where a capture buffer is used instead of stdout.
-pub fn insert_history_lines_to_writer<B, W>(
-    terminal: &mut crate::custom_terminal::Terminal<B>,
-    writer: &mut W,
-    lines: Vec<Line>,
-) where
-    B: ratatui::backend::Backend,
-    W: Write,
-{
     let screen_size = terminal.backend().size().unwrap_or(Size::new(0, 0));
     let cursor_pos = terminal.get_cursor_position().ok();
 
@@ -45,22 +32,10 @@ pub fn insert_history_lines_to_writer<B, W>(
         // If the viewport is not at the bottom of the screen, scroll it down to make room.
         // Don't scroll it past the bottom of the screen.
         let scroll_amount = wrapped_lines.min(screen_size.height - area.bottom());
-
-        // Emit ANSI to scroll the lower region (from the top of the viewport to the bottom
-        // of the screen) downward by `scroll_amount` lines. We do this by:
-        //   1) Limiting the scroll region to [area.top()+1 .. screen_height] (1-based bounds)
-        //   2) Placing the cursor at the top margin of that region
-        //   3) Emitting Reverse Index (RI, ESC M) `scroll_amount` times
-        //   4) Resetting the scroll region back to full screen
-        let top_1based = area.top() + 1; // Convert 0-based row to 1-based for DECSTBM
-        queue!(writer, SetScrollRegion(top_1based..screen_size.height)).ok();
-        queue!(writer, MoveTo(0, area.top())).ok();
-        for _ in 0..scroll_amount {
-            // Reverse Index (RI): ESC M
-            queue!(writer, Print("\x1bM")).ok();
-        }
-        queue!(writer, ResetScrollRegion).ok();
-
+        terminal
+            .backend_mut()
+            .scroll_region_down(area.top()..screen_size.height, scroll_amount)
+            .ok();
         let cursor_top = area.top().saturating_sub(1);
         area.y += scroll_amount;
         terminal.set_viewport_area(area);
@@ -84,23 +59,23 @@ pub fn insert_history_lines_to_writer<B, W>(
     // ││                            ││
     // │╰────────────────────────────╯│
     // └──────────────────────────────┘
-    queue!(writer, SetScrollRegion(1..area.top())).ok();
+    queue!(std::io::stdout(), SetScrollRegion(1..area.top())).ok();
 
     // NB: we are using MoveTo instead of set_cursor_position here to avoid messing with the
     // terminal's last_known_cursor_position, which hopefully will still be accurate after we
     // fetch/restore the cursor position. insert_history_lines should be cursor-position-neutral :)
-    queue!(writer, MoveTo(0, cursor_top)).ok();
+    queue!(std::io::stdout(), MoveTo(0, cursor_top)).ok();
 
     for line in lines {
-        queue!(writer, Print("\r\n")).ok();
-        write_spans(writer, line.iter()).ok();
+        queue!(std::io::stdout(), Print("\r\n")).ok();
+        write_spans(&mut std::io::stdout(), line.iter()).ok();
     }
 
-    queue!(writer, ResetScrollRegion).ok();
+    queue!(std::io::stdout(), ResetScrollRegion).ok();
 
     // Restore the cursor position to where it was before we started.
     if let Some(cursor_pos) = cursor_pos {
-        queue!(writer, MoveTo(cursor_pos.x, cursor_pos.y)).ok();
+        queue!(std::io::stdout(), MoveTo(cursor_pos.x, cursor_pos.y)).ok();
     }
 }
 
@@ -113,25 +88,19 @@ fn wrapped_line_count(lines: &[Line], width: u16) -> u16 {
 }
 
 fn line_height(line: &Line, width: u16) -> u16 {
-    // Use the same visible-width slicing semantics as the live row builder so
-    // our pre-scroll estimation matches how rows will actually wrap.
-    let w = width.max(1) as usize;
-    let mut rows = 0u16;
-    let mut remaining = line
+    use unicode_width::UnicodeWidthStr;
+    // get the total display width of the line, accounting for double-width chars
+    let total_width = line
         .spans
         .iter()
-        .map(|s| s.content.as_ref())
-        .collect::<Vec<_>>()
-        .join("");
-    while !remaining.is_empty() {
-        let (_prefix, suffix, taken) = crate::live_wrap::take_prefix_by_width(&remaining, w);
-        rows = rows.saturating_add(1);
-        if taken >= remaining.len() {
-            break;
-        }
-        remaining = suffix.to_string();
+        .map(|span| span.content.width())
+        .sum::<usize>();
+    // divide by width to get the number of lines, rounding up
+    if width == 0 {
+        1
+    } else {
+        (total_width as u16).div_ceil(width).max(1)
     }
-    rows.max(1)
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -314,12 +283,4 @@ mod tests {
             String::from_utf8(expected).unwrap()
         );
     }
-
-    #[test]
-    fn line_height_counts_double_width_emoji() {
-        let line = Line::from("😀😀😀"); // each emoji ~ width 2
-        assert_eq!(line_height(&line, 4), 2);
-        assert_eq!(line_height(&line, 2), 3);
-        assert_eq!(line_height(&line, 6), 1);
-    }
 }

codex-rs/tui/src/lib.rs

@@ -3,16 +3,15 @@
 // alternate‑screen mode starts; that file opts‑out locally via `allow`.
 #![deny(clippy::print_stdout, clippy::print_stderr)]
 use app::App;
-use codex_core::BUILT_IN_OSS_MODEL_PROVIDER_ID;
 use codex_core::config::Config;
 use codex_core::config::ConfigOverrides;
 use codex_core::config_types::SandboxMode;
 use codex_core::protocol::AskForApproval;
 use codex_core::util::is_inside_git_repo;
 use codex_login::load_auth;
-use codex_ollama::DEFAULT_OSS_MODEL;
 use log_layer::TuiLogLayer;
 use std::fs::OpenOptions;
+use std::io::Write;
 use std::path::PathBuf;
 use tracing::error;
 use tracing_appender::non_blocking;
@@ -26,19 +25,15 @@ mod bottom_pane;
 mod chatwidget;
 mod citation_regex;
 mod cli;
-mod colors;
-pub mod custom_terminal;
+mod custom_terminal;
 mod exec_command;
 mod file_search;
 mod get_git_diff;
 mod git_warning_screen;
 mod history_cell;
-pub mod insert_history;
-pub mod live_wrap;
+mod insert_history;
 mod log_layer;
 mod markdown;
-pub mod onboarding;
-mod shimmer;
 mod slash_command;
 mod status_indicator_widget;
 mod text_block;
@@ -74,37 +69,18 @@ pub async fn run_main(
         )
     };
 
-    // When using `--oss`, let the bootstrapper pick the model (defaulting to
-    // gpt-oss:20b) and ensure it is present locally. Also, force the built‑in
-    // `oss` model provider.
-    let model = if let Some(model) = &cli.model {
-        Some(model.clone())
-    } else if cli.oss {
-        Some(DEFAULT_OSS_MODEL.to_owned())
-    } else {
-        None // No model specified, will use the default.
-    };
-
-    let model_provider_override = if cli.oss {
-        Some(BUILT_IN_OSS_MODEL_PROVIDER_ID.to_owned())
-    } else {
-        None
-    };
-
     let config = {
         // Load configuration and support CLI overrides.
         let overrides = ConfigOverrides {
-            model,
+            model: cli.model.clone(),
             approval_policy,
             sandbox_mode,
             cwd: cli.cwd.clone().map(|p| p.canonicalize().unwrap_or(p)),
-            model_provider: model_provider_override,
+            model_provider: None,
             config_profile: cli.config_profile.clone(),
             codex_linux_sandbox_exe,
             base_instructions: None,
             include_plan_tool: Some(true),
-            disable_response_storage: cli.oss.then_some(true),
-            show_raw_agent_reasoning: cli.oss.then_some(true),
         };
         // Parse `-c` overrides from the CLI.
         let cli_kv_overrides = match cli.config_overrides.parse_overrides() {
@@ -159,12 +135,6 @@ pub async fn run_main(
         .with_target(false)
         .with_filter(env_filter());
 
-    if cli.oss {
-        codex_ollama::ensure_oss_ready(&config)
-            .await
-            .map_err(|e| std::io::Error::other(format!("OSS setup failed: {e}")))?;
-    }
-
     // Channel that carries formatted log lines to the UI.
     let (log_tx, log_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
     let tui_layer = TuiLogLayer::new(log_tx.clone(), 120).with_filter(env_filter());
@@ -206,6 +176,24 @@ pub async fn run_main(
         eprintln!("");
     }
 
+    let show_login_screen = should_show_login_screen(&config);
+    if show_login_screen {
+        std::io::stdout()
+            .write_all(b"No API key detected.\nLogin with your ChatGPT account? [Yn] ")?;
+        std::io::stdout().flush()?;
+        let mut input = String::new();
+        std::io::stdin().read_line(&mut input)?;
+        let trimmed = input.trim();
+        if !(trimmed.is_empty() || trimmed.eq_ignore_ascii_case("y")) {
+            std::process::exit(1);
+        }
+        // Spawn a task to run the login command.
+        // Block until the login command is finished.
+        codex_login::login_with_chatgpt(&config.codex_home, false).await?;
+
+        std::io::stdout().write_all(b"Login successful.\n")?;
+    }
+
     // Determine whether we need to display the "not a git repo" warning
     // modal. The flag is shown when the current working directory is *not*
     // inside a Git repository **and** the user did *not* pass the
@@ -271,7 +259,7 @@ fn restore() {
 
 #[allow(clippy::unwrap_used)]
 fn should_show_login_screen(config: &Config) -> bool {
-    if config.model_provider.requires_openai_auth {
+    if config.model_provider.requires_auth {
         // Reading the OpenAI API key is an async operation because it may need
         // to refresh the token. Block on it.
         let codex_home = config.codex_home.clone();

codex-rs/tui/src/live_wrap.rs

@@ -1,290 +0,0 @@
-use unicode_width::UnicodeWidthChar;
-use unicode_width::UnicodeWidthStr;
-
-/// A single visual row produced by RowBuilder.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Row {
-    pub text: String,
-    /// True if this row ends with an explicit line break (as opposed to a hard wrap).
-    pub explicit_break: bool,
-}
-
-impl Row {
-    pub fn width(&self) -> usize {
-        self.text.width()
-    }
-}
-
-/// Incrementally wraps input text into visual rows of at most `width` cells.
-///
-/// Step 1: plain-text only. ANSI-carry and styled spans will be added later.
-pub struct RowBuilder {
-    target_width: usize,
-    /// Buffer for the current logical line (until a '\n' is seen).
-    current_line: String,
-    /// Output rows built so far for the current logical line and previous ones.
-    rows: Vec<Row>,
-}
-
-impl RowBuilder {
-    pub fn new(target_width: usize) -> Self {
-        Self {
-            target_width: target_width.max(1),
-            current_line: String::new(),
-            rows: Vec::new(),
-        }
-    }
-
-    pub fn width(&self) -> usize {
-        self.target_width
-    }
-
-    pub fn set_width(&mut self, width: usize) {
-        self.target_width = width.max(1);
-        // Rewrap everything we have (simple approach for Step 1).
-        let mut all = String::new();
-        for row in self.rows.drain(..) {
-            all.push_str(&row.text);
-            if row.explicit_break {
-                all.push('\n');
-            }
-        }
-        all.push_str(&self.current_line);
-        self.current_line.clear();
-        self.push_fragment(&all);
-    }
-
-    /// Push an input fragment. May contain newlines.
-    pub fn push_fragment(&mut self, fragment: &str) {
-        if fragment.is_empty() {
-            return;
-        }
-        let mut start = 0usize;
-        for (i, ch) in fragment.char_indices() {
-            if ch == '\n' {
-                // Flush anything pending before the newline.
-                if start < i {
-                    self.current_line.push_str(&fragment[start..i]);
-                }
-                self.flush_current_line(true);
-                start = i + ch.len_utf8();
-            }
-        }
-        if start < fragment.len() {
-            self.current_line.push_str(&fragment[start..]);
-            self.wrap_current_line();
-        }
-    }
-
-    /// Mark the end of the current logical line (equivalent to pushing a '\n').
-    pub fn end_line(&mut self) {
-        self.flush_current_line(true);
-    }
-
-    /// Drain and return all produced rows.
-    pub fn drain_rows(&mut self) -> Vec<Row> {
-        std::mem::take(&mut self.rows)
-    }
-
-    /// Return a snapshot of produced rows (non-draining).
-    pub fn rows(&self) -> &[Row] {
-        &self.rows
-    }
-
-    /// Rows suitable for display, including the current partial line if any.
-    pub fn display_rows(&self) -> Vec<Row> {
-        let mut out = self.rows.clone();
-        if !self.current_line.is_empty() {
-            out.push(Row {
-                text: self.current_line.clone(),
-                explicit_break: false,
-            });
-        }
-        out
-    }
-
-    /// Drain the oldest rows that exceed `max_keep` display rows (including the
-    /// current partial line, if any). Returns the drained rows in order.
-    pub fn drain_commit_ready(&mut self, max_keep: usize) -> Vec<Row> {
-        let display_count = self.rows.len() + if self.current_line.is_empty() { 0 } else { 1 };
-        if display_count <= max_keep {
-            return Vec::new();
-        }
-        let to_commit = display_count - max_keep;
-        let commit_count = to_commit.min(self.rows.len());
-        let mut drained = Vec::with_capacity(commit_count);
-        for _ in 0..commit_count {
-            drained.push(self.rows.remove(0));
-        }
-        drained
-    }
-
-    fn flush_current_line(&mut self, explicit_break: bool) {
-        // Wrap any remaining content in the current line and then finalize with explicit_break.
-        self.wrap_current_line();
-        // If the current line ended exactly on a width boundary and is non-empty, represent
-        // the explicit break as an empty explicit row so that fragmentation invariance holds.
-        if explicit_break {
-            if self.current_line.is_empty() {
-                // We ended on a boundary previously; add an empty explicit row.
-                self.rows.push(Row {
-                    text: String::new(),
-                    explicit_break: true,
-                });
-            } else {
-                // There is leftover content that did not wrap yet; push it now with the explicit flag.
-                let mut s = String::new();
-                std::mem::swap(&mut s, &mut self.current_line);
-                self.rows.push(Row {
-                    text: s,
-                    explicit_break: true,
-                });
-            }
-        }
-        // Reset current line buffer for next logical line.
-        self.current_line.clear();
-    }
-
-    fn wrap_current_line(&mut self) {
-        // While the current_line exceeds width, cut a prefix.
-        loop {
-            if self.current_line.is_empty() {
-                break;
-            }
-            let (prefix, suffix, taken) =
-                take_prefix_by_width(&self.current_line, self.target_width);
-            if taken == 0 {
-                // Avoid infinite loop on pathological inputs; take one scalar and continue.
-                if let Some((i, ch)) = self.current_line.char_indices().next() {
-                    let len = i + ch.len_utf8();
-                    let p = self.current_line[..len].to_string();
-                    self.rows.push(Row {
-                        text: p,
-                        explicit_break: false,
-                    });
-                    self.current_line = self.current_line[len..].to_string();
-                    continue;
-                }
-                break;
-            }
-            if suffix.is_empty() {
-                // Fits entirely; keep in buffer (do not push yet) so we can append more later.
-                break;
-            } else {
-                // Emit wrapped prefix as a non-explicit row and continue with the remainder.
-                self.rows.push(Row {
-                    text: prefix,
-                    explicit_break: false,
-                });
-                self.current_line = suffix.to_string();
-            }
-        }
-    }
-}
-
-/// Take a prefix of `text` whose visible width is at most `max_cols`.
-/// Returns (prefix, suffix, prefix_width).
-pub fn take_prefix_by_width(text: &str, max_cols: usize) -> (String, &str, usize) {
-    if max_cols == 0 || text.is_empty() {
-        return (String::new(), text, 0);
-    }
-    let mut cols = 0usize;
-    let mut end_idx = 0usize;
-    for (i, ch) in text.char_indices() {
-        let ch_width = UnicodeWidthChar::width(ch).unwrap_or(0);
-        if cols.saturating_add(ch_width) > max_cols {
-            break;
-        }
-        cols += ch_width;
-        end_idx = i + ch.len_utf8();
-        if cols == max_cols {
-            break;
-        }
-    }
-    let prefix = text[..end_idx].to_string();
-    let suffix = &text[end_idx..];
-    (prefix, suffix, cols)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use pretty_assertions::assert_eq;
-
-    #[test]
-    fn rows_do_not_exceed_width_ascii() {
-        let mut rb = RowBuilder::new(10);
-        rb.push_fragment("hello whirl this is a test");
-        let rows = rb.rows().to_vec();
-        assert_eq!(
-            rows,
-            vec![
-                Row {
-                    text: "hello whir".to_string(),
-                    explicit_break: false
-                },
-                Row {
-                    text: "l this is ".to_string(),
-                    explicit_break: false
-                }
-            ]
-        );
-    }
-
-    #[test]
-    fn rows_do_not_exceed_width_emoji_cjk() {
-        // 😀 is width 2; 你/好 are width 2.
-        let mut rb = RowBuilder::new(6);
-        rb.push_fragment("😀😀 你好");
-        let rows = rb.rows().to_vec();
-        // At width 6, we expect the first row to fit exactly two emojis and a space
-        // (2 + 2 + 1 = 5) plus one more column for the first CJK char (2 would overflow),
-        // so only the two emojis and the space fit; the rest remains buffered.
-        assert_eq!(
-            rows,
-            vec![Row {
-                text: "😀😀 ".to_string(),
-                explicit_break: false
-            }]
-        );
-    }
-
-    #[test]
-    fn fragmentation_invariance_long_token() {
-        let s = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; // 26 chars
-        let mut rb_all = RowBuilder::new(7);
-        rb_all.push_fragment(s);
-        let all_rows = rb_all.rows().to_vec();
-
-        let mut rb_chunks = RowBuilder::new(7);
-        for i in (0..s.len()).step_by(3) {
-            let end = (i + 3).min(s.len());
-            rb_chunks.push_fragment(&s[i..end]);
-        }
-        let chunk_rows = rb_chunks.rows().to_vec();
-
-        assert_eq!(all_rows, chunk_rows);
-    }
-
-    #[test]
-    fn newline_splits_rows() {
-        let mut rb = RowBuilder::new(10);
-        rb.push_fragment("hello\nworld");
-        let rows = rb.display_rows();
-        assert!(rows.iter().any(|r| r.explicit_break));
-        assert_eq!(rows[0].text, "hello");
-        // Second row should begin with 'world'
-        assert!(rows.iter().any(|r| r.text.starts_with("world")));
-    }
-
-    #[test]
-    fn rewrap_on_width_change() {
-        let mut rb = RowBuilder::new(10);
-        rb.push_fragment("abcdefghijK");
-        assert!(!rb.rows().is_empty());
-        rb.set_width(5);
-        for r in rb.rows() {
-            assert!(r.width() <= 5);
-        }
-    }
-}

codex-rs/tui/src/main.rs

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

codex-rs/tui/src/markdown.rs

@@ -1,4 +1,3 @@
-use crate::citation_regex::CITATION_REGEX;
 use codex_core::config::Config;
 use codex_core::config_types::UriBasedFileOpener;
 use ratatui::text::Line;
@@ -6,7 +5,8 @@ use ratatui::text::Span;
 use std::borrow::Cow;
 use std::path::Path;
 
-#[allow(dead_code)]
+use crate::citation_regex::CITATION_REGEX;
+
 pub(crate) fn append_markdown(
     markdown_source: &str,
     lines: &mut Vec<Line<'static>>,
@@ -15,7 +15,6 @@ pub(crate) fn append_markdown(
     append_markdown_with_opener_and_cwd(markdown_source, lines, config.file_opener, &config.cwd);
 }
 
-#[allow(dead_code)]
 fn append_markdown_with_opener_and_cwd(
     markdown_source: &str,
     lines: &mut Vec<Line<'static>>,
@@ -61,7 +60,6 @@ fn append_markdown_with_opener_and_cwd(
 /// ```text
 /// <scheme>://file<ABS_PATH>:<LINE>
 /// ```
-#[allow(dead_code)]
 fn rewrite_file_citations<'a>(
     src: &'a str,
     file_opener: UriBasedFileOpener,

codex-rs/tui/src/onboarding/auth.rs

@@ -1,316 +0,0 @@
-use crossterm::event::KeyCode;
-use crossterm::event::KeyEvent;
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::prelude::Widget;
-use ratatui::style::Color;
-use ratatui::style::Modifier;
-use ratatui::style::Style;
-use ratatui::text::Line;
-use ratatui::text::Span;
-use ratatui::widgets::Paragraph;
-use ratatui::widgets::WidgetRef;
-use ratatui::widgets::Wrap;
-
-use codex_login::AuthMode;
-
-use crate::app_event::AppEvent;
-use crate::app_event_sender::AppEventSender;
-use crate::colors::LIGHT_BLUE;
-use crate::colors::SUCCESS_GREEN;
-use crate::onboarding::onboarding_screen::KeyEventResult;
-use crate::onboarding::onboarding_screen::KeyboardHandler;
-use crate::shimmer::FrameTicker;
-use crate::shimmer::shimmer_spans;
-use std::path::PathBuf;
-// no additional imports
-
-#[derive(Debug)]
-pub(crate) enum SignInState {
-    PickMode,
-    ChatGptContinueInBrowser(#[allow(dead_code)] ContinueInBrowserState),
-    ChatGptSuccess,
-}
-
-#[derive(Debug)]
-/// Used to manage the lifecycle of SpawnedLogin and FrameTicker and ensure they get cleaned up.
-pub(crate) struct ContinueInBrowserState {
-    _login_child: Option<codex_login::SpawnedLogin>,
-    _frame_ticker: Option<FrameTicker>,
-}
-
-impl Drop for ContinueInBrowserState {
-    fn drop(&mut self) {
-        if let Some(child) = &self._login_child {
-            if let Ok(mut locked) = child.child.lock() {
-                // Best-effort terminate and reap the child to avoid zombies.
-                let _ = locked.kill();
-                let _ = locked.wait();
-            }
-        }
-    }
-}
-
-impl KeyboardHandler for AuthModeWidget {
-    fn handle_key_event(&mut self, key_event: KeyEvent) -> KeyEventResult {
-        match key_event.code {
-            KeyCode::Up | KeyCode::Char('k') => {
-                self.mode = AuthMode::ChatGPT;
-                KeyEventResult::None
-            }
-            KeyCode::Down | KeyCode::Char('j') => {
-                self.mode = AuthMode::ApiKey;
-                KeyEventResult::None
-            }
-            KeyCode::Char('1') => {
-                self.mode = AuthMode::ChatGPT;
-                self.start_chatgpt_login();
-                KeyEventResult::None
-            }
-            KeyCode::Char('2') => {
-                self.mode = AuthMode::ApiKey;
-                self.verify_api_key()
-            }
-            KeyCode::Enter => match self.mode {
-                AuthMode::ChatGPT => match &self.sign_in_state {
-                    SignInState::PickMode => self.start_chatgpt_login(),
-                    SignInState::ChatGptContinueInBrowser(_) => KeyEventResult::None,
-                    SignInState::ChatGptSuccess => KeyEventResult::Continue,
-                },
-                AuthMode::ApiKey => self.verify_api_key(),
-            },
-            KeyCode::Esc => {
-                if matches!(self.sign_in_state, SignInState::ChatGptContinueInBrowser(_)) {
-                    self.sign_in_state = SignInState::PickMode;
-                    self.event_tx.send(AppEvent::RequestRedraw);
-                    KeyEventResult::None
-                } else {
-                    KeyEventResult::Quit
-                }
-            }
-            KeyCode::Char('q') => KeyEventResult::Quit,
-            _ => KeyEventResult::None,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct AuthModeWidget {
-    pub mode: AuthMode,
-    pub error: Option<String>,
-    pub sign_in_state: SignInState,
-    pub event_tx: AppEventSender,
-    pub codex_home: PathBuf,
-}
-
-impl AuthModeWidget {
-    fn render_pick_mode(&self, area: Rect, buf: &mut Buffer) {
-        let mut lines: Vec<Line> = vec![
-            Line::from(vec![
-                Span::raw("> "),
-                Span::styled(
-                    "Sign in with your ChatGPT account?",
-                    Style::default().add_modifier(Modifier::BOLD),
-                ),
-            ]),
-            Line::from(""),
-        ];
-
-        let create_mode_item = |idx: usize,
-                                selected_mode: AuthMode,
-                                text: &str,
-                                description: &str|
-         -> Vec<Line<'static>> {
-            let is_selected = self.mode == selected_mode;
-            let caret = if is_selected { ">" } else { " " };
-
-            let line1 = if is_selected {
-                Line::from(vec![
-                    Span::styled(
-                        format!("{} {}. ", caret, idx + 1),
-                        Style::default().fg(LIGHT_BLUE).add_modifier(Modifier::DIM),
-                    ),
-                    Span::styled(text.to_owned(), Style::default().fg(LIGHT_BLUE)),
-                ])
-            } else {
-                Line::from(format!("  {}. {text}", idx + 1))
-            };
-
-            let line2 = if is_selected {
-                Line::from(format!("     {description}"))
-                    .style(Style::default().fg(LIGHT_BLUE).add_modifier(Modifier::DIM))
-            } else {
-                Line::from(format!("     {description}"))
-                    .style(Style::default().add_modifier(Modifier::DIM))
-            };
-
-            vec![line1, line2]
-        };
-
-        lines.extend(create_mode_item(
-            0,
-            AuthMode::ChatGPT,
-            "Sign in with ChatGPT or create a new account",
-            "Leverages your plan, starting at $20 a month for Plus",
-        ));
-        lines.extend(create_mode_item(
-            1,
-            AuthMode::ApiKey,
-            "Provide your own API key",
-            "Pay only for what you use",
-        ));
-        lines.push(Line::from(""));
-        lines.push(
-            Line::from("Press Enter to continue")
-                .style(Style::default().add_modifier(Modifier::DIM)),
-        );
-        if let Some(err) = &self.error {
-            lines.push(Line::from(""));
-            lines.push(Line::from(Span::styled(
-                err.as_str(),
-                Style::default().fg(Color::Red),
-            )));
-        }
-
-        Paragraph::new(lines)
-            .wrap(Wrap { trim: false })
-            .render(area, buf);
-    }
-
-    fn render_continue_in_browser(&self, area: Rect, buf: &mut Buffer) {
-        let idx = self.current_frame();
-        let mut spans = vec![Span::from("> ")];
-        spans.extend(shimmer_spans("Finish signing in via your browser", idx));
-        let lines = vec![
-            Line::from(spans),
-            Line::from(""),
-            Line::from("  Press Escape to cancel")
-                .style(Style::default().add_modifier(Modifier::DIM)),
-        ];
-        Paragraph::new(lines)
-            .wrap(Wrap { trim: false })
-            .render(area, buf);
-    }
-
-    fn render_chatgpt_success(&self, area: Rect, buf: &mut Buffer) {
-        let lines = vec![
-            Line::from("✓ Signed in with your ChatGPT account")
-                .style(Style::default().fg(SUCCESS_GREEN)),
-            Line::from(""),
-            Line::from("> Before you start:"),
-            Line::from(""),
-            Line::from("  Codex can make mistakes"),
-            Line::from("  Check important info")
-                .style(Style::default().add_modifier(Modifier::DIM)),
-            Line::from(""),
-            Line::from("  Due to prompt injection risks, only use it with code you trust"),
-            Line::from("  For more details see https://github.com/openai/codex")
-                .style(Style::default().add_modifier(Modifier::DIM)),
-            Line::from(""),
-            Line::from("  Powered by your ChatGPT account"),
-            Line::from("  Uses your plan's rate limits and training data preferences")
-                .style(Style::default().add_modifier(Modifier::DIM)),
-            Line::from(""),
-            Line::from("  Press Enter to continue").style(Style::default().fg(LIGHT_BLUE)),
-        ];
-
-        Paragraph::new(lines)
-            .wrap(Wrap { trim: false })
-            .render(area, buf);
-    }
-
-    fn start_chatgpt_login(&mut self) -> KeyEventResult {
-        self.error = None;
-        match codex_login::spawn_login_with_chatgpt(&self.codex_home) {
-            Ok(child) => {
-                self.spawn_completion_poller(child.clone());
-                self.sign_in_state =
-                    SignInState::ChatGptContinueInBrowser(ContinueInBrowserState {
-                        _login_child: Some(child),
-                        _frame_ticker: Some(FrameTicker::new(self.event_tx.clone())),
-                    });
-                self.event_tx.send(AppEvent::RequestRedraw);
-                KeyEventResult::None
-            }
-            Err(e) => {
-                self.sign_in_state = SignInState::PickMode;
-                self.error = Some(e.to_string());
-                self.event_tx.send(AppEvent::RequestRedraw);
-                KeyEventResult::None
-            }
-        }
-    }
-
-    /// TODO: Read/write from the correct hierarchy config overrides + auth json + OPENAI_API_KEY.
-    fn verify_api_key(&mut self) -> KeyEventResult {
-        if std::env::var("OPENAI_API_KEY").is_err() {
-            self.error =
-                Some("Set OPENAI_API_KEY in your environment. Learn more: https://platform.openai.com/docs/libraries".to_string());
-            self.event_tx.send(AppEvent::RequestRedraw);
-            KeyEventResult::None
-        } else {
-            KeyEventResult::Continue
-        }
-    }
-
-    fn spawn_completion_poller(&self, child: codex_login::SpawnedLogin) {
-        let child_arc = child.child.clone();
-        let stderr_buf = child.stderr.clone();
-        let event_tx = self.event_tx.clone();
-        std::thread::spawn(move || {
-            loop {
-                let done = {
-                    if let Ok(mut locked) = child_arc.lock() {
-                        match locked.try_wait() {
-                            Ok(Some(status)) => Some(status.success()),
-                            Ok(None) => None,
-                            Err(_) => Some(false),
-                        }
-                    } else {
-                        Some(false)
-                    }
-                };
-                if let Some(success) = done {
-                    if success {
-                        event_tx.send(AppEvent::OnboardingAuthComplete(Ok(())));
-                    } else {
-                        let err = stderr_buf
-                            .lock()
-                            .ok()
-                            .and_then(|b| String::from_utf8(b.clone()).ok())
-                            .unwrap_or_else(|| "login_with_chatgpt subprocess failed".to_string());
-                        event_tx.send(AppEvent::OnboardingAuthComplete(Err(err)));
-                    }
-                    break;
-                }
-                std::thread::sleep(std::time::Duration::from_millis(250));
-            }
-        });
-    }
-
-    fn current_frame(&self) -> usize {
-        // Derive frame index from wall-clock time to avoid storing animation state.
-        // 100ms per frame to match the previous ticker cadence.
-        let now_ms = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .map(|d| d.as_millis())
-            .unwrap_or(0);
-        (now_ms / 100) as usize
-    }
-}
-
-impl WidgetRef for AuthModeWidget {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        match self.sign_in_state {
-            SignInState::PickMode => {
-                self.render_pick_mode(area, buf);
-            }
-            SignInState::ChatGptContinueInBrowser(_) => {
-                self.render_continue_in_browser(area, buf);
-            }
-            SignInState::ChatGptSuccess => {
-                self.render_chatgpt_success(area, buf);
-            }
-        }
-    }
-}

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

@@ -1,3 +0,0 @@
-mod auth;
-pub mod onboarding_screen;
-mod welcome;

codex-rs/tui/src/onboarding/onboarding_screen.rs

@@ -1,157 +0,0 @@
-use crossterm::event::KeyEvent;
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::widgets::WidgetRef;
-
-use codex_login::AuthMode;
-
-use crate::app_event::AppEvent;
-use crate::app_event_sender::AppEventSender;
-use crate::onboarding::auth::AuthModeWidget;
-use crate::onboarding::auth::SignInState;
-use crate::onboarding::welcome::WelcomeWidget;
-use std::path::PathBuf;
-
-enum Step {
-    Welcome(WelcomeWidget),
-    Auth(AuthModeWidget),
-}
-
-pub(crate) trait KeyboardHandler {
-    fn handle_key_event(&mut self, key_event: KeyEvent) -> KeyEventResult;
-}
-
-pub(crate) enum KeyEventResult {
-    Continue,
-    Quit,
-    None,
-}
-
-pub(crate) struct OnboardingScreen {
-    event_tx: AppEventSender,
-    steps: Vec<Step>,
-}
-
-impl OnboardingScreen {
-    pub(crate) fn new(event_tx: AppEventSender, codex_home: PathBuf) -> Self {
-        let steps: Vec<Step> = vec![
-            Step::Welcome(WelcomeWidget {}),
-            Step::Auth(AuthModeWidget {
-                event_tx: event_tx.clone(),
-                mode: AuthMode::ChatGPT,
-                error: None,
-                sign_in_state: SignInState::PickMode,
-                codex_home,
-            }),
-        ];
-        Self { event_tx, steps }
-    }
-
-    pub(crate) fn on_auth_complete(&mut self, result: Result<(), String>) -> KeyEventResult {
-        if let Some(Step::Auth(state)) = self.steps.last_mut() {
-            match result {
-                Ok(()) => {
-                    state.sign_in_state = SignInState::ChatGptSuccess;
-                    self.event_tx.send(AppEvent::RequestRedraw);
-                    KeyEventResult::None
-                }
-                Err(e) => {
-                    state.sign_in_state = SignInState::PickMode;
-                    state.error = Some(e);
-                    self.event_tx.send(AppEvent::RequestRedraw);
-                    KeyEventResult::None
-                }
-            }
-        } else {
-            KeyEventResult::None
-        }
-    }
-}
-
-impl KeyboardHandler for OnboardingScreen {
-    fn handle_key_event(&mut self, key_event: KeyEvent) -> KeyEventResult {
-        if let Some(last_step) = self.steps.last_mut() {
-            self.event_tx.send(AppEvent::RequestRedraw);
-            last_step.handle_key_event(key_event)
-        } else {
-            KeyEventResult::None
-        }
-    }
-}
-
-impl WidgetRef for &OnboardingScreen {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        // Render steps top-to-bottom, measuring each step's height dynamically.
-        let mut y = area.y;
-        let bottom = area.y.saturating_add(area.height);
-        let width = area.width;
-
-        // Helper to scan a temporary buffer and return number of used rows.
-        fn used_rows(tmp: &Buffer, width: u16, height: u16) -> u16 {
-            if width == 0 || height == 0 {
-                return 0;
-            }
-            let mut last_non_empty: Option<u16> = None;
-            for yy in 0..height {
-                let mut any = false;
-                for xx in 0..width {
-                    let sym = tmp[(xx, yy)].symbol();
-                    if !sym.trim().is_empty() {
-                        any = true;
-                        break;
-                    }
-                }
-                if any {
-                    last_non_empty = Some(yy);
-                }
-            }
-            last_non_empty.map(|v| v + 2).unwrap_or(0)
-        }
-
-        let mut i = 0usize;
-        while i < self.steps.len() && y < bottom {
-            let step = &self.steps[i];
-            let max_h = bottom.saturating_sub(y);
-            if max_h == 0 || width == 0 {
-                break;
-            }
-            let scratch_area = Rect::new(0, 0, width, max_h);
-            let mut scratch = Buffer::empty(scratch_area);
-            step.render_ref(scratch_area, &mut scratch);
-            let h = used_rows(&scratch, width, max_h).min(max_h);
-            if h > 0 {
-                let target = Rect {
-                    x: area.x,
-                    y,
-                    width,
-                    height: h,
-                };
-                step.render_ref(target, buf);
-                y = y.saturating_add(h);
-            }
-            i += 1;
-        }
-    }
-}
-
-impl KeyboardHandler for Step {
-    fn handle_key_event(&mut self, key_event: KeyEvent) -> KeyEventResult {
-        match self {
-            Step::Welcome(_) => KeyEventResult::None,
-            Step::Auth(widget) => widget.handle_key_event(key_event),
-        }
-    }
-}
-
-impl WidgetRef for Step {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        match self {
-            Step::Welcome(widget) => {
-                widget.render_ref(area, buf);
-            }
-            Step::Auth(widget) => {
-                widget.render_ref(area, buf);
-            }
-        }
-    }
-}

codex-rs/tui/src/onboarding/welcome.rs

@@ -1,23 +0,0 @@
-use ratatui::buffer::Buffer;
-use ratatui::layout::Rect;
-use ratatui::prelude::Widget;
-use ratatui::style::Modifier;
-use ratatui::style::Style;
-use ratatui::text::Line;
-use ratatui::text::Span;
-use ratatui::widgets::WidgetRef;
-
-pub(crate) struct WelcomeWidget {}
-
-impl WidgetRef for &WelcomeWidget {
-    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        let line = Line::from(vec![
-            Span::raw("> "),
-            Span::styled(
-                "Welcome to Codex, OpenAI's coding agent that runs in your terminal",
-                Style::default().add_modifier(Modifier::BOLD),
-            ),
-        ]);
-        line.render(area, buf);
-    }
-}

codex-rs/tui/src/shimmer.rs

@@ -1,84 +0,0 @@
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::time::Duration;
-
-use ratatui::style::Color;
-use ratatui::style::Modifier;
-use ratatui::style::Style;
-use ratatui::text::Span;
-
-use crate::app_event::AppEvent;
-use crate::app_event_sender::AppEventSender;
-
-#[derive(Debug)]
-pub(crate) struct FrameTicker {
-    running: Arc<AtomicBool>,
-}
-
-impl FrameTicker {
-    pub(crate) fn new(app_event_tx: AppEventSender) -> Self {
-        let running = Arc::new(AtomicBool::new(true));
-        let running_clone = running.clone();
-        let app_event_tx_clone = app_event_tx.clone();
-        std::thread::spawn(move || {
-            while running_clone.load(Ordering::Relaxed) {
-                std::thread::sleep(Duration::from_millis(100));
-                app_event_tx_clone.send(AppEvent::RequestRedraw);
-            }
-        });
-        Self { running }
-    }
-}
-
-impl Drop for FrameTicker {
-    fn drop(&mut self) {
-        self.running.store(false, Ordering::Relaxed);
-    }
-}
-
-pub(crate) fn shimmer_spans(text: &str, frame_idx: usize) -> Vec<Span<'static>> {
-    let chars: Vec<char> = text.chars().collect();
-    let padding = 10usize;
-    let period = chars.len() + padding * 2;
-    let pos = frame_idx % period;
-    let has_true_color = supports_color::on_cached(supports_color::Stream::Stdout)
-        .map(|level| level.has_16m)
-        .unwrap_or(false);
-    let band_half_width = 6.0;
-
-    let mut spans: Vec<Span<'static>> = Vec::with_capacity(chars.len());
-    for (i, ch) in 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
-        };
-        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 {
-            Style::default()
-                .fg(Color::Rgb(level, level, level))
-                .add_modifier(Modifier::BOLD)
-        } else {
-            Style::default().fg(color_for_level(level))
-        };
-        spans.push(Span::styled(ch.to_string(), style));
-    }
-    spans
-}
-
-fn color_for_level(level: u8) -> Color {
-    if level < 128 {
-        Color::DarkGray
-    } else if level < 192 {
-        Color::Gray
-    } else {
-        Color::White
-    }
-}

codex-rs/tui/src/slash_command.rs

@@ -13,10 +13,8 @@ pub enum SlashCommand {
     // DO NOT ALPHA-SORT! Enum order is presentation order in the popup, so
     // more frequently used commands should be listed first.
     New,
-    Init,
     Compact,
     Diff,
-    Status,
     Quit,
     #[cfg(debug_assertions)]
     TestApproval,
@@ -26,12 +24,12 @@ impl SlashCommand {
     /// User-visible description shown in the popup.
     pub fn description(self) -> &'static str {
         match self {
-            SlashCommand::New => "Start a new chat",
-            SlashCommand::Init => "Create an AGENTS.md file with instructions for Codex",
-            SlashCommand::Compact => "Compact the chat history",
-            SlashCommand::Quit => "Exit the application",
-            SlashCommand::Diff => "Show git diff (including untracked files)",
-            SlashCommand::Status => "Show current session configuration and token usage",
+            SlashCommand::New => "Start a new chat.",
+            SlashCommand::Compact => "Compact the chat history.",
+            SlashCommand::Quit => "Exit the application.",
+            SlashCommand::Diff => {
+                "Show git diff of the working directory (including untracked files)"
+            }
             #[cfg(debug_assertions)]
             SlashCommand::TestApproval => "Test approval request",
         }

codex-rs/tui/src/status_indicator_widget.rs

@@ -9,22 +9,24 @@ use std::thread;
 use std::time::Duration;
 
 use ratatui::buffer::Buffer;
+use ratatui::layout::Alignment;
 use ratatui::layout::Rect;
 use ratatui::style::Color;
 use ratatui::style::Modifier;
 use ratatui::style::Style;
+use ratatui::style::Stylize;
 use ratatui::text::Line;
 use ratatui::text::Span;
+use ratatui::widgets::Block;
+use ratatui::widgets::BorderType;
+use ratatui::widgets::Borders;
+use ratatui::widgets::Padding;
 use ratatui::widgets::Paragraph;
 use ratatui::widgets::WidgetRef;
-use unicode_width::UnicodeWidthStr;
 
 use crate::app_event::AppEvent;
 use crate::app_event_sender::AppEventSender;
 
-// We render the live text using markdown so it visually matches the history
-// cells. Before rendering we strip any ANSI escape sequences to avoid writing
-// raw control bytes into the back buffer.
 use codex_ansi_escape::ansi_escape_line;
 
 pub(crate) struct StatusIndicatorWidget {
@@ -32,14 +34,6 @@ pub(crate) struct StatusIndicatorWidget {
     /// time).
     text: String,
 
-    /// Animation state: reveal target `text` progressively like a typewriter.
-    /// We compute the currently visible prefix length based on the current
-    /// frame index and a constant typing speed.  The `base_frame` and
-    /// `reveal_len_at_base` form the anchor from which we advance.
-    last_target_len: usize,
-    base_frame: usize,
-    reveal_len_at_base: usize,
-
     frame_idx: Arc<AtomicUsize>,
     running: Arc<AtomicBool>,
     // Keep one sender alive to prevent the channel from closing while the
@@ -63,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);
@@ -72,13 +66,9 @@ impl StatusIndicatorWidget {
         }
 
         Self {
-            text: String::from("waiting for model"),
-            last_target_len: 0,
-            base_frame: 0,
-            reveal_len_at_base: 0,
+            text: String::from("waiting for logs…"),
             frame_idx,
             running,
-
             _app_event_tx: app_event_tx,
         }
     }
@@ -89,67 +79,7 @@ impl StatusIndicatorWidget {
 
     /// Update the line that is displayed in the widget.
     pub(crate) fn update_text(&mut self, text: String) {
-        // If the text hasn't changed, don't reset the baseline; let the
-        // animation continue advancing naturally.
-        if text == self.text {
-            return;
-        }
-        // Update the target text, preserving newlines so wrapping matches history cells.
-        // Strip ANSI escapes for the character count so the typewriter animation speed is stable.
-        let stripped = {
-            let line = ansi_escape_line(&text);
-            line.spans
-                .iter()
-                .map(|s| s.content.as_ref())
-                .collect::<Vec<_>>()
-                .join("")
-        };
-        let new_len = stripped.chars().count();
-
-        // Compute how many characters are currently revealed so we can carry
-        // this forward as the new baseline when target text changes.
-        let current_frame = self.frame_idx.load(std::sync::atomic::Ordering::Relaxed);
-        let shown_now = self.current_shown_len(current_frame);
-
-        self.text = text;
-        self.last_target_len = new_len;
-        self.base_frame = current_frame;
-        self.reveal_len_at_base = shown_now.min(new_len);
-    }
-
-    /// Reset the animation and start revealing `text` from the beginning.
-    #[cfg(test)]
-    pub(crate) fn restart_with_text(&mut self, text: String) {
-        let sanitized = text.replace(['\n', '\r'], " ");
-        let stripped = {
-            let line = ansi_escape_line(&sanitized);
-            line.spans
-                .iter()
-                .map(|s| s.content.as_ref())
-                .collect::<Vec<_>>()
-                .join("")
-        };
-
-        let new_len = stripped.chars().count();
-        let current_frame = self.frame_idx.load(std::sync::atomic::Ordering::Relaxed);
-
-        self.text = sanitized;
-        self.last_target_len = new_len;
-        self.base_frame = current_frame;
-        // Start from zero revealed characters for a fresh typewriter cycle.
-        self.reveal_len_at_base = 0;
-    }
-
-    /// Calculate how many characters should currently be visible given the
-    /// animation baseline and frame counter.
-    fn current_shown_len(&self, current_frame: usize) -> usize {
-        // Increase typewriter speed (~5x): reveal more characters per frame.
-        const TYPING_CHARS_PER_FRAME: usize = 7;
-        let frames = current_frame.saturating_sub(self.base_frame);
-        let advanced = self
-            .reveal_len_at_base
-            .saturating_add(frames.saturating_mul(TYPING_CHARS_PER_FRAME));
-        advanced.min(self.last_target_len)
+        self.text = text.replace(['\n', '\r'], " ");
     }
 }
 
@@ -162,140 +92,100 @@ impl Drop for StatusIndicatorWidget {
 
 impl WidgetRef for StatusIndicatorWidget {
     fn render_ref(&self, area: Rect, buf: &mut Buffer) {
-        // Ensure minimal height
-        if area.height == 0 || area.width == 0 {
-            return;
-        }
-
-        // Build animated gradient header for the word "Working".
+        let widget_style = Style::default();
+        let block = Block::default()
+            .padding(Padding::new(1, 0, 0, 0))
+            .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);
-        let band_half_width = 2.0; // width of the bright band in characters
+        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
-            };
-
-            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 {
-                Style::default()
-                    .fg(Color::Rgb(level, level, level))
-                    .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))
-            };
-
-            header_spans.push(Span::styled(ch.to_string(), style));
-        }
-
-        // Plain rendering: no borders or padding so the live cell is visually indistinguishable from terminal scrollback.
-        let inner_width = area.width as usize;
-
-        // Compose a single status line like: "▌ Working [•] waiting for model"
-        let mut spans: Vec<Span<'static>> = Vec::new();
-        spans.push(Span::styled("▌ ", Style::default().fg(Color::Cyan)));
-        // Gradient header
-        spans.extend(header_spans);
-        // Space after header
-        spans.push(Span::styled(
-            " ",
+        header_spans.push(Span::styled(
+            "Working ",
             Style::default()
                 .fg(Color::White)
                 .add_modifier(Modifier::BOLD),
         ));
 
-        // Truncate spans to fit the width.
-        let mut acc: Vec<Span<'static>> = Vec::new();
-        let mut used = 0usize;
-        for s in spans {
-            let w = s.content.width();
-            if used + w <= inner_width {
-                acc.push(s);
-                used += w;
+        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::White)
+                    .add_modifier(Modifier::BOLD)
             } else {
-                break;
+                Style::default().dim()
+            };
+            header_spans.push(Span::styled(".", style));
+        }
+
+        header_spans.push(Span::styled(
+            "] ",
+            Style::default()
+                .fg(Color::White)
+                .add_modifier(Modifier::BOLD),
+        ));
+
+        // Ensure we do not overflow width.
+        let inner_width = block.inner(area).width as usize;
+
+        // Sanitize and colour‑strip the potentially colourful log text.  This
+        // ensures that **no** raw ANSI escape sequences leak into the
+        // back‑buffer which would otherwise cause cursor jumps or stray
+        // artefacts when the terminal is resized.
+        let line = ansi_escape_line(&self.text);
+        let mut sanitized_tail: String = line
+            .spans
+            .iter()
+            .map(|s| s.content.as_ref())
+            .collect::<Vec<_>>()
+            .join("");
+
+        // Truncate *after* stripping escape codes so width calculation is
+        // accurate. See UTF‑8 boundary comments above.
+        let header_len: usize = header_spans.iter().map(|s| s.content.len()).sum();
+
+        if header_len + sanitized_tail.len() > inner_width {
+            let available_bytes = inner_width.saturating_sub(header_len);
+
+            if sanitized_tail.is_char_boundary(available_bytes) {
+                sanitized_tail.truncate(available_bytes);
+            } else {
+                let mut idx = available_bytes;
+                while idx < sanitized_tail.len() && !sanitized_tail.is_char_boundary(idx) {
+                    idx += 1;
+                }
+                sanitized_tail.truncate(idx);
             }
         }
-        let lines = vec![Line::from(acc)];
 
-        // No-op once full text is revealed; the app no longer reacts to a completion event.
+        let mut spans = header_spans;
 
-        let paragraph = Paragraph::new(lines);
+        // Re‑apply the DIM modifier so the tail appears visually subdued
+        // irrespective of the colour information preserved by
+        // `ansi_escape_line`.
+        spans.push(Span::styled(sanitized_tail, Style::default().dim()));
+
+        let paragraph = Paragraph::new(Line::from(spans))
+            .block(block)
+            .alignment(Alignment::Left);
         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
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::app_event::AppEvent;
-    use crate::app_event_sender::AppEventSender;
-    use std::sync::mpsc::channel;
-
-    #[test]
-    fn renders_without_left_border_or_padding() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut w = StatusIndicatorWidget::new(tx);
-        w.restart_with_text("Hello".to_string());
-
-        let area = ratatui::layout::Rect::new(0, 0, 30, 1);
-        // Allow a short delay so the typewriter reveals the first character.
-        std::thread::sleep(std::time::Duration::from_millis(120));
-        let mut buf = ratatui::buffer::Buffer::empty(area);
-        w.render_ref(area, &mut buf);
-
-        // Leftmost column has the left bar
-        let ch0 = buf[(0, 0)].symbol().chars().next().unwrap_or(' ');
-        assert_eq!(ch0, '▌', "expected left bar at col 0: {ch0:?}");
-    }
-
-    #[test]
-    fn working_header_is_present_on_last_line() {
-        let (tx_raw, _rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let mut w = StatusIndicatorWidget::new(tx);
-        w.restart_with_text("Hi".to_string());
-        // Ensure some frames elapse so we get a stable state.
-        std::thread::sleep(std::time::Duration::from_millis(120));
-
-        let area = ratatui::layout::Rect::new(0, 0, 30, 1);
-        let mut buf = ratatui::buffer::Buffer::empty(area);
-        w.render_ref(area, &mut buf);
-
-        // Single line; it should contain the animated "Working" header.
-        let mut row = String::new();
-        for x in 0..area.width {
-            row.push(buf[(x, 0)].symbol().chars().next().unwrap_or(' '));
-        }
-        assert!(row.contains("Working"), "expected Working header: {row:?}");
-    }
-}

codex-rs/tui/src/tui.rs

@@ -3,14 +3,11 @@ use std::io::Stdout;
 use std::io::stdout;
 
 use codex_core::config::Config;
-use crossterm::cursor::MoveTo;
 use crossterm::event::DisableBracketedPaste;
 use crossterm::event::EnableBracketedPaste;
 use crossterm::event::KeyboardEnhancementFlags;
 use crossterm::event::PopKeyboardEnhancementFlags;
 use crossterm::event::PushKeyboardEnhancementFlags;
-use crossterm::terminal::Clear;
-use crossterm::terminal::ClearType;
 use ratatui::backend::CrosstermBackend;
 use ratatui::crossterm::execute;
 use ratatui::crossterm::terminal::disable_raw_mode;
@@ -39,9 +36,6 @@ pub fn init(_config: &Config) -> Result<Tui> {
     )?;
     set_panic_hook();
 
-    // Clear screen and move cursor to top-left before drawing UI
-    execute!(stdout(), Clear(ClearType::All), MoveTo(0, 0))?;
-
     let backend = CrosstermBackend::new(stdout());
     let tui = Terminal::with_options(backend)?;
     Ok(tui)

codex-rs/tui/src/user_approval_widget.rs

@@ -47,8 +47,6 @@ pub(crate) enum ApprovalRequest {
 }
 
 /// Options displayed in the *select* mode.
-///
-/// The `key` is matched case-insensitively.
 struct SelectOption {
     label: Line<'static>,
     description: &'static str,
@@ -189,16 +187,6 @@ impl UserApprovalWidget<'_> {
         }
     }
 
-    /// Normalize a key for comparison.
-    /// - For `KeyCode::Char`, converts to lowercase for case-insensitive matching.
-    /// - Other key codes are returned unchanged.
-    fn normalize_keycode(code: KeyCode) -> KeyCode {
-        match code {
-            KeyCode::Char(c) => KeyCode::Char(c.to_ascii_lowercase()),
-            other => other,
-        }
-    }
-
     /// Handle Ctrl-C pressed by the user while the modal is visible.
     /// Behaves like pressing Escape: abort the request and close the modal.
     pub(crate) fn on_ctrl_c(&mut self) {
@@ -222,12 +210,7 @@ impl UserApprovalWidget<'_> {
                 self.send_decision(ReviewDecision::Abort);
             }
             other => {
-                let normalized = Self::normalize_keycode(other);
-                if let Some(opt) = self
-                    .select_options
-                    .iter()
-                    .find(|opt| Self::normalize_keycode(opt.key) == normalized)
-                {
+                if let Some(opt) = self.select_options.iter().find(|opt| opt.key == other) {
                     self.send_decision(opt.decision);
                 }
             }
@@ -347,59 +330,3 @@ impl WidgetRef for &UserApprovalWidget<'_> {
             );
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crossterm::event::KeyCode;
-    use crossterm::event::KeyEvent;
-    use crossterm::event::KeyModifiers;
-    use std::path::PathBuf;
-    use std::sync::mpsc::channel;
-
-    #[test]
-    fn lowercase_shortcut_is_accepted() {
-        let (tx_raw, rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let req = ApprovalRequest::Exec {
-            id: "1".to_string(),
-            command: vec!["echo".to_string()],
-            cwd: PathBuf::new(),
-            reason: None,
-        };
-        let mut widget = UserApprovalWidget::new(req, tx);
-        widget.handle_key_event(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE));
-        assert!(widget.is_complete());
-        let events: Vec<AppEvent> = rx.try_iter().collect();
-        assert!(events.iter().any(|e| matches!(
-            e,
-            AppEvent::CodexOp(Op::ExecApproval {
-                decision: ReviewDecision::Approved,
-                ..
-            })
-        )));
-    }
-
-    #[test]
-    fn uppercase_shortcut_is_accepted() {
-        let (tx_raw, rx) = channel::<AppEvent>();
-        let tx = AppEventSender::new(tx_raw);
-        let req = ApprovalRequest::Exec {
-            id: "2".to_string(),
-            command: vec!["echo".to_string()],
-            cwd: PathBuf::new(),
-            reason: None,
-        };
-        let mut widget = UserApprovalWidget::new(req, tx);
-        widget.handle_key_event(KeyEvent::new(KeyCode::Char('Y'), KeyModifiers::NONE));
-        assert!(widget.is_complete());
-        let events: Vec<AppEvent> = rx.try_iter().collect();
-        assert!(events.iter().any(|e| matches!(
-            e,
-            AppEvent::CodexOp(Op::ExecApproval {
-                decision: ReviewDecision::Approved,
-                ..
-            })
-        )));
-    }
-}

codex-rs/tui/tests/vt100_history.rs

@@ -1,214 +0,0 @@
-#![cfg(feature = "vt100-tests")]
-#![expect(clippy::expect_used)]
-
-use ratatui::backend::TestBackend;
-use ratatui::layout::Rect;
-use ratatui::style::Color;
-use ratatui::style::Style;
-use ratatui::text::Line;
-use ratatui::text::Span;
-
-// Small helper macro to assert a collection contains an item with a clearer
-// failure message.
-macro_rules! assert_contains {
-    ($collection:expr, $item:expr $(,)?) => {
-        assert!(
-            $collection.contains(&$item),
-            "Expected {:?} to contain {:?}",
-            $collection,
-            $item
-        );
-    };
-    ($collection:expr, $item:expr, $($arg:tt)+) => {
-        assert!($collection.contains(&$item), $($arg)+);
-    };
-}
-
-struct TestScenario {
-    width: u16,
-    height: u16,
-    term: codex_tui::custom_terminal::Terminal<TestBackend>,
-}
-
-impl TestScenario {
-    fn new(width: u16, height: u16, viewport: Rect) -> Self {
-        let backend = TestBackend::new(width, height);
-        let mut term = codex_tui::custom_terminal::Terminal::with_options(backend)
-            .expect("failed to construct terminal");
-        term.set_viewport_area(viewport);
-        Self {
-            width,
-            height,
-            term,
-        }
-    }
-
-    fn run_insert(&mut self, lines: Vec<Line<'static>>) -> Vec<u8> {
-        let mut buf: Vec<u8> = Vec::new();
-        codex_tui::insert_history::insert_history_lines_to_writer(&mut self.term, &mut buf, lines);
-        buf
-    }
-
-    fn screen_rows_from_bytes(&self, bytes: &[u8]) -> Vec<String> {
-        let mut parser = vt100::Parser::new(self.height, self.width, 0);
-        parser.process(bytes);
-        let screen = parser.screen();
-
-        let mut rows: Vec<String> = Vec::with_capacity(self.height as usize);
-        for row in 0..self.height {
-            let mut s = String::with_capacity(self.width as usize);
-            for col in 0..self.width {
-                if let Some(cell) = screen.cell(row, col) {
-                    if let Some(ch) = cell.contents().chars().next() {
-                        s.push(ch);
-                    } else {
-                        s.push(' ');
-                    }
-                } else {
-                    s.push(' ');
-                }
-            }
-            rows.push(s.trim_end().to_string());
-        }
-        rows
-    }
-}
-
-#[test]
-fn hist_001_basic_insertion_no_wrap() {
-    // Screen of 20x6; viewport is the last row (height=1 at y=5)
-    let area = Rect::new(0, 5, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let lines = vec![Line::from("first"), Line::from("second")];
-    let buf = scenario.run_insert(lines);
-    let rows = scenario.screen_rows_from_bytes(&buf);
-    assert_contains!(rows, String::from("first"));
-    assert_contains!(rows, String::from("second"));
-    let first_idx = rows
-        .iter()
-        .position(|r| r == "first")
-        .expect("expected 'first' row to be present");
-    let second_idx = rows
-        .iter()
-        .position(|r| r == "second")
-        .expect("expected 'second' row to be present");
-    assert_eq!(second_idx, first_idx + 1, "rows should be adjacent");
-}
-
-#[test]
-fn hist_002_long_token_wraps() {
-    let area = Rect::new(0, 5, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let long = "A".repeat(45); // > 2 lines at width 20
-    let lines = vec![Line::from(long.clone())];
-    let buf = scenario.run_insert(lines);
-    let mut parser = vt100::Parser::new(6, 20, 0);
-    parser.process(&buf);
-    let screen = parser.screen();
-
-    // Count total A's on the screen
-    let mut count_a = 0usize;
-    for row in 0..6 {
-        for col in 0..20 {
-            if let Some(cell) = screen.cell(row, col) {
-                if let Some(ch) = cell.contents().chars().next() {
-                    if ch == 'A' {
-                        count_a += 1;
-                    }
-                }
-            }
-        }
-    }
-
-    assert_eq!(
-        count_a,
-        long.len(),
-        "wrapped content did not preserve all characters"
-    );
-}
-
-#[test]
-fn hist_003_emoji_and_cjk() {
-    let area = Rect::new(0, 5, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let text = String::from("😀😀😀😀😀 你好世界");
-    let lines = vec![Line::from(text.clone())];
-    let buf = scenario.run_insert(lines);
-    let rows = scenario.screen_rows_from_bytes(&buf);
-    let reconstructed: String = rows.join("").chars().filter(|c| *c != ' ').collect();
-    for ch in text.chars().filter(|c| !c.is_whitespace()) {
-        assert!(
-            reconstructed.contains(ch),
-            "missing character {ch:?} in reconstructed screen"
-        );
-    }
-}
-
-#[test]
-fn hist_004_mixed_ansi_spans() {
-    let area = Rect::new(0, 5, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let line = Line::from(vec![
-        Span::styled("red", Style::default().fg(Color::Red)),
-        Span::raw("+plain"),
-    ]);
-    let buf = scenario.run_insert(vec![line]);
-    let rows = scenario.screen_rows_from_bytes(&buf);
-    assert_contains!(rows, String::from("red+plain"));
-}
-
-#[test]
-fn hist_006_cursor_restoration() {
-    let area = Rect::new(0, 5, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let lines = vec![Line::from("x")];
-    let buf = scenario.run_insert(lines);
-    let s = String::from_utf8_lossy(&buf);
-    // CUP to 1;1 (ANSI: ESC[1;1H)
-    assert!(
-        s.contains("\u{1b}[1;1H"),
-        "expected final CUP to 1;1 in output, got: {s:?}"
-    );
-    // Reset scroll region
-    assert!(
-        s.contains("\u{1b}[r"),
-        "expected reset scroll region in output, got: {s:?}"
-    );
-}
-
-#[test]
-fn hist_005_pre_scroll_region_down() {
-    // Viewport not at bottom: y=3 (0-based), height=1
-    let area = Rect::new(0, 3, 20, 1);
-    let mut scenario = TestScenario::new(20, 6, area);
-
-    let lines = vec![Line::from("first"), Line::from("second")];
-    let buf = scenario.run_insert(lines);
-    let s = String::from_utf8_lossy(&buf);
-    // Expect we limited scroll region to [top+1 .. screen_height] => [4 .. 6] (1-based)
-    assert!(
-        s.contains("\u{1b}[4;6r"),
-        "expected pre-scroll SetScrollRegion 4..6, got: {s:?}"
-    );
-    // Expect we moved cursor to top of that region: row 3 (0-based) => CUP 4;1H
-    assert!(
-        s.contains("\u{1b}[4;1H"),
-        "expected cursor at top of pre-scroll region, got: {s:?}"
-    );
-    // Expect at least two Reverse Index commands (ESC M) for two inserted lines
-    let ri_count = s.matches("\u{1b}M").count();
-    assert!(
-        ri_count >= 1,
-        "expected at least one RI (ESC M), got: {s:?}"
-    );
-    // After pre-scroll, we set insertion scroll region to [1 .. new_top] => [1 .. 5]
-    assert!(
-        s.contains("\u{1b}[1;5r"),
-        "expected insertion SetScrollRegion 1..5, got: {s:?}"
-    );
-}

codex-rs/tui/tests/vt100_live_commit.rs

@@ -1,101 +0,0 @@
-#![cfg(feature = "vt100-tests")]
-
-use ratatui::backend::TestBackend;
-use ratatui::layout::Rect;
-use ratatui::text::Line;
-
-#[test]
-fn live_001_commit_on_overflow() {
-    let backend = TestBackend::new(20, 6);
-    let mut term = match codex_tui::custom_terminal::Terminal::with_options(backend) {
-        Ok(t) => t,
-        Err(e) => panic!("failed to construct terminal: {e}"),
-    };
-    let area = Rect::new(0, 5, 20, 1);
-    term.set_viewport_area(area);
-
-    // Build 5 explicit rows at width 20.
-    let mut rb = codex_tui::live_wrap::RowBuilder::new(20);
-    rb.push_fragment("one\n");
-    rb.push_fragment("two\n");
-    rb.push_fragment("three\n");
-    rb.push_fragment("four\n");
-    rb.push_fragment("five\n");
-
-    // Keep the last 3 in the live ring; commit the first 2.
-    let commit_rows = rb.drain_commit_ready(3);
-    let lines: Vec<Line<'static>> = commit_rows
-        .into_iter()
-        .map(|r| Line::from(r.text))
-        .collect();
-
-    let mut buf: Vec<u8> = Vec::new();
-    codex_tui::insert_history::insert_history_lines_to_writer(&mut term, &mut buf, lines);
-
-    let mut parser = vt100::Parser::new(6, 20, 0);
-    parser.process(&buf);
-    let screen = parser.screen();
-
-    // The words "one" and "two" should appear above the viewport.
-    let mut joined = String::new();
-    for row in 0..6 {
-        for col in 0..20 {
-            if let Some(cell) = screen.cell(row, col) {
-                if let Some(ch) = cell.contents().chars().next() {
-                    joined.push(ch);
-                } else {
-                    joined.push(' ');
-                }
-            }
-        }
-        joined.push('\n');
-    }
-    assert!(
-        joined.contains("one"),
-        "expected committed 'one' to be visible\n{joined}"
-    );
-    assert!(
-        joined.contains("two"),
-        "expected committed 'two' to be visible\n{joined}"
-    );
-    // The last three (three,four,five) remain in the live ring, not committed here.
-}
-
-#[test]
-fn live_002_pre_scroll_and_commit() {
-    let backend = TestBackend::new(20, 6);
-    let mut term = match codex_tui::custom_terminal::Terminal::with_options(backend) {
-        Ok(t) => t,
-        Err(e) => panic!("failed to construct terminal: {e}"),
-    };
-    // Viewport not at bottom: y=3
-    let area = Rect::new(0, 3, 20, 1);
-    term.set_viewport_area(area);
-
-    let mut rb = codex_tui::live_wrap::RowBuilder::new(20);
-    rb.push_fragment("alpha\n");
-    rb.push_fragment("beta\n");
-    rb.push_fragment("gamma\n");
-    rb.push_fragment("delta\n");
-
-    // Keep 3, commit 1.
-    let commit_rows = rb.drain_commit_ready(3);
-    let lines: Vec<Line<'static>> = commit_rows
-        .into_iter()
-        .map(|r| Line::from(r.text))
-        .collect();
-
-    let mut buf: Vec<u8> = Vec::new();
-    codex_tui::insert_history::insert_history_lines_to_writer(&mut term, &mut buf, lines);
-    let s = String::from_utf8_lossy(&buf);
-
-    // Expect a SetScrollRegion to [area.top()+1 .. screen_height] and a cursor move to top of that region.
-    assert!(
-        s.contains("\u{1b}[4;6r"),
-        "expected pre-scroll region 4..6, got: {s:?}"
-    );
-    assert!(
-        s.contains("\u{1b}[4;1H"),
-        "expected cursor CUP 4;1H, got: {s:?}"
-    );
-}