client

2026-02-06 08:53:41 +00:00 · 2025-12-02 16:16:38 -08:00 · 2025-12-02 14:54:33 -08:00 · 2025-12-02 14:45:44 -08:00 · 2025-11-25 16:01:19 -08:00 · 2025-11-25 15:56:48 -08:00
200 changed files with 3579 additions and 10268 deletions
--- a/.github/workflows/cla.yml
+++ b/.github/workflows/cla.yml
@@ -46,4 +46,7 @@ jobs:
          path-to-document: https://github.com/openai/codex/blob/main/docs/CLA.md
          path-to-signatures: signatures/cla.json
          branch: cla-signatures
-          allowlist: codex,dependabot,dependabot[bot],github-actions[bot]
+          allowlist: |
+            codex
+            dependabot
+            dependabot[bot]
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -14,7 +14,6 @@ In the codex-rs folder where the rust code lives:
 - Do not use unsigned integer even if the number cannot be negative.
 - When writing tests, prefer comparing the equality of entire objects over fields one by one.
 - When making a change that adds or changes an API, ensure that the documentation in the `docs/` folder is up to date if applicable.
- Always prefer async functions when possible.

 Run `just fmt` (in `codex-rs` directory) automatically after making Rust code changes; do not ask for approval to run it. Before finalizing a change to `codex-rs`, run `just fix -p <project>` (in `codex-rs` directory) to fix any linter issues in the code. Prefer scoping with `-p` to avoid slow workspace‑wide Clippy builds; only run `just fix` without `-p` if you changed shared crates. Additionally, run the tests:

--- a/codex-cli/bin/codex.js
+++ b/codex-cli/bin/codex.js
@@ -95,6 +95,14 @@ function detectPackageManager() {
    return "bun";
  }

+  if (
+    process.env.BUN_INSTALL ||
+    process.env.BUN_INSTALL_GLOBAL_DIR ||
+    process.env.BUN_INSTALL_BIN_DIR
+  ) {
+    return "bun";
+  }
+
  return userAgent ? "npm" : null;
 }

--- a/codex-rs/Cargo.lock
+++ b/codex-rs/Cargo.lock
@@ -198,9 +198,9 @@ dependencies = [

 [[package]]
 name = "arboard"
-version = "3.6.1"
+version = "3.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+checksum = "55f533f8e0af236ffe5eb979b99381df3258853f00ba2e44b6e1955292c75227"
 dependencies = [
 "clipboard-win",
 "image",
@@ -212,7 +212,7 @@ dependencies = [
 "objc2-foundation",
 "parking_lot",
 "percent-encoding",
- "windows-sys 0.60.2",
+ "windows-sys 0.52.0",
 "wl-clipboard-rs",
 "x11rb",
 ]
@@ -858,7 +858,6 @@ dependencies = [
 "http",
 "pretty_assertions",
 "regex-lite",
- "reqwest",
 "serde",
 "serde_json",
 "thiserror 2.0.17",
@@ -866,7 +865,6 @@ dependencies = [
 "tokio-test",
 "tokio-util",
 "tracing",
- "wiremock",
 ]

 [[package]]
@@ -1070,7 +1068,6 @@ dependencies = [
 "serde_json",
 "thiserror 2.0.17",
 "tokio",
- "tracing",
 ]

 [[package]]
@@ -1119,10 +1116,12 @@ name = "codex-common"
 version = "0.0.0"
 dependencies = [
 "clap",
+ "codex-app-server-protocol",
 "codex-core",
 "codex-lmstudio",
 "codex-ollama",
 "codex-protocol",
+ "once_cell",
 "serde",
 "toml",
 ]
@@ -1145,6 +1144,7 @@ dependencies = [
 "codex-apply-patch",
 "codex-arg0",
 "codex-async-utils",
+ "codex-client",
 "codex-core",
 "codex-execpolicy",
 "codex-file-search",
@@ -1187,7 +1187,6 @@ dependencies = [
 "seccompiler",
 "serde",
 "serde_json",
- "serde_yaml",
 "serial_test",
 "sha1",
 "sha2",
@@ -1283,7 +1282,6 @@ dependencies = [
 "serde_json",
 "shlex",
 "starlark",
- "tempfile",
 "thiserror 2.0.17",
 ]

@@ -1615,7 +1613,6 @@ dependencies = [
 "textwrap 0.16.2",
 "tokio",
 "tokio-stream",
- "tokio-util",
 "toml",
 "tracing",
 "tracing-appender",
@@ -1625,7 +1622,6 @@ dependencies = [
 "unicode-segmentation",
 "unicode-width 0.2.1",
 "url",
- "uuid",
 "vt100",
 ]

@@ -2541,7 +2537,7 @@ checksum = "0ce92ff622d6dadf7349484f42c93271a0d49b7cc4d466a936405bacbe10aa78"
 dependencies = [
 "cfg-if",
 "rustix 1.0.8",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -3298,9 +3294,9 @@ dependencies = [

 [[package]]
 name = "image"
-version = "0.25.9"
+version = "0.25.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6506c6c10786659413faa717ceebcb8f70731c0a60cbae39795fdf114519c1a"
+checksum = "529feb3e6769d234375c4cf1ee2ce713682b8e76538cb13f9fc23e1400a591e7"
 dependencies = [
 "bytemuck",
 "byteorder-lite",
@@ -3308,8 +3304,8 @@ dependencies = [
 "num-traits",
 "png",
 "tiff",
- "zune-core 0.5.0",
- "zune-jpeg 0.5.5",
+ "zune-core",
+ "zune-jpeg",
 ]

 [[package]]
@@ -3445,7 +3441,7 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9"
 dependencies = [
 "hermit-abi",
 "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -4469,12 +4465,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

-[[package]]
-name = "pastey"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57d6c094ee800037dff99e02cab0eaf3142826586742a270ab3d7a62656bd27a"
-
 [[package]]
 name = "path-absolutize"
 version = "3.1.1"
@@ -5090,9 +5080,9 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

 [[package]]
 name = "reqwest"
-version = "0.12.24"
+version = "0.12.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d0946410b9f7b082a427e4ef5c8ff541a88b357bc6c637c40db3a68ac70a36f"
+checksum = "d429f34c8092b2d42c7c93cec323bb4adeb7c67698f70839adec842ec10c7ceb"
 dependencies = [
 "base64",
 "bytes",
@@ -5153,9 +5143,8 @@ dependencies = [

 [[package]]
 name = "rmcp"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b18323edc657390a6ed4d7a9110b0dec2dc3ed128eb2a123edfbafabdbddc5"
+version = "0.9.0"
+source = "git+https://github.com/bolinfest/rust-sdk?branch=pr556#4d9cc16f4c76c84486344f542ed9a3e9364019ba"
 dependencies = [
 "async-trait",
 "base64",
@@ -5166,7 +5155,7 @@ dependencies = [
 "http-body",
 "http-body-util",
 "oauth2",
- "pastey",
+ "paste",
 "pin-project-lite",
 "process-wrap",
 "rand 0.9.2",
@@ -5188,9 +5177,8 @@ dependencies = [

 [[package]]
 name = "rmcp-macros"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c75d0a62676bf8c8003c4e3c348e2ceb6a7b3e48323681aaf177fdccdac2ce50"
+version = "0.9.0"
+source = "git+https://github.com/bolinfest/rust-sdk?branch=pr556#4d9cc16f4c76c84486344f542ed9a3e9364019ba"
 dependencies = [
 "darling 0.21.3",
 "proc-macro2",
@@ -5230,7 +5218,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys 0.4.15",
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -5749,9 +5737,9 @@ dependencies = [

 [[package]]
 name = "serde_with"
-version = "3.16.1"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7"
+checksum = "f2c45cd61fefa9db6f254525d46e392b852e0e61d9a1fd36e5bd183450a556d5"
 dependencies = [
 "base64",
 "chrono",
@@ -5760,7 +5748,8 @@ dependencies = [
 "indexmap 2.12.0",
 "schemars 0.9.0",
 "schemars 1.0.4",
- "serde_core",
+ "serde",
+ "serde_derive",
 "serde_json",
 "serde_with_macros",
 "time",
@@ -5768,29 +5757,16 @@ dependencies = [

 [[package]]
 name = "serde_with_macros"
-version = "3.16.1"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c"
+checksum = "de90945e6565ce0d9a25098082ed4ee4002e047cb59892c318d66821e14bb30f"
 dependencies = [
- "darling 0.21.3",
+ "darling 0.20.11",
 "proc-macro2",
 "quote",
 "syn 2.0.104",
 ]

-[[package]]
-name = "serde_yaml"
-version = "0.9.34+deprecated"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
-dependencies = [
- "indexmap 2.12.0",
- "itoa",
- "ryu",
- "serde",
- "unsafe-libyaml",
-]
-
 [[package]]
 name = "serial2"
 version = "0.2.31"
@@ -6434,7 +6410,7 @@ dependencies = [
 "half",
 "quick-error",
 "weezl",
- "zune-jpeg 0.4.19",
+ "zune-jpeg",
 ]

 [[package]]
@@ -6602,7 +6578,6 @@ dependencies = [
 "futures-sink",
 "futures-util",
 "pin-project-lite",
- "slab",
 "tokio",
 ]

@@ -6740,9 +6715,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"

 [[package]]
 name = "tracing"
-version = "0.1.43"
+version = "0.1.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
+checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
 dependencies = [
 "log",
 "pin-project-lite",
@@ -6764,9 +6739,9 @@ dependencies = [

 [[package]]
 name = "tracing-attributes"
-version = "0.1.31"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -6775,9 +6750,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.35"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
+checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
 dependencies = [
 "once_cell",
 "valuable",
@@ -7006,12 +6981,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

-[[package]]
-name = "unsafe-libyaml"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
-
 [[package]]
 name = "untrusted"
 version = "0.9.0"
@@ -7401,7 +7370,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.52.0",
 ]

 [[package]]
@@ -8126,28 +8095,13 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f423a2c17029964870cfaabb1f13dfab7d092a62a29a89264f4d36990ca414a"

-[[package]]
-name = "zune-core"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "111f7d9820f05fd715df3144e254d6fc02ee4088b0644c0ffd0efc9e6d9d2773"
-
 [[package]]
 name = "zune-jpeg"
 version = "0.4.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2c9e525af0a6a658e031e95f14b7f889976b74a11ba0eca5a5fc9ac8a1c43a6a"
 dependencies = [
- "zune-core 0.4.12",
-]
-
-[[package]]
-name = "zune-jpeg"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6fb7703e32e9a07fb3f757360338b3a567a5054f21b5f52a666752e333d58e"
-dependencies = [
- "zune-core 0.5.0",
+ "zune-core",
 ]

 [[package]]
--- a/codex-rs/Cargo.toml
+++ b/codex-rs/Cargo.toml
@@ -59,15 +59,15 @@ license = "Apache-2.0"
 # Internal
 app_test_support = { path = "app-server/tests/common" }
 codex-ansi-escape = { path = "ansi-escape" }
-codex-api = { path = "codex-api" }
 codex-app-server = { path = "app-server" }
 codex-app-server-protocol = { path = "app-server-protocol" }
 codex-apply-patch = { path = "apply-patch" }
 codex-arg0 = { path = "arg0" }
 codex-async-utils = { path = "async-utils" }
 codex-backend-client = { path = "backend-client" }
-codex-chatgpt = { path = "chatgpt" }
+codex-api = { path = "codex-api" }
 codex-client = { path = "codex-client" }
+codex-chatgpt = { path = "chatgpt" }
 codex-common = { path = "common" }
 codex-core = { path = "core" }
 codex-exec = { path = "exec" }
@@ -136,7 +136,7 @@ icu_decimal = "2.1"
 icu_locale_core = "2.1"
 icu_provider = { version = "2.1", features = ["sync"] }
 ignore = "0.4.23"
-image = { version = "^0.25.9", default-features = false }
+image = { version = "^0.25.8", default-features = false }
 indexmap = "2.12.0"
 insta = "1.43.2"
 itertools = "0.14.0"
@@ -169,17 +169,16 @@ pulldown-cmark = "0.10"
 rand = "0.9"
 ratatui = "0.29.0"
 ratatui-macros = "0.6.0"
-regex = "1.12.2"
 regex-lite = "0.1.7"
+regex = "1.12.2"
 reqwest = "0.12"
-rmcp = { version = "0.10.0", default-features = false }
+rmcp = { version = "0.9.0", default-features = false }
 schemars = "0.8.22"
 seccompiler = "0.5.0"
 sentry = "0.34.0"
 serde = "1"
 serde_json = "1"
-serde_yaml = "0.9"
-serde_with = "3.16"
+serde_with = "3.14"
 serial_test = "3.2.0"
 sha1 = "0.10.6"
 sha2 = "0.10"
@@ -204,7 +203,7 @@ tokio-util = "0.7.16"
 toml = "0.9.5"
 toml_edit = "0.23.5"
 tonic = "0.13.1"
-tracing = "0.1.43"
+tracing = "0.1.41"
 tracing-appender = "0.2.3"
 tracing-subscriber = "0.3.20"
 tracing-test = "0.2.5"
@@ -289,6 +288,7 @@ opt-level = 0
 # ratatui = { path = "../../ratatui" }
 crossterm = { git = "https://github.com/nornagon/crossterm", branch = "nornagon/color-query" }
 ratatui = { git = "https://github.com/nornagon/ratatui", branch = "nornagon-v0.29.0-patch" }
+rmcp = { git = "https://github.com/bolinfest/rust-sdk", branch = "pr556" }

 # Uncomment to debug local changes.
 # rmcp = { path = "../../rust-sdk/crates/rmcp" }
--- a/codex-rs/app-server-protocol/src/protocol/common.rs
+++ b/codex-rs/app-server-protocol/src/protocol/common.rs
@@ -131,7 +131,7 @@ client_request_definitions! {
    },
    ReviewStart => "review/start" {
        params: v2::ReviewStartParams,
-        response: v2::ReviewStartResponse,
+        response: v2::TurnStartResponse,
    },

    ModelList => "model/list" {
@@ -139,11 +139,6 @@ client_request_definitions! {
        response: v2::ModelListResponse,
    },

-    McpServersList => "mcpServers/list" {
-        params: v2::ListMcpServersParams,
-        response: v2::ListMcpServersResponse,
-    },
-
    LoginAccount => "account/login/start" {
        params: v2::LoginAccountParams,
        response: v2::LoginAccountResponse,
@@ -169,12 +164,6 @@ client_request_definitions! {
        response: v2::FeedbackUploadResponse,
    },

-    /// Execute a command (argv vector) under the server's sandbox.
-    OneOffCommandExec => "command/exec" {
-        params: v2::CommandExecParams,
-        response: v2::CommandExecResponse,
-    },
-
    ConfigRead => "config/read" {
        params: v2::ConfigReadParams,
        response: v2::ConfigReadResponse,
@@ -517,12 +506,10 @@ server_notification_definitions! {
    TurnStarted => "turn/started" (v2::TurnStartedNotification),
    TurnCompleted => "turn/completed" (v2::TurnCompletedNotification),
    TurnDiffUpdated => "turn/diff/updated" (v2::TurnDiffUpdatedNotification),
-    TurnPlanUpdated => "turn/plan/updated" (v2::TurnPlanUpdatedNotification),
    ItemStarted => "item/started" (v2::ItemStartedNotification),
    ItemCompleted => "item/completed" (v2::ItemCompletedNotification),
    AgentMessageDelta => "item/agentMessage/delta" (v2::AgentMessageDeltaNotification),
    CommandExecutionOutputDelta => "item/commandExecution/outputDelta" (v2::CommandExecutionOutputDeltaNotification),
-    FileChangeOutputDelta => "item/fileChange/outputDelta" (v2::FileChangeOutputDeltaNotification),
    McpToolCallProgress => "item/mcpToolCall/progress" (v2::McpToolCallProgressNotification),
    AccountUpdated => "account/updated" (v2::AccountUpdatedNotification),
    AccountRateLimitsUpdated => "account/rateLimits/updated" (v2::AccountRateLimitsUpdatedNotification),
--- a/codex-rs/app-server-protocol/src/protocol/mappers.rs
+++ b/codex-rs/app-server-protocol/src/protocol/mappers.rs
@@ -1,15 +0,0 @@
-use crate::protocol::v1;
-use crate::protocol::v2;
-
-impl From<v1::ExecOneOffCommandParams> for v2::CommandExecParams {
-    fn from(value: v1::ExecOneOffCommandParams) -> Self {
-        Self {
-            command: value.command,
-            timeout_ms: value
-                .timeout_ms
-                .map(|timeout| i64::try_from(timeout).unwrap_or(60_000)),
-            cwd: value.cwd,
-            sandbox_policy: value.sandbox_policy.map(std::convert::Into::into),
-        }
-    }
-}
--- a/codex-rs/app-server-protocol/src/protocol/mod.rs
+++ b/codex-rs/app-server-protocol/src/protocol/mod.rs
@@ -2,7 +2,6 @@
 // Exposes protocol pieces used by `lib.rs` via `pub use protocol::common::*;`.

 pub mod common;
-mod mappers;
 pub mod thread_history;
 pub mod v1;
 pub mod v2;
--- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs
+++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs
@@ -1,6 +1,5 @@
 use crate::protocol::v2::ThreadItem;
 use crate::protocol::v2::Turn;
-use crate::protocol::v2::TurnError;
 use crate::protocol::v2::TurnStatus;
 use crate::protocol::v2::UserInput;
 use codex_protocol::protocol::AgentReasoningEvent;
@@ -143,7 +142,6 @@ impl ThreadHistoryBuilder {
        PendingTurn {
            id: self.next_turn_id(),
            items: Vec::new(),
-            error: None,
            status: TurnStatus::Completed,
        }
    }
@@ -192,7 +190,6 @@ impl ThreadHistoryBuilder {
 struct PendingTurn {
    id: String,
    items: Vec<ThreadItem>,
-    error: Option<TurnError>,
    status: TurnStatus,
 }

@@ -201,7 +198,6 @@ impl From<PendingTurn> for Turn {
        Self {
            id: value.id,
            items: value.items,
-            error: value.error,
            status: value.status,
        }
    }
--- a/codex-rs/app-server-protocol/src/protocol/v1.rs
+++ b/codex-rs/app-server-protocol/src/protocol/v1.rs
@@ -3,11 +3,11 @@ use std::path::PathBuf;

 use codex_protocol::ConversationId;
 use codex_protocol::config_types::ForcedLoginMethod;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::SandboxMode;
 use codex_protocol::config_types::Verbosity;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ReasoningEffort;
 use codex_protocol::parse_command::ParsedCommand;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::EventMsg;
--- a/codex-rs/app-server-protocol/src/protocol/v2.rs
+++ b/codex-rs/app-server-protocol/src/protocol/v2.rs
@@ -2,16 +2,15 @@ use std::collections::HashMap;
 use std::path::PathBuf;

 use crate::protocol::common::AuthMode;
+use codex_protocol::ConversationId;
 use codex_protocol::account::PlanType;
 use codex_protocol::approvals::SandboxCommandAssessment as CoreSandboxCommandAssessment;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::items::AgentMessageContent as CoreAgentMessageContent;
 use codex_protocol::items::TurnItem as CoreTurnItem;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ReasoningEffort;
 use codex_protocol::parse_command::ParsedCommand as CoreParsedCommand;
-use codex_protocol::plan_tool::PlanItemArg as CorePlanItemArg;
-use codex_protocol::plan_tool::StepStatus as CorePlanStepStatus;
 use codex_protocol::protocol::CodexErrorInfo as CoreCodexErrorInfo;
 use codex_protocol::protocol::CreditsSnapshot as CoreCreditsSnapshot;
 use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot;
@@ -21,9 +20,6 @@ use codex_protocol::protocol::TokenUsage as CoreTokenUsage;
 use codex_protocol::protocol::TokenUsageInfo as CoreTokenUsageInfo;
 use codex_protocol::user_input::UserInput as CoreUserInput;
 use mcp_types::ContentBlock as McpContentBlock;
-use mcp_types::Resource as McpResource;
-use mcp_types::ResourceTemplate as McpResourceTemplate;
-use mcp_types::Tool as McpTool;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
@@ -134,21 +130,6 @@ v2_enum_from_core!(
    }
 );

-v2_enum_from_core!(
-    pub enum ReviewDelivery from codex_protocol::protocol::ReviewDelivery {
-        Inline, Detached
-    }
-);
-
-v2_enum_from_core!(
-    pub enum McpAuthStatus from codex_protocol::protocol::McpAuthStatus {
-        Unsupported,
-        NotLoggedIn,
-        BearerToken,
-        OAuth
-    }
-);
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
@@ -209,8 +190,6 @@ pub struct OverriddenMetadata {
 pub struct ConfigWriteResponse {
    pub status: WriteStatus,
    pub version: String,
-    /// Canonical path to the config file that was written.
-    pub file_path: String,
    pub overridden_metadata: Option<OverriddenMetadata>,
 }

@@ -247,11 +226,10 @@ pub struct ConfigReadResponse {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ConfigValueWriteParams {
+    pub file_path: String,
    pub key_path: String,
    pub value: JsonValue,
    pub merge_strategy: MergeStrategy,
-    /// Path to the config file to write; defaults to the user's `config.toml` when omitted.
-    pub file_path: Option<String>,
    pub expected_version: Option<String>,
 }

@@ -259,9 +237,8 @@ pub struct ConfigValueWriteParams {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ConfigBatchWriteParams {
+    pub file_path: String,
    pub edits: Vec<ConfigEdit>,
-    /// Path to the config file to write; defaults to the user's `config.toml` when omitted.
-    pub file_path: Option<String>,
    pub expected_version: Option<String>,
 }

@@ -630,44 +607,13 @@ pub struct ModelListResponse {
    pub next_cursor: Option<String>,
 }

-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct ListMcpServersParams {
-    /// Opaque pagination cursor returned by a previous call.
-    pub cursor: Option<String>,
-    /// Optional page size; defaults to a server-defined value.
-    pub limit: Option<u32>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct McpServer {
-    pub name: String,
-    pub tools: std::collections::HashMap<String, McpTool>,
-    pub resources: Vec<McpResource>,
-    pub resource_templates: Vec<McpResourceTemplate>,
-    pub auth_status: McpAuthStatus,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct ListMcpServersResponse {
-    pub data: Vec<McpServer>,
-    /// Opaque cursor to pass to the next call to continue after the last item.
-    /// If None, there are no more items to return.
-    pub next_cursor: Option<String>,
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct FeedbackUploadParams {
    pub classification: String,
    pub reason: Option<String>,
-    pub thread_id: Option<String>,
+    pub conversation_id: Option<ConversationId>,
    pub include_logs: bool,
 }

@@ -678,26 +624,6 @@ pub struct FeedbackUploadResponse {
    pub thread_id: String,
 }

-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct CommandExecParams {
-    pub command: Vec<String>,
-    #[ts(type = "number | null")]
-    pub timeout_ms: Option<i64>,
-    pub cwd: Option<PathBuf>,
-    pub sandbox_policy: Option<SandboxPolicy>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct CommandExecResponse {
-    pub exit_code: i32,
-    pub stdout: String,
-    pub stderr: String,
-}
-
 // === Threads, Turns, and Items ===
 // Thread APIs
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default, JsonSchema, TS)]
@@ -832,7 +758,6 @@ pub struct Thread {
    /// Model provider used for this thread (for example, 'openai').
    pub model_provider: String,
    /// Unix timestamp (in seconds) when the thread was created.
-    #[ts(type = "number")]
    pub created_at: i64,
    /// [UNSTABLE] Path to the thread on disk.
    pub path: PathBuf,
@@ -923,9 +848,8 @@ pub struct Turn {
    /// For all other responses and notifications returning a Turn,
    /// the items field will be an empty list.
    pub items: Vec<ThreadItem>,
+    #[serde(flatten)]
    pub status: TurnStatus,
-    /// Only populated when the Turn's status is failed.
-    pub error: Option<TurnError>,
 }

 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS, Error)]
@@ -947,12 +871,12 @@ pub struct ErrorNotification {
 }

 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
+#[serde(tag = "status", rename_all = "camelCase")]
+#[ts(tag = "status", export_to = "v2/")]
 pub enum TurnStatus {
    Completed,
    Interrupted,
-    Failed,
+    Failed { error: TurnError },
    InProgress,
 }

@@ -984,22 +908,9 @@ pub struct ReviewStartParams {
    pub thread_id: String,
    pub target: ReviewTarget,

-    /// Where to run the review: inline (default) on the current thread or
-    /// detached on a new thread (returned in `reviewThreadId`).
+    /// When true, also append the final review message to the original thread.
    #[serde(default)]
-    pub delivery: Option<ReviewDelivery>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct ReviewStartResponse {
-    pub turn: Turn,
-    /// Identifies the thread where the review runs.
-    ///
-    /// For inline reviews, this is the original thread id.
-    /// For detached reviews, this is the id of the new review thread.
-    pub review_thread_id: String,
+    pub append_to_original_thread: bool,
 }

 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -1121,7 +1032,6 @@ pub enum ThreadItem {
        /// The command's exit code.
        exit_code: Option<i32>,
        /// The duration of the command execution in milliseconds.
-        #[ts(type = "number | null")]
        duration_ms: Option<i64>,
    },
    #[serde(rename_all = "camelCase")]
@@ -1147,13 +1057,13 @@ pub enum ThreadItem {
    WebSearch { id: String, query: String },
    #[serde(rename_all = "camelCase")]
    #[ts(rename_all = "camelCase")]
+    TodoList { id: String, items: Vec<TodoItem> },
+    #[serde(rename_all = "camelCase")]
+    #[ts(rename_all = "camelCase")]
    ImageView { id: String, path: String },
    #[serde(rename_all = "camelCase")]
    #[ts(rename_all = "camelCase")]
-    EnteredReviewMode { id: String, review: String },
-    #[serde(rename_all = "camelCase")]
-    #[ts(rename_all = "camelCase")]
-    ExitedReviewMode { id: String, review: String },
+    CodeReview { id: String, review: String },
 }

 impl From<CoreTurnItem> for ThreadItem {
@@ -1249,6 +1159,15 @@ pub struct McpToolCallError {
    pub message: String,
 }

+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export_to = "v2/")]
+pub struct TodoItem {
+    pub id: String,
+    pub text: String,
+    pub completed: bool,
+}
+
 // === Server Notifications ===
 // Thread/Turn lifecycle notifications and item progress events
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
@@ -1289,57 +1208,10 @@ pub struct TurnCompletedNotification {
 /// Notification that the turn-level unified diff has changed.
 /// Contains the latest aggregated diff across all file changes in the turn.
 pub struct TurnDiffUpdatedNotification {
-    pub thread_id: String,
    pub turn_id: String,
    pub diff: String,
 }

-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct TurnPlanUpdatedNotification {
-    pub thread_id: String,
-    pub turn_id: String,
-    pub explanation: Option<String>,
-    pub plan: Vec<TurnPlanStep>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct TurnPlanStep {
-    pub step: String,
-    pub status: TurnPlanStepStatus,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub enum TurnPlanStepStatus {
-    Pending,
-    InProgress,
-    Completed,
-}
-
-impl From<CorePlanItemArg> for TurnPlanStep {
-    fn from(value: CorePlanItemArg) -> Self {
-        Self {
-            step: value.step,
-            status: value.status.into(),
-        }
-    }
-}
-
-impl From<CorePlanStepStatus> for TurnPlanStepStatus {
-    fn from(value: CorePlanStepStatus) -> Self {
-        match value {
-            CorePlanStepStatus::Pending => Self::Pending,
-            CorePlanStepStatus::InProgress => Self::InProgress,
-            CorePlanStepStatus::Completed => Self::Completed,
-        }
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
@@ -1363,8 +1235,6 @@ pub struct ItemCompletedNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct AgentMessageDeltaNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
    pub delta: String,
 }
@@ -1373,11 +1243,8 @@ pub struct AgentMessageDeltaNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ReasoningSummaryTextDeltaNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
    pub delta: String,
-    #[ts(type = "number")]
    pub summary_index: i64,
 }

@@ -1385,10 +1252,7 @@ pub struct ReasoningSummaryTextDeltaNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ReasoningSummaryPartAddedNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
-    #[ts(type = "number")]
    pub summary_index: i64,
 }

@@ -1396,11 +1260,8 @@ pub struct ReasoningSummaryPartAddedNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct ReasoningTextDeltaNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
    pub delta: String,
-    #[ts(type = "number")]
    pub content_index: i64,
 }

@@ -1408,18 +1269,6 @@ pub struct ReasoningTextDeltaNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct CommandExecutionOutputDeltaNotification {
-    pub thread_id: String,
-    pub turn_id: String,
-    pub item_id: String,
-    pub delta: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, JsonSchema, TS)]
-#[serde(rename_all = "camelCase")]
-#[ts(export_to = "v2/")]
-pub struct FileChangeOutputDeltaNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
    pub delta: String,
 }
@@ -1428,8 +1277,6 @@ pub struct FileChangeOutputDeltaNotification {
 #[serde(rename_all = "camelCase")]
 #[ts(export_to = "v2/")]
 pub struct McpToolCallProgressNotification {
-    pub thread_id: String,
-    pub turn_id: String,
    pub item_id: String,
    pub message: String,
 }
@@ -1535,9 +1382,7 @@ impl From<CoreRateLimitSnapshot> for RateLimitSnapshot {
 #[ts(export_to = "v2/")]
 pub struct RateLimitWindow {
    pub used_percent: i32,
-    #[ts(type = "number | null")]
    pub window_duration_mins: Option<i64>,
-    #[ts(type = "number | null")]
    pub resets_at: Option<i64>,
 }

--- a/codex-rs/app-server-test-client/src/main.rs
+++ b/codex-rs/app-server-test-client/src/main.rs
@@ -563,9 +563,7 @@ impl CodexClient {
                ServerNotification::TurnCompleted(payload) => {
                    if payload.turn.id == turn_id {
                        println!("\n< turn/completed notification: {:?}", payload.turn.status);
-                        if payload.turn.status == TurnStatus::Failed
-                            && let Some(error) = payload.turn.error
-                        {
+                        if let TurnStatus::Failed { error } = &payload.turn.status {
                            println!("[turn error] {}", error.message);
                        }
                        break;
--- a/codex-rs/app-server/Cargo.toml
+++ b/codex-rs/app-server/Cargo.toml
@@ -31,7 +31,6 @@ chrono = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
-mcp-types = { workspace = true }
 tempfile = { workspace = true }
 toml = { workspace = true }
 tokio = { workspace = true, features = [
--- a/codex-rs/app-server/README.md
+++ b/codex-rs/app-server/README.md
@@ -1,15 +1,15 @@
 # codex-app-server

-`codex app-server` is the interface Codex uses to power rich interfaces such as the [Codex VS Code extension](https://marketplace.visualstudio.com/items?itemName=openai.chatgpt).
+`codex app-server` is the interface Codex uses to power rich interfaces such as the [Codex VS Code extension](https://marketplace.visualstudio.com/items?itemName=openai.chatgpt). The message schema is currently unstable, but those who wish to build experimental UIs on top of Codex may find it valuable.

 ## Table of Contents
 - [Protocol](#protocol)
 - [Message Schema](#message-schema)
- [Core Primitives](#core-primitives)
 - [Lifecycle Overview](#lifecycle-overview)
 - [Initialization](#initialization)
- [API Overview](#api-overview)
- [Events](#events)
+- [Core primitives](#core-primitives)
+- [Thread & turn endpoints](#thread--turn-endpoints)
+- [Events (work-in-progress)](#events-work-in-progress)
 - [Auth endpoints](#auth-endpoints)

 ## Protocol
@@ -25,15 +25,6 @@ codex app-server generate-ts --out DIR
 codex app-server generate-json-schema --out DIR
 ```

-## Core Primitives
-
-The API exposes three top level primitives representing an interaction between a user and Codex:
- **Thread**: A conversation between a user and the Codex agent. Each thread contains multiple turns.
- **Turn**: One turn of the conversation, typically starting with a user message and finishing with an agent message. Each turn contains multiple items.
- **Item**: Represents user inputs and agent outputs as part of the turn, persisted and used as the context for future conversations. Example items include user message, agent reasoning, agent message, shell command, file edit, etc.
-
-Use the thread APIs to create, list, or archive conversations. Drive a conversation with turn APIs and stream progress via turn notifications.
-
 ## Lifecycle Overview

 - Initialize once: Immediately after launching the codex app-server process, send an `initialize` request with your client metadata, then emit an `initialized` notification. Any other request before this handshake gets rejected.
@@ -46,32 +37,37 @@ Use the thread APIs to create, list, or archive conversations. Drive a conversat

 Clients must send a single `initialize` request before invoking any other method, then acknowledge with an `initialized` notification. The server returns the user agent string it will present to upstream services; subsequent requests issued before initialization receive a `"Not initialized"` error, and repeated `initialize` calls receive an `"Already initialized"` error.

-Applications building on top of `codex app-server` should identify themselves via the `clientInfo` parameter.
+Example:

-Example (from OpenAI's official VSCode extension):
 ```json
 { "method": "initialize", "id": 0, "params": {
    "clientInfo": { "name": "codex-vscode", "title": "Codex VS Code Extension", "version": "0.1.0" }
 } }
+{ "id": 0, "result": { "userAgent": "codex-app-server/0.1.0 codex-vscode/0.1.0" } }
+{ "method": "initialized" }
 ```

-## API Overview
+## Core primitives
+
+We have 3 top level primitives:
+- Thread - a conversation between the Codex agent and a user. Each thread contains multiple turns.
+- Turn - one turn of the conversation, typically starting with a user message and finishing with an agent message. Each turn contains multiple items.
+- Item - represents user inputs and agent outputs as part of the turn, persisted and used as the context for future conversations.
+
+## Thread & turn endpoints
+
+The JSON-RPC API exposes dedicated methods for managing Codex conversations. Threads store long-lived conversation metadata, and turns store the per-message exchange (input → Codex output, including streamed items). Use the thread APIs to create, list, or archive sessions, then drive the conversation with turn APIs and notifications.
+
+### Quick reference
 - `thread/start` — create a new thread; emits `thread/started` and auto-subscribes you to turn/item events for that thread.
 - `thread/resume` — reopen an existing thread by id so subsequent `turn/start` calls append to it.
 - `thread/list` — page through stored rollouts; supports cursor-based pagination and optional `modelProviders` filtering.
 - `thread/archive` — move a thread’s rollout file into the archived directory; returns `{}` on success.
 - `turn/start` — add user input to a thread and begin Codex generation; responds with the initial `turn` object and streams `turn/started`, `item/*`, and `turn/completed` notifications.
 - `turn/interrupt` — request cancellation of an in-flight turn by `(thread_id, turn_id)`; success is an empty `{}` response and the turn finishes with `status: "interrupted"`.
- `review/start` — kick off Codex’s automated reviewer for a thread; responds like `turn/start` and emits `item/started`/`item/completed` notifications with `enteredReviewMode` and `exitedReviewMode` items, plus a final assistant `agentMessage` containing the review.
- `command/exec` — run a single command under the server sandbox without starting a thread/turn (handy for utilities and validation).
- `model/list` — list available models (with reasoning effort options).
- `feedback/upload` — submit a feedback report (classification + optional reason/logs and conversation_id); returns the tracking thread id.
- `command/exec` — run a single command under the server sandbox without starting a thread/turn (handy for utilities and validation).
- `config/read` — fetch the effective config on disk after resolving config layering.
- `config/value/write` — write a single config key/value to the user's config.toml on disk.
- `config/batchWrite` — apply multiple config edits atomically to the user's config.toml on disk.
+- `review/start` — kick off Codex’s automated reviewer for a thread; responds like `turn/start` and emits a `item/completed` notification with a `codeReview` item when results are ready.

-### Example: Start or resume a thread
+### 1) Start or resume a thread

 Start a fresh thread when you need a new Codex conversation.

@@ -102,7 +98,7 @@ To continue a stored session, call `thread/resume` with the `thread.id` you prev
 { "id": 11, "result": { "thread": { "id": "thr_123", … } } }
 ```

-### Example: List threads (with pagination & filters)
+### 2) List threads (pagination & filters)

 `thread/list` lets you render a history UI. Pass any combination of:
 - `cursor` — opaque string from a prior response; omit for the first page.
@@ -127,7 +123,7 @@ Example:

 When `nextCursor` is `null`, you’ve reached the final page.

-### Example: Archive a thread
+### 3) Archive a thread

 Use `thread/archive` to move the persisted rollout (stored as a JSONL file on disk) into the archived sessions directory.

@@ -138,7 +134,7 @@ Use `thread/archive` to move the persisted rollout (stored as a JSONL file on di

 An archived thread will not appear in future calls to `thread/list`.

-### Example: Start a turn (send user input)
+### 4) Start a turn (send user input)

 Turns attach user input (text or images) to a thread and trigger Codex generation. The `input` field is a list of discriminated unions:

@@ -172,7 +168,7 @@ You can optionally specify config overrides on the new turn. If specified, these
 } } }
 ```

-### Example: Interrupt an active turn
+### 5) Interrupt an active turn

 You can cancel a running Turn with `turn/interrupt`.

@@ -186,7 +182,7 @@ You can cancel a running Turn with `turn/interrupt`.

 The server requests cancellations for running subprocesses, then emits a `turn/completed` event with `status: "interrupted"`. Rely on the `turn/completed` to know when Codex-side cleanup is done.

-### Example: Request a code review
+### 6) Request a code review

 Use `review/start` to run Codex’s reviewer on the currently checked-out project. The request takes the thread id plus a `target` describing what should be reviewed:

@@ -194,77 +190,51 @@ Use `review/start` to run Codex’s reviewer on the currently checked-out projec
 - `{"type":"baseBranch","branch":"main"}` — diff against the provided branch’s upstream (see prompt for the exact `git merge-base`/`git diff` instructions Codex will run).
 - `{"type":"commit","sha":"abc1234","title":"Optional subject"}` — review a specific commit.
 - `{"type":"custom","instructions":"Free-form reviewer instructions"}` — fallback prompt equivalent to the legacy manual review request.
- `delivery` (`"inline"` or `"detached"`, default `"inline"`) — where the review runs:
-  - `"inline"`: run the review as a new turn on the existing thread. The response’s `reviewThreadId` equals the original `threadId`, and no new `thread/started` notification is emitted.
-  - `"detached"`: fork a new review thread from the parent conversation and run the review there. The response’s `reviewThreadId` is the id of this new review thread, and the server emits a `thread/started` notification for it before streaming review items.
+- `appendToOriginalThread` (bool, default `false`) — when `true`, Codex also records a final assistant-style message with the review summary in the original thread. When `false`, only the `codeReview` item is emitted for the review run and no extra message is added to the original thread.

 Example request/response:

 ```json
 { "method": "review/start", "id": 40, "params": {
    "threadId": "thr_123",
-    "delivery": "inline",
+    "appendToOriginalThread": true,
    "target": { "type": "commit", "sha": "1234567deadbeef", "title": "Polish tui colors" }
 } }
-{ "id": 40, "result": {
-    "turn": {
-        "id": "turn_900",
-        "status": "inProgress",
-        "items": [
-            { "type": "userMessage", "id": "turn_900", "content": [ { "type": "text", "text": "Review commit 1234567: Polish tui colors" } ] }
-        ],
-        "error": null
-    },
-    "reviewThreadId": "thr_123"
-} }
+{ "id": 40, "result": { "turn": {
+    "id": "turn_900",
+    "status": "inProgress",
+    "items": [
+        { "type": "userMessage", "id": "turn_900", "content": [ { "type": "text", "text": "Review commit 1234567: Polish tui colors" } ] }
+    ],
+    "error": null
+} } }
 ```

-For a detached review, use `"delivery": "detached"`. The response is the same shape, but `reviewThreadId` will be the id of the new review thread (different from the original `threadId`). The server also emits a `thread/started` notification for that new thread before streaming the review turn.
-
 Codex streams the usual `turn/started` notification followed by an `item/started`
-with an `enteredReviewMode` item so clients can show progress:
+with the same `codeReview` item id so clients can show progress:

 ```json
 { "method": "item/started", "params": { "item": {
-    "type": "enteredReviewMode",
+    "type": "codeReview",
    "id": "turn_900",
    "review": "current changes"
 } } }
 ```

-When the reviewer finishes, the server emits `item/started` and `item/completed`
-containing an `exitedReviewMode` item with the final review text:
+When the reviewer finishes, the server emits `item/completed` containing the same
+`codeReview` item with the final review text:

 ```json
 { "method": "item/completed", "params": { "item": {
-    "type": "exitedReviewMode",
+    "type": "codeReview",
    "id": "turn_900",
    "review": "Looks solid overall...\n\n- Prefer Stylize helpers — app.rs:10-20\n  ..."
 } } }
 ```

-The `review` string is plain text that already bundles the overall explanation plus a bullet list for each structured finding (matching `ThreadItem::ExitedReviewMode` in the generated schema). Use this notification to render the reviewer output in your client.
+The `review` string is plain text that already bundles the overall explanation plus a bullet list for each structured finding (matching `ThreadItem::CodeReview` in the generated schema). Use this notification to render the reviewer output in your client.

-### Example: One-off command execution
-
-Run a standalone command (argv vector) in the server’s sandbox without creating a thread or turn:
-
-```json
-{ "method": "command/exec", "id": 32, "params": {
-    "command": ["ls", "-la"],
-    "cwd": "/Users/me/project",                    // optional; defaults to server cwd
-    "sandboxPolicy": { "type": "workspaceWrite" }, // optional; defaults to user config
-    "timeoutMs": 10000                             // optional; ms timeout; defaults to server timeout
-} }
-{ "id": 32, "result": { "exitCode": 0, "stdout": "...", "stderr": "" } }
-```
-
-Notes:
- Empty `command` arrays are rejected.
- `sandboxPolicy` accepts the same shape used by `turn/start` (e.g., `dangerFullAccess`, `readOnly`, `workspaceWrite` with flags).
- When omitted, `timeoutMs` falls back to the server default.
-
-## Events
+## Events (work-in-progress)

 Event notifications are the server-initiated event stream for thread lifecycles, turn lifecycles, and the items within them. After you start or resume a thread, keep reading stdout for `thread/started`, `turn/*`, and `item/*` notifications.

@@ -274,12 +244,10 @@ The app-server streams JSON-RPC notifications while a turn is running. Each turn

 - `turn/started` — `{ turn }` with the turn id, empty `items`, and `status: "inProgress"`.
 - `turn/completed` — `{ turn }` where `turn.status` is `completed`, `interrupted`, or `failed`; failures carry `{ error: { message, codexErrorInfo? } }`.
- `turn/diff/updated` — `{ threadId, turnId, diff }` represents the up-to-date snapshot of the turn-level unified diff, emitted after every FileChange item. `diff` is the latest aggregated unified diff across every file change in the turn. UIs can render this to show the full "what changed" view without stitching individual `fileChange` items.
- `turn/plan/updated` — `{ turnId, explanation?, plan }` whenever the agent shares or changes its plan; each `plan` entry is `{ step, status }` with `status` in `pending`, `inProgress`, or `completed`.

 Today both notifications carry an empty `items` array even when item events were streamed; rely on `item/*` notifications for the canonical item list until this is fixed.

-#### Items
+#### Thread items

 `ThreadItem` is the tagged union carried in turn responses and `item/*` notifications. Currently we support events for the following items:
 - `userMessage` — `{id, content}` where `content` is a list of user inputs (`text`, `image`, or `localImage`).
@@ -289,9 +257,6 @@ Today both notifications carry an empty `items` array even when item events were
 - `fileChange` — `{id, changes, status}` describing proposed edits; `changes` list `{path, kind, diff}` and `status` is `inProgress`, `completed`, `failed`, or `declined`.
 - `mcpToolCall` — `{id, server, tool, status, arguments, result?, error?}` describing MCP calls; `status` is `inProgress`, `completed`, or `failed`.
 - `webSearch` — `{id, query}` for a web search request issued by the agent.
- `imageView` — `{id, path}` emitted when the agent invokes the image viewer tool.
- `enteredReviewMode` — `{id, review}` sent when the reviewer starts; `review` is a short user-facing label such as `"current changes"` or the requested target description.
- `exitedReviewMode` — `{id, review}` emitted when the reviewer finishes; `review` is the full plain-text review (usually, overall notes plus bullet point findings).
 - `compacted` - `{threadId, turnId}` when codex compacts the conversation history. This can happen automatically.

 All items emit two shared lifecycle events:
@@ -309,7 +274,7 @@ There are additional item-specific events:
 - `item/commandExecution/outputDelta` — streams stdout/stderr for the command; append deltas in order to render live output alongside `aggregatedOutput` in the final item.
 Final `commandExecution` items include parsed `commandActions`, `status`, `exitCode`, and `durationMs` so the UI can summarize what ran and whether it succeeded.
 #### fileChange
- `item/fileChange/outputDelta` - contains the tool call response of the underlying `apply_patch` tool call.
+`fileChange` items contain a `changes` list with `{path, kind, diff}` entries (`kind` is `add`, `delete`, or `update` with an optional `movePath`). The `status` tracks whether apply succeeded (`completed`), failed, or was `declined`.

 ### Errors
 `error` event is emitted whenever the server hits an error mid-turn (for example, upstream model errors or quota limits). Carries the same `{ error: { message, codexErrorInfo? } }` payload as `turn.status: "failed"` and may precede that terminal notification.
@@ -358,7 +323,7 @@ UI guidance for IDEs: surface an approval dialog as soon as the request arrives.

 The JSON-RPC auth/account surface exposes request/response methods plus server-initiated notifications (no `id`). Use these to determine auth state, start or cancel logins, logout, and inspect ChatGPT rate limits.

-### API Overview
+### Quick reference
 - `account/read` — fetch current account info; optionally refresh tokens.
 - `account/login/start` — begin login (`apiKey` or `chatgpt`).
 - `account/login/completed` (notify) — emitted when a login attempt finishes (success or error).
@@ -443,3 +408,9 @@ Field notes:
 - `usedPercent` is current usage within the OpenAI quota window.
 - `windowDurationMins` is the quota window length.
 - `resetsAt` is a Unix timestamp (seconds) for the next reset.
+
+### Dev notes
+
+- `codex app-server generate-ts --out <dir>` emits v2 types under `v2/`.
+- `codex app-server generate-json-schema --out <dir>` outputs `codex_app_server_protocol.schemas.json`.
+- See [“Authentication and authorization” in the config docs](../../docs/config.md#authentication-and-authorization) for configuration knobs.
--- a/codex-rs/app-server/src/bespoke_event_handling.rs
+++ b/codex-rs/app-server/src/bespoke_event_handling.rs
@@ -18,7 +18,6 @@ use codex_app_server_protocol::ContextCompactedNotification;
 use codex_app_server_protocol::ErrorNotification;
 use codex_app_server_protocol::ExecCommandApprovalParams;
 use codex_app_server_protocol::ExecCommandApprovalResponse;
-use codex_app_server_protocol::FileChangeOutputDeltaNotification;
 use codex_app_server_protocol::FileChangeRequestApprovalParams;
 use codex_app_server_protocol::FileChangeRequestApprovalResponse;
 use codex_app_server_protocol::FileUpdateChange;
@@ -44,8 +43,6 @@ use codex_app_server_protocol::TurnCompletedNotification;
 use codex_app_server_protocol::TurnDiffUpdatedNotification;
 use codex_app_server_protocol::TurnError;
 use codex_app_server_protocol::TurnInterruptResponse;
-use codex_app_server_protocol::TurnPlanStep;
-use codex_app_server_protocol::TurnPlanUpdatedNotification;
 use codex_app_server_protocol::TurnStatus;
 use codex_core::CodexConversation;
 use codex_core::parse_command::shlex_join;
@@ -62,9 +59,7 @@ use codex_core::protocol::ReviewDecision;
 use codex_core::protocol::TokenCountEvent;
 use codex_core::protocol::TurnDiffEvent;
 use codex_core::review_format::format_review_findings_block;
-use codex_core::review_prompts;
 use codex_protocol::ConversationId;
-use codex_protocol::plan_tool::UpdatePlanArgs;
 use codex_protocol::protocol::ReviewOutputEvent;
 use std::collections::HashMap;
 use std::convert::TryFrom;
@@ -179,7 +174,6 @@ pub(crate) async fn apply_bespoke_event_handling(
            cwd,
            reason,
            risk,
-            proposed_execpolicy_amendment: _,
            parsed_cmd,
        }) => match api_version {
            ApiVersion::V1 => {
@@ -263,8 +257,6 @@ pub(crate) async fn apply_bespoke_event_handling(
        }
        EventMsg::AgentMessageContentDelta(event) => {
            let notification = AgentMessageDeltaNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
                item_id: event.item_id,
                delta: event.delta,
            };
@@ -283,8 +275,6 @@ pub(crate) async fn apply_bespoke_event_handling(
        }
        EventMsg::ReasoningContentDelta(event) => {
            let notification = ReasoningSummaryTextDeltaNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
                item_id: event.item_id,
                delta: event.delta,
                summary_index: event.summary_index,
@@ -297,8 +287,6 @@ pub(crate) async fn apply_bespoke_event_handling(
        }
        EventMsg::ReasoningRawContentDelta(event) => {
            let notification = ReasoningTextDeltaNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
                item_id: event.item_id,
                delta: event.delta,
                content_index: event.content_index,
@@ -309,8 +297,6 @@ pub(crate) async fn apply_bespoke_event_handling(
        }
        EventMsg::AgentReasoningSectionBreak(event) => {
            let notification = ReasoningSummaryPartAddedNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
                item_id: event.item_id,
                summary_index: event.summary_index,
            };
@@ -353,51 +339,17 @@ pub(crate) async fn apply_bespoke_event_handling(
                }))
                .await;
        }
-        EventMsg::ViewImageToolCall(view_image_event) => {
-            let item = ThreadItem::ImageView {
-                id: view_image_event.call_id.clone(),
-                path: view_image_event.path.to_string_lossy().into_owned(),
-            };
-            let started = ItemStartedNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
-                item: item.clone(),
-            };
-            outgoing
-                .send_server_notification(ServerNotification::ItemStarted(started))
-                .await;
-            let completed = ItemCompletedNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
-                item,
-            };
-            outgoing
-                .send_server_notification(ServerNotification::ItemCompleted(completed))
-                .await;
-        }
        EventMsg::EnteredReviewMode(review_request) => {
-            let review = review_request
-                .user_facing_hint
-                .unwrap_or_else(|| review_prompts::user_facing_hint(&review_request.target));
-            let item = ThreadItem::EnteredReviewMode {
-                id: event_turn_id.clone(),
-                review,
-            };
-            let started = ItemStartedNotification {
+            let notification = ItemStartedNotification {
                thread_id: conversation_id.to_string(),
                turn_id: event_turn_id.clone(),
-                item: item.clone(),
+                item: ThreadItem::CodeReview {
+                    id: event_turn_id.clone(),
+                    review: review_request.user_facing_hint,
+                },
            };
            outgoing
-                .send_server_notification(ServerNotification::ItemStarted(started))
-                .await;
-            let completed = ItemCompletedNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
-                item,
-            };
-            outgoing
-                .send_server_notification(ServerNotification::ItemCompleted(completed))
+                .send_server_notification(ServerNotification::ItemStarted(notification))
                .await;
        }
        EventMsg::ItemStarted(item_started_event) => {
@@ -423,29 +375,21 @@ pub(crate) async fn apply_bespoke_event_handling(
                .await;
        }
        EventMsg::ExitedReviewMode(review_event) => {
-            let review = match review_event.review_output {
+            let review_text = match review_event.review_output {
                Some(output) => render_review_output_text(&output),
                None => REVIEW_FALLBACK_MESSAGE.to_string(),
            };
-            let item = ThreadItem::ExitedReviewMode {
-                id: event_turn_id.clone(),
-                review,
-            };
-            let started = ItemStartedNotification {
+            let review_item_id = event_turn_id.clone();
+            let notification = ItemCompletedNotification {
                thread_id: conversation_id.to_string(),
                turn_id: event_turn_id.clone(),
-                item: item.clone(),
+                item: ThreadItem::CodeReview {
+                    id: review_item_id,
+                    review: review_text,
+                },
            };
            outgoing
-                .send_server_notification(ServerNotification::ItemStarted(started))
-                .await;
-            let completed = ItemCompletedNotification {
-                thread_id: conversation_id.to_string(),
-                turn_id: event_turn_id.clone(),
-                item,
-            };
-            outgoing
-                .send_server_notification(ServerNotification::ItemCompleted(completed))
+                .send_server_notification(ServerNotification::ItemCompleted(notification))
                .await;
        }
        EventMsg::PatchApplyBegin(patch_begin_event) => {
@@ -528,44 +472,15 @@ pub(crate) async fn apply_bespoke_event_handling(
                .await;
        }
        EventMsg::ExecCommandOutputDelta(exec_command_output_delta_event) => {
-            let item_id = exec_command_output_delta_event.call_id.clone();
-            let delta = String::from_utf8_lossy(&exec_command_output_delta_event.chunk).to_string();
-            // The underlying EventMsg::ExecCommandOutputDelta is used for shell, unified_exec,
-            // and apply_patch tool calls. We represent apply_patch with the FileChange item, and
-            // everything else with the CommandExecution item.
-            //
-            // We need to detect which item type it is so we can emit the right notification.
-            // We already have state tracking FileChange items on item/started, so let's use that.
-            let is_file_change = {
-                let map = turn_summary_store.lock().await;
-                map.get(&conversation_id)
-                    .is_some_and(|summary| summary.file_change_started.contains(&item_id))
+            let notification = CommandExecutionOutputDeltaNotification {
+                item_id: exec_command_output_delta_event.call_id.clone(),
+                delta: String::from_utf8_lossy(&exec_command_output_delta_event.chunk).to_string(),
            };
-            if is_file_change {
-                let notification = FileChangeOutputDeltaNotification {
-                    thread_id: conversation_id.to_string(),
-                    turn_id: event_turn_id.clone(),
-                    item_id,
-                    delta,
-                };
-                outgoing
-                    .send_server_notification(ServerNotification::FileChangeOutputDelta(
-                        notification,
-                    ))
-                    .await;
-            } else {
-                let notification = CommandExecutionOutputDeltaNotification {
-                    thread_id: conversation_id.to_string(),
-                    turn_id: event_turn_id.clone(),
-                    item_id,
-                    delta,
-                };
-                outgoing
-                    .send_server_notification(ServerNotification::CommandExecutionOutputDelta(
-                        notification,
-                    ))
-                    .await;
-            }
+            outgoing
+                .send_server_notification(ServerNotification::CommandExecutionOutputDelta(
+                    notification,
+                ))
+                .await;
        }
        EventMsg::ExecCommandEnd(exec_command_end_event) => {
            let ExecCommandEndEvent {
@@ -652,7 +567,6 @@ pub(crate) async fn apply_bespoke_event_handling(
        }
        EventMsg::TurnDiff(turn_diff_event) => {
            handle_turn_diff(
-                conversation_id,
                &event_turn_id,
                turn_diff_event,
                api_version,
@@ -660,23 +574,12 @@ pub(crate) async fn apply_bespoke_event_handling(
            )
            .await;
        }
-        EventMsg::PlanUpdate(plan_update_event) => {
-            handle_turn_plan_update(
-                conversation_id,
-                &event_turn_id,
-                plan_update_event,
-                api_version,
-                outgoing.as_ref(),
-            )
-            .await;
-        }

        _ => {}
    }
 }

 async fn handle_turn_diff(
-    conversation_id: ConversationId,
    event_turn_id: &str,
    turn_diff_event: TurnDiffEvent,
    api_version: ApiVersion,
@@ -684,7 +587,6 @@ async fn handle_turn_diff(
 ) {
    if let ApiVersion::V2 = api_version {
        let notification = TurnDiffUpdatedNotification {
-            thread_id: conversation_id.to_string(),
            turn_id: event_turn_id.to_string(),
            diff: turn_diff_event.unified_diff,
        };
@@ -694,35 +596,10 @@ async fn handle_turn_diff(
    }
 }

-async fn handle_turn_plan_update(
-    conversation_id: ConversationId,
-    event_turn_id: &str,
-    plan_update_event: UpdatePlanArgs,
-    api_version: ApiVersion,
-    outgoing: &OutgoingMessageSender,
-) {
-    if let ApiVersion::V2 = api_version {
-        let notification = TurnPlanUpdatedNotification {
-            thread_id: conversation_id.to_string(),
-            turn_id: event_turn_id.to_string(),
-            explanation: plan_update_event.explanation,
-            plan: plan_update_event
-                .plan
-                .into_iter()
-                .map(TurnPlanStep::from)
-                .collect(),
-        };
-        outgoing
-            .send_server_notification(ServerNotification::TurnPlanUpdated(notification))
-            .await;
-    }
-}
-
 async fn emit_turn_completed_with_status(
    conversation_id: ConversationId,
    event_turn_id: String,
    status: TurnStatus,
-    error: Option<TurnError>,
    outgoing: &OutgoingMessageSender,
 ) {
    let notification = TurnCompletedNotification {
@@ -730,7 +607,6 @@ async fn emit_turn_completed_with_status(
        turn: Turn {
            id: event_turn_id,
            items: vec![],
-            error,
            status,
        },
    };
@@ -819,12 +695,13 @@ async fn handle_turn_complete(
 ) {
    let turn_summary = find_and_remove_turn_summary(conversation_id, turn_summary_store).await;

-    let (status, error) = match turn_summary.last_error {
-        Some(error) => (TurnStatus::Failed, Some(error)),
-        None => (TurnStatus::Completed, None),
+    let status = if let Some(error) = turn_summary.last_error {
+        TurnStatus::Failed { error }
+    } else {
+        TurnStatus::Completed
    };

-    emit_turn_completed_with_status(conversation_id, event_turn_id, status, error, outgoing).await;
+    emit_turn_completed_with_status(conversation_id, event_turn_id, status, outgoing).await;
 }

 async fn handle_turn_interrupted(
@@ -839,7 +716,6 @@ async fn handle_turn_interrupted(
        conversation_id,
        event_turn_id,
        TurnStatus::Interrupted,
-        None,
        outgoing,
    )
    .await;
@@ -1239,15 +1115,12 @@ mod tests {
    use anyhow::Result;
    use anyhow::anyhow;
    use anyhow::bail;
-    use codex_app_server_protocol::TurnPlanStepStatus;
    use codex_core::protocol::CreditsSnapshot;
    use codex_core::protocol::McpInvocation;
    use codex_core::protocol::RateLimitSnapshot;
    use codex_core::protocol::RateLimitWindow;
    use codex_core::protocol::TokenUsage;
    use codex_core::protocol::TokenUsageInfo;
-    use codex_protocol::plan_tool::PlanItemArg;
-    use codex_protocol::plan_tool::StepStatus;
    use mcp_types::CallToolResult;
    use mcp_types::ContentBlock;
    use mcp_types::TextContent;
@@ -1312,7 +1185,6 @@ mod tests {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, event_turn_id);
                assert_eq!(n.turn.status, TurnStatus::Completed);
-                assert_eq!(n.turn.error, None);
            }
            other => bail!("unexpected message: {other:?}"),
        }
@@ -1353,7 +1225,6 @@ mod tests {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, event_turn_id);
                assert_eq!(n.turn.status, TurnStatus::Interrupted);
-                assert_eq!(n.turn.error, None);
            }
            other => bail!("unexpected message: {other:?}"),
        }
@@ -1393,13 +1264,14 @@ mod tests {
        match msg {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, event_turn_id);
-                assert_eq!(n.turn.status, TurnStatus::Failed);
                assert_eq!(
-                    n.turn.error,
-                    Some(TurnError {
-                        message: "bad".to_string(),
-                        codex_error_info: Some(V2CodexErrorInfo::Other),
-                    })
+                    n.turn.status,
+                    TurnStatus::Failed {
+                        error: TurnError {
+                            message: "bad".to_string(),
+                            codex_error_info: Some(V2CodexErrorInfo::Other),
+                        }
+                    }
                );
            }
            other => bail!("unexpected message: {other:?}"),
@@ -1408,56 +1280,6 @@ mod tests {
        Ok(())
    }

-    #[tokio::test]
-    async fn test_handle_turn_plan_update_emits_notification_for_v2() -> Result<()> {
-        let (tx, mut rx) = mpsc::channel(CHANNEL_CAPACITY);
-        let outgoing = OutgoingMessageSender::new(tx);
-        let update = UpdatePlanArgs {
-            explanation: Some("need plan".to_string()),
-            plan: vec![
-                PlanItemArg {
-                    step: "first".to_string(),
-                    status: StepStatus::Pending,
-                },
-                PlanItemArg {
-                    step: "second".to_string(),
-                    status: StepStatus::Completed,
-                },
-            ],
-        };
-
-        let conversation_id = ConversationId::new();
-
-        handle_turn_plan_update(
-            conversation_id,
-            "turn-123",
-            update,
-            ApiVersion::V2,
-            &outgoing,
-        )
-        .await;
-
-        let msg = rx
-            .recv()
-            .await
-            .ok_or_else(|| anyhow!("should send one notification"))?;
-        match msg {
-            OutgoingMessage::AppServerNotification(ServerNotification::TurnPlanUpdated(n)) => {
-                assert_eq!(n.thread_id, conversation_id.to_string());
-                assert_eq!(n.turn_id, "turn-123");
-                assert_eq!(n.explanation.as_deref(), Some("need plan"));
-                assert_eq!(n.plan.len(), 2);
-                assert_eq!(n.plan[0].step, "first");
-                assert_eq!(n.plan[0].status, TurnPlanStepStatus::Pending);
-                assert_eq!(n.plan[1].step, "second");
-                assert_eq!(n.plan[1].status, TurnPlanStepStatus::Completed);
-            }
-            other => bail!("unexpected message: {other:?}"),
-        }
-        assert!(rx.try_recv().is_err(), "no extra messages expected");
-        Ok(())
-    }
-
    #[tokio::test]
    async fn test_handle_token_count_event_emits_usage_and_rate_limits() -> Result<()> {
        let conversation_id = ConversationId::new();
@@ -1670,13 +1492,14 @@ mod tests {
        match msg {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, a_turn1);
-                assert_eq!(n.turn.status, TurnStatus::Failed);
                assert_eq!(
-                    n.turn.error,
-                    Some(TurnError {
-                        message: "a1".to_string(),
-                        codex_error_info: Some(V2CodexErrorInfo::BadRequest),
-                    })
+                    n.turn.status,
+                    TurnStatus::Failed {
+                        error: TurnError {
+                            message: "a1".to_string(),
+                            codex_error_info: Some(V2CodexErrorInfo::BadRequest),
+                        }
+                    }
                );
            }
            other => bail!("unexpected message: {other:?}"),
@@ -1690,13 +1513,14 @@ mod tests {
        match msg {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, b_turn1);
-                assert_eq!(n.turn.status, TurnStatus::Failed);
                assert_eq!(
-                    n.turn.error,
-                    Some(TurnError {
-                        message: "b1".to_string(),
-                        codex_error_info: None,
-                    })
+                    n.turn.status,
+                    TurnStatus::Failed {
+                        error: TurnError {
+                            message: "b1".to_string(),
+                            codex_error_info: None,
+                        }
+                    }
                );
            }
            other => bail!("unexpected message: {other:?}"),
@@ -1711,7 +1535,6 @@ mod tests {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnCompleted(n)) => {
                assert_eq!(n.turn.id, a_turn2);
                assert_eq!(n.turn.status, TurnStatus::Completed);
-                assert_eq!(n.turn.error, None);
            }
            other => bail!("unexpected message: {other:?}"),
        }
@@ -1856,10 +1679,8 @@ mod tests {
        let (tx, mut rx) = mpsc::channel(CHANNEL_CAPACITY);
        let outgoing = OutgoingMessageSender::new(tx);
        let unified_diff = "--- a\n+++ b\n".to_string();
-        let conversation_id = ConversationId::new();

        handle_turn_diff(
-            conversation_id,
            "turn-1",
            TurnDiffEvent {
                unified_diff: unified_diff.clone(),
@@ -1877,7 +1698,6 @@ mod tests {
            OutgoingMessage::AppServerNotification(ServerNotification::TurnDiffUpdated(
                notification,
            )) => {
-                assert_eq!(notification.thread_id, conversation_id.to_string());
                assert_eq!(notification.turn_id, "turn-1");
                assert_eq!(notification.diff, unified_diff);
            }
@@ -1891,10 +1711,8 @@ mod tests {
    async fn test_handle_turn_diff_is_noop_for_v1() -> Result<()> {
        let (tx, mut rx) = mpsc::channel(CHANNEL_CAPACITY);
        let outgoing = OutgoingMessageSender::new(tx);
-        let conversation_id = ConversationId::new();

        handle_turn_diff(
-            conversation_id,
            "turn-1",
            TurnDiffEvent {
                unified_diff: "diff".to_string(),
--- a/codex-rs/app-server/src/codex_message_processor.rs
+++ b/codex-rs/app-server/src/codex_message_processor.rs
@@ -21,9 +21,9 @@ use codex_app_server_protocol::CancelLoginAccountParams;
 use codex_app_server_protocol::CancelLoginAccountResponse;
 use codex_app_server_protocol::CancelLoginChatGptResponse;
 use codex_app_server_protocol::ClientRequest;
-use codex_app_server_protocol::CommandExecParams;
 use codex_app_server_protocol::ConversationGitInfo;
 use codex_app_server_protocol::ConversationSummary;
+use codex_app_server_protocol::ExecOneOffCommandParams;
 use codex_app_server_protocol::ExecOneOffCommandResponse;
 use codex_app_server_protocol::FeedbackUploadParams;
 use codex_app_server_protocol::FeedbackUploadResponse;
@@ -45,8 +45,6 @@ use codex_app_server_protocol::InterruptConversationParams;
 use codex_app_server_protocol::JSONRPCErrorError;
 use codex_app_server_protocol::ListConversationsParams;
 use codex_app_server_protocol::ListConversationsResponse;
-use codex_app_server_protocol::ListMcpServersParams;
-use codex_app_server_protocol::ListMcpServersResponse;
 use codex_app_server_protocol::LoginAccountParams;
 use codex_app_server_protocol::LoginApiKeyParams;
 use codex_app_server_protocol::LoginApiKeyResponse;
@@ -54,7 +52,6 @@ use codex_app_server_protocol::LoginChatGptCompleteNotification;
 use codex_app_server_protocol::LoginChatGptResponse;
 use codex_app_server_protocol::LogoutAccountResponse;
 use codex_app_server_protocol::LogoutChatGptResponse;
-use codex_app_server_protocol::McpServer;
 use codex_app_server_protocol::ModelListParams;
 use codex_app_server_protocol::ModelListResponse;
 use codex_app_server_protocol::NewConversationParams;
@@ -64,10 +61,8 @@ use codex_app_server_protocol::RemoveConversationSubscriptionResponse;
 use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::ResumeConversationParams;
 use codex_app_server_protocol::ResumeConversationResponse;
-use codex_app_server_protocol::ReviewDelivery as ApiReviewDelivery;
 use codex_app_server_protocol::ReviewStartParams;
-use codex_app_server_protocol::ReviewStartResponse;
-use codex_app_server_protocol::ReviewTarget as ApiReviewTarget;
+use codex_app_server_protocol::ReviewTarget;
 use codex_app_server_protocol::SandboxMode;
 use codex_app_server_protocol::SendUserMessageParams;
 use codex_app_server_protocol::SendUserMessageResponse;
@@ -122,14 +117,10 @@ use codex_core::exec_env::create_env;
 use codex_core::features::Feature;
 use codex_core::find_conversation_path_by_id_str;
 use codex_core::git_info::git_diff_to_remote;
-use codex_core::mcp::collect_mcp_snapshot;
-use codex_core::mcp::group_tools_by_server;
 use codex_core::parse_cursor;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::Op;
-use codex_core::protocol::ReviewDelivery as CoreReviewDelivery;
 use codex_core::protocol::ReviewRequest;
-use codex_core::protocol::ReviewTarget as CoreReviewTarget;
 use codex_core::protocol::SessionConfiguredEvent;
 use codex_core::read_head_for_summary;
 use codex_feedback::CodexFeedback;
@@ -141,7 +132,6 @@ use codex_protocol::config_types::ForcedLoginMethod;
 use codex_protocol::items::TurnItem;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::GitInfo as CoreGitInfo;
-use codex_protocol::protocol::McpAuthStatus as CoreMcpAuthStatus;
 use codex_protocol::protocol::RateLimitSnapshot as CoreRateLimitSnapshot;
 use codex_protocol::protocol::RolloutItem;
 use codex_protocol::protocol::SessionMetaLine;
@@ -262,7 +252,8 @@ impl CodexMessageProcessor {
    }

    fn review_request_from_target(
-        target: ApiReviewTarget,
+        target: ReviewTarget,
+        append_to_original_thread: bool,
    ) -> Result<(ReviewRequest, String), JSONRPCErrorError> {
        fn invalid_request(message: String) -> JSONRPCErrorError {
            JSONRPCErrorError {
@@ -272,52 +263,77 @@ impl CodexMessageProcessor {
            }
        }

-        let cleaned_target = match target {
-            ApiReviewTarget::UncommittedChanges => ApiReviewTarget::UncommittedChanges,
-            ApiReviewTarget::BaseBranch { branch } => {
+        match target {
+            // TODO(jif) those messages will be extracted in a follow-up PR.
+            ReviewTarget::UncommittedChanges => Ok((
+                ReviewRequest {
+                    prompt: "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.".to_string(),
+                    user_facing_hint: "current changes".to_string(),
+                    append_to_original_thread,
+                },
+                "Review uncommitted changes".to_string(),
+            )),
+            ReviewTarget::BaseBranch { branch } => {
                let branch = branch.trim().to_string();
                if branch.is_empty() {
                    return Err(invalid_request("branch must not be empty".to_string()));
                }
-                ApiReviewTarget::BaseBranch { branch }
+                let prompt = format!("Review the code changes against the base branch '{branch}'. Start by finding the merge diff between the current branch and {branch}'s upstream e.g. (`git merge-base HEAD \"$(git rev-parse --abbrev-ref \"{branch}@{{upstream}}\")\"`), then run `git diff` against that SHA to see what changes we would merge into the {branch} branch. Provide prioritized, actionable findings.");
+                let hint = format!("changes against '{branch}'");
+                let display = format!("Review changes against base branch '{branch}'");
+                Ok((
+                    ReviewRequest {
+                        prompt,
+                        user_facing_hint: hint,
+                        append_to_original_thread,
+                    },
+                    display,
+                ))
            }
-            ApiReviewTarget::Commit { sha, title } => {
+            ReviewTarget::Commit { sha, title } => {
                let sha = sha.trim().to_string();
                if sha.is_empty() {
                    return Err(invalid_request("sha must not be empty".to_string()));
                }
-                let title = title
+                let brief_title = title
                    .map(|t| t.trim().to_string())
                    .filter(|t| !t.is_empty());
-                ApiReviewTarget::Commit { sha, title }
+                let prompt = if let Some(title) = brief_title.clone() {
+                    format!("Review the code changes introduced by commit {sha} (\"{title}\"). Provide prioritized, actionable findings.")
+                } else {
+                    format!("Review the code changes introduced by commit {sha}. Provide prioritized, actionable findings.")
+                };
+                let short_sha = sha.chars().take(7).collect::<String>();
+                let hint = format!("commit {short_sha}");
+                let display = if let Some(title) = brief_title {
+                    format!("Review commit {short_sha}: {title}")
+                } else {
+                    format!("Review commit {short_sha}")
+                };
+                Ok((
+                    ReviewRequest {
+                        prompt,
+                        user_facing_hint: hint,
+                        append_to_original_thread,
+                    },
+                    display,
+                ))
            }
-            ApiReviewTarget::Custom { instructions } => {
+            ReviewTarget::Custom { instructions } => {
                let trimmed = instructions.trim().to_string();
                if trimmed.is_empty() {
-                    return Err(invalid_request(
-                        "instructions must not be empty".to_string(),
-                    ));
-                }
-                ApiReviewTarget::Custom {
-                    instructions: trimmed,
+                    return Err(invalid_request("instructions must not be empty".to_string()));
                }
+                Ok((
+                    ReviewRequest {
+                        prompt: trimmed.clone(),
+                        user_facing_hint: trimmed.clone(),
+                        append_to_original_thread,
+                    },
+                    trimmed,
+                ))
            }
-        };
-
-        let core_target = match cleaned_target {
-            ApiReviewTarget::UncommittedChanges => CoreReviewTarget::UncommittedChanges,
-            ApiReviewTarget::BaseBranch { branch } => CoreReviewTarget::BaseBranch { branch },
-            ApiReviewTarget::Commit { sha, title } => CoreReviewTarget::Commit { sha, title },
-            ApiReviewTarget::Custom { instructions } => CoreReviewTarget::Custom { instructions },
-        };
-
-        let hint = codex_core::review_prompts::user_facing_hint(&core_target);
-        let review_request = ReviewRequest {
-            target: core_target,
-            user_facing_hint: Some(hint.clone()),
-        };
-
-        Ok((review_request, hint))
+        }
    }

    pub async fn process_request(&mut self, request: ClientRequest) {
@@ -369,9 +385,6 @@ impl CodexMessageProcessor {
            ClientRequest::ModelList { request_id, params } => {
                self.list_models(request_id, params).await;
            }
-            ClientRequest::McpServersList { request_id, params } => {
-                self.list_mcp_servers(request_id, params).await;
-            }
            ClientRequest::LoginAccount { request_id, params } => {
                self.login_v2(request_id, params).await;
            }
@@ -456,11 +469,8 @@ impl CodexMessageProcessor {
            ClientRequest::FuzzyFileSearch { request_id, params } => {
                self.fuzzy_file_search(request_id, params).await;
            }
-            ClientRequest::OneOffCommandExec { request_id, params } => {
-                self.exec_one_off_command(request_id, params).await;
-            }
            ClientRequest::ExecOneOffCommand { request_id, params } => {
-                self.exec_one_off_command(request_id, params.into()).await;
+                self.exec_one_off_command(request_id, params).await;
            }
            ClientRequest::ConfigRead { .. }
            | ClientRequest::ConfigValueWrite { .. }
@@ -1146,7 +1156,7 @@ impl CodexMessageProcessor {
        }
    }

-    async fn exec_one_off_command(&self, request_id: RequestId, params: CommandExecParams) {
+    async fn exec_one_off_command(&self, request_id: RequestId, params: ExecOneOffCommandParams) {
        tracing::debug!("ExecOneOffCommand params: {params:?}");

        if params.command.is_empty() {
@@ -1161,9 +1171,7 @@ impl CodexMessageProcessor {

        let cwd = params.cwd.unwrap_or_else(|| self.config.cwd.clone());
        let env = create_env(&self.config.shell_environment_policy);
-        let timeout_ms = params
-            .timeout_ms
-            .and_then(|timeout_ms| u64::try_from(timeout_ms).ok());
+        let timeout_ms = params.timeout_ms;
        let exec_params = ExecParams {
            command: params.command,
            cwd,
@@ -1176,7 +1184,6 @@ impl CodexMessageProcessor {

        let effective_policy = params
            .sandbox_policy
-            .map(|policy| policy.to_core())
            .unwrap_or_else(|| self.config.sandbox_policy.clone());

        let codex_linux_sandbox_exe = self.config.codex_linux_sandbox_exe.clone();
@@ -1862,7 +1869,8 @@ impl CodexMessageProcessor {

    async fn list_models(&self, request_id: RequestId, params: ModelListParams) {
        let ModelListParams { limit, cursor } = params;
-        let models = supported_models(self.conversation_manager.clone()).await;
+        let auth_mode = self.auth_manager.auth().map(|auth| auth.mode);
+        let models = supported_models(auth_mode);
        let total = models.len();

        if total == 0 {
@@ -1916,85 +1924,6 @@ impl CodexMessageProcessor {
        self.outgoing.send_response(request_id, response).await;
    }

-    async fn list_mcp_servers(&self, request_id: RequestId, params: ListMcpServersParams) {
-        let snapshot = collect_mcp_snapshot(self.config.as_ref()).await;
-
-        let tools_by_server = group_tools_by_server(&snapshot.tools);
-
-        let mut server_names: Vec<String> = self
-            .config
-            .mcp_servers
-            .keys()
-            .cloned()
-            .chain(snapshot.auth_statuses.keys().cloned())
-            .chain(snapshot.resources.keys().cloned())
-            .chain(snapshot.resource_templates.keys().cloned())
-            .collect();
-        server_names.sort();
-        server_names.dedup();
-
-        let total = server_names.len();
-        let limit = params.limit.unwrap_or(total as u32).max(1) as usize;
-        let effective_limit = limit.min(total);
-        let start = match params.cursor {
-            Some(cursor) => match cursor.parse::<usize>() {
-                Ok(idx) => idx,
-                Err(_) => {
-                    let error = JSONRPCErrorError {
-                        code: INVALID_REQUEST_ERROR_CODE,
-                        message: format!("invalid cursor: {cursor}"),
-                        data: None,
-                    };
-                    self.outgoing.send_error(request_id, error).await;
-                    return;
-                }
-            },
-            None => 0,
-        };
-
-        if start > total {
-            let error = JSONRPCErrorError {
-                code: INVALID_REQUEST_ERROR_CODE,
-                message: format!("cursor {start} exceeds total MCP servers {total}"),
-                data: None,
-            };
-            self.outgoing.send_error(request_id, error).await;
-            return;
-        }
-
-        let end = start.saturating_add(effective_limit).min(total);
-
-        let data: Vec<McpServer> = server_names[start..end]
-            .iter()
-            .map(|name| McpServer {
-                name: name.clone(),
-                tools: tools_by_server.get(name).cloned().unwrap_or_default(),
-                resources: snapshot.resources.get(name).cloned().unwrap_or_default(),
-                resource_templates: snapshot
-                    .resource_templates
-                    .get(name)
-                    .cloned()
-                    .unwrap_or_default(),
-                auth_status: snapshot
-                    .auth_statuses
-                    .get(name)
-                    .cloned()
-                    .unwrap_or(CoreMcpAuthStatus::Unsupported)
-                    .into(),
-            })
-            .collect();
-
-        let next_cursor = if end < total {
-            Some(end.to_string())
-        } else {
-            None
-        };
-
-        let response = ListMcpServersResponse { data, next_cursor };
-
-        self.outgoing.send_response(request_id, response).await;
-    }
-
    async fn handle_resume_conversation(
        &self,
        request_id: RequestId,
@@ -2542,7 +2471,6 @@ impl CodexMessageProcessor {
                let turn = Turn {
                    id: turn_id.clone(),
                    items: vec![],
-                    error: None,
                    status: TurnStatus::InProgress,
                };

@@ -2569,221 +2497,60 @@ impl CodexMessageProcessor {
        }
    }

-    fn build_review_turn(turn_id: String, display_text: &str) -> Turn {
-        let items = if display_text.is_empty() {
-            Vec::new()
-        } else {
-            vec![ThreadItem::UserMessage {
-                id: turn_id.clone(),
-                content: vec![V2UserInput::Text {
-                    text: display_text.to_string(),
-                }],
-            }]
-        };
-
-        Turn {
-            id: turn_id,
-            items,
-            error: None,
-            status: TurnStatus::InProgress,
-        }
-    }
-
-    async fn emit_review_started(
-        &self,
-        request_id: &RequestId,
-        turn: Turn,
-        parent_thread_id: String,
-        review_thread_id: String,
-    ) {
-        let response = ReviewStartResponse {
-            turn: turn.clone(),
-            review_thread_id,
-        };
-        self.outgoing
-            .send_response(request_id.clone(), response)
-            .await;
-
-        let notif = TurnStartedNotification {
-            thread_id: parent_thread_id,
-            turn,
-        };
-        self.outgoing
-            .send_server_notification(ServerNotification::TurnStarted(notif))
-            .await;
-    }
-
-    async fn start_inline_review(
-        &self,
-        request_id: &RequestId,
-        parent_conversation: Arc<CodexConversation>,
-        review_request: ReviewRequest,
-        display_text: &str,
-        parent_thread_id: String,
-    ) -> std::result::Result<(), JSONRPCErrorError> {
-        let turn_id = parent_conversation
-            .submit(Op::Review { review_request })
-            .await;
-
-        match turn_id {
-            Ok(turn_id) => {
-                let turn = Self::build_review_turn(turn_id, display_text);
-                self.emit_review_started(
-                    request_id,
-                    turn,
-                    parent_thread_id.clone(),
-                    parent_thread_id,
-                )
-                .await;
-                Ok(())
-            }
-            Err(err) => Err(JSONRPCErrorError {
-                code: INTERNAL_ERROR_CODE,
-                message: format!("failed to start review: {err}"),
-                data: None,
-            }),
-        }
-    }
-
-    async fn start_detached_review(
-        &mut self,
-        request_id: &RequestId,
-        parent_conversation_id: ConversationId,
-        review_request: ReviewRequest,
-        display_text: &str,
-    ) -> std::result::Result<(), JSONRPCErrorError> {
-        let rollout_path = find_conversation_path_by_id_str(
-            &self.config.codex_home,
-            &parent_conversation_id.to_string(),
-        )
-        .await
-        .map_err(|err| JSONRPCErrorError {
-            code: INTERNAL_ERROR_CODE,
-            message: format!("failed to locate conversation id {parent_conversation_id}: {err}"),
-            data: None,
-        })?
-        .ok_or_else(|| JSONRPCErrorError {
-            code: INVALID_REQUEST_ERROR_CODE,
-            message: format!("no rollout found for conversation id {parent_conversation_id}"),
-            data: None,
-        })?;
-
-        let mut config = self.config.as_ref().clone();
-        config.model = self.config.review_model.clone();
-
-        let NewConversation {
-            conversation_id,
-            conversation,
-            session_configured,
-            ..
-        } = self
-            .conversation_manager
-            .fork_conversation(usize::MAX, config, rollout_path)
-            .await
-            .map_err(|err| JSONRPCErrorError {
-                code: INTERNAL_ERROR_CODE,
-                message: format!("error creating detached review conversation: {err}"),
-                data: None,
-            })?;
-
-        if let Err(err) = self
-            .attach_conversation_listener(conversation_id, false, ApiVersion::V2)
-            .await
-        {
-            tracing::warn!(
-                "failed to attach listener for review conversation {}: {}",
-                conversation_id,
-                err.message
-            );
-        }
-
-        let rollout_path = conversation.rollout_path();
-        let fallback_provider = self.config.model_provider_id.as_str();
-        match read_summary_from_rollout(rollout_path.as_path(), fallback_provider).await {
-            Ok(summary) => {
-                let thread = summary_to_thread(summary);
-                let notif = ThreadStartedNotification { thread };
-                self.outgoing
-                    .send_server_notification(ServerNotification::ThreadStarted(notif))
-                    .await;
-            }
-            Err(err) => {
-                tracing::warn!(
-                    "failed to load summary for review conversation {}: {}",
-                    session_configured.session_id,
-                    err
-                );
-            }
-        }
-
-        let turn_id = conversation
-            .submit(Op::Review { review_request })
-            .await
-            .map_err(|err| JSONRPCErrorError {
-                code: INTERNAL_ERROR_CODE,
-                message: format!("failed to start detached review turn: {err}"),
-                data: None,
-            })?;
-
-        let turn = Self::build_review_turn(turn_id, display_text);
-        let review_thread_id = conversation_id.to_string();
-        self.emit_review_started(request_id, turn, review_thread_id.clone(), review_thread_id)
-            .await;
-
-        Ok(())
-    }
-
-    async fn review_start(&mut self, request_id: RequestId, params: ReviewStartParams) {
+    async fn review_start(&self, request_id: RequestId, params: ReviewStartParams) {
        let ReviewStartParams {
            thread_id,
            target,
-            delivery,
+            append_to_original_thread,
        } = params;
-        let (parent_conversation_id, parent_conversation) =
-            match self.conversation_from_thread_id(&thread_id).await {
-                Ok(v) => v,
-                Err(error) => {
-                    self.outgoing.send_error(request_id, error).await;
-                    return;
-                }
-            };
-
-        let (review_request, display_text) = match Self::review_request_from_target(target) {
-            Ok(value) => value,
-            Err(err) => {
-                self.outgoing.send_error(request_id, err).await;
+        let (_, conversation) = match self.conversation_from_thread_id(&thread_id).await {
+            Ok(v) => v,
+            Err(error) => {
+                self.outgoing.send_error(request_id, error).await;
                return;
            }
        };

-        let delivery = delivery.unwrap_or(ApiReviewDelivery::Inline).to_core();
-        match delivery {
-            CoreReviewDelivery::Inline => {
-                if let Err(err) = self
-                    .start_inline_review(
-                        &request_id,
-                        parent_conversation,
-                        review_request,
-                        display_text.as_str(),
-                        thread_id.clone(),
-                    )
-                    .await
-                {
+        let (review_request, display_text) =
+            match Self::review_request_from_target(target, append_to_original_thread) {
+                Ok(value) => value,
+                Err(err) => {
                    self.outgoing.send_error(request_id, err).await;
+                    return;
                }
+            };
+
+        let turn_id = conversation.submit(Op::Review { review_request }).await;
+
+        match turn_id {
+            Ok(turn_id) => {
+                let mut items = Vec::new();
+                if !display_text.is_empty() {
+                    items.push(ThreadItem::UserMessage {
+                        id: turn_id.clone(),
+                        content: vec![V2UserInput::Text { text: display_text }],
+                    });
+                }
+                let turn = Turn {
+                    id: turn_id.clone(),
+                    items,
+                    status: TurnStatus::InProgress,
+                };
+                let response = TurnStartResponse { turn: turn.clone() };
+                self.outgoing.send_response(request_id, response).await;
+
+                let notif = TurnStartedNotification { thread_id, turn };
+                self.outgoing
+                    .send_server_notification(ServerNotification::TurnStarted(notif))
+                    .await;
            }
-            CoreReviewDelivery::Detached => {
-                if let Err(err) = self
-                    .start_detached_review(
-                        &request_id,
-                        parent_conversation_id,
-                        review_request,
-                        display_text.as_str(),
-                    )
-                    .await
-                {
-                    self.outgoing.send_error(request_id, err).await;
-                }
+            Err(err) => {
+                let error = JSONRPCErrorError {
+                    code: INTERNAL_ERROR_CODE,
+                    message: format!("failed to start review: {err}"),
+                    data: None,
+                };
+                self.outgoing.send_error(request_id, error).await;
            }
        }
    }
@@ -3020,26 +2787,10 @@ impl CodexMessageProcessor {
        let FeedbackUploadParams {
            classification,
            reason,
-            thread_id,
+            conversation_id,
            include_logs,
        } = params;

-        let conversation_id = match thread_id.as_deref() {
-            Some(thread_id) => match ConversationId::from_string(thread_id) {
-                Ok(conversation_id) => Some(conversation_id),
-                Err(err) => {
-                    let error = JSONRPCErrorError {
-                        code: INVALID_REQUEST_ERROR_CODE,
-                        message: format!("invalid thread id: {err}"),
-                        data: None,
-                    };
-                    self.outgoing.send_error(request_id, error).await;
-                    return;
-                }
-            },
-            None => None,
-        };
-
        let snapshot = self.feedback.snapshot(conversation_id);
        let thread_id = snapshot.thread_id.clone();

--- a/codex-rs/app-server/src/config_api.rs
+++ b/codex-rs/app-server/src/config_api.rs
@@ -109,17 +109,12 @@ impl ConfigApi {

    async fn apply_edits(
        &self,
-        file_path: Option<String>,
+        file_path: String,
        expected_version: Option<String>,
        edits: Vec<(String, JsonValue, MergeStrategy)>,
    ) -> Result<ConfigWriteResponse, JSONRPCErrorError> {
        let allowed_path = self.codex_home.join(CONFIG_FILE_NAME);
-        let provided_path = file_path
-            .as_ref()
-            .map(PathBuf::from)
-            .unwrap_or_else(|| allowed_path.clone());
-
-        if !paths_match(&allowed_path, &provided_path) {
+        if !paths_match(&allowed_path, &file_path) {
            return Err(config_write_error(
                ConfigWriteErrorCode::ConfigLayerReadonly,
                "Only writes to the user config are allowed",
@@ -195,16 +190,9 @@ impl ConfigApi {
            .map(|_| WriteStatus::OkOverridden)
            .unwrap_or(WriteStatus::Ok);

-        let file_path = provided_path
-            .canonicalize()
-            .unwrap_or(provided_path.clone())
-            .display()
-            .to_string();
-
        Ok(ConfigWriteResponse {
            status,
            version: updated_layers.user.version.clone(),
-            file_path,
            overridden_metadata: overridden,
        })
    }
@@ -599,14 +587,15 @@ fn canonical_json(value: &JsonValue) -> JsonValue {
    }
 }

-fn paths_match(expected: &Path, provided: &Path) -> bool {
+fn paths_match(expected: &Path, provided: &str) -> bool {
+    let provided_path = PathBuf::from(provided);
    if let (Ok(expanded_expected), Ok(expanded_provided)) =
-        (expected.canonicalize(), provided.canonicalize())
+        (expected.canonicalize(), provided_path.canonicalize())
    {
        return expanded_expected == expanded_provided;
    }

-    expected == provided
+    expected == provided_path
 }

 fn value_at_path<'a>(root: &'a TomlValue, segments: &[String]) -> Option<&'a TomlValue> {
@@ -806,7 +795,7 @@ mod tests {

        let result = api
            .write_value(ConfigValueWriteParams {
-                file_path: Some(tmp.path().join(CONFIG_FILE_NAME).display().to_string()),
+                file_path: tmp.path().join(CONFIG_FILE_NAME).display().to_string(),
                key_path: "approval_policy".to_string(),
                value: json!("never"),
                merge_strategy: MergeStrategy::Replace,
@@ -843,7 +832,7 @@ mod tests {
        let api = ConfigApi::new(tmp.path().to_path_buf(), vec![]);
        let error = api
            .write_value(ConfigValueWriteParams {
-                file_path: Some(tmp.path().join(CONFIG_FILE_NAME).display().to_string()),
+                file_path: tmp.path().join(CONFIG_FILE_NAME).display().to_string(),
                key_path: "model".to_string(),
                value: json!("gpt-5"),
                merge_strategy: MergeStrategy::Replace,
@@ -863,30 +852,6 @@ mod tests {
        );
    }

-    #[tokio::test]
-    async fn write_value_defaults_to_user_config_path() {
-        let tmp = tempdir().expect("tempdir");
-        std::fs::write(tmp.path().join(CONFIG_FILE_NAME), "").unwrap();
-
-        let api = ConfigApi::new(tmp.path().to_path_buf(), vec![]);
-        api.write_value(ConfigValueWriteParams {
-            file_path: None,
-            key_path: "model".to_string(),
-            value: json!("gpt-new"),
-            merge_strategy: MergeStrategy::Replace,
-            expected_version: None,
-        })
-        .await
-        .expect("write succeeds");
-
-        let contents =
-            std::fs::read_to_string(tmp.path().join(CONFIG_FILE_NAME)).expect("read config");
-        assert!(
-            contents.contains("model = \"gpt-new\""),
-            "config.toml should be updated even when file_path is omitted"
-        );
-    }
-
    #[tokio::test]
    async fn invalid_user_value_rejected_even_if_overridden_by_managed() {
        let tmp = tempdir().expect("tempdir");
@@ -907,7 +872,7 @@ mod tests {

        let error = api
            .write_value(ConfigValueWriteParams {
-                file_path: Some(tmp.path().join(CONFIG_FILE_NAME).display().to_string()),
+                file_path: tmp.path().join(CONFIG_FILE_NAME).display().to_string(),
                key_path: "approval_policy".to_string(),
                value: json!("bogus"),
                merge_strategy: MergeStrategy::Replace,
@@ -992,7 +957,7 @@ mod tests {

        let result = api
            .write_value(ConfigValueWriteParams {
-                file_path: Some(tmp.path().join(CONFIG_FILE_NAME).display().to_string()),
+                file_path: tmp.path().join(CONFIG_FILE_NAME).display().to_string(),
                key_path: "approval_policy".to_string(),
                value: json!("on-request"),
                merge_strategy: MergeStrategy::Replace,
--- a/codex-rs/app-server/src/models.rs
+++ b/codex-rs/app-server/src/models.rs
@@ -1,15 +1,12 @@
-use std::sync::Arc;
-
+use codex_app_server_protocol::AuthMode;
 use codex_app_server_protocol::Model;
 use codex_app_server_protocol::ReasoningEffortOption;
-use codex_core::ConversationManager;
-use codex_protocol::openai_models::ModelPreset;
-use codex_protocol::openai_models::ReasoningEffortPreset;
+use codex_common::model_presets::ModelPreset;
+use codex_common::model_presets::ReasoningEffortPreset;
+use codex_common::model_presets::builtin_model_presets;

-pub async fn supported_models(conversation_manager: Arc<ConversationManager>) -> Vec<Model> {
-    conversation_manager
-        .list_models()
-        .await
+pub fn supported_models(auth_mode: Option<AuthMode>) -> Vec<Model> {
+    builtin_model_presets(auth_mode)
        .into_iter()
        .map(model_from_preset)
        .collect()
@@ -30,7 +27,7 @@ fn model_from_preset(preset: ModelPreset) -> Model {
 }

 fn reasoning_efforts_from_preset(
-    efforts: Vec<ReasoningEffortPreset>,
+    efforts: &'static [ReasoningEffortPreset],
 ) -> Vec<ReasoningEffortOption> {
    efforts
        .iter()
--- a/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs
+++ b/codex-rs/app-server/tests/suite/codex_message_processor_flow.rs
@@ -23,10 +23,10 @@ use codex_app_server_protocol::SendUserTurnResponse;
 use codex_app_server_protocol::ServerRequest;
 use codex_core::protocol::AskForApproval;
 use codex_core::protocol::SandboxPolicy;
+use codex_core::protocol_config_types::ReasoningEffort;
 use codex_core::protocol_config_types::ReasoningSummary;
 use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;
 use codex_protocol::config_types::SandboxMode;
-use codex_protocol::openai_models::ReasoningEffort;
 use codex_protocol::parse_command::ParsedCommand;
 use codex_protocol::protocol::Event;
 use codex_protocol::protocol::EventMsg;
--- a/codex-rs/app-server/tests/suite/config.rs
+++ b/codex-rs/app-server/tests/suite/config.rs
@@ -10,10 +10,10 @@ use codex_app_server_protocol::Tools;
 use codex_app_server_protocol::UserSavedConfig;
 use codex_core::protocol::AskForApproval;
 use codex_protocol::config_types::ForcedLoginMethod;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::SandboxMode;
 use codex_protocol::config_types::Verbosity;
-use codex_protocol::openai_models::ReasoningEffort;
 use pretty_assertions::assert_eq;
 use std::collections::HashMap;
 use std::path::Path;
--- a/codex-rs/app-server/tests/suite/v2/config_rpc.rs
+++ b/codex-rs/app-server/tests/suite/v2/config_rpc.rs
@@ -206,7 +206,7 @@ model = "gpt-old"

    let write_id = mcp
        .send_config_value_write_request(ConfigValueWriteParams {
-            file_path: None,
+            file_path: codex_home.path().join("config.toml").display().to_string(),
            key_path: "model".to_string(),
            value: json!("gpt-new"),
            merge_strategy: MergeStrategy::Replace,
@@ -219,16 +219,8 @@ model = "gpt-old"
    )
    .await??;
    let write: ConfigWriteResponse = to_response(write_resp)?;
-    let expected_file_path = codex_home
-        .path()
-        .join("config.toml")
-        .canonicalize()
-        .unwrap()
-        .display()
-        .to_string();

    assert_eq!(write.status, WriteStatus::Ok);
-    assert_eq!(write.file_path, expected_file_path);
    assert!(write.overridden_metadata.is_none());

    let verify_id = mcp
@@ -262,7 +254,7 @@ model = "gpt-old"

    let write_id = mcp
        .send_config_value_write_request(ConfigValueWriteParams {
-            file_path: Some(codex_home.path().join("config.toml").display().to_string()),
+            file_path: codex_home.path().join("config.toml").display().to_string(),
            key_path: "model".to_string(),
            value: json!("gpt-new"),
            merge_strategy: MergeStrategy::Replace,
@@ -296,7 +288,7 @@ async fn config_batch_write_applies_multiple_edits() -> Result<()> {

    let batch_id = mcp
        .send_config_batch_write_request(ConfigBatchWriteParams {
-            file_path: Some(codex_home.path().join("config.toml").display().to_string()),
+            file_path: codex_home.path().join("config.toml").display().to_string(),
            edits: vec![
                ConfigEdit {
                    key_path: "sandbox_mode".to_string(),
@@ -322,14 +314,6 @@ async fn config_batch_write_applies_multiple_edits() -> Result<()> {
    .await??;
    let batch_write: ConfigWriteResponse = to_response(batch_resp)?;
    assert_eq!(batch_write.status, WriteStatus::Ok);
-    let expected_file_path = codex_home
-        .path()
-        .join("config.toml")
-        .canonicalize()
-        .unwrap()
-        .display()
-        .to_string();
-    assert_eq!(batch_write.file_path, expected_file_path);

    let read_id = mcp
        .send_config_read_request(ConfigReadParams {
--- a/codex-rs/app-server/tests/suite/v2/model_list.rs
+++ b/codex-rs/app-server/tests/suite/v2/model_list.rs
@@ -11,7 +11,7 @@ use codex_app_server_protocol::ModelListParams;
 use codex_app_server_protocol::ModelListResponse;
 use codex_app_server_protocol::ReasoningEffortOption;
 use codex_app_server_protocol::RequestId;
-use codex_protocol::openai_models::ReasoningEffort;
+use codex_protocol::config_types::ReasoningEffort;
 use pretty_assertions::assert_eq;
 use tempfile::TempDir;
 use tokio::time::timeout;
--- a/codex-rs/app-server/tests/suite/v2/review.rs
+++ b/codex-rs/app-server/tests/suite/v2/review.rs
@@ -9,13 +9,12 @@ use codex_app_server_protocol::JSONRPCError;
 use codex_app_server_protocol::JSONRPCNotification;
 use codex_app_server_protocol::JSONRPCResponse;
 use codex_app_server_protocol::RequestId;
-use codex_app_server_protocol::ReviewDelivery;
 use codex_app_server_protocol::ReviewStartParams;
-use codex_app_server_protocol::ReviewStartResponse;
 use codex_app_server_protocol::ReviewTarget;
 use codex_app_server_protocol::ThreadItem;
 use codex_app_server_protocol::ThreadStartParams;
 use codex_app_server_protocol::ThreadStartResponse;
+use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStatus;
 use serde_json::json;
 use tempfile::TempDir;
@@ -60,7 +59,7 @@ async fn review_start_runs_review_turn_and_emits_code_review_item() -> Result<()
    let review_req = mcp
        .send_review_start_request(ReviewStartParams {
            thread_id: thread_id.clone(),
-            delivery: Some(ReviewDelivery::Inline),
+            append_to_original_thread: true,
            target: ReviewTarget::Commit {
                sha: "1234567deadbeef".to_string(),
                title: Some("Tidy UI colors".to_string()),
@@ -72,43 +71,43 @@ async fn review_start_runs_review_turn_and_emits_code_review_item() -> Result<()
        mcp.read_stream_until_response_message(RequestId::Integer(review_req)),
    )
    .await??;
-    let ReviewStartResponse {
-        turn,
-        review_thread_id,
-    } = to_response::<ReviewStartResponse>(review_resp)?;
-    assert_eq!(review_thread_id, thread_id.clone());
+    let TurnStartResponse { turn } = to_response::<TurnStartResponse>(review_resp)?;
    let turn_id = turn.id.clone();
    assert_eq!(turn.status, TurnStatus::InProgress);
-
-    // Confirm we see the EnteredReviewMode marker on the main thread.
-    let mut saw_entered_review_mode = false;
-    for _ in 0..10 {
-        let item_started: JSONRPCNotification = timeout(
-            DEFAULT_READ_TIMEOUT,
-            mcp.read_stream_until_notification_message("item/started"),
-        )
-        .await??;
-        let started: ItemStartedNotification =
-            serde_json::from_value(item_started.params.expect("params must be present"))?;
-        match started.item {
-            ThreadItem::EnteredReviewMode { id, review } => {
-                assert_eq!(id, turn_id);
-                assert_eq!(review, "commit 1234567: Tidy UI colors");
-                saw_entered_review_mode = true;
-                break;
-            }
-            _ => continue,
+    assert_eq!(turn.items.len(), 1);
+    match &turn.items[0] {
+        ThreadItem::UserMessage { content, .. } => {
+            assert_eq!(content.len(), 1);
+            assert!(matches!(
+                &content[0],
+                codex_app_server_protocol::UserInput::Text { .. }
+            ));
        }
+        other => panic!("expected user message, got {other:?}"),
+    }
+
+    let _started: JSONRPCNotification = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_notification_message("turn/started"),
+    )
+    .await??;
+    let item_started: JSONRPCNotification = timeout(
+        DEFAULT_READ_TIMEOUT,
+        mcp.read_stream_until_notification_message("item/started"),
+    )
+    .await??;
+    let started: ItemStartedNotification =
+        serde_json::from_value(item_started.params.expect("params must be present"))?;
+    match started.item {
+        ThreadItem::CodeReview { id, review } => {
+            assert_eq!(id, turn_id);
+            assert_eq!(review, "commit 1234567");
+        }
+        other => panic!("expected code review item, got {other:?}"),
    }
-    assert!(
-        saw_entered_review_mode,
-        "did not observe enteredReviewMode item"
-    );

-    // Confirm we see the ExitedReviewMode marker (with review text)
-    // on the same turn. Ignore any other items the stream surfaces.
    let mut review_body: Option<String> = None;
-    for _ in 0..10 {
+    for _ in 0..5 {
        let review_notif: JSONRPCNotification = timeout(
            DEFAULT_READ_TIMEOUT,
            mcp.read_stream_until_notification_message("item/completed"),
@@ -117,12 +116,13 @@ async fn review_start_runs_review_turn_and_emits_code_review_item() -> Result<()
        let completed: ItemCompletedNotification =
            serde_json::from_value(review_notif.params.expect("params must be present"))?;
        match completed.item {
-            ThreadItem::ExitedReviewMode { id, review } => {
+            ThreadItem::CodeReview { id, review } => {
                assert_eq!(id, turn_id);
                review_body = Some(review);
                break;
            }
-            _ => continue,
+            ThreadItem::UserMessage { .. } => continue,
+            other => panic!("unexpected item/completed payload: {other:?}"),
        }
    }

@@ -146,7 +146,7 @@ async fn review_start_rejects_empty_base_branch() -> Result<()> {
    let request_id = mcp
        .send_review_start_request(ReviewStartParams {
            thread_id,
-            delivery: Some(ReviewDelivery::Inline),
+            append_to_original_thread: true,
            target: ReviewTarget::BaseBranch {
                branch: "   ".to_string(),
            },
@@ -167,56 +167,6 @@ async fn review_start_rejects_empty_base_branch() -> Result<()> {
    Ok(())
 }

-#[tokio::test]
-async fn review_start_with_detached_delivery_returns_new_thread_id() -> Result<()> {
-    let review_payload = json!({
-        "findings": [],
-        "overall_correctness": "ok",
-        "overall_explanation": "detached review",
-        "overall_confidence_score": 0.5
-    })
-    .to_string();
-    let responses = vec![create_final_assistant_message_sse_response(
-        &review_payload,
-    )?];
-    let server = create_mock_chat_completions_server_unchecked(responses).await;
-
-    let codex_home = TempDir::new()?;
-    create_config_toml(codex_home.path(), &server.uri())?;
-
-    let mut mcp = McpProcess::new(codex_home.path()).await?;
-    timeout(DEFAULT_READ_TIMEOUT, mcp.initialize()).await??;
-
-    let thread_id = start_default_thread(&mut mcp).await?;
-
-    let review_req = mcp
-        .send_review_start_request(ReviewStartParams {
-            thread_id: thread_id.clone(),
-            delivery: Some(ReviewDelivery::Detached),
-            target: ReviewTarget::Custom {
-                instructions: "detached review".to_string(),
-            },
-        })
-        .await?;
-    let review_resp: JSONRPCResponse = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_response_message(RequestId::Integer(review_req)),
-    )
-    .await??;
-    let ReviewStartResponse {
-        turn,
-        review_thread_id,
-    } = to_response::<ReviewStartResponse>(review_resp)?;
-
-    assert_eq!(turn.status, TurnStatus::InProgress);
-    assert_ne!(
-        review_thread_id, thread_id,
-        "detached review should run on a different thread"
-    );
-
-    Ok(())
-}
-
 #[tokio::test]
 async fn review_start_rejects_empty_commit_sha() -> Result<()> {
    let server = create_mock_chat_completions_server_unchecked(vec![]).await;
@@ -230,7 +180,7 @@ async fn review_start_rejects_empty_commit_sha() -> Result<()> {
    let request_id = mcp
        .send_review_start_request(ReviewStartParams {
            thread_id,
-            delivery: Some(ReviewDelivery::Inline),
+            append_to_original_thread: true,
            target: ReviewTarget::Commit {
                sha: "\t".to_string(),
                title: None,
@@ -265,7 +215,7 @@ async fn review_start_rejects_empty_custom_instructions() -> Result<()> {
    let request_id = mcp
        .send_review_start_request(ReviewStartParams {
            thread_id,
-            delivery: Some(ReviewDelivery::Inline),
+            append_to_original_thread: true,
            target: ReviewTarget::Custom {
                instructions: "\n\n".to_string(),
            },
--- a/codex-rs/app-server/tests/suite/v2/turn_start.rs
+++ b/codex-rs/app-server/tests/suite/v2/turn_start.rs
@@ -11,7 +11,6 @@ use app_test_support::to_response;
 use codex_app_server_protocol::ApprovalDecision;
 use codex_app_server_protocol::CommandExecutionRequestApprovalResponse;
 use codex_app_server_protocol::CommandExecutionStatus;
-use codex_app_server_protocol::FileChangeOutputDeltaNotification;
 use codex_app_server_protocol::FileChangeRequestApprovalResponse;
 use codex_app_server_protocol::ItemCompletedNotification;
 use codex_app_server_protocol::ItemStartedNotification;
@@ -30,8 +29,8 @@ use codex_app_server_protocol::TurnStartResponse;
 use codex_app_server_protocol::TurnStartedNotification;
 use codex_app_server_protocol::TurnStatus;
 use codex_app_server_protocol::UserInput as V2UserInput;
+use codex_core::protocol_config_types::ReasoningEffort;
 use codex_core::protocol_config_types::ReasoningSummary;
-use codex_protocol::openai_models::ReasoningEffort;
 use core_test_support::skip_if_no_network;
 use pretty_assertions::assert_eq;
 use std::path::Path;
@@ -726,26 +725,6 @@ async fn turn_start_file_change_approval_v2() -> Result<()> {
    )
    .await?;

-    let output_delta_notif = timeout(
-        DEFAULT_READ_TIMEOUT,
-        mcp.read_stream_until_notification_message("item/fileChange/outputDelta"),
-    )
-    .await??;
-    let output_delta: FileChangeOutputDeltaNotification = serde_json::from_value(
-        output_delta_notif
-            .params
-            .clone()
-            .expect("item/fileChange/outputDelta params"),
-    )?;
-    assert_eq!(output_delta.thread_id, thread.id);
-    assert_eq!(output_delta.turn_id, turn.id);
-    assert_eq!(output_delta.item_id, "patch-call");
-    assert!(
-        !output_delta.delta.is_empty(),
-        "expected delta to be non-empty, got: {}",
-        output_delta.delta
-    );
-
    let completed_file_change = timeout(DEFAULT_READ_TIMEOUT, async {
        loop {
            let completed_notif = mcp
--- a/codex-rs/cli/src/main.rs
+++ b/codex-rs/cli/src/main.rs
@@ -18,8 +18,6 @@ use codex_cli::login::run_logout;
 use codex_cloud_tasks::Cli as CloudTasksCli;
 use codex_common::CliConfigOverrides;
 use codex_exec::Cli as ExecCli;
-use codex_exec::Command as ExecCommand;
-use codex_exec::ReviewArgs;
 use codex_execpolicy::ExecPolicyCheckCommand;
 use codex_responses_api_proxy::Args as ResponsesApiProxyArgs;
 use codex_tui::AppExitInfo;
@@ -74,9 +72,6 @@ enum Subcommand {
    #[clap(visible_alias = "e")]
    Exec(ExecCli),

-    /// Run a code review non-interactively.
-    Review(ReviewArgs),
-
    /// Manage login.
    Login(LoginCommand),

@@ -454,15 +449,6 @@ async fn cli_main(codex_linux_sandbox_exe: Option<PathBuf>) -> anyhow::Result<()
            );
            codex_exec::run_main(exec_cli, codex_linux_sandbox_exe).await?;
        }
-        Some(Subcommand::Review(review_args)) => {
-            let mut exec_cli = ExecCli::try_parse_from(["codex", "exec"])?;
-            exec_cli.command = Some(ExecCommand::Review(review_args));
-            prepend_config_flags(
-                &mut exec_cli.config_overrides,
-                root_config_overrides.clone(),
-            );
-            codex_exec::run_main(exec_cli, codex_linux_sandbox_exe).await?;
-        }
        Some(Subcommand::McpServer) => {
            codex_mcp_server::run_main(codex_linux_sandbox_exe, root_config_overrides).await?;
        }
--- a/codex-rs/cli/tests/execpolicy.rs
+++ b/codex-rs/cli/tests/execpolicy.rs
@@ -40,15 +40,17 @@ prefix_rule(
    assert_eq!(
        result,
        json!({
-            "decision": "forbidden",
-            "matchedRules": [
-                {
-                    "prefixRuleMatch": {
-                        "matchedPrefix": ["git", "push"],
-                        "decision": "forbidden"
+            "match": {
+                "decision": "forbidden",
+                "matchedRules": [
+                    {
+                        "prefixRuleMatch": {
+                            "matchedPrefix": ["git", "push"],
+                            "decision": "forbidden"
+                        }
                    }
-                }
-            ]
+                ]
+            }
        })
    );

--- a/codex-rs/client.md
+++ b/codex-rs/client.md
@@ -0,0 +1,206 @@
+# Client Extraction Plan
+
+## Goals
+- Split the HTTP transport/client code out of `codex-core` into a reusable crate that is agnostic of Codex/OpenAI business logic and API schemas.
+- Create a separate API library crate that houses typed requests/responses for well-known APIs (Responses, Chat Completions, Compact) and plugs into the transport crate via minimal traits.
+- Preserve current behaviour (auth headers, retries, SSE handling, rate-limit parsing, compaction, fixtures) while making the APIs symmetric and avoiding code duplication.
+- Keep existing consumers (`codex-core`, tests, and tools) stable by providing a small compatibility layer during the transition.
+
+## Snapshot of Today
+- `core/src/client.rs (ModelClient)` owns config/auth/session state, chooses wire API, builds payloads, drives retries, parses SSE, compaction, and rate-limit headers.
+- `core/src/chat_completions.rs` implements the Chat Completions call + SSE parser + aggregation helper.
+- `core/src/client_common.rs` holds `Prompt`, tool specs, shared request structs (`ResponsesApiRequest`, `TextControls`), and `ResponseEvent`/`ResponseStream`.
+- `core/src/default_client.rs` wraps `reqwest` with Codex UA/originator defaults.
+- `core/src/model_provider_info.rs` models providers (base URL, headers, env keys, retry/timeout tuning) and builds `CodexRequestBuilder`s.
+    - Current retry logic is co-located with API handling; streaming SSE parsing is duplicated across Responses/Chat.
+
+## Target Crates (with interfaces)
+
+- `codex-client` (generic transport)
+  - Owns the generic HTTP machinery: a `CodexHttpClient`/`CodexRequestBuilder`-style wrapper, retry/backoff hooks, streaming connector (SSE framing + idle timeout), header injection, and optional telemetry callbacks.
+  - Does **not** know about OpenAI/Codex-specific paths, headers, or error codes; it only exposes HTTP-level concepts (status, headers, bodies, connection errors).
+  - Minimal surface:
+    ```rust
+    pub trait HttpTransport {
+        fn execute(&self, req: Request) -> Result<Response, TransportError>;
+        fn stream(&self, req: Request) -> Result<ByteStream, TransportError>;
+    }
+
+    pub struct Request {
+        pub method: Method,
+        pub url: String,
+        pub headers: HeaderMap,
+        pub body: Option<serde_json::Value>,
+        pub timeout: Option<Duration>,
+    }
+    ```
+  - Generic client traits (request/response/chunk are abstract over the transport):
+    ```rust
+    #[async_trait::async_trait]
+    pub trait UnaryClient<Req, Resp> {
+        async fn run(&self, req: Req) -> Result<Resp, TransportError>;
+    }
+
+    #[async_trait::async_trait]
+    pub trait StreamClient<Req, Chunk> {
+        async fn run(&self, req: Req) -> Result<ResponseStream<Chunk>, TransportError>;
+    }
+
+    pub struct RetryPolicy {
+        pub max_attempts: u64,
+        pub base_delay: Duration,
+        pub retry_on: RetryOn, // e.g., transport errors + 429/5xx
+    }
+    ```
+    - `RetryOn` lives in `codex-client` and captures HTTP status classes and transport failures that qualify for retry.
+    - Implementations in `codex-api` plug in their own request types, parsers, and retry policies while reusing the transport’s backoff and error types.
+    - Planned runtime helper:
+      ```rust
+      pub async fn run_with_retry<T, F, Fut>(
+          policy: RetryPolicy,
+          make_req: impl Fn() -> Request,
+          op: F,
+      ) -> Result<T, TransportError>
+      where
+          F: Fn(Request) -> Fut,
+          Fut: Future<Output = Result<T, TransportError>>,
+      {
+          for attempt in 0..=policy.max_attempts {
+              let req = make_req();
+              match op(req).await {
+                  Ok(resp) => return Ok(resp),
+                  Err(err) if policy.retry_on.should_retry(&err, attempt) => {
+                      tokio::time::sleep(backoff(policy.base_delay, attempt + 1)).await;
+                  }
+                  Err(err) => return Err(err),
+              }
+          }
+          Err(TransportError::RetryLimit)
+      }
+      ```
+      - Unary clients wrap `transport.execute` with this helper and then deserialize.
+      - Stream clients wrap the **initial** `transport.stream` call with this helper. Mid-stream disconnects are surfaced as `StreamError`s; automatic resume/reconnect can be added later on top of this primitive if we introduce cursor support.
+  - Common helpers: `retry::backoff(attempt)`, `errors::{TransportError, StreamError}`.
+  - Streaming utility (SSE framing only):
+    ```rust
+    pub fn sse_stream<S>(
+        bytes: S,
+        idle_timeout: Duration,
+        tx: mpsc::Sender<Result<String, StreamError>>,
+        telemetry: Option<Box<dyn Telemetry>>,
+    )
+    where
+        S: Stream<Item = Result<Bytes, TransportError>> + Unpin + Send + 'static;
+    ```
+    - `sse_stream` is responsible for timeouts, connection-level errors, and emitting raw `data:` chunks as UTF-8 strings; parsing those strings into structured events is done in `codex-api`.
+
+- `codex-api` (OpenAI/Codex API library)
+  - Owns typed models for Responses/Chat/Compact plus shared helpers (`Prompt`, tool specs, text controls, `ResponsesApiRequest`, etc.).
+  - Knows about OpenAI/Codex semantics:
+    - URL shapes (`/v1/responses`, `/v1/chat/completions`, `/responses/compact`).
+    - Provider configuration (`WireApi`, base URLs, query params, per-provider retry knobs).
+    - Rate-limit headers (`x-codex-*`) and their mapping into `RateLimitSnapshot` / `CreditsSnapshot`.
+    - Error body formats (`{ error: { type, code, message, plan_type, resets_at } }`) and how they become API errors (context window exceeded, quota/usage limit, etc.).
+    - SSE event names (`response.output_item.done`, `response.completed`, `response.failed`, etc.) and their mapping into high-level events.
+  - Provides a provider abstraction (conceptually similar to `ModelProviderInfo`):
+    ```rust
+    pub struct Provider {
+        pub name: String,
+        pub base_url: String,
+        pub wire: WireApi, // Responses | Chat
+        pub headers: HeaderMap,
+        pub retry: RetryConfig,
+        pub stream_idle_timeout: Duration,
+    }
+
+    pub trait AuthProvider {
+        /// Returns a bearer token to use for this request (if any).
+        /// Implementations are expected to be cheap and to surface already-refreshed tokens;
+        /// higher layers (`codex-core`) remain responsible for token refresh flows.
+        fn bearer_token(&self) -> Option<String>;
+
+        /// Optional ChatGPT account id header for Chat mode.
+        fn account_id(&self) -> Option<String>;
+    }
+    ```
+  - Ready-made clients built on `HttpTransport`:
+    ```rust
+    pub struct ResponsesClient<T: HttpTransport, A: AuthProvider> { /* ... */ }
+    impl<T, A> ResponsesClient<T, A> {
+        pub async fn stream(&self, prompt: &Prompt) -> ApiResult<ResponseStream<ApiEvent>>;
+        pub async fn compact(&self, prompt: &Prompt) -> ApiResult<Vec<ResponseItem>>;
+    }
+
+    pub struct ChatClient<T: HttpTransport, A: AuthProvider> { /* ... */ }
+    impl<T, A> ChatClient<T, A> {
+        pub async fn stream(&self, prompt: &Prompt) -> ApiResult<ResponseStream<ApiEvent>>;
+    }
+
+    pub struct CompactClient<T: HttpTransport, A: AuthProvider> { /* ... */ }
+    impl<T, A> CompactClient<T, A> {
+        pub async fn compact(&self, prompt: &Prompt) -> ApiResult<Vec<ResponseItem>>;
+    }
+    ```
+  - Streaming events unified across wire APIs (this can closely mirror `ResponseEvent` today, and we may type-alias one to the other during migration):
+    ```rust
+    pub enum ApiEvent {
+        Created,
+        OutputItemAdded(ResponseItem),
+        OutputItemDone(ResponseItem),
+        OutputTextDelta(String),
+        ReasoningContentDelta { delta: String, content_index: i64 },
+        ReasoningSummaryDelta { delta: String, summary_index: i64 },
+        RateLimits(RateLimitSnapshot),
+        Completed { response_id: String, token_usage: Option<TokenUsage> },
+    }
+    ```
+  - Error layering:
+    - `codex-client`: defines `TransportError` / `StreamError` (status codes, IO, timeouts).
+    - `codex-api`: defines `ApiError` that wraps `TransportError` plus API-specific errors parsed from bodies and headers.
+    - `codex-core`: maps `ApiError` into existing `CodexErr` variants so downstream callers remain unchanged.
+  - Aggregation strategies (today’s `AggregateStreamExt`) live here as adapters (`Aggregated`, `Streaming`) that transform `ResponseStream<ApiEvent>` into the higher-level views used by `codex-core`.
+
+## Implementation Steps
+
+1. **Create crates**: add `codex-client` and `codex-api` (names keep the `codex-` prefix). Stub lib files with feature flags/tests wired into the workspace; wire them into `Cargo.toml`.
+2. **Extract API-level SSE + rate limits into `codex-api`**:
+   - Move the Responses SSE parser (`process_sse`), rate-limit parsing, and related tests from `core/src/client.rs` into `codex-api`, keeping the behavior identical.
+   - Introduce `ApiEvent` (initially equivalent to `ResponseEvent`) and `ApiError`, and adjust the parser to emit those.
+   - Provide test-only helpers for fixture streams (replacement for `CODEX_RS_SSE_FIXTURE`) in `codex-api`.
+3. **Lift transport layer into `codex-client`**:
+   - Move `CodexHttpClient`/`CodexRequestBuilder`, UA/originator plumbing, and backoff helpers from `core/src/default_client.rs` into `codex-client` (or a thin wrapper on top of it).
+   - Introduce `HttpTransport`, `Request`, `RetryPolicy`, `RetryOn`, and `run_with_retry` as described above.
+   - Keep sandbox/no-proxy toggles behind injected configuration so `codex-client` stays generic and does not depend on Codex-specific env vars.
+4. **Model provider abstraction in `codex-api`**:
+   - Relocate `ModelProviderInfo` (base URL, env/header resolution, retry knobs, wire API enum) into `codex-api`, expressed in terms of `Provider` and `AuthProvider`.
+   - Ensure provider logic handles:
+     - URL building for Responses/Chat/Compact (including Azure special cases).
+     - Static and env-based headers.
+     - Per-provider retry and idle-timeout settings that map cleanly into `RetryPolicy`/`RetryOn`.
+5. **API crate wiring**:
+   - Move `Prompt`, tool specs, `ResponsesApiRequest`, `TextControls`, and `ResponseEvent/ResponseStream` into `codex-api` under modules (`common`, `responses`, `chat`, `compact`), keeping public types stable or re-exported through `codex-core` as needed.
+   - Rebuild Responses and Chat clients on top of `HttpTransport` + `StreamClient`, reusing shared retry + SSE helpers; keep aggregation adapters as reusable strategies instead of `ModelClient`-local logic.
+   - Implement Compact on top of `UnaryClient` and the unary `execute` path with JSON deserialization, sharing the same retry policy.
+   - Keep request builders symmetric: each client prepares a `Request<serde_json::Value>`, attaches headers/auth via `AuthProvider`, and plugs in its parser (streaming clients) or deserializer (unary) while sharing retry/backoff configuration derived from `Provider`.
+6. **Core integration layer**:
+   - Replace `core::ModelClient` internals with thin adapters that construct `codex-api` clients using `Config`, `AuthManager`, and `OtelEventManager`.
+   - Keep the public `ModelClient` API and `ResponseEvent`/`ResponseStream` types stable by re-exporting `codex-api` types or providing type aliases.
+   - Preserve existing auth flows (including ChatGPT token refresh) inside `codex-core` or a thin adapter, using `AuthProvider` to surface bearer tokens to `codex-api` and handling 401/refresh semantics at this layer.
+7. **Tests/migration**:
+   - Move unit tests for SSE parsing, retry/backoff decisions, and provider/header behavior into the new crates; keep integration tests in `core` using the compatibility layer.
+   - Update fixtures to be consumed via test-only adapters in `codex-api`.
+   - Run targeted `just fmt`, `just fix -p` for the touched crates, and scoped `cargo test -p codex-client`, `-p codex-api`, and existing `codex-core` suites.
+
+## Design Decisions
+
+- **UA construction**
+  - `codex-client` exposes an optional UA suffix/provider hook (tiny feature) and remains unaware of the CLI; `codex-core` / the CLI compute the full UA (including `terminal::user_agent()`) and pass the suffix or builder down.
+- **Config vs provider**
+  - Most configuration stays in `codex-core`. `codex-api::Provider` only contains what is strictly required for HTTP (base URLs, query params, retry/timeout knobs, wire API), while higher-level knobs (reasoning defaults, verbosity flags, etc.) remain core concerns.
+- **Auth flow ownership**
+  - Auth flows (including ChatGPT token refresh) remain in `codex-core`. `AuthProvider` simply exposes already-fresh tokens/account IDs; 401 handling and refresh retries stay in the existing auth layer.
+- **Error enums**
+  - `codex-client` continues to define `TransportError` / `StreamError`. `codex-api` defines an `ApiError` (deriving `thiserror::Error`) that wraps `TransportError` and API-specific failures, and `codex-core` maps `ApiError` into existing `CodexErr` variants for callers.
+- **Streaming reconnection semantics**
+  - For now, mid-stream SSE failures are surfaced as errors and only the initial connection is retried via `run_with_retry`. We will revisit mid-stream reconnect/resume once the underlying APIs support cursor/idempotent event semantics.
+
--- a/codex-rs/cloud-tasks/src/cli.rs
+++ b/codex-rs/cloud-tasks/src/cli.rs
@@ -28,10 +28,6 @@ pub struct ExecCommand {
    #[arg(long = "env", value_name = "ENV_ID")]
    pub environment: String,

-    /// Git branch to run in Codex Cloud.
-    #[arg(long = "branch", value_name = "BRANCH", default_value = "main")]
-    pub branch: String,
-
    /// Number of assistant attempts (best-of-N).
    #[arg(
        long = "attempts",
--- a/codex-rs/cloud-tasks/src/lib.rs
+++ b/codex-rs/cloud-tasks/src/lib.rs
@@ -101,7 +101,6 @@ async fn run_exec_command(args: crate::cli::ExecCommand) -> anyhow::Result<()> {
    let crate::cli::ExecCommand {
        query,
        environment,
-        branch,
        attempts,
    } = args;
    let ctx = init_backend("codex_cloud_tasks_exec").await?;
@@ -111,7 +110,7 @@ async fn run_exec_command(args: crate::cli::ExecCommand) -> anyhow::Result<()> {
        &*ctx.backend,
        &env_id,
        &prompt,
-        &branch,
+        "main",
        false,
        attempts,
    )
--- a/codex-rs/codex-api/Cargo.toml
+++ b/codex-rs/codex-api/Cargo.toml
@@ -25,8 +25,6 @@ anyhow = { workspace = true }
 assert_matches = { workspace = true }
 pretty_assertions = { workspace = true }
 tokio-test = { workspace = true }
-wiremock = { workspace = true }
-reqwest = { workspace = true }

 [lints]
 workspace = true
--- a/codex-rs/codex-api/src/common.rs
+++ b/codex-rs/codex-api/src/common.rs
@@ -1,8 +1,8 @@
 use crate::error::ApiError;
+use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
 use codex_protocol::config_types::Verbosity as VerbosityConfig;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::protocol::RateLimitSnapshot;
 use codex_protocol::protocol::TokenUsage;
 use futures::Stream;
--- a/codex-rs/codex-api/src/endpoint/mod.rs
+++ b/codex-rs/codex-api/src/endpoint/mod.rs
@@ -1,5 +1,4 @@
 pub mod chat;
 pub mod compact;
-pub mod models;
 pub mod responses;
 mod streaming;
--- a/codex-rs/codex-api/src/endpoint/models.rs
+++ b/codex-rs/codex-api/src/endpoint/models.rs
@@ -1,216 +0,0 @@
-use crate::auth::AuthProvider;
-use crate::auth::add_auth_headers;
-use crate::error::ApiError;
-use crate::provider::Provider;
-use crate::telemetry::run_with_request_telemetry;
-use codex_client::HttpTransport;
-use codex_client::RequestTelemetry;
-use codex_protocol::openai_models::ModelsResponse;
-use http::HeaderMap;
-use http::Method;
-use std::sync::Arc;
-
-pub struct ModelsClient<T: HttpTransport, A: AuthProvider> {
-    transport: T,
-    provider: Provider,
-    auth: A,
-    request_telemetry: Option<Arc<dyn RequestTelemetry>>,
-}
-
-impl<T: HttpTransport, A: AuthProvider> ModelsClient<T, A> {
-    pub fn new(transport: T, provider: Provider, auth: A) -> Self {
-        Self {
-            transport,
-            provider,
-            auth,
-            request_telemetry: None,
-        }
-    }
-
-    pub fn with_telemetry(mut self, request: Option<Arc<dyn RequestTelemetry>>) -> Self {
-        self.request_telemetry = request;
-        self
-    }
-
-    fn path(&self) -> &'static str {
-        "models"
-    }
-
-    pub async fn list_models(
-        &self,
-        client_version: &str,
-        extra_headers: HeaderMap,
-    ) -> Result<ModelsResponse, ApiError> {
-        let builder = || {
-            let mut req = self.provider.build_request(Method::GET, self.path());
-            req.headers.extend(extra_headers.clone());
-
-            let separator = if req.url.contains('?') { '&' } else { '?' };
-            req.url = format!("{}{}client_version={client_version}", req.url, separator);
-
-            add_auth_headers(&self.auth, req)
-        };
-
-        let resp = run_with_request_telemetry(
-            self.provider.retry.to_policy(),
-            self.request_telemetry.clone(),
-            builder,
-            |req| self.transport.execute(req),
-        )
-        .await?;
-
-        serde_json::from_slice::<ModelsResponse>(&resp.body).map_err(|e| {
-            ApiError::Stream(format!(
-                "failed to decode models response: {e}; body: {}",
-                String::from_utf8_lossy(&resp.body)
-            ))
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::provider::RetryConfig;
-    use crate::provider::WireApi;
-    use async_trait::async_trait;
-    use codex_client::Request;
-    use codex_client::Response;
-    use codex_client::StreamResponse;
-    use codex_client::TransportError;
-    use http::HeaderMap;
-    use http::StatusCode;
-    use pretty_assertions::assert_eq;
-    use serde_json::json;
-    use std::sync::Arc;
-    use std::sync::Mutex;
-    use std::time::Duration;
-
-    #[derive(Clone, Default)]
-    struct CapturingTransport {
-        last_request: Arc<Mutex<Option<Request>>>,
-        body: Arc<ModelsResponse>,
-    }
-
-    #[async_trait]
-    impl HttpTransport for CapturingTransport {
-        async fn execute(&self, req: Request) -> Result<Response, TransportError> {
-            *self.last_request.lock().unwrap() = Some(req);
-            let body = serde_json::to_vec(&*self.body).unwrap();
-            Ok(Response {
-                status: StatusCode::OK,
-                headers: HeaderMap::new(),
-                body: body.into(),
-            })
-        }
-
-        async fn stream(&self, _req: Request) -> Result<StreamResponse, TransportError> {
-            Err(TransportError::Build("stream should not run".to_string()))
-        }
-    }
-
-    #[derive(Clone, Default)]
-    struct DummyAuth;
-
-    impl AuthProvider for DummyAuth {
-        fn bearer_token(&self) -> Option<String> {
-            None
-        }
-    }
-
-    fn provider(base_url: &str) -> Provider {
-        Provider {
-            name: "test".to_string(),
-            base_url: base_url.to_string(),
-            query_params: None,
-            wire: WireApi::Responses,
-            headers: HeaderMap::new(),
-            retry: RetryConfig {
-                max_attempts: 1,
-                base_delay: Duration::from_millis(1),
-                retry_429: false,
-                retry_5xx: true,
-                retry_transport: true,
-            },
-            stream_idle_timeout: Duration::from_secs(1),
-        }
-    }
-
-    #[tokio::test]
-    async fn appends_client_version_query() {
-        let response = ModelsResponse { models: Vec::new() };
-
-        let transport = CapturingTransport {
-            last_request: Arc::new(Mutex::new(None)),
-            body: Arc::new(response),
-        };
-
-        let client = ModelsClient::new(
-            transport.clone(),
-            provider("https://example.com/api/codex"),
-            DummyAuth,
-        );
-
-        let result = client
-            .list_models("0.99.0", HeaderMap::new())
-            .await
-            .expect("request should succeed");
-
-        assert_eq!(result.models.len(), 0);
-
-        let url = transport
-            .last_request
-            .lock()
-            .unwrap()
-            .as_ref()
-            .unwrap()
-            .url
-            .clone();
-        assert_eq!(
-            url,
-            "https://example.com/api/codex/models?client_version=0.99.0"
-        );
-    }
-
-    #[tokio::test]
-    async fn parses_models_response() {
-        let response = ModelsResponse {
-            models: vec![
-                serde_json::from_value(json!({
-                    "slug": "gpt-test",
-                    "display_name": "gpt-test",
-                    "description": "desc",
-                    "default_reasoning_level": "medium",
-                    "supported_reasoning_levels": ["low", "medium", "high"],
-                    "shell_type": "shell_command",
-                    "visibility": "list",
-                    "minimal_client_version": [0, 99, 0],
-                    "supported_in_api": true,
-                    "priority": 1
-                }))
-                .unwrap(),
-            ],
-        };
-
-        let transport = CapturingTransport {
-            last_request: Arc::new(Mutex::new(None)),
-            body: Arc::new(response),
-        };
-
-        let client = ModelsClient::new(
-            transport,
-            provider("https://example.com/api/codex"),
-            DummyAuth,
-        );
-
-        let result = client
-            .list_models("0.99.0", HeaderMap::new())
-            .await
-            .expect("request should succeed");
-
-        assert_eq!(result.models.len(), 1);
-        assert_eq!(result.models[0].slug, "gpt-test");
-        assert_eq!(result.models[0].supported_in_api, true);
-        assert_eq!(result.models[0].priority, 1);
-    }
-}
--- a/codex-rs/codex-api/src/lib.rs
+++ b/codex-rs/codex-api/src/lib.rs
@@ -22,7 +22,6 @@ pub use crate::common::create_text_param_for_request;
 pub use crate::endpoint::chat::AggregateStreamExt;
 pub use crate::endpoint::chat::ChatClient;
 pub use crate::endpoint::compact::CompactClient;
-pub use crate::endpoint::models::ModelsClient;
 pub use crate::endpoint::responses::ResponsesClient;
 pub use crate::endpoint::responses::ResponsesOptions;
 pub use crate::error::ApiError;
--- a/codex-rs/codex-api/tests/models_integration.rs
+++ b/codex-rs/codex-api/tests/models_integration.rs
@@ -1,100 +0,0 @@
-use codex_api::AuthProvider;
-use codex_api::ModelsClient;
-use codex_api::provider::Provider;
-use codex_api::provider::RetryConfig;
-use codex_api::provider::WireApi;
-use codex_client::ReqwestTransport;
-use codex_protocol::openai_models::ClientVersion;
-use codex_protocol::openai_models::ModelInfo;
-use codex_protocol::openai_models::ModelVisibility;
-use codex_protocol::openai_models::ModelsResponse;
-use codex_protocol::openai_models::ReasoningLevel;
-use codex_protocol::openai_models::ShellType;
-use http::HeaderMap;
-use http::Method;
-use wiremock::Mock;
-use wiremock::MockServer;
-use wiremock::ResponseTemplate;
-use wiremock::matchers::method;
-use wiremock::matchers::path;
-
-#[derive(Clone, Default)]
-struct DummyAuth;
-
-impl AuthProvider for DummyAuth {
-    fn bearer_token(&self) -> Option<String> {
-        None
-    }
-}
-
-fn provider(base_url: &str) -> Provider {
-    Provider {
-        name: "test".to_string(),
-        base_url: base_url.to_string(),
-        query_params: None,
-        wire: WireApi::Responses,
-        headers: HeaderMap::new(),
-        retry: RetryConfig {
-            max_attempts: 1,
-            base_delay: std::time::Duration::from_millis(1),
-            retry_429: false,
-            retry_5xx: true,
-            retry_transport: true,
-        },
-        stream_idle_timeout: std::time::Duration::from_secs(1),
-    }
-}
-
-#[tokio::test]
-async fn models_client_hits_models_endpoint() {
-    let server = MockServer::start().await;
-    let base_url = format!("{}/api/codex", server.uri());
-
-    let response = ModelsResponse {
-        models: vec![ModelInfo {
-            slug: "gpt-test".to_string(),
-            display_name: "gpt-test".to_string(),
-            description: Some("desc".to_string()),
-            default_reasoning_level: ReasoningLevel::Medium,
-            supported_reasoning_levels: vec![
-                ReasoningLevel::Low,
-                ReasoningLevel::Medium,
-                ReasoningLevel::High,
-            ],
-            shell_type: ShellType::ShellCommand,
-            visibility: ModelVisibility::List,
-            minimal_client_version: ClientVersion(0, 1, 0),
-            supported_in_api: true,
-            priority: 1,
-        }],
-    };
-
-    Mock::given(method("GET"))
-        .and(path("/api/codex/models"))
-        .respond_with(
-            ResponseTemplate::new(200)
-                .insert_header("content-type", "application/json")
-                .set_body_json(&response),
-        )
-        .mount(&server)
-        .await;
-
-    let transport = ReqwestTransport::new(reqwest::Client::new());
-    let client = ModelsClient::new(transport, provider(&base_url), DummyAuth);
-
-    let result = client
-        .list_models("0.1.0", HeaderMap::new())
-        .await
-        .expect("models request should succeed");
-
-    assert_eq!(result.models.len(), 1);
-    assert_eq!(result.models[0].slug, "gpt-test");
-
-    let received = server
-        .received_requests()
-        .await
-        .expect("should capture requests");
-    assert_eq!(received.len(), 1);
-    assert_eq!(received[0].method, Method::GET.as_str());
-    assert_eq!(received[0].url.path(), "/api/codex/models");
-}
--- a/codex-rs/codex-client/Cargo.toml
+++ b/codex-rs/codex-client/Cargo.toml
@@ -1,22 +1,21 @@
 [package]
-edition.workspace = true
-license.workspace = true
 name = "codex-client"
 version.workspace = true
+edition.workspace = true
+license.workspace = true

 [dependencies]
 async-trait = { workspace = true }
 bytes = { workspace = true }
-eventsource-stream = { workspace = true }
 futures = { workspace = true }
 http = { workspace = true }
-rand = { workspace = true }
 reqwest = { workspace = true, features = ["json", "stream"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt", "time", "sync"] }
-tracing = { workspace = true }
+rand = { workspace = true }
+eventsource-stream = { workspace = true }

 [lints]
 workspace = true
--- a/codex-rs/codex-client/src/transport.rs
+++ b/codex-rs/codex-client/src/transport.rs
@@ -8,9 +8,6 @@ use futures::stream::BoxStream;
 use http::HeaderMap;
 use http::Method;
 use http::StatusCode;
-use tracing::Level;
-use tracing::enabled;
-use tracing::trace;

 pub type ByteStream = BoxStream<'static, Result<Bytes, TransportError>>;

@@ -86,15 +83,6 @@ impl HttpTransport for ReqwestTransport {
    }

    async fn stream(&self, req: Request) -> Result<StreamResponse, TransportError> {
-        if enabled!(Level::TRACE) {
-            trace!(
-                "{} to {}: {}",
-                req.method,
-                req.url,
-                req.body.as_ref().unwrap_or_default()
-            );
-        }
-
        let builder = self.build(req)?;
        let resp = builder.send().await.map_err(Self::map_error)?;
        let status = resp.status();
--- a/codex-rs/common/Cargo.toml
+++ b/codex-rs/common/Cargo.toml
@@ -9,10 +9,12 @@ workspace = true

 [dependencies]
 clap = { workspace = true, features = ["derive", "wrap_help"], optional = true }
+codex-app-server-protocol = { workspace = true }
 codex-core = { workspace = true }
 codex-lmstudio = { workspace = true }
 codex-ollama = { workspace = true }
 codex-protocol = { workspace = true }
+once_cell = { workspace = true }
 serde = { workspace = true, optional = true }
 toml = { workspace = true, optional = true }

--- a/codex-rs/common/src/config_summary.rs
+++ b/codex-rs/common/src/config_summary.rs
@@ -12,14 +12,15 @@ pub fn create_config_summary_entries(config: &Config) -> Vec<(&'static str, Stri
        ("approval", config.approval_policy.to_string()),
        ("sandbox", summarize_sandbox_policy(&config.sandbox_policy)),
    ];
-    if config.model_provider.wire_api == WireApi::Responses {
+    if config.model_provider.wire_api == WireApi::Responses
+        && config.model_family.supports_reasoning_summaries
+    {
        let reasoning_effort = config
            .model_reasoning_effort
-            .map(|effort| effort.to_string());
-        entries.push((
-            "reasoning effort",
-            reasoning_effort.unwrap_or_else(|| "none".to_string()),
-        ));
+            .or(config.model_family.default_reasoning_effort)
+            .map(|effort| effort.to_string())
+            .unwrap_or_else(|| "none".to_string());
+        entries.push(("reasoning effort", reasoning_effort));
        entries.push((
            "reasoning summaries",
            config.model_reasoning_summary.to_string(),
--- a/codex-rs/common/src/lib.rs
+++ b/codex-rs/common/src/lib.rs
@@ -32,6 +32,8 @@ mod config_summary;
 pub use config_summary::create_config_summary_entries;
 // Shared fuzzy matcher (used by TUI selection popups and other UI filtering)
 pub mod fuzzy_match;
+// Shared model presets used by TUI and MCP server
+pub mod model_presets;
 // Shared approval presets (AskForApproval + Sandbox) used by TUI and MCP server
 // Not to be confused with AskForApproval, which we should probably rename to EscalationPolicy.
 pub mod approval_presets;
--- a/codex-rs/core/src/openai_models/model_presets.rs
+++ b/codex-rs/core/src/openai_models/model_presets.rs
@@ -1,38 +1,76 @@
+use std::collections::HashMap;
+
 use codex_app_server_protocol::AuthMode;
-use codex_protocol::openai_models::ModelPreset;
-use codex_protocol::openai_models::ModelUpgrade;
-use codex_protocol::openai_models::ReasoningEffort;
-use codex_protocol::openai_models::ReasoningEffortPreset;
+use codex_core::protocol_config_types::ReasoningEffort;
 use once_cell::sync::Lazy;

 pub const HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG: &str = "hide_gpt5_1_migration_prompt";
 pub const HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG: &str =
    "hide_gpt-5.1-codex-max_migration_prompt";

+/// A reasoning effort option that can be surfaced for a model.
+#[derive(Debug, Clone, Copy)]
+pub struct ReasoningEffortPreset {
+    /// Effort level that the model supports.
+    pub effort: ReasoningEffort,
+    /// Short human description shown next to the effort in UIs.
+    pub description: &'static str,
+}
+
+#[derive(Debug, Clone)]
+pub struct ModelUpgrade {
+    pub id: &'static str,
+    pub reasoning_effort_mapping: Option<HashMap<ReasoningEffort, ReasoningEffort>>,
+    pub migration_config_key: &'static str,
+}
+
+/// Metadata describing a Codex-supported model.
+#[derive(Debug, Clone)]
+pub struct ModelPreset {
+    /// Stable identifier for the preset.
+    pub id: &'static str,
+    /// Model slug (e.g., "gpt-5").
+    pub model: &'static str,
+    /// Display name shown in UIs.
+    pub display_name: &'static str,
+    /// Short human description shown in UIs.
+    pub description: &'static str,
+    /// Reasoning effort applied when none is explicitly chosen.
+    pub default_reasoning_effort: ReasoningEffort,
+    /// Supported reasoning effort options.
+    pub supported_reasoning_efforts: &'static [ReasoningEffortPreset],
+    /// Whether this is the default model for new users.
+    pub is_default: bool,
+    /// recommended upgrade model
+    pub upgrade: Option<ModelUpgrade>,
+    /// Whether this preset should appear in the picker UI.
+    pub show_in_picker: bool,
+}
+
 static PRESETS: Lazy<Vec<ModelPreset>> = Lazy::new(|| {
    vec![
        ModelPreset {
-            id: "gpt-5.1-codex-max".to_string(),
-            model: "gpt-5.1-codex-max".to_string(),
-            display_name: "gpt-5.1-codex-max".to_string(),
-            description: "Latest Codex-optimized flagship for deep and fast reasoning.".to_string(),
+            id: "gpt-5.1-codex-max",
+            model: "gpt-5.1-codex-max",
+            display_name: "gpt-5.1-codex-max",
+            description: "Latest Codex-optimized flagship for deep and fast reasoning.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Low,
-                    description: "Fast responses with lighter reasoning".to_string(),
+                    description: "Fast responses with lighter reasoning",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Balances speed and reasoning depth for everyday tasks".to_string(),
+                    description: "Balances speed and reasoning depth for everyday tasks",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex problems".to_string(),
+                    description: "Maximizes reasoning depth for complex problems",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::XHigh,
-                    description: "Extra high reasoning depth for complex problems".to_string(),
+                    description: "Extra high reasoning depth for complex problems",
                },
            ],
            is_default: true,
@@ -40,184 +78,184 @@ static PRESETS: Lazy<Vec<ModelPreset>> = Lazy::new(|| {
            show_in_picker: true,
        },
        ModelPreset {
-            id: "gpt-5.1-codex".to_string(),
-            model: "gpt-5.1-codex".to_string(),
-            display_name: "gpt-5.1-codex".to_string(),
-            description: "Optimized for codex.".to_string(),
+            id: "gpt-5.1-codex",
+            model: "gpt-5.1-codex",
+            display_name: "gpt-5.1-codex",
+            description: "Optimized for codex.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Low,
-                    description: "Fastest responses with limited reasoning".to_string(),
+                    description: "Fastest responses with limited reasoning",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Dynamically adjusts reasoning based on the task".to_string(),
+                    description: "Dynamically adjusts reasoning based on the task",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems"
-                        .to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-max".to_string(),
+                id: "gpt-5.1-codex-max",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: true,
        },
        ModelPreset {
-            id: "gpt-5.1-codex-mini".to_string(),
-            model: "gpt-5.1-codex-mini".to_string(),
-            display_name: "gpt-5.1-codex-mini".to_string(),
-            description: "Optimized for codex. Cheaper, faster, but less capable.".to_string(),
+            id: "gpt-5.1-codex-mini",
+            model: "gpt-5.1-codex-mini",
+            display_name: "gpt-5.1-codex-mini",
+            description: "Optimized for codex. Cheaper, faster, but less capable.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Dynamically adjusts reasoning based on the task".to_string(),
+                    description: "Dynamically adjusts reasoning based on the task",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems"
-                        .to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-max".to_string(),
+                id: "gpt-5.1-codex-max",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: true,
        },
        ModelPreset {
-            id: "gpt-5.1".to_string(),
-            model: "gpt-5.1".to_string(),
-            display_name: "gpt-5.1".to_string(),
-            description: "Broad world knowledge with strong general reasoning.".to_string(),
+            id: "gpt-5.1",
+            model: "gpt-5.1",
+            display_name: "gpt-5.1",
+            description: "Broad world knowledge with strong general reasoning.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Low,
-                    description: "Balances speed with some reasoning; useful for straightforward queries and short explanations".to_string(),
+                    description: "Balances speed with some reasoning; useful for straightforward queries and short explanations",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks".to_string(),
+                    description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems".to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-max".to_string(),
+                id: "gpt-5.1-codex-max",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: true,
        },
        // Deprecated models.
        ModelPreset {
-            id: "gpt-5-codex".to_string(),
-            model: "gpt-5-codex".to_string(),
-            display_name: "gpt-5-codex".to_string(),
-            description: "Optimized for codex.".to_string(),
+            id: "gpt-5-codex",
+            model: "gpt-5-codex",
+            display_name: "gpt-5-codex",
+            description: "Optimized for codex.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Low,
-                    description: "Fastest responses with limited reasoning".to_string(),
+                    description: "Fastest responses with limited reasoning",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Dynamically adjusts reasoning based on the task".to_string(),
+                    description: "Dynamically adjusts reasoning based on the task",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems".to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-max".to_string(),
+                id: "gpt-5.1-codex-max",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: false,
        },
        ModelPreset {
-            id: "gpt-5-codex-mini".to_string(),
-            model: "gpt-5-codex-mini".to_string(),
-            display_name: "gpt-5-codex-mini".to_string(),
-            description: "Optimized for codex. Cheaper, faster, but less capable.".to_string(),
+            id: "gpt-5-codex-mini",
+            model: "gpt-5-codex-mini",
+            display_name: "gpt-5-codex-mini",
+            description: "Optimized for codex. Cheaper, faster, but less capable.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Dynamically adjusts reasoning based on the task".to_string(),
+                    description: "Dynamically adjusts reasoning based on the task",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems".to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-mini".to_string(),
+                id: "gpt-5.1-codex-mini",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT5_1_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: false,
        },
        ModelPreset {
-            id: "gpt-5".to_string(),
-            model: "gpt-5".to_string(),
-            display_name: "gpt-5".to_string(),
-            description: "Broad world knowledge with strong general reasoning.".to_string(),
+            id: "gpt-5",
+            model: "gpt-5",
+            display_name: "gpt-5",
+            description: "Broad world knowledge with strong general reasoning.",
            default_reasoning_effort: ReasoningEffort::Medium,
-            supported_reasoning_efforts: vec![
+            supported_reasoning_efforts: &[
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Minimal,
-                    description: "Fastest responses with little reasoning".to_string(),
+                    description: "Fastest responses with little reasoning",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Low,
-                    description: "Balances speed with some reasoning; useful for straightforward queries and short explanations".to_string(),
+                    description: "Balances speed with some reasoning; useful for straightforward queries and short explanations",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::Medium,
-                    description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks".to_string(),
+                    description: "Provides a solid balance of reasoning depth and latency for general-purpose tasks",
                },
                ReasoningEffortPreset {
                    effort: ReasoningEffort::High,
-                    description: "Maximizes reasoning depth for complex or ambiguous problems".to_string(),
+                    description: "Maximizes reasoning depth for complex or ambiguous problems",
                },
            ],
            is_default: false,
            upgrade: Some(ModelUpgrade {
-                id: "gpt-5.1-codex-max".to_string(),
+                id: "gpt-5.1-codex-max",
                reasoning_effort_mapping: None,
-                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG.to_string(),
+                migration_config_key: HIDE_GPT_5_1_CODEX_MAX_MIGRATION_PROMPT_CONFIG,
            }),
            show_in_picker: false,
        },
    ]
 });

-pub(crate) fn builtin_model_presets(_auth_mode: Option<AuthMode>) -> Vec<ModelPreset> {
+pub fn builtin_model_presets(auth_mode: Option<AuthMode>) -> Vec<ModelPreset> {
    PRESETS
        .iter()
-        .filter(|preset| preset.show_in_picker)
+        .filter(|preset| match auth_mode {
+            Some(AuthMode::ApiKey) => preset.show_in_picker && preset.id != "gpt-5.1-codex-max",
+            _ => preset.show_in_picker,
+        })
        .cloned()
        .collect()
 }

-// todo(aibrahim): remove this once we migrate tests
 pub fn all_model_presets() -> &'static Vec<ModelPreset> {
    &PRESETS
 }
@@ -225,10 +263,21 @@ pub fn all_model_presets() -> &'static Vec<ModelPreset> {
 #[cfg(test)]
 mod tests {
    use super::*;
+    use codex_app_server_protocol::AuthMode;

    #[test]
    fn only_one_default_model_is_configured() {
        let default_models = PRESETS.iter().filter(|preset| preset.is_default).count();
        assert!(default_models == 1);
    }
+
+    #[test]
+    fn gpt_5_1_codex_max_hidden_for_api_key_auth() {
+        let presets = builtin_model_presets(Some(AuthMode::ApiKey));
+        assert!(
+            presets
+                .iter()
+                .all(|preset| preset.id != "gpt-5.1-codex-max")
+        );
+    }
 }
--- a/codex-rs/core/Cargo.toml
+++ b/codex-rs/core/Cargo.toml
@@ -1,8 +1,8 @@
 [package]
-name = "codex-core"
-version.workspace = true
 edition.workspace = true
 license.workspace = true
+name = "codex-core"
+version.workspace = true

 [lib]
 doctest = false
@@ -18,12 +18,13 @@ askama = { workspace = true }
 async-channel = { workspace = true }
 async-trait = { workspace = true }
 base64 = { workspace = true }
-chrono = { workspace = true, features = ["serde"] }
 chardetng = { workspace = true }
+chrono = { workspace = true, features = ["serde"] }
+codex-api = { workspace = true }
 codex-app-server-protocol = { workspace = true }
 codex-apply-patch = { workspace = true }
 codex-async-utils = { workspace = true }
-codex-api = { workspace = true }
+codex-client = { workspace = true }
 codex-execpolicy = { workspace = true }
 codex-file-search = { workspace = true }
 codex-git = { workspace = true }
@@ -37,8 +38,8 @@ codex-utils-string = { workspace = true }
 codex-windows-sandbox = { package = "codex-windows-sandbox", path = "../windows-sandbox-rs" }
 dirs = { workspace = true }
 dunce = { workspace = true }
-env-flags = { workspace = true }
 encoding_rs = { workspace = true }
+env-flags = { workspace = true }
 eventsource-stream = { workspace = true }
 futures = { workspace = true }
 http = { workspace = true }
@@ -46,21 +47,19 @@ indexmap = { workspace = true }
 keyring = { workspace = true, features = ["crypto-rust"] }
 libc = { workspace = true }
 mcp-types = { workspace = true }
+once_cell = { workspace = true }
 os_info = { workspace = true }
 rand = { workspace = true }
+regex = { workspace = true }
 regex-lite = { workspace = true }
 reqwest = { workspace = true, features = ["json", "stream"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-serde_yaml = { workspace = true }
 sha1 = { workspace = true }
 sha2 = { workspace = true }
 shlex = { workspace = true }
 similar = { workspace = true }
 strum_macros = { workspace = true }
-url = { workspace = true }
-once_cell = { workspace = true }
-regex = { workspace = true }
 tempfile = { workspace = true }
 test-case = "3.3.1"
 test-log = { workspace = true }
@@ -84,6 +83,7 @@ toml_edit = { workspace = true }
 tracing = { workspace = true, features = ["log"] }
 tree-sitter = { workspace = true }
 tree-sitter-bash = { workspace = true }
+url = { workspace = true }
 uuid = { workspace = true, features = ["serde", "v4", "v5"] }
 which = { workspace = true }
 wildmatch = { workspace = true }
@@ -93,9 +93,9 @@ deterministic_process_ids = []


 [target.'cfg(target_os = "linux")'.dependencies]
+keyring = { workspace = true, features = ["linux-native-async-persistent"] }
 landlock = { workspace = true }
 seccompiler = { workspace = true }
-keyring = { workspace = true, features = ["linux-native-async-persistent"] }

 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9"
--- a/codex-rs/core/src/api_bridge.rs
+++ b/codex-rs/core/src/api_bridge.rs
@@ -33,20 +33,12 @@ pub(crate) fn map_api_error(err: ApiError) -> CodexErr {
                headers,
                body,
            } => {
-                let body_text = body.unwrap_or_default();
-
-                if status == http::StatusCode::BAD_REQUEST {
-                    if body_text
-                        .contains("The image data you provided does not represent a valid image")
-                    {
-                        CodexErr::InvalidImageRequest()
-                    } else {
-                        CodexErr::InvalidRequest(body_text)
-                    }
-                } else if status == http::StatusCode::INTERNAL_SERVER_ERROR {
+                if status == http::StatusCode::INTERNAL_SERVER_ERROR {
                    CodexErr::InternalServerError
                } else if status == http::StatusCode::TOO_MANY_REQUESTS {
-                    if let Ok(err) = serde_json::from_str::<UsageErrorResponse>(&body_text) {
+                    if let Some(body) = body
+                        && let Ok(err) = serde_json::from_str::<UsageErrorResponse>(&body)
+                    {
                        if err.error.error_type.as_deref() == Some("usage_limit_reached") {
                            let rate_limits = headers.as_ref().and_then(parse_rate_limit);
                            let resets_at = err
@@ -70,7 +62,7 @@ pub(crate) fn map_api_error(err: ApiError) -> CodexErr {
                } else {
                    CodexErr::UnexpectedStatus(UnexpectedResponseError {
                        status,
-                        body: body_text,
+                        body: body.unwrap_or_default(),
                        request_id: extract_request_id(headers.as_ref()),
                    })
                }
--- a/codex-rs/core/src/apply_patch.rs
+++ b/codex-rs/core/src/apply_patch.rs
@@ -70,9 +70,7 @@ pub(crate) async fn apply_patch(
                )
                .await;
            match rx_approve.await.unwrap_or_default() {
-                ReviewDecision::Approved
-                | ReviewDecision::ApprovedExecpolicyAmendment { .. }
-                | ReviewDecision::ApprovedForSession => {
+                ReviewDecision::Approved | ReviewDecision::ApprovedForSession => {
                    InternalApplyPatchInvocation::DelegateToExec(ApplyPatchExec {
                        action,
                        user_explicitly_approved_this_action: true,
--- a/codex-rs/core/src/auth.rs
+++ b/codex-rs/core/src/auth.rs
@@ -1201,8 +1201,4 @@ impl AuthManager {
        self.reload();
        Ok(removed)
    }
-
-    pub fn get_auth_mode(&self) -> Option<AuthMode> {
-        self.auth().map(|a| a.mode)
-    }
 }
--- a/codex-rs/core/src/client.rs
+++ b/codex-rs/core/src/client.rs
@@ -20,9 +20,9 @@ use codex_api::error::ApiError;
 use codex_app_server_protocol::AuthMode;
 use codex_otel::otel_event_manager::OtelEventManager;
 use codex_protocol::ConversationId;
+use codex_protocol::config_types::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::config_types::ReasoningSummary as ReasoningSummaryConfig;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::protocol::SessionSource;
 use eventsource_stream::Event;
 use eventsource_stream::EventStreamError;
@@ -46,10 +46,10 @@ use crate::default_client::build_reqwest_client;
 use crate::error::CodexErr;
 use crate::error::Result;
 use crate::flags::CODEX_RS_SSE_FIXTURE;
+use crate::model_family::ModelFamily;
 use crate::model_provider_info::ModelProviderInfo;
 use crate::model_provider_info::WireApi;
 use crate::openai_model_info::get_model_info;
-use crate::openai_models::model_family::ModelFamily;
 use crate::tools::spec::create_tools_json_for_chat_completions_api;
 use crate::tools::spec::create_tools_json_for_responses_api;

@@ -57,7 +57,6 @@ use crate::tools::spec::create_tools_json_for_responses_api;
 pub struct ModelClient {
    config: Arc<Config>,
    auth_manager: Option<Arc<AuthManager>>,
-    model_family: ModelFamily,
    otel_event_manager: OtelEventManager,
    provider: ModelProviderInfo,
    conversation_id: ConversationId,
@@ -71,7 +70,6 @@ impl ModelClient {
    pub fn new(
        config: Arc<Config>,
        auth_manager: Option<Arc<AuthManager>>,
-        model_family: ModelFamily,
        otel_event_manager: OtelEventManager,
        provider: ModelProviderInfo,
        effort: Option<ReasoningEffortConfig>,
@@ -82,7 +80,6 @@ impl ModelClient {
        Self {
            config,
            auth_manager,
-            model_family,
            otel_event_manager,
            provider,
            conversation_id,
@@ -93,18 +90,16 @@ impl ModelClient {
    }

    pub fn get_model_context_window(&self) -> Option<i64> {
-        let model_family = self.get_model_family();
-        let effective_context_window_percent = model_family.effective_context_window_percent;
+        let pct = self.config.model_family.effective_context_window_percent;
        self.config
            .model_context_window
-            .or_else(|| get_model_info(&model_family).map(|info| info.context_window))
-            .map(|w| w.saturating_mul(effective_context_window_percent) / 100)
+            .or_else(|| get_model_info(&self.config.model_family).map(|info| info.context_window))
+            .map(|w| w.saturating_mul(pct) / 100)
    }

    pub fn get_auto_compact_token_limit(&self) -> Option<i64> {
-        let model_family = self.get_model_family();
        self.config.model_auto_compact_token_limit.or_else(|| {
-            get_model_info(&model_family).and_then(|info| info.auto_compact_token_limit)
+            get_model_info(&self.config.model_family).and_then(|info| info.auto_compact_token_limit)
        })
    }

@@ -154,8 +149,9 @@ impl ModelClient {
        }

        let auth_manager = self.auth_manager.clone();
-        let model_family = self.get_model_family();
-        let instructions = prompt.get_full_instructions(&model_family).into_owned();
+        let instructions = prompt
+            .get_full_instructions(&self.config.model_family)
+            .into_owned();
        let tools_json = create_tools_json_for_chat_completions_api(&prompt.tools)?;
        let api_prompt = build_api_prompt(prompt, instructions, tools_json);
        let conversation_id = self.conversation_id.to_string();
@@ -208,13 +204,16 @@ impl ModelClient {
        }

        let auth_manager = self.auth_manager.clone();
-        let model_family = self.get_model_family();
-        let instructions = prompt.get_full_instructions(&model_family).into_owned();
+        let instructions = prompt
+            .get_full_instructions(&self.config.model_family)
+            .into_owned();
        let tools_json: Vec<Value> = create_tools_json_for_responses_api(&prompt.tools)?;

-        let reasoning = if model_family.supports_reasoning_summaries {
+        let reasoning = if self.config.model_family.supports_reasoning_summaries {
            Some(Reasoning {
-                effort: self.effort.or(model_family.default_reasoning_effort),
+                effort: self
+                    .effort
+                    .or(self.config.model_family.default_reasoning_effort),
                summary: Some(self.summary),
            })
        } else {
@@ -227,15 +226,15 @@ impl ModelClient {
            vec![]
        };

-        let verbosity = if model_family.support_verbosity {
+        let verbosity = if self.config.model_family.support_verbosity {
            self.config
                .model_verbosity
-                .or(model_family.default_verbosity)
+                .or(self.config.model_family.default_verbosity)
        } else {
            if self.config.model_verbosity.is_some() {
                warn!(
                    "model_verbosity is set but ignored as the model does not support verbosity: {}",
-                    model_family.family
+                    self.config.model_family.family
                );
            }
            None
@@ -306,7 +305,7 @@ impl ModelClient {

    /// Returns the currently configured model family.
    pub fn get_model_family(&self) -> ModelFamily {
-        self.model_family.clone()
+        self.config.model_family.clone()
    }

    /// Returns the current reasoning effort setting.
@@ -343,7 +342,7 @@ impl ModelClient {
            .with_telemetry(Some(request_telemetry));

        let instructions = prompt
-            .get_full_instructions(&self.get_model_family())
+            .get_full_instructions(&self.config.model_family)
            .into_owned();
        let payload = ApiCompactionInput {
            model: &self.config.model,
--- a/codex-rs/core/src/client_common.rs
+++ b/codex-rs/core/src/client_common.rs
@@ -1,6 +1,6 @@
 use crate::client_common::tools::ToolSpec;
 use crate::error::Result;
-use crate::openai_models::model_family::ModelFamily;
+use crate::model_family::ModelFamily;
 pub use codex_api::common::ResponseEvent;
 use codex_apply_patch::APPLY_PATCH_TOOL_INSTRUCTIONS;
 use codex_protocol::models::ResponseItem;
@@ -252,7 +252,7 @@ impl Stream for ResponseStream {

 #[cfg(test)]
 mod tests {
-    use crate::openai_models::model_family::find_family_for_model;
+    use crate::model_family::find_family_for_model;
    use codex_api::ResponsesApiRequest;
    use codex_api::common::OpenAiVerbosity;
    use codex_api::common::TextControls;
@@ -309,7 +309,7 @@ mod tests {
            },
        ];
        for test_case in test_cases {
-            let model_family = find_family_for_model(test_case.slug);
+            let model_family = find_family_for_model(test_case.slug).expect("known model slug");
            let expected = if test_case.expects_apply_patch_instructions {
                format!(
                    "{}\n{}",
--- a/codex-rs/core/src/codex.rs
+++ b/codex-rs/core/src/codex.rs
--- a/codex-rs/core/src/codex_delegate.rs
+++ b/codex-rs/core/src/codex_delegate.rs
@@ -25,7 +25,6 @@ use crate::codex::Session;
 use crate::codex::TurnContext;
 use crate::config::Config;
 use crate::error::CodexErr;
-use crate::openai_models::models_manager::ModelsManager;
 use codex_protocol::protocol::InitialHistory;

 /// Start an interactive sub-Codex conversation and return IO channels.
@@ -36,7 +35,6 @@ use codex_protocol::protocol::InitialHistory;
 pub(crate) async fn run_codex_conversation_interactive(
    config: Config,
    auth_manager: Arc<AuthManager>,
-    models_manager: Arc<ModelsManager>,
    parent_session: Arc<Session>,
    parent_ctx: Arc<TurnContext>,
    cancel_token: CancellationToken,
@@ -48,7 +46,6 @@ pub(crate) async fn run_codex_conversation_interactive(
    let CodexSpawnOk { codex, .. } = Codex::spawn(
        config,
        auth_manager,
-        models_manager,
        initial_history.unwrap_or(InitialHistory::New),
        SessionSource::SubAgent(SubAgentSource::Review),
    )
@@ -91,11 +88,9 @@ pub(crate) async fn run_codex_conversation_interactive(
 /// Convenience wrapper for one-time use with an initial prompt.
 ///
 /// Internally calls the interactive variant, then immediately submits the provided input.
-#[allow(clippy::too_many_arguments)]
 pub(crate) async fn run_codex_conversation_one_shot(
    config: Config,
    auth_manager: Arc<AuthManager>,
-    models_manager: Arc<ModelsManager>,
    input: Vec<UserInput>,
    parent_session: Arc<Session>,
    parent_ctx: Arc<TurnContext>,
@@ -108,7 +103,6 @@ pub(crate) async fn run_codex_conversation_one_shot(
    let io = run_codex_conversation_interactive(
        config,
        auth_manager,
-        models_manager,
        parent_session,
        parent_ctx,
        child_cancel.clone(),
@@ -281,7 +275,6 @@ async fn handle_exec_approval(
        event.cwd,
        event.reason,
        event.risk,
-        event.proposed_execpolicy_amendment,
    );
    let decision = await_approval_with_cancel(
        approval_fut,
--- a/codex-rs/core/src/compact.rs
+++ b/codex-rs/core/src/compact.rs
@@ -32,13 +32,13 @@ pub const SUMMARIZATION_PROMPT: &str = include_str!("../templates/compact/prompt
 pub const SUMMARY_PREFIX: &str = include_str!("../templates/compact/summary_prefix.md");
 const COMPACT_USER_MESSAGE_MAX_TOKENS: usize = 20_000;

-pub(crate) fn should_use_remote_compact_task(session: &Session) -> bool {
+pub(crate) async fn should_use_remote_compact_task(session: &Session) -> bool {
    session
        .services
        .auth_manager
        .auth()
        .is_some_and(|auth| auth.mode == AuthMode::ChatGPT)
-        && session.enabled(Feature::RemoteCompaction)
+        && session.enabled(Feature::RemoteCompaction).await
 }

 pub(crate) async fn run_inline_auto_compact_task(
--- a/codex-rs/core/src/config/edit.rs
+++ b/codex-rs/core/src/config/edit.rs
@@ -2,8 +2,8 @@ use crate::config::CONFIG_TOML_FILE;
 use crate::config::types::McpServerConfig;
 use crate::config::types::Notice;
 use anyhow::Context;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::TrustLevel;
-use codex_protocol::openai_models::ReasoningEffort;
 use std::collections::BTreeMap;
 use std::path::Path;
 use std::path::PathBuf;
@@ -574,7 +574,7 @@ impl ConfigEditsBuilder {
 mod tests {
    use super::*;
    use crate::config::types::McpServerTransportConfig;
-    use codex_protocol::openai_models::ReasoningEffort;
+    use codex_protocol::config_types::ReasoningEffort;
    use pretty_assertions::assert_eq;
    use tempfile::tempdir;
    use tokio::runtime::Builder;
--- a/codex-rs/core/src/config/mod.rs
+++ b/codex-rs/core/src/config/mod.rs
@@ -22,25 +22,26 @@ use crate::features::FeatureOverrides;
 use crate::features::Features;
 use crate::features::FeaturesToml;
 use crate::git_info::resolve_root_git_project_for_trust;
+use crate::model_family::ModelFamily;
+use crate::model_family::derive_default_model_family;
+use crate::model_family::find_family_for_model;
 use crate::model_provider_info::LMSTUDIO_OSS_PROVIDER_ID;
 use crate::model_provider_info::ModelProviderInfo;
 use crate::model_provider_info::OLLAMA_OSS_PROVIDER_ID;
 use crate::model_provider_info::built_in_model_providers;
 use crate::openai_model_info::get_model_info;
-use crate::openai_models::model_family::find_family_for_model;
 use crate::project_doc::DEFAULT_PROJECT_DOC_FILENAME;
 use crate::project_doc::LOCAL_PROJECT_DOC_FILENAME;
 use crate::protocol::AskForApproval;
 use crate::protocol::SandboxPolicy;
-use crate::util::resolve_path;
 use codex_app_server_protocol::Tools;
 use codex_app_server_protocol::UserSavedConfig;
 use codex_protocol::config_types::ForcedLoginMethod;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::SandboxMode;
 use codex_protocol::config_types::TrustLevel;
 use codex_protocol::config_types::Verbosity;
-use codex_protocol::openai_models::ReasoningEffort;
 use codex_rmcp_client::OAuthCredentialsStoreMode;
 use dirs::home_dir;
 use dunce::canonicalize;
@@ -60,8 +61,9 @@ pub mod edit;
 pub mod profile;
 pub mod types;

-pub const OPENAI_DEFAULT_MODEL: &str = "gpt-5.1-codex-max";
-const OPENAI_DEFAULT_REVIEW_MODEL: &str = "gpt-5.1-codex-max";
+pub const OPENAI_DEFAULT_MODEL: &str = "gpt-5.1-codex";
+const OPENAI_DEFAULT_REVIEW_MODEL: &str = "gpt-5.1-codex";
+pub const GPT_5_CODEX_MEDIUM_MODEL: &str = "gpt-5.1-codex";

 /// Maximum number of bytes of the documentation that will be embedded. Larger
 /// files are *silently truncated* to this size so we do not take up too much of
@@ -79,6 +81,8 @@ pub struct Config {
    /// Model used specifically for review sessions. Defaults to "gpt-5.1-codex-max".
    pub review_model: String,

+    pub model_family: ModelFamily,
+
    /// Size of the context window for the model, in tokens.
    pub model_context_window: Option<i64>,

@@ -156,9 +160,6 @@ pub struct Config {
    /// Enable ASCII animations and shimmer effects in the TUI.
    pub animations: bool,

-    /// Show startup tooltips in the TUI welcome screen.
-    pub show_tooltips: bool,
-
    /// The directory that should be treated as the current working directory
    /// for the session. All relative paths inside the business-logic layer are
    /// resolved against this path.
@@ -191,7 +192,6 @@ pub struct Config {
    /// Additional filenames to try when looking for project-level docs.
    pub project_doc_fallback_filenames: Vec<String>,

-    // todo(aibrahim): this should be used in the override model family
    /// Token budget applied when storing tool/function outputs in the context manager.
    pub tool_output_token_limit: Option<usize>,

@@ -222,12 +222,6 @@ pub struct Config {
    /// request using the Responses API.
    pub model_reasoning_summary: ReasoningSummary,

-    /// Optional override to force-enable reasoning summaries for the configured model.
-    pub model_supports_reasoning_summaries: Option<bool>,
-
-    /// Optional override to force reasoning summary format for the configured model.
-    pub model_reasoning_summary_format: Option<ReasoningSummaryFormat>,
-
    /// Optional verbosity control for GPT-5 models (Responses API `text.verbosity`).
    pub model_verbosity: Option<Verbosity>,

@@ -1022,8 +1016,15 @@ impl Config {
        let additional_writable_roots: Vec<PathBuf> = additional_writable_roots
            .into_iter()
            .map(|path| {
-                let absolute = resolve_path(&resolved_cwd, &path);
-                canonicalize(&absolute).unwrap_or(absolute)
+                let absolute = if path.is_absolute() {
+                    path
+                } else {
+                    resolved_cwd.join(path)
+                };
+                match canonicalize(&absolute) {
+                    Ok(canonical) => canonical,
+                    Err(_) => absolute,
+                }
            })
            .collect();
        let active_project = cfg
@@ -1111,7 +1112,15 @@ impl Config {
            .or(cfg.model)
            .unwrap_or_else(default_model);

-        let model_family = find_family_for_model(&model);
+        let mut model_family =
+            find_family_for_model(&model).unwrap_or_else(|| derive_default_model_family(&model));
+
+        if let Some(supports_reasoning_summaries) = cfg.model_supports_reasoning_summaries {
+            model_family.supports_reasoning_summaries = supports_reasoning_summaries;
+        }
+        if let Some(model_reasoning_summary_format) = cfg.model_reasoning_summary_format {
+            model_family.reasoning_summary_format = model_reasoning_summary_format;
+        }

        let openai_model_info = get_model_info(&model_family);
        let model_context_window = cfg
@@ -1168,6 +1177,7 @@ impl Config {
        let config = Self {
            model,
            review_model,
+            model_family,
            model_context_window,
            model_auto_compact_token_limit,
            model_provider_id,
@@ -1223,8 +1233,6 @@ impl Config {
                .model_reasoning_summary
                .or(cfg.model_reasoning_summary)
                .unwrap_or_default(),
-            model_supports_reasoning_summaries: cfg.model_supports_reasoning_summaries,
-            model_reasoning_summary_format: cfg.model_reasoning_summary_format.clone(),
            model_verbosity: config_profile.model_verbosity.or(cfg.model_verbosity),
            chatgpt_base_url: config_profile
                .chatgpt_base_url
@@ -1250,7 +1258,6 @@ impl Config {
                .map(|t| t.notifications.clone())
                .unwrap_or_default(),
            animations: cfg.tui.as_ref().map(|t| t.animations).unwrap_or(true),
-            show_tooltips: cfg.tui.as_ref().map(|t| t.show_tooltips).unwrap_or(true),
            otel: {
                let t: OtelConfigToml = cfg.otel.unwrap_or_default();
                let log_user_prompt = t.log_user_prompt.unwrap_or(false);
@@ -1292,7 +1299,11 @@ impl Config {
            return Ok(None);
        };

-        let full_path = resolve_path(cwd, p);
+        let full_path = if p.is_relative() {
+            cwd.join(p)
+        } else {
+            p.to_path_buf()
+        };

        let contents = std::fs::read_to_string(&full_path).map_err(|e| {
            std::io::Error::new(
@@ -1425,7 +1436,6 @@ persistence = "none"
        let tui = parsed.tui.expect("config should include tui section");

        assert_eq!(tui.notifications, Notifications::Enabled(true));
-        assert!(tui.show_tooltips);
    }

    #[test]
@@ -2950,6 +2960,7 @@ model_verbosity = "high"
            Config {
                model: "o3".to_string(),
                review_model: OPENAI_DEFAULT_REVIEW_MODEL.to_string(),
+                model_family: find_family_for_model("o3").expect("known model slug"),
                model_context_window: Some(200_000),
                model_auto_compact_token_limit: Some(180_000),
                model_provider_id: "openai".to_string(),
@@ -2977,8 +2988,6 @@ model_verbosity = "high"
                show_raw_agent_reasoning: false,
                model_reasoning_effort: Some(ReasoningEffort::High),
                model_reasoning_summary: ReasoningSummary::Detailed,
-                model_supports_reasoning_summaries: None,
-                model_reasoning_summary_format: None,
                model_verbosity: None,
                chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
                base_instructions: None,
@@ -3000,7 +3009,6 @@ model_verbosity = "high"
                disable_paste_burst: false,
                tui_notifications: Default::default(),
                animations: true,
-                show_tooltips: true,
                otel: OtelConfig::default(),
            },
            o3_profile_config
@@ -3025,6 +3033,7 @@ model_verbosity = "high"
        let expected_gpt3_profile_config = Config {
            model: "gpt-3.5-turbo".to_string(),
            review_model: OPENAI_DEFAULT_REVIEW_MODEL.to_string(),
+            model_family: find_family_for_model("gpt-3.5-turbo").expect("known model slug"),
            model_context_window: Some(16_385),
            model_auto_compact_token_limit: Some(14_746),
            model_provider_id: "openai-chat-completions".to_string(),
@@ -3052,8 +3061,6 @@ model_verbosity = "high"
            show_raw_agent_reasoning: false,
            model_reasoning_effort: None,
            model_reasoning_summary: ReasoningSummary::default(),
-            model_supports_reasoning_summaries: None,
-            model_reasoning_summary_format: None,
            model_verbosity: None,
            chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
            base_instructions: None,
@@ -3075,7 +3082,6 @@ model_verbosity = "high"
            disable_paste_burst: false,
            tui_notifications: Default::default(),
            animations: true,
-            show_tooltips: true,
            otel: OtelConfig::default(),
        };

@@ -3115,6 +3121,7 @@ model_verbosity = "high"
        let expected_zdr_profile_config = Config {
            model: "o3".to_string(),
            review_model: OPENAI_DEFAULT_REVIEW_MODEL.to_string(),
+            model_family: find_family_for_model("o3").expect("known model slug"),
            model_context_window: Some(200_000),
            model_auto_compact_token_limit: Some(180_000),
            model_provider_id: "openai".to_string(),
@@ -3142,8 +3149,6 @@ model_verbosity = "high"
            show_raw_agent_reasoning: false,
            model_reasoning_effort: None,
            model_reasoning_summary: ReasoningSummary::default(),
-            model_supports_reasoning_summaries: None,
-            model_reasoning_summary_format: None,
            model_verbosity: None,
            chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
            base_instructions: None,
@@ -3165,7 +3170,6 @@ model_verbosity = "high"
            disable_paste_burst: false,
            tui_notifications: Default::default(),
            animations: true,
-            show_tooltips: true,
            otel: OtelConfig::default(),
        };

@@ -3191,6 +3195,7 @@ model_verbosity = "high"
        let expected_gpt5_profile_config = Config {
            model: "gpt-5.1".to_string(),
            review_model: OPENAI_DEFAULT_REVIEW_MODEL.to_string(),
+            model_family: find_family_for_model("gpt-5.1").expect("known model slug"),
            model_context_window: Some(272_000),
            model_auto_compact_token_limit: Some(244_800),
            model_provider_id: "openai".to_string(),
@@ -3218,8 +3223,6 @@ model_verbosity = "high"
            show_raw_agent_reasoning: false,
            model_reasoning_effort: Some(ReasoningEffort::High),
            model_reasoning_summary: ReasoningSummary::Detailed,
-            model_supports_reasoning_summaries: None,
-            model_reasoning_summary_format: None,
            model_verbosity: Some(Verbosity::High),
            chatgpt_base_url: "https://chatgpt.com/backend-api/".to_string(),
            base_instructions: None,
@@ -3241,7 +3244,6 @@ model_verbosity = "high"
            disable_paste_burst: false,
            tui_notifications: Default::default(),
            animations: true,
-            show_tooltips: true,
            otel: OtelConfig::default(),
        };

--- a/codex-rs/core/src/config/profile.rs
+++ b/codex-rs/core/src/config/profile.rs
@@ -2,10 +2,10 @@ use serde::Deserialize;
 use std::path::PathBuf;

 use crate::protocol::AskForApproval;
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::SandboxMode;
 use codex_protocol::config_types::Verbosity;
-use codex_protocol::openai_models::ReasoningEffort;

 /// Collection of common configuration options that a user can define as a unit
 /// in `config.toml`.
--- a/codex-rs/core/src/config/types.rs
+++ b/codex-rs/core/src/config/types.rs
@@ -256,8 +256,8 @@ pub struct History {
    /// If true, history entries will not be written to disk.
    pub persistence: HistoryPersistence,

-    /// If set, the maximum size of the history file in bytes. The oldest entries
-    /// are dropped once the file exceeds this limit.
+    /// If set, the maximum size of the history file in bytes.
+    /// TODO(mbolin): Not currently honored.
    pub max_bytes: Option<usize>,
 }

@@ -368,11 +368,6 @@ pub struct Tui {
    /// Defaults to `true`.
    #[serde(default = "default_true")]
    pub animations: bool,
-
-    /// Show startup tooltips in the TUI welcome screen.
-    /// Defaults to `true`.
-    #[serde(default = "default_true")]
-    pub show_tooltips: bool,
 }

 const fn default_true() -> bool {
--- a/codex-rs/core/src/context_manager/history.rs
+++ b/codex-rs/core/src/context_manager/history.rs
@@ -5,8 +5,6 @@ use crate::truncate::approx_token_count;
 use crate::truncate::approx_tokens_from_byte_count;
 use crate::truncate::truncate_function_output_items_with_policy;
 use crate::truncate::truncate_text;
-use codex_protocol::models::ContentItem;
-use codex_protocol::models::FunctionCallOutputContentItem;
 use codex_protocol::models::FunctionCallOutputPayload;
 use codex_protocol::models::ResponseItem;
 use codex_protocol::protocol::TokenUsage;
@@ -120,37 +118,6 @@ impl ContextManager {
        self.items = items;
    }

-    pub(crate) fn replace_last_turn_images(&mut self, placeholder: &str) {
-        let Some(last_item) = self.items.last_mut() else {
-            return;
-        };
-
-        match last_item {
-            ResponseItem::Message { role, content, .. } if role == "user" => {
-                for item in content.iter_mut() {
-                    if matches!(item, ContentItem::InputImage { .. }) {
-                        *item = ContentItem::InputText {
-                            text: placeholder.to_string(),
-                        };
-                    }
-                }
-            }
-            ResponseItem::FunctionCallOutput { output, .. } => {
-                let Some(content_items) = output.content_items.as_mut() else {
-                    return;
-                };
-                for item in content_items.iter_mut() {
-                    if matches!(item, FunctionCallOutputContentItem::InputImage { .. }) {
-                        *item = FunctionCallOutputContentItem::InputText {
-                            text: placeholder.to_string(),
-                        };
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
    pub(crate) fn update_token_info(
        &mut self,
        usage: &TokenUsage,
--- a/codex-rs/core/src/conversation_manager.rs
+++ b/codex-rs/core/src/conversation_manager.rs
@@ -7,7 +7,6 @@ use crate::codex_conversation::CodexConversation;
 use crate::config::Config;
 use crate::error::CodexErr;
 use crate::error::Result as CodexResult;
-use crate::openai_models::models_manager::ModelsManager;
 use crate::protocol::Event;
 use crate::protocol::EventMsg;
 use crate::protocol::SessionConfiguredEvent;
@@ -15,7 +14,6 @@ use crate::rollout::RolloutRecorder;
 use codex_protocol::ConversationId;
 use codex_protocol::items::TurnItem;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ModelPreset;
 use codex_protocol::protocol::InitialHistory;
 use codex_protocol::protocol::RolloutItem;
 use codex_protocol::protocol::SessionSource;
@@ -37,7 +35,6 @@ pub struct NewConversation {
 pub struct ConversationManager {
    conversations: Arc<RwLock<HashMap<ConversationId, Arc<CodexConversation>>>>,
    auth_manager: Arc<AuthManager>,
-    models_manager: Arc<ModelsManager>,
    session_source: SessionSource,
 }

@@ -45,9 +42,8 @@ impl ConversationManager {
    pub fn new(auth_manager: Arc<AuthManager>, session_source: SessionSource) -> Self {
        Self {
            conversations: Arc::new(RwLock::new(HashMap::new())),
-            auth_manager: auth_manager.clone(),
+            auth_manager,
            session_source,
-            models_manager: Arc::new(ModelsManager::new(auth_manager.get_auth_mode())),
        }
    }

@@ -65,19 +61,14 @@ impl ConversationManager {
    }

    pub async fn new_conversation(&self, config: Config) -> CodexResult<NewConversation> {
-        self.spawn_conversation(
-            config,
-            self.auth_manager.clone(),
-            self.models_manager.clone(),
-        )
-        .await
+        self.spawn_conversation(config, self.auth_manager.clone())
+            .await
    }

    async fn spawn_conversation(
        &self,
        config: Config,
        auth_manager: Arc<AuthManager>,
-        models_manager: Arc<ModelsManager>,
    ) -> CodexResult<NewConversation> {
        let CodexSpawnOk {
            codex,
@@ -85,7 +76,6 @@ impl ConversationManager {
        } = Codex::spawn(
            config,
            auth_manager,
-            models_manager,
            InitialHistory::New,
            self.session_source.clone(),
        )
@@ -162,7 +152,6 @@ impl ConversationManager {
        } = Codex::spawn(
            config,
            auth_manager,
-            self.models_manager.clone(),
            initial_history,
            self.session_source.clone(),
        )
@@ -200,25 +189,10 @@ impl ConversationManager {
        let CodexSpawnOk {
            codex,
            conversation_id,
-        } = Codex::spawn(
-            config,
-            auth_manager,
-            self.models_manager.clone(),
-            history,
-            self.session_source.clone(),
-        )
-        .await?;
+        } = Codex::spawn(config, auth_manager, history, self.session_source.clone()).await?;

        self.finalize_spawn(codex, conversation_id).await
    }
-
-    pub async fn list_models(&self) -> Vec<ModelPreset> {
-        self.models_manager.available_models.read().await.clone()
-    }
-
-    pub fn get_models_manager(&self) -> Arc<ModelsManager> {
-        self.models_manager.clone()
-    }
 }

 /// Return a prefix of `items` obtained by cutting strictly before the nth user message
--- a/codex-rs/core/src/error.rs
+++ b/codex-rs/core/src/error.rs
@@ -1,3 +1,4 @@
+use crate::codex::ProcessedResponseItem;
 use crate::exec::ExecToolCallOutput;
 use crate::token_data::KnownPlan;
 use crate::token_data::PlanType;
@@ -60,7 +61,9 @@ pub enum SandboxErr {
 pub enum CodexErr {
    // todo(aibrahim): git rid of this error carrying the dangling artifacts
    #[error("turn aborted. Something went wrong? Hit `/feedback` to report the issue.")]
-    TurnAborted,
+    TurnAborted {
+        dangling_artifacts: Vec<ProcessedResponseItem>,
+    },

    /// Returned by ResponsesClient when the SSE stream disconnects or errors out **after** the HTTP
    /// handshake has succeeded but **before** it finished emitting `response.completed`.
@@ -100,14 +103,6 @@ pub enum CodexErr {
    #[error("{0}")]
    UnexpectedStatus(UnexpectedResponseError),

-    /// Invalid request.
-    #[error("{0}")]
-    InvalidRequest(String),
-
-    /// Invalid image.
-    #[error("Image poisoning")]
-    InvalidImageRequest(),
-
    #[error("{0}")]
    UsageLimitReached(UsageLimitReachedError),

@@ -178,7 +173,9 @@ pub enum CodexErr {

 impl From<CancelErr> for CodexErr {
    fn from(_: CancelErr) -> Self {
-        CodexErr::TurnAborted
+        CodexErr::TurnAborted {
+            dangling_artifacts: Vec::new(),
+        }
    }
 }

--- a/codex-rs/core/src/exec.rs
+++ b/codex-rs/core/src/exec.rs
@@ -485,19 +485,6 @@ pub struct ExecToolCallOutput {
    pub timed_out: bool,
 }

-impl Default for ExecToolCallOutput {
-    fn default() -> Self {
-        Self {
-            exit_code: 0,
-            stdout: StreamOutput::new(String::new()),
-            stderr: StreamOutput::new(String::new()),
-            aggregated_output: StreamOutput::new(String::new()),
-            duration: Duration::ZERO,
-            timed_out: false,
-        }
-    }
-}
-
 #[cfg_attr(not(target_os = "windows"), allow(unused_variables))]
 async fn exec(
    params: ExecParams,
--- a/codex-rs/core/src/exec_policy.rs
+++ b/codex-rs/core/src/exec_policy.rs
@@ -4,35 +4,25 @@ use std::path::PathBuf;
 use std::sync::Arc;

 use crate::command_safety::is_dangerous_command::requires_initial_appoval;
-use codex_execpolicy::AmendError;
 use codex_execpolicy::Decision;
-use codex_execpolicy::Error as ExecPolicyRuleError;
 use codex_execpolicy::Evaluation;
 use codex_execpolicy::Policy;
 use codex_execpolicy::PolicyParser;
-use codex_execpolicy::RuleMatch;
-use codex_execpolicy::blocking_append_allow_prefix_rule;
-use codex_protocol::approvals::ExecPolicyAmendment;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::SandboxPolicy;
 use thiserror::Error;
 use tokio::fs;
-use tokio::sync::RwLock;
-use tokio::task::spawn_blocking;

 use crate::bash::parse_shell_lc_plain_commands;
 use crate::features::Feature;
 use crate::features::Features;
 use crate::sandboxing::SandboxPermissions;
-use crate::tools::sandboxing::ExecApprovalRequirement;
+use crate::tools::sandboxing::ApprovalRequirement;

 const FORBIDDEN_REASON: &str = "execpolicy forbids this command";
-const PROMPT_CONFLICT_REASON: &str =
-    "execpolicy requires approval for this command, but AskForApproval is set to Never";
 const PROMPT_REASON: &str = "execpolicy requires approval for this command";
 const POLICY_DIR_NAME: &str = "policy";
 const POLICY_EXTENSION: &str = "codexpolicy";
-const DEFAULT_POLICY_FILE: &str = "default.codexpolicy";

 #[derive(Debug, Error)]
 pub enum ExecPolicyError {
@@ -55,30 +45,12 @@ pub enum ExecPolicyError {
    },
 }

-#[derive(Debug, Error)]
-pub enum ExecPolicyUpdateError {
-    #[error("failed to update execpolicy file {path}: {source}")]
-    AppendRule { path: PathBuf, source: AmendError },
-
-    #[error("failed to join blocking execpolicy update task: {source}")]
-    JoinBlockingTask { source: tokio::task::JoinError },
-
-    #[error("failed to update in-memory execpolicy: {source}")]
-    AddRule {
-        #[from]
-        source: ExecPolicyRuleError,
-    },
-
-    #[error("cannot append execpolicy rule because execpolicy feature is disabled")]
-    FeatureDisabled,
-}
-
 pub(crate) async fn exec_policy_for(
    features: &Features,
    codex_home: &Path,
-) -> Result<Arc<RwLock<Policy>>, ExecPolicyError> {
+) -> Result<Arc<Policy>, ExecPolicyError> {
    if !features.enabled(Feature::ExecPolicy) {
-        return Ok(Arc::new(RwLock::new(Policy::empty())));
+        return Ok(Arc::new(Policy::empty()));
    }

    let policy_dir = codex_home.join(POLICY_DIR_NAME);
@@ -102,7 +74,7 @@ pub(crate) async fn exec_policy_for(
            })?;
    }

-    let policy = Arc::new(RwLock::new(parser.build()));
+    let policy = Arc::new(parser.build());
    tracing::debug!(
        "loaded execpolicy from {} files in {}",
        policy_paths.len(),
@@ -112,133 +84,59 @@ pub(crate) async fn exec_policy_for(
    Ok(policy)
 }

-pub(crate) fn default_policy_path(codex_home: &Path) -> PathBuf {
-    codex_home.join(POLICY_DIR_NAME).join(DEFAULT_POLICY_FILE)
-}
+fn evaluate_with_policy(
+    policy: &Policy,
+    command: &[String],
+    approval_policy: AskForApproval,
+) -> Option<ApprovalRequirement> {
+    let commands = parse_shell_lc_plain_commands(command).unwrap_or_else(|| vec![command.to_vec()]);
+    let evaluation = policy.check_multiple(commands.iter());

-pub(crate) async fn append_execpolicy_amendment_and_update(
-    codex_home: &Path,
-    current_policy: &Arc<RwLock<Policy>>,
-    prefix: &[String],
-) -> Result<(), ExecPolicyUpdateError> {
-    let policy_path = default_policy_path(codex_home);
-    let prefix = prefix.to_vec();
-    spawn_blocking({
-        let policy_path = policy_path.clone();
-        let prefix = prefix.clone();
-        move || blocking_append_allow_prefix_rule(&policy_path, &prefix)
-    })
-    .await
-    .map_err(|source| ExecPolicyUpdateError::JoinBlockingTask { source })?
-    .map_err(|source| ExecPolicyUpdateError::AppendRule {
-        path: policy_path,
-        source,
-    })?;
-
-    current_policy
-        .write()
-        .await
-        .add_prefix_rule(&prefix, Decision::Allow)?;
-
-    Ok(())
-}
-
-/// Returns a proposed execpolicy amendment only when heuristics caused
-/// the prompt decision, so we can offer to apply that amendment for future runs.
-///
-/// The amendment uses the first command heuristics marked as `Prompt`. If any explicit
-/// execpolicy rule also prompts, we return `None` because applying the amendment would not
-/// skip that policy requirement.
-///
-/// Examples:
-/// - execpolicy: empty. Command: `["python"]`. Heuristics prompt -> `Some(vec!["python"])`.
-/// - execpolicy: empty. Command: `["bash", "-c", "cd /some/folder && prog1 --option1 arg1 && prog2 --option2 arg2"]`.
-///   Parsed commands include `cd /some/folder`, `prog1 --option1 arg1`, and `prog2 --option2 arg2`. If heuristics allow `cd` but prompt
-///   on `prog1`, we return `Some(vec!["prog1", "--option1", "arg1"])`.
-/// - execpolicy: contains a `prompt for prefix ["prog2"]` rule. For the same command as above,
-///   we return `None` because an execpolicy prompt still applies even if we amend execpolicy to allow ["prog1", "--option1", "arg1"].
-fn proposed_execpolicy_amendment(evaluation: &Evaluation) -> Option<ExecPolicyAmendment> {
-    if evaluation.decision != Decision::Prompt {
-        return None;
-    }
-
-    let mut first_prompt_from_heuristics: Option<Vec<String>> = None;
-    for rule_match in &evaluation.matched_rules {
-        match rule_match {
-            RuleMatch::HeuristicsRuleMatch { command, decision } => {
-                if *decision == Decision::Prompt && first_prompt_from_heuristics.is_none() {
-                    first_prompt_from_heuristics = Some(command.clone());
+    match evaluation {
+        Evaluation::Match { decision, .. } => match decision {
+            Decision::Forbidden => Some(ApprovalRequirement::Forbidden {
+                reason: FORBIDDEN_REASON.to_string(),
+            }),
+            Decision::Prompt => {
+                let reason = PROMPT_REASON.to_string();
+                if matches!(approval_policy, AskForApproval::Never) {
+                    Some(ApprovalRequirement::Forbidden { reason })
+                } else {
+                    Some(ApprovalRequirement::NeedsApproval {
+                        reason: Some(reason),
+                    })
                }
            }
-            _ if rule_match.decision() == Decision::Prompt => {
-                return None;
-            }
-            _ => {}
-        }
+            Decision::Allow => Some(ApprovalRequirement::Skip {
+                bypass_sandbox: true,
+            }),
+        },
+        Evaluation::NoMatch { .. } => None,
    }
-
-    first_prompt_from_heuristics.map(ExecPolicyAmendment::from)
 }

-/// Only return PROMPT_REASON when an execpolicy rule drove the prompt decision.
-fn derive_prompt_reason(evaluation: &Evaluation) -> Option<String> {
-    evaluation.matched_rules.iter().find_map(|rule_match| {
-        if !matches!(rule_match, RuleMatch::HeuristicsRuleMatch { .. })
-            && rule_match.decision() == Decision::Prompt
-        {
-            Some(PROMPT_REASON.to_string())
-        } else {
-            None
-        }
-    })
-}
-
-pub(crate) async fn create_exec_approval_requirement_for_command(
-    exec_policy: &Arc<RwLock<Policy>>,
-    features: &Features,
+pub(crate) fn create_approval_requirement_for_command(
+    policy: &Policy,
    command: &[String],
    approval_policy: AskForApproval,
    sandbox_policy: &SandboxPolicy,
    sandbox_permissions: SandboxPermissions,
-) -> ExecApprovalRequirement {
-    let commands = parse_shell_lc_plain_commands(command).unwrap_or_else(|| vec![command.to_vec()]);
-    let heuristics_fallback = |cmd: &[String]| {
-        if requires_initial_appoval(approval_policy, sandbox_policy, cmd, sandbox_permissions) {
-            Decision::Prompt
-        } else {
-            Decision::Allow
-        }
-    };
-    let policy = exec_policy.read().await;
-    let evaluation = policy.check_multiple(commands.iter(), &heuristics_fallback);
-    let has_policy_allow = evaluation.matched_rules.iter().any(|rule_match| {
-        !matches!(rule_match, RuleMatch::HeuristicsRuleMatch { .. })
-            && rule_match.decision() == Decision::Allow
-    });
+) -> ApprovalRequirement {
+    if let Some(requirement) = evaluate_with_policy(policy, command, approval_policy) {
+        return requirement;
+    }

-    match evaluation.decision {
-        Decision::Forbidden => ExecApprovalRequirement::Forbidden {
-            reason: FORBIDDEN_REASON.to_string(),
-        },
-        Decision::Prompt => {
-            if matches!(approval_policy, AskForApproval::Never) {
-                ExecApprovalRequirement::Forbidden {
-                    reason: PROMPT_CONFLICT_REASON.to_string(),
-                }
-            } else {
-                ExecApprovalRequirement::NeedsApproval {
-                    reason: derive_prompt_reason(&evaluation),
-                    proposed_execpolicy_amendment: if features.enabled(Feature::ExecPolicy) {
-                        proposed_execpolicy_amendment(&evaluation)
-                    } else {
-                        None
-                    },
-                }
-            }
+    if requires_initial_appoval(
+        approval_policy,
+        sandbox_policy,
+        command,
+        sandbox_permissions,
+    ) {
+        ApprovalRequirement::NeedsApproval { reason: None }
+    } else {
+        ApprovalRequirement::Skip {
+            bypass_sandbox: false,
        }
-        Decision::Allow => ExecApprovalRequirement::Skip {
-            bypass_sandbox: has_policy_allow,
-        },
    }
 }

@@ -297,7 +195,6 @@ mod tests {
    use codex_protocol::protocol::SandboxPolicy;
    use pretty_assertions::assert_eq;
    use std::fs;
-    use std::sync::Arc;
    use tempfile::tempdir;

    #[tokio::test]
@@ -311,19 +208,10 @@ mod tests {
            .expect("policy result");

        let commands = [vec!["rm".to_string()]];
-        assert_eq!(
-            Evaluation {
-                decision: Decision::Allow,
-                matched_rules: vec![RuleMatch::HeuristicsRuleMatch {
-                    command: vec!["rm".to_string()],
-                    decision: Decision::Allow
-                }],
-            },
-            policy
-                .read()
-                .await
-                .check_multiple(commands.iter(), &|_| Decision::Allow)
-        );
+        assert!(matches!(
+            policy.check_multiple(commands.iter()),
+            Evaluation::NoMatch { .. }
+        ));
        assert!(!temp_dir.path().join(POLICY_DIR_NAME).exists());
    }

@@ -354,19 +242,10 @@ mod tests {
            .await
            .expect("policy result");
        let command = [vec!["rm".to_string()]];
-        assert_eq!(
-            Evaluation {
-                decision: Decision::Forbidden,
-                matched_rules: vec![RuleMatch::PrefixRuleMatch {
-                    matched_prefix: vec!["rm".to_string()],
-                    decision: Decision::Forbidden
-                }],
-            },
-            policy
-                .read()
-                .await
-                .check_multiple(command.iter(), &|_| Decision::Allow)
-        );
+        assert!(matches!(
+            policy.check_multiple(command.iter()),
+            Evaluation::Match { .. }
+        ));
    }

    #[tokio::test]
@@ -382,23 +261,14 @@ mod tests {
            .await
            .expect("policy result");
        let command = [vec!["ls".to_string()]];
-        assert_eq!(
-            Evaluation {
-                decision: Decision::Allow,
-                matched_rules: vec![RuleMatch::HeuristicsRuleMatch {
-                    command: vec!["ls".to_string()],
-                    decision: Decision::Allow
-                }],
-            },
-            policy
-                .read()
-                .await
-                .check_multiple(command.iter(), &|_| Decision::Allow)
-        );
+        assert!(matches!(
+            policy.check_multiple(command.iter()),
+            Evaluation::NoMatch { .. }
+        ));
    }

-    #[tokio::test]
-    async fn evaluates_bash_lc_inner_commands() {
+    #[test]
+    fn evaluates_bash_lc_inner_commands() {
        let policy_src = r#"
 prefix_rule(pattern=["rm"], decision="forbidden")
 "#;
@@ -406,7 +276,7 @@ prefix_rule(pattern=["rm"], decision="forbidden")
        parser
            .parse("test.codexpolicy", policy_src)
            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
+        let policy = parser.build();

        let forbidden_script = vec![
            "bash".to_string(),
@@ -414,325 +284,86 @@ prefix_rule(pattern=["rm"], decision="forbidden")
            "rm -rf /tmp".to_string(),
        ];

-        let requirement = create_exec_approval_requirement_for_command(
-            &policy,
-            &Features::with_defaults(),
-            &forbidden_script,
-            AskForApproval::OnRequest,
-            &SandboxPolicy::DangerFullAccess,
-            SandboxPermissions::UseDefault,
-        )
-        .await;
+        let requirement =
+            evaluate_with_policy(&policy, &forbidden_script, AskForApproval::OnRequest)
+                .expect("expected match for forbidden command");

        assert_eq!(
            requirement,
-            ExecApprovalRequirement::Forbidden {
+            ApprovalRequirement::Forbidden {
                reason: FORBIDDEN_REASON.to_string()
            }
        );
    }

-    #[tokio::test]
-    async fn exec_approval_requirement_prefers_execpolicy_match() {
+    #[test]
+    fn approval_requirement_prefers_execpolicy_match() {
        let policy_src = r#"prefix_rule(pattern=["rm"], decision="prompt")"#;
        let mut parser = PolicyParser::new();
        parser
            .parse("test.codexpolicy", policy_src)
            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
+        let policy = parser.build();
        let command = vec!["rm".to_string()];

-        let requirement = create_exec_approval_requirement_for_command(
+        let requirement = create_approval_requirement_for_command(
            &policy,
-            &Features::with_defaults(),
            &command,
            AskForApproval::OnRequest,
            &SandboxPolicy::DangerFullAccess,
            SandboxPermissions::UseDefault,
-        )
-        .await;
+        );

        assert_eq!(
            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: Some(PROMPT_REASON.to_string()),
-                proposed_execpolicy_amendment: None,
+            ApprovalRequirement::NeedsApproval {
+                reason: Some(PROMPT_REASON.to_string())
            }
        );
    }

-    #[tokio::test]
-    async fn exec_approval_requirement_respects_approval_policy() {
+    #[test]
+    fn approval_requirement_respects_approval_policy() {
        let policy_src = r#"prefix_rule(pattern=["rm"], decision="prompt")"#;
        let mut parser = PolicyParser::new();
        parser
            .parse("test.codexpolicy", policy_src)
            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
+        let policy = parser.build();
        let command = vec!["rm".to_string()];

-        let requirement = create_exec_approval_requirement_for_command(
+        let requirement = create_approval_requirement_for_command(
            &policy,
-            &Features::with_defaults(),
            &command,
            AskForApproval::Never,
            &SandboxPolicy::DangerFullAccess,
            SandboxPermissions::UseDefault,
-        )
-        .await;
+        );

        assert_eq!(
            requirement,
-            ExecApprovalRequirement::Forbidden {
-                reason: PROMPT_CONFLICT_REASON.to_string()
+            ApprovalRequirement::Forbidden {
+                reason: PROMPT_REASON.to_string()
            }
        );
    }

-    #[tokio::test]
-    async fn exec_approval_requirement_falls_back_to_heuristics() {
-        let command = vec!["cargo".to_string(), "build".to_string()];
+    #[test]
+    fn approval_requirement_falls_back_to_heuristics() {
+        let command = vec!["python".to_string()];

-        let empty_policy = Arc::new(RwLock::new(Policy::empty()));
-        let requirement = create_exec_approval_requirement_for_command(
+        let empty_policy = Policy::empty();
+        let requirement = create_approval_requirement_for_command(
            &empty_policy,
-            &Features::with_defaults(),
            &command,
            AskForApproval::UnlessTrusted,
            &SandboxPolicy::ReadOnly,
            SandboxPermissions::UseDefault,
-        )
-        .await;
+        );

        assert_eq!(
            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(command))
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn heuristics_apply_when_other_commands_match_policy() {
-        let policy_src = r#"prefix_rule(pattern=["apple"], decision="allow")"#;
-        let mut parser = PolicyParser::new();
-        parser
-            .parse("test.codexpolicy", policy_src)
-            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
-        let command = vec![
-            "bash".to_string(),
-            "-lc".to_string(),
-            "apple | orange".to_string(),
-        ];
-
-        assert_eq!(
-            create_exec_approval_requirement_for_command(
-                &policy,
-                &Features::with_defaults(),
-                &command,
-                AskForApproval::UnlessTrusted,
-                &SandboxPolicy::DangerFullAccess,
-                SandboxPermissions::UseDefault,
-            )
-            .await,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(vec![
-                    "orange".to_string()
-                ]))
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn append_execpolicy_amendment_updates_policy_and_file() {
-        let codex_home = tempdir().expect("create temp dir");
-        let current_policy = Arc::new(RwLock::new(Policy::empty()));
-        let prefix = vec!["echo".to_string(), "hello".to_string()];
-
-        append_execpolicy_amendment_and_update(codex_home.path(), &current_policy, &prefix)
-            .await
-            .expect("update policy");
-
-        let evaluation = current_policy.read().await.check(
-            &["echo".to_string(), "hello".to_string(), "world".to_string()],
-            &|_| Decision::Allow,
-        );
-        assert!(matches!(
-            evaluation,
-            Evaluation {
-                decision: Decision::Allow,
-                ..
-            }
-        ));
-
-        let contents = fs::read_to_string(default_policy_path(codex_home.path()))
-            .expect("policy file should have been created");
-        assert_eq!(
-            contents,
-            r#"prefix_rule(pattern=["echo", "hello"], decision="allow")
-"#
-        );
-    }
-
-    #[tokio::test]
-    async fn append_execpolicy_amendment_rejects_empty_prefix() {
-        let codex_home = tempdir().expect("create temp dir");
-        let current_policy = Arc::new(RwLock::new(Policy::empty()));
-
-        let result =
-            append_execpolicy_amendment_and_update(codex_home.path(), &current_policy, &[]).await;
-
-        assert!(matches!(
-            result,
-            Err(ExecPolicyUpdateError::AppendRule {
-                source: AmendError::EmptyPrefix,
-                ..
-            })
-        ));
-    }
-
-    #[tokio::test]
-    async fn proposed_execpolicy_amendment_is_present_for_single_command_without_policy_match() {
-        let command = vec!["cargo".to_string(), "build".to_string()];
-
-        let empty_policy = Arc::new(RwLock::new(Policy::empty()));
-        let requirement = create_exec_approval_requirement_for_command(
-            &empty_policy,
-            &Features::with_defaults(),
-            &command,
-            AskForApproval::UnlessTrusted,
-            &SandboxPolicy::ReadOnly,
-            SandboxPermissions::UseDefault,
-        )
-        .await;
-
-        assert_eq!(
-            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(command))
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn proposed_execpolicy_amendment_is_disabled_when_execpolicy_feature_disabled() {
-        let command = vec!["cargo".to_string(), "build".to_string()];
-
-        let mut features = Features::with_defaults();
-        features.disable(Feature::ExecPolicy);
-
-        let requirement = create_exec_approval_requirement_for_command(
-            &Arc::new(RwLock::new(Policy::empty())),
-            &features,
-            &command,
-            AskForApproval::UnlessTrusted,
-            &SandboxPolicy::ReadOnly,
-            SandboxPermissions::UseDefault,
-        )
-        .await;
-
-        assert_eq!(
-            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: None,
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn proposed_execpolicy_amendment_is_omitted_when_policy_prompts() {
-        let policy_src = r#"prefix_rule(pattern=["rm"], decision="prompt")"#;
-        let mut parser = PolicyParser::new();
-        parser
-            .parse("test.codexpolicy", policy_src)
-            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
-        let command = vec!["rm".to_string()];
-
-        let requirement = create_exec_approval_requirement_for_command(
-            &policy,
-            &Features::with_defaults(),
-            &command,
-            AskForApproval::OnRequest,
-            &SandboxPolicy::DangerFullAccess,
-            SandboxPermissions::UseDefault,
-        )
-        .await;
-
-        assert_eq!(
-            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: Some(PROMPT_REASON.to_string()),
-                proposed_execpolicy_amendment: None,
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn proposed_execpolicy_amendment_is_present_for_multi_command_scripts() {
-        let command = vec![
-            "bash".to_string(),
-            "-lc".to_string(),
-            "cargo build && echo ok".to_string(),
-        ];
-        let requirement = create_exec_approval_requirement_for_command(
-            &Arc::new(RwLock::new(Policy::empty())),
-            &Features::with_defaults(),
-            &command,
-            AskForApproval::UnlessTrusted,
-            &SandboxPolicy::ReadOnly,
-            SandboxPermissions::UseDefault,
-        )
-        .await;
-
-        assert_eq!(
-            requirement,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(vec![
-                    "cargo".to_string(),
-                    "build".to_string()
-                ])),
-            }
-        );
-    }
-
-    #[tokio::test]
-    async fn proposed_execpolicy_amendment_uses_first_no_match_in_multi_command_scripts() {
-        let policy_src = r#"prefix_rule(pattern=["cat"], decision="allow")"#;
-        let mut parser = PolicyParser::new();
-        parser
-            .parse("test.codexpolicy", policy_src)
-            .expect("parse policy");
-        let policy = Arc::new(RwLock::new(parser.build()));
-
-        let command = vec![
-            "bash".to_string(),
-            "-lc".to_string(),
-            "cat && apple".to_string(),
-        ];
-
-        assert_eq!(
-            create_exec_approval_requirement_for_command(
-                &policy,
-                &Features::with_defaults(),
-                &command,
-                AskForApproval::UnlessTrusted,
-                &SandboxPolicy::ReadOnly,
-                SandboxPermissions::UseDefault,
-            )
-            .await,
-            ExecApprovalRequirement::NeedsApproval {
-                reason: None,
-                proposed_execpolicy_amendment: Some(ExecPolicyAmendment::new(vec![
-                    "apple".to_string()
-                ])),
-            }
+            ApprovalRequirement::NeedsApproval { reason: None }
        );
    }
 }
--- a/codex-rs/core/src/features.rs
+++ b/codex-rs/core/src/features.rs
@@ -27,23 +27,16 @@ pub enum Stage {
 /// Unique features toggled via configuration.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum Feature {
-    // Stable.
    /// Create a ghost commit at each turn.
    GhostCommit,
-    /// Include the view_image tool.
-    ViewImageTool,
-    /// Send warnings to the model to correct it on the tool usage.
-    ModelWarnings,
-    /// Enable the default shell tool.
-    ShellTool,
-
-    // Experimental
    /// Use the single unified PTY-backed exec tool.
    UnifiedExec,
    /// Enable experimental RMCP features such as OAuth login.
    RmcpClient,
    /// Include the freeform apply_patch tool.
    ApplyPatchFreeform,
+    /// Include the view_image tool.
+    ViewImageTool,
    /// Allow the model to request web searches.
    WebSearchRequest,
    /// Gate the execpolicy enforcement for shell/unified exec.
@@ -54,10 +47,10 @@ pub enum Feature {
    WindowsSandbox,
    /// Remote compaction enabled (only for ChatGPT auth)
    RemoteCompaction,
+    /// Enable the default shell tool.
+    ShellTool,
    /// Allow model to call multiple tools in parallel (only for models supporting it).
    ParallelToolCalls,
-    /// Experimental skills injection (CLI flag-driven).
-    Skills,
 }

 impl Feature {
@@ -272,18 +265,6 @@ pub const FEATURES: &[FeatureSpec] = &[
        stage: Stage::Stable,
        default_enabled: true,
    },
-    FeatureSpec {
-        id: Feature::ShellTool,
-        key: "shell_tool",
-        stage: Stage::Stable,
-        default_enabled: true,
-    },
-    FeatureSpec {
-        id: Feature::ModelWarnings,
-        key: "warnings",
-        stage: Stage::Stable,
-        default_enabled: true,
-    },
    // Unstable features.
    FeatureSpec {
        id: Feature::UnifiedExec,
@@ -340,9 +321,9 @@ pub const FEATURES: &[FeatureSpec] = &[
        default_enabled: false,
    },
    FeatureSpec {
-        id: Feature::Skills,
-        key: "skills",
-        stage: Stage::Experimental,
-        default_enabled: false,
+        id: Feature::ShellTool,
+        key: "shell_tool",
+        stage: Stage::Stable,
+        default_enabled: true,
    },
 ];
--- a/codex-rs/core/src/git_info.rs
+++ b/codex-rs/core/src/git_info.rs
@@ -2,7 +2,6 @@ use std::collections::HashSet;
 use std::path::Path;
 use std::path::PathBuf;

-use crate::util::resolve_path;
 use codex_app_server_protocol::GitSha;
 use codex_protocol::protocol::GitInfo;
 use futures::future::join_all;
@@ -132,15 +131,11 @@ pub async fn recent_commits(cwd: &Path, limit: usize) -> Vec<CommitLogEntry> {
    }

    let fmt = "%H%x1f%ct%x1f%s"; // <sha> <US> <commit_time> <US> <subject>
-    let limit_arg = (limit > 0).then(|| limit.to_string());
-    let mut args: Vec<String> = vec!["log".to_string()];
-    if let Some(n) = &limit_arg {
-        args.push("-n".to_string());
-        args.push(n.clone());
-    }
-    args.push(format!("--pretty=format:{fmt}"));
-    let arg_refs: Vec<&str> = args.iter().map(String::as_str).collect();
-    let Some(log_out) = run_git_command_with_timeout(&arg_refs, cwd).await else {
+    let n = limit.max(1).to_string();
+    let Some(log_out) =
+        run_git_command_with_timeout(&["log", "-n", &n, &format!("--pretty=format:{fmt}")], cwd)
+            .await
+    else {
        return Vec::new();
    };
    if !log_out.status.success() {
@@ -549,7 +544,11 @@ pub fn resolve_root_git_project_for_trust(cwd: &Path) -> Option<PathBuf> {
        .trim()
        .to_string();

-    let git_dir_path_raw = resolve_path(base, &PathBuf::from(&git_dir_s));
+    let git_dir_path_raw = if Path::new(&git_dir_s).is_absolute() {
+        PathBuf::from(&git_dir_s)
+    } else {
+        base.join(&git_dir_s)
+    };

    // Normalize to handle macOS /var vs /private/var and resolve ".." segments.
    let git_dir_path = std::fs::canonicalize(&git_dir_path_raw).unwrap_or(git_dir_path_raw);
--- a/codex-rs/core/src/lib.rs
+++ b/codex-rs/core/src/lib.rs
@@ -32,7 +32,6 @@ pub mod git_info;
 pub mod landlock;
 pub mod mcp;
 mod mcp_connection_manager;
-pub mod openai_models;
 pub use mcp_connection_manager::MCP_SANDBOX_STATE_CAPABILITY;
 pub use mcp_connection_manager::MCP_SANDBOX_STATE_NOTIFICATION;
 pub use mcp_connection_manager::SandboxState;
@@ -41,8 +40,9 @@ mod message_history;
 mod model_provider_info;
 pub mod parse_command;
 pub mod powershell;
+mod response_processing;
 pub mod sandboxing;
-mod stream_events_utils;
+pub mod status;
 mod text_encoding;
 pub mod token_data;
 mod truncate;
@@ -59,7 +59,6 @@ pub use model_provider_info::create_oss_provider_with_base_url;
 mod conversation_manager;
 mod event_mapping;
 pub mod review_format;
-pub mod review_prompts;
 pub use codex_protocol::protocol::InitialHistory;
 pub use conversation_manager::ConversationManager;
 pub use conversation_manager::NewConversation;
@@ -67,13 +66,13 @@ pub use conversation_manager::NewConversation;
 pub use auth::AuthManager;
 pub use auth::CodexAuth;
 pub mod default_client;
+pub mod model_family;
 mod openai_model_info;
 pub mod project_doc;
 mod rollout;
 pub(crate) mod safety;
 pub mod seatbelt;
 pub mod shell;
-pub mod skills;
 pub mod spawn;
 pub mod terminal;
 mod tools;
--- a/codex-rs/core/src/mcp/mod.rs
+++ b/codex-rs/core/src/mcp/mod.rs
@@ -1,168 +1 @@
 pub mod auth;
-use std::collections::HashMap;
-
-use async_channel::unbounded;
-use codex_protocol::protocol::McpListToolsResponseEvent;
-use mcp_types::Tool as McpTool;
-use tokio_util::sync::CancellationToken;
-
-use crate::config::Config;
-use crate::mcp::auth::compute_auth_statuses;
-use crate::mcp_connection_manager::McpConnectionManager;
-
-const MCP_TOOL_NAME_PREFIX: &str = "mcp";
-const MCP_TOOL_NAME_DELIMITER: &str = "__";
-
-pub async fn collect_mcp_snapshot(config: &Config) -> McpListToolsResponseEvent {
-    if config.mcp_servers.is_empty() {
-        return McpListToolsResponseEvent {
-            tools: HashMap::new(),
-            resources: HashMap::new(),
-            resource_templates: HashMap::new(),
-            auth_statuses: HashMap::new(),
-        };
-    }
-
-    let auth_status_entries = compute_auth_statuses(
-        config.mcp_servers.iter(),
-        config.mcp_oauth_credentials_store_mode,
-    )
-    .await;
-
-    let mut mcp_connection_manager = McpConnectionManager::default();
-    let (tx_event, rx_event) = unbounded();
-    drop(rx_event);
-    let cancel_token = CancellationToken::new();
-
-    mcp_connection_manager
-        .initialize(
-            config.mcp_servers.clone(),
-            config.mcp_oauth_credentials_store_mode,
-            auth_status_entries.clone(),
-            tx_event,
-            cancel_token.clone(),
-        )
-        .await;
-
-    let snapshot =
-        collect_mcp_snapshot_from_manager(&mcp_connection_manager, auth_status_entries).await;
-
-    cancel_token.cancel();
-
-    snapshot
-}
-
-pub fn split_qualified_tool_name(qualified_name: &str) -> Option<(String, String)> {
-    let mut parts = qualified_name.split(MCP_TOOL_NAME_DELIMITER);
-    let prefix = parts.next()?;
-    if prefix != MCP_TOOL_NAME_PREFIX {
-        return None;
-    }
-    let server_name = parts.next()?;
-    let tool_name: String = parts.collect::<Vec<_>>().join(MCP_TOOL_NAME_DELIMITER);
-    if tool_name.is_empty() {
-        return None;
-    }
-    Some((server_name.to_string(), tool_name))
-}
-
-pub fn group_tools_by_server(
-    tools: &HashMap<String, McpTool>,
-) -> HashMap<String, HashMap<String, McpTool>> {
-    let mut grouped = HashMap::new();
-    for (qualified_name, tool) in tools {
-        if let Some((server_name, tool_name)) = split_qualified_tool_name(qualified_name) {
-            grouped
-                .entry(server_name)
-                .or_insert_with(HashMap::new)
-                .insert(tool_name, tool.clone());
-        }
-    }
-    grouped
-}
-
-pub(crate) async fn collect_mcp_snapshot_from_manager(
-    mcp_connection_manager: &McpConnectionManager,
-    auth_status_entries: HashMap<String, crate::mcp::auth::McpAuthStatusEntry>,
-) -> McpListToolsResponseEvent {
-    let (tools, resources, resource_templates) = tokio::join!(
-        mcp_connection_manager.list_all_tools(),
-        mcp_connection_manager.list_all_resources(),
-        mcp_connection_manager.list_all_resource_templates(),
-    );
-
-    let auth_statuses = auth_status_entries
-        .iter()
-        .map(|(name, entry)| (name.clone(), entry.auth_status))
-        .collect();
-
-    McpListToolsResponseEvent {
-        tools: tools
-            .into_iter()
-            .map(|(name, tool)| (name, tool.tool))
-            .collect(),
-        resources,
-        resource_templates,
-        auth_statuses,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use mcp_types::ToolInputSchema;
-    use pretty_assertions::assert_eq;
-
-    fn make_tool(name: &str) -> McpTool {
-        McpTool {
-            annotations: None,
-            description: None,
-            input_schema: ToolInputSchema {
-                properties: None,
-                required: None,
-                r#type: "object".to_string(),
-            },
-            name: name.to_string(),
-            output_schema: None,
-            title: None,
-        }
-    }
-
-    #[test]
-    fn split_qualified_tool_name_returns_server_and_tool() {
-        assert_eq!(
-            split_qualified_tool_name("mcp__alpha__do_thing"),
-            Some(("alpha".to_string(), "do_thing".to_string()))
-        );
-    }
-
-    #[test]
-    fn split_qualified_tool_name_rejects_invalid_names() {
-        assert_eq!(split_qualified_tool_name("other__alpha__do_thing"), None);
-        assert_eq!(split_qualified_tool_name("mcp__alpha__"), None);
-    }
-
-    #[test]
-    fn group_tools_by_server_strips_prefix_and_groups() {
-        let mut tools = HashMap::new();
-        tools.insert("mcp__alpha__do_thing".to_string(), make_tool("do_thing"));
-        tools.insert(
-            "mcp__alpha__nested__op".to_string(),
-            make_tool("nested__op"),
-        );
-        tools.insert("mcp__beta__do_other".to_string(), make_tool("do_other"));
-
-        let mut expected_alpha = HashMap::new();
-        expected_alpha.insert("do_thing".to_string(), make_tool("do_thing"));
-        expected_alpha.insert("nested__op".to_string(), make_tool("nested__op"));
-
-        let mut expected_beta = HashMap::new();
-        expected_beta.insert("do_other".to_string(), make_tool("do_other"));
-
-        let mut expected = HashMap::new();
-        expected.insert("alpha".to_string(), expected_alpha);
-        expected.insert("beta".to_string(), expected_beta);
-
-        assert_eq!(group_tools_by_server(&tools), expected);
-    }
-}
--- a/codex-rs/core/src/mcp_connection_manager.rs
+++ b/codex-rs/core/src/mcp_connection_manager.rs
@@ -12,6 +12,7 @@ use std::env;
 use std::ffi::OsString;
 use std::path::PathBuf;
 use std::sync::Arc;
+use std::sync::Mutex;
 use std::time::Duration;

 use crate::mcp::auth::McpAuthStatusEntry;
@@ -54,7 +55,6 @@ use serde::Serialize;
 use serde_json::json;
 use sha1::Digest;
 use sha1::Sha1;
-use tokio::sync::Mutex;
 use tokio::sync::oneshot;
 use tokio::task::JoinSet;
 use tokio_util::sync::CancellationToken;
@@ -128,7 +128,7 @@ struct ElicitationRequestManager {
 }

 impl ElicitationRequestManager {
-    async fn resolve(
+    fn resolve(
        &self,
        server_name: String,
        id: RequestId,
@@ -136,7 +136,7 @@ impl ElicitationRequestManager {
    ) -> Result<()> {
        self.requests
            .lock()
-            .await
+            .map_err(|e| anyhow!("failed to lock elicitation requests: {e:?}"))?
            .remove(&(server_name, id))
            .ok_or_else(|| anyhow!("elicitation request not found"))?
            .send(response)
@@ -151,8 +151,7 @@ impl ElicitationRequestManager {
            let server_name = server_name.clone();
            async move {
                let (tx, rx) = oneshot::channel();
-                {
-                    let mut lock = elicitation_requests.lock().await;
+                if let Ok(mut lock) = elicitation_requests.lock() {
                    lock.insert((server_name.clone(), id.clone()), tx);
                }
                let _ = tx_event
@@ -366,15 +365,13 @@ impl McpConnectionManager {
            .context("failed to get client")
    }

-    pub async fn resolve_elicitation(
+    pub fn resolve_elicitation(
        &self,
        server_name: String,
        id: RequestId,
        response: ElicitationResponse,
    ) -> Result<()> {
-        self.elicitation_requests
-            .resolve(server_name, id, response)
-            .await
+        self.elicitation_requests.resolve(server_name, id, response)
    }

    /// Returns a single map that contains all tools. Each key is the
--- a/codex-rs/core/src/message_history.rs
+++ b/codex-rs/core/src/message_history.rs
@@ -16,14 +16,8 @@

 use std::fs::File;
 use std::fs::OpenOptions;
-use std::io::BufRead;
-use std::io::BufReader;
-use std::io::Read;
 use std::io::Result;
-use std::io::Seek;
-use std::io::SeekFrom;
 use std::io::Write;
-use std::path::Path;
 use std::path::PathBuf;

 use serde::Deserialize;
@@ -45,13 +39,10 @@ use std::os::unix::fs::PermissionsExt;
 /// Filename that stores the message history inside `~/.codex`.
 const HISTORY_FILENAME: &str = "history.jsonl";

-/// When history exceeds the hard cap, trim it down to this fraction of `max_bytes`.
-const HISTORY_SOFT_CAP_RATIO: f64 = 0.8;
-
 const MAX_RETRIES: usize = 10;
 const RETRY_SLEEP: Duration = Duration::from_millis(100);

-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct HistoryEntry {
    pub session_id: String,
    pub ts: u64,
@@ -106,12 +97,11 @@ pub(crate) async fn append_entry(
        .map_err(|e| std::io::Error::other(format!("failed to serialise history entry: {e}")))?;
    line.push('\n');

-    // Open the history file for read/write access (append-only on Unix).
+    // Open in append-only mode.
    let mut options = OpenOptions::new();
-    options.read(true).write(true).create(true);
+    options.append(true).read(true).create(true);
    #[cfg(unix)]
    {
-        options.append(true);
        options.mode(0o600);
    }

@@ -120,8 +110,6 @@ pub(crate) async fn append_entry(
    // Ensure permissions.
    ensure_owner_only_permissions(&history_file).await?;

-    let history_max_bytes = config.history.max_bytes;
-
    // Perform a blocking write under an advisory write lock using std::fs.
    tokio::task::spawn_blocking(move || -> Result<()> {
        // Retry a few times to avoid indefinite blocking when contended.
@@ -129,12 +117,8 @@ pub(crate) async fn append_entry(
            match history_file.try_lock() {
                Ok(()) => {
                    // While holding the exclusive lock, write the full line.
-                    // We do not open the file with `append(true)` on Windows, so ensure the
-                    // cursor is positioned at the end before writing.
-                    history_file.seek(SeekFrom::End(0))?;
                    history_file.write_all(line.as_bytes())?;
                    history_file.flush()?;
-                    enforce_history_limit(&mut history_file, history_max_bytes)?;
                    return Ok(());
                }
                Err(std::fs::TryLockError::WouldBlock) => {
@@ -154,144 +138,27 @@ pub(crate) async fn append_entry(
    Ok(())
 }

-/// Trim the history file to honor `max_bytes`, dropping the oldest lines while holding
-/// the write lock so the newest entry is always retained. When the file exceeds the
-/// hard cap, it rewrites the remaining tail to a soft cap to avoid trimming again
-/// immediately on the next write.
-fn enforce_history_limit(file: &mut File, max_bytes: Option<usize>) -> Result<()> {
-    let Some(max_bytes) = max_bytes else {
-        return Ok(());
-    };
-
-    if max_bytes == 0 {
-        return Ok(());
-    }
-
-    let max_bytes = match u64::try_from(max_bytes) {
-        Ok(value) => value,
-        Err(_) => return Ok(()),
-    };
-
-    let mut current_len = file.metadata()?.len();
-
-    if current_len <= max_bytes {
-        return Ok(());
-    }
-
-    let mut reader_file = file.try_clone()?;
-    reader_file.seek(SeekFrom::Start(0))?;
-
-    let mut buf_reader = BufReader::new(reader_file);
-    let mut line_lengths = Vec::new();
-    let mut line_buf = String::new();
-
-    loop {
-        line_buf.clear();
-
-        let bytes = buf_reader.read_line(&mut line_buf)?;
-
-        if bytes == 0 {
-            break;
-        }
-
-        line_lengths.push(bytes as u64);
-    }
-
-    if line_lengths.is_empty() {
-        return Ok(());
-    }
-
-    let last_index = line_lengths.len() - 1;
-    let trim_target = trim_target_bytes(max_bytes, line_lengths[last_index]);
-
-    let mut drop_bytes = 0u64;
-    let mut idx = 0usize;
-
-    while current_len > trim_target && idx < last_index {
-        current_len = current_len.saturating_sub(line_lengths[idx]);
-        drop_bytes += line_lengths[idx];
-        idx += 1;
-    }
-
-    if drop_bytes == 0 {
-        return Ok(());
-    }
-
-    let mut reader = buf_reader.into_inner();
-    reader.seek(SeekFrom::Start(drop_bytes))?;
-
-    let capacity = usize::try_from(current_len).unwrap_or(0);
-    let mut tail = Vec::with_capacity(capacity);
-
-    reader.read_to_end(&mut tail)?;
-
-    file.set_len(0)?;
-    file.seek(SeekFrom::Start(0))?;
-    file.write_all(&tail)?;
-    file.flush()?;
-
-    Ok(())
-}
-
-fn trim_target_bytes(max_bytes: u64, newest_entry_len: u64) -> u64 {
-    let soft_cap_bytes = ((max_bytes as f64) * HISTORY_SOFT_CAP_RATIO)
-        .floor()
-        .clamp(1.0, max_bytes as f64) as u64;
-
-    soft_cap_bytes.max(newest_entry_len)
-}
-
 /// Asynchronously fetch the history file's *identifier* (inode on Unix) and
 /// the current number of entries by counting newline characters.
 pub(crate) async fn history_metadata(config: &Config) -> (u64, usize) {
    let path = history_filepath(config);
-    history_metadata_for_file(&path).await
-}

-/// Given a `log_id` (on Unix this is the file's inode number,
-/// on Windows this is the file's creation time) and a zero-based
-/// `offset`, return the corresponding `HistoryEntry` if the identifier matches
-/// the current history file **and** the requested offset exists. Any I/O or
-/// parsing errors are logged and result in `None`.
-///
-/// Note this function is not async because it uses a sync advisory file
-/// locking API.
-pub(crate) fn lookup(log_id: u64, offset: usize, config: &Config) -> Option<HistoryEntry> {
-    let path = history_filepath(config);
-    lookup_history_entry(&path, log_id, offset)
-}
-
-/// On Unix systems, ensure the file permissions are `0o600` (rw-------). If the
-/// permissions cannot be changed the error is propagated to the caller.
-#[cfg(unix)]
-async fn ensure_owner_only_permissions(file: &File) -> Result<()> {
-    let metadata = file.metadata()?;
-    let current_mode = metadata.permissions().mode() & 0o777;
-    if current_mode != 0o600 {
-        let mut perms = metadata.permissions();
-        perms.set_mode(0o600);
-        let perms_clone = perms.clone();
-        let file_clone = file.try_clone()?;
-        tokio::task::spawn_blocking(move || file_clone.set_permissions(perms_clone)).await??;
-    }
-    Ok(())
-}
-
-#[cfg(windows)]
-// On Windows, simply succeed.
-async fn ensure_owner_only_permissions(_file: &File) -> Result<()> {
-    Ok(())
-}
-
-async fn history_metadata_for_file(path: &Path) -> (u64, usize) {
-    let log_id = match fs::metadata(path).await {
-        Ok(metadata) => history_log_id(&metadata).unwrap_or(0),
-        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return (0, 0),
-        Err(_) => return (0, 0),
+    #[cfg(unix)]
+    let log_id = {
+        use std::os::unix::fs::MetadataExt;
+        // Obtain metadata (async) to get the identifier.
+        let meta = match fs::metadata(&path).await {
+            Ok(m) => m,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return (0, 0),
+            Err(_) => return (0, 0),
+        };
+        meta.ino()
    };
+    #[cfg(not(unix))]
+    let log_id = 0u64;

    // Open the file.
-    let mut file = match fs::File::open(path).await {
+    let mut file = match fs::File::open(&path).await {
        Ok(f) => f,
        Err(_) => return (log_id, 0),
    };
@@ -312,11 +179,21 @@ async fn history_metadata_for_file(path: &Path) -> (u64, usize) {
    (log_id, count)
 }

-fn lookup_history_entry(path: &Path, log_id: u64, offset: usize) -> Option<HistoryEntry> {
+/// Given a `log_id` (on Unix this is the file's inode number) and a zero-based
+/// `offset`, return the corresponding `HistoryEntry` if the identifier matches
+/// the current history file **and** the requested offset exists. Any I/O or
+/// parsing errors are logged and result in `None`.
+///
+/// Note this function is not async because it uses a sync advisory file
+/// locking API.
+#[cfg(unix)]
+pub(crate) fn lookup(log_id: u64, offset: usize, config: &Config) -> Option<HistoryEntry> {
    use std::io::BufRead;
    use std::io::BufReader;
+    use std::os::unix::fs::MetadataExt;

-    let file: File = match OpenOptions::new().read(true).open(path) {
+    let path = history_filepath(config);
+    let file: File = match OpenOptions::new().read(true).open(&path) {
        Ok(f) => f,
        Err(e) => {
            tracing::warn!(error = %e, "failed to open history file");
@@ -332,9 +209,7 @@ fn lookup_history_entry(path: &Path, log_id: u64, offset: usize) -> Option<Histo
        }
    };

-    let current_log_id = history_log_id(&metadata)?;
-
-    if log_id != 0 && current_log_id != log_id {
+    if metadata.ino() != log_id {
        return None;
    }

@@ -381,238 +256,31 @@ fn lookup_history_entry(path: &Path, log_id: u64, offset: usize) -> Option<Histo
    None
 }

-#[cfg(unix)]
-fn history_log_id(metadata: &std::fs::Metadata) -> Option<u64> {
-    use std::os::unix::fs::MetadataExt;
-    Some(metadata.ino())
-}
-
-#[cfg(windows)]
-fn history_log_id(metadata: &std::fs::Metadata) -> Option<u64> {
-    use std::os::windows::fs::MetadataExt;
-    Some(metadata.creation_time())
-}
-
-#[cfg(not(any(unix, windows)))]
-fn history_log_id(_metadata: &std::fs::Metadata) -> Option<u64> {
+/// Fallback stub for non-Unix systems: currently always returns `None`.
+#[cfg(not(unix))]
+pub(crate) fn lookup(log_id: u64, offset: usize, config: &Config) -> Option<HistoryEntry> {
+    let _ = (log_id, offset, config);
    None
 }

-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::config::Config;
-    use crate::config::ConfigOverrides;
-    use crate::config::ConfigToml;
-    use codex_protocol::ConversationId;
-    use pretty_assertions::assert_eq;
-    use std::fs::File;
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    #[tokio::test]
-    async fn lookup_reads_history_entries() {
-        let temp_dir = TempDir::new().expect("create temp dir");
-        let history_path = temp_dir.path().join(HISTORY_FILENAME);
-
-        let entries = vec![
-            HistoryEntry {
-                session_id: "first-session".to_string(),
-                ts: 1,
-                text: "first".to_string(),
-            },
-            HistoryEntry {
-                session_id: "second-session".to_string(),
-                ts: 2,
-                text: "second".to_string(),
-            },
-        ];
-
-        let mut file = File::create(&history_path).expect("create history file");
-        for entry in &entries {
-            writeln!(
-                file,
-                "{}",
-                serde_json::to_string(entry).expect("serialize history entry")
-            )
-            .expect("write history entry");
-        }
-
-        let (log_id, count) = history_metadata_for_file(&history_path).await;
-        assert_eq!(count, entries.len());
-
-        let second_entry =
-            lookup_history_entry(&history_path, log_id, 1).expect("fetch second history entry");
-        assert_eq!(second_entry, entries[1]);
-    }
-
-    #[tokio::test]
-    async fn lookup_uses_stable_log_id_after_appends() {
-        let temp_dir = TempDir::new().expect("create temp dir");
-        let history_path = temp_dir.path().join(HISTORY_FILENAME);
-
-        let initial = HistoryEntry {
-            session_id: "first-session".to_string(),
-            ts: 1,
-            text: "first".to_string(),
-        };
-        let appended = HistoryEntry {
-            session_id: "second-session".to_string(),
-            ts: 2,
-            text: "second".to_string(),
-        };
-
-        let mut file = File::create(&history_path).expect("create history file");
-        writeln!(
-            file,
-            "{}",
-            serde_json::to_string(&initial).expect("serialize initial entry")
-        )
-        .expect("write initial entry");
-
-        let (log_id, count) = history_metadata_for_file(&history_path).await;
-        assert_eq!(count, 1);
-
-        let mut append = std::fs::OpenOptions::new()
-            .append(true)
-            .open(&history_path)
-            .expect("open history file for append");
-        writeln!(
-            append,
-            "{}",
-            serde_json::to_string(&appended).expect("serialize appended entry")
-        )
-        .expect("append history entry");
-
-        let fetched =
-            lookup_history_entry(&history_path, log_id, 1).expect("lookup appended history entry");
-        assert_eq!(fetched, appended);
-    }
-
-    #[tokio::test]
-    async fn append_entry_trims_history_when_beyond_max_bytes() {
-        let codex_home = TempDir::new().expect("create temp dir");
-
-        let mut config = Config::load_from_base_config_with_overrides(
-            ConfigToml::default(),
-            ConfigOverrides::default(),
-            codex_home.path().to_path_buf(),
-        )
-        .expect("load config");
-
-        let conversation_id = ConversationId::new();
-
-        let entry_one = "a".repeat(200);
-        let entry_two = "b".repeat(200);
-
-        let history_path = codex_home.path().join("history.jsonl");
-
-        append_entry(&entry_one, &conversation_id, &config)
-            .await
-            .expect("write first entry");
-
-        let first_len = std::fs::metadata(&history_path).expect("metadata").len();
-        let limit_bytes = first_len + 10;
-
-        config.history.max_bytes =
-            Some(usize::try_from(limit_bytes).expect("limit should fit into usize"));
-
-        append_entry(&entry_two, &conversation_id, &config)
-            .await
-            .expect("write second entry");
-
-        let contents = std::fs::read_to_string(&history_path).expect("read history");
-
-        let entries = contents
-            .lines()
-            .map(|line| serde_json::from_str::<HistoryEntry>(line).expect("parse entry"))
-            .collect::<Vec<HistoryEntry>>();
-
-        assert_eq!(
-            entries.len(),
-            1,
-            "only one entry left because entry_one should be evicted"
-        );
-        assert_eq!(entries[0].text, entry_two);
-        assert!(std::fs::metadata(&history_path).expect("metadata").len() <= limit_bytes);
-    }
-
-    #[tokio::test]
-    async fn append_entry_trims_history_to_soft_cap() {
-        let codex_home = TempDir::new().expect("create temp dir");
-
-        let mut config = Config::load_from_base_config_with_overrides(
-            ConfigToml::default(),
-            ConfigOverrides::default(),
-            codex_home.path().to_path_buf(),
-        )
-        .expect("load config");
-
-        let conversation_id = ConversationId::new();
-
-        let short_entry = "a".repeat(200);
-        let long_entry = "b".repeat(400);
-
-        let history_path = codex_home.path().join("history.jsonl");
-
-        append_entry(&short_entry, &conversation_id, &config)
-            .await
-            .expect("write first entry");
-
-        let short_entry_len = std::fs::metadata(&history_path).expect("metadata").len();
-
-        append_entry(&long_entry, &conversation_id, &config)
-            .await
-            .expect("write second entry");
-
-        let two_entry_len = std::fs::metadata(&history_path).expect("metadata").len();
-
-        let long_entry_len = two_entry_len
-            .checked_sub(short_entry_len)
-            .expect("second entry length should be larger than first entry length");
-
-        config.history.max_bytes = Some(
-            usize::try_from((2 * long_entry_len) + (short_entry_len / 2))
-                .expect("max bytes should fit into usize"),
-        );
-
-        append_entry(&long_entry, &conversation_id, &config)
-            .await
-            .expect("write third entry");
-
-        let contents = std::fs::read_to_string(&history_path).expect("read history");
-
-        let entries = contents
-            .lines()
-            .map(|line| serde_json::from_str::<HistoryEntry>(line).expect("parse entry"))
-            .collect::<Vec<HistoryEntry>>();
-
-        assert_eq!(entries.len(), 1);
-        assert_eq!(entries[0].text, long_entry);
-
-        let pruned_len = std::fs::metadata(&history_path).expect("metadata").len();
-        let max_bytes = config
-            .history
-            .max_bytes
-            .expect("max bytes should be configured") as u64;
-
-        assert!(pruned_len <= max_bytes);
-
-        let soft_cap_bytes = ((max_bytes as f64) * HISTORY_SOFT_CAP_RATIO)
-            .floor()
-            .clamp(1.0, max_bytes as f64) as u64;
-        let len_without_first = 2 * long_entry_len;
-
-        assert!(
-            len_without_first <= max_bytes,
-            "dropping only the first entry would satisfy the hard cap"
-        );
-        assert!(
-            len_without_first > soft_cap_bytes,
-            "soft cap should require more aggressive trimming than the hard cap"
-        );
-
-        assert_eq!(pruned_len, long_entry_len);
-        assert!(pruned_len <= soft_cap_bytes.max(long_entry_len));
+/// On Unix systems ensure the file permissions are `0o600` (rw-------). If the
+/// permissions cannot be changed the error is propagated to the caller.
+#[cfg(unix)]
+async fn ensure_owner_only_permissions(file: &File) -> Result<()> {
+    let metadata = file.metadata()?;
+    let current_mode = metadata.permissions().mode() & 0o777;
+    if current_mode != 0o600 {
+        let mut perms = metadata.permissions();
+        perms.set_mode(0o600);
+        let perms_clone = perms.clone();
+        let file_clone = file.try_clone()?;
+        tokio::task::spawn_blocking(move || file_clone.set_permissions(perms_clone)).await??;
    }
+    Ok(())
+}
+
+#[cfg(not(unix))]
+async fn ensure_owner_only_permissions(_file: &File) -> Result<()> {
+    // For now, on non-Unix, simply succeed.
+    Ok(())
 }
--- a/codex-rs/core/src/openai_models/model_family.rs
+++ b/codex-rs/core/src/openai_models/model_family.rs
@@ -1,7 +1,6 @@
+use codex_protocol::config_types::ReasoningEffort;
 use codex_protocol::config_types::Verbosity;
-use codex_protocol::openai_models::ReasoningEffort;

-use crate::config::Config;
 use crate::config::types::ReasoningSummaryFormat;
 use crate::tools::handlers::apply_patch::ApplyPatchToolType;
 use crate::tools::spec::ConfigShellToolType;
@@ -9,11 +8,11 @@ use crate::truncate::TruncationPolicy;

 /// The `instructions` field in the payload sent to a model should always start
 /// with this content.
-const BASE_INSTRUCTIONS: &str = include_str!("../../prompt.md");
+const BASE_INSTRUCTIONS: &str = include_str!("../prompt.md");

-const GPT_5_CODEX_INSTRUCTIONS: &str = include_str!("../../gpt_5_codex_prompt.md");
-const GPT_5_1_INSTRUCTIONS: &str = include_str!("../../gpt_5_1_prompt.md");
-const GPT_5_1_CODEX_MAX_INSTRUCTIONS: &str = include_str!("../../gpt-5.1-codex-max_prompt.md");
+const GPT_5_CODEX_INSTRUCTIONS: &str = include_str!("../gpt_5_codex_prompt.md");
+const GPT_5_1_INSTRUCTIONS: &str = include_str!("../gpt_5_1_prompt.md");
+const GPT_5_1_CODEX_MAX_INSTRUCTIONS: &str = include_str!("../gpt-5.1-codex-max_prompt.md");

 /// A model family is a group of models that share certain characteristics.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -73,18 +72,6 @@ pub struct ModelFamily {
    pub truncation_policy: TruncationPolicy,
 }

-impl ModelFamily {
-    pub fn with_config_overrides(mut self, config: &Config) -> Self {
-        if let Some(supports_reasoning_summaries) = config.model_supports_reasoning_summaries {
-            self.supports_reasoning_summaries = supports_reasoning_summaries;
-        }
-        if let Some(reasoning_summary_format) = config.model_reasoning_summary_format.as_ref() {
-            self.reasoning_summary_format = reasoning_summary_format.clone();
-        }
-        self
-    }
-}
-
 macro_rules! model_family {
    (
        $slug:expr, $family:expr $(, $key:ident : $value:expr )* $(,)?
@@ -113,14 +100,13 @@ macro_rules! model_family {
        $(
            mf.$key = $value;
        )*
-        mf
+        Some(mf)
    }};
 }

-// todo(aibrahim): remove this function
 /// 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) -> ModelFamily {
+pub fn find_family_for_model(slug: &str) -> Option<ModelFamily> {
    if slug.starts_with("o3") {
        model_family!(
            slug, "o3",
@@ -252,11 +238,11 @@ pub fn find_family_for_model(slug: &str) -> ModelFamily {
            truncation_policy: TruncationPolicy::Bytes(10_000),
        )
    } else {
-        derive_default_model_family(slug)
+        None
    }
 }

-fn derive_default_model_family(model: &str) -> ModelFamily {
+pub fn derive_default_model_family(model: &str) -> ModelFamily {
    ModelFamily {
        slug: model.to_string(),
        family: model.to_string(),
--- a/codex-rs/core/src/openai_model_info.rs
+++ b/codex-rs/core/src/openai_model_info.rs
@@ -1,4 +1,4 @@
-use crate::openai_models::model_family::ModelFamily;
+use crate::model_family::ModelFamily;

 // Shared constants for commonly used window/token sizes.
 pub(crate) const CONTEXT_WINDOW_272K: i64 = 272_000;
@@ -76,8 +76,6 @@ pub(crate) fn get_model_info(model_family: &ModelFamily) -> Option<ModelInfo> {

        _ if slug.starts_with("codex-") => Some(ModelInfo::new(CONTEXT_WINDOW_272K)),

-        _ if slug.starts_with("exp-") => Some(ModelInfo::new(CONTEXT_WINDOW_272K)),
-
        _ => None,
    }
 }
--- a/codex-rs/core/src/openai_models/mod.rs
+++ b/codex-rs/core/src/openai_models/mod.rs
@@ -1,3 +0,0 @@
-pub mod model_family;
-pub mod model_presets;
-pub mod models_manager;
--- a/codex-rs/core/src/openai_models/models_manager.rs
+++ b/codex-rs/core/src/openai_models/models_manager.rs
@@ -1,34 +0,0 @@
-use codex_app_server_protocol::AuthMode;
-use codex_protocol::openai_models::ModelPreset;
-use tokio::sync::RwLock;
-
-use crate::config::Config;
-use crate::openai_models::model_family::ModelFamily;
-use crate::openai_models::model_family::find_family_for_model;
-use crate::openai_models::model_presets::builtin_model_presets;
-
-#[derive(Debug)]
-pub struct ModelsManager {
-    pub available_models: RwLock<Vec<ModelPreset>>,
-    pub etag: String,
-    pub auth_mode: Option<AuthMode>,
-}
-
-impl ModelsManager {
-    pub fn new(auth_mode: Option<AuthMode>) -> Self {
-        Self {
-            available_models: RwLock::new(builtin_model_presets(auth_mode)),
-            etag: String::new(),
-            auth_mode,
-        }
-    }
-
-    pub async fn refresh_available_models(&self) {
-        let models = builtin_model_presets(self.auth_mode);
-        *self.available_models.write().await = models;
-    }
-
-    pub fn construct_model_family(&self, model: &str, config: &Config) -> ModelFamily {
-        find_family_for_model(model).with_config_overrides(config)
-    }
-}
--- a/codex-rs/core/src/project_doc.rs
+++ b/codex-rs/core/src/project_doc.rs
@@ -14,9 +14,6 @@
 //! 3.  We do **not** walk past the Git root.

 use crate::config::Config;
-use crate::features::Feature;
-use crate::skills::load_skills;
-use crate::skills::render_skills_section;
 use dunce::canonicalize as normalize_path;
 use std::path::PathBuf;
 use tokio::io::AsyncReadExt;
@@ -34,47 +31,18 @@ const PROJECT_DOC_SEPARATOR: &str = "\n\n--- project-doc ---\n\n";
 /// Combines `Config::instructions` and `AGENTS.md` (if present) into a single
 /// string of instructions.
 pub(crate) async fn get_user_instructions(config: &Config) -> Option<String> {
-    let skills_section = if config.features.enabled(Feature::Skills) {
-        let skills_outcome = load_skills(config);
-        for err in &skills_outcome.errors {
-            error!(
-                "failed to load skill {}: {}",
-                err.path.display(),
-                err.message
-            );
-        }
-        render_skills_section(&skills_outcome.skills)
-    } else {
-        None
-    };
-
-    let project_docs = match read_project_docs(config).await {
-        Ok(docs) => docs,
+    match read_project_docs(config).await {
+        Ok(Some(project_doc)) => match &config.user_instructions {
+            Some(original_instructions) => Some(format!(
+                "{original_instructions}{PROJECT_DOC_SEPARATOR}{project_doc}"
+            )),
+            None => Some(project_doc),
+        },
+        Ok(None) => config.user_instructions.clone(),
        Err(e) => {
            error!("error trying to find project doc: {e:#}");
-            return config.user_instructions.clone();
+            config.user_instructions.clone()
        }
-    };
-
-    let combined_project_docs = merge_project_docs_with_skills(project_docs, skills_section);
-
-    let mut parts: Vec<String> = Vec::new();
-
-    if let Some(instructions) = config.user_instructions.clone() {
-        parts.push(instructions);
-    }
-
-    if let Some(project_doc) = combined_project_docs {
-        if !parts.is_empty() {
-            parts.push(PROJECT_DOC_SEPARATOR.to_string());
-        }
-        parts.push(project_doc);
-    }
-
-    if parts.is_empty() {
-        None
-    } else {
-        Some(parts.concat())
    }
 }

@@ -227,25 +195,12 @@ fn candidate_filenames<'a>(config: &'a Config) -> Vec<&'a str> {
    names
 }

-fn merge_project_docs_with_skills(
-    project_doc: Option<String>,
-    skills_section: Option<String>,
-) -> Option<String> {
-    match (project_doc, skills_section) {
-        (Some(doc), Some(skills)) => Some(format!("{doc}\n\n{skills}")),
-        (Some(doc), None) => Some(doc),
-        (None, Some(skills)) => Some(skills),
-        (None, None) => None,
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::config::ConfigOverrides;
    use crate::config::ConfigToml;
    use std::fs;
-    use std::path::PathBuf;
    use tempfile::TempDir;

    /// Helper that returns a `Config` pointing at `root` and using `limit` as
@@ -264,7 +219,6 @@ mod tests {

        config.cwd = root.path().to_path_buf();
        config.project_doc_max_bytes = limit;
-        config.features.enable(Feature::Skills);

        config.user_instructions = instructions.map(ToOwned::to_owned);
        config
@@ -493,60 +447,4 @@ mod tests {
                .eq(DEFAULT_PROJECT_DOC_FILENAME)
        );
    }
-
-    #[tokio::test]
-    async fn skills_are_appended_to_project_doc() {
-        let tmp = tempfile::tempdir().expect("tempdir");
-        fs::write(tmp.path().join("AGENTS.md"), "base doc").unwrap();
-
-        let cfg = make_config(&tmp, 4096, None);
-        create_skill(
-            cfg.codex_home.clone(),
-            "pdf-processing",
-            "extract from pdfs",
-        );
-
-        let res = get_user_instructions(&cfg)
-            .await
-            .expect("instructions expected");
-        let expected_path = dunce::canonicalize(
-            cfg.codex_home
-                .join("skills/pdf-processing/SKILL.md")
-                .as_path(),
-        )
-        .unwrap_or_else(|_| cfg.codex_home.join("skills/pdf-processing/SKILL.md"));
-        let expected_path_str = expected_path.to_string_lossy().replace('\\', "/");
-        let usage_rules = "- Discovery: Available skills are listed in project docs and may also appear in a runtime \"## Skills\" section (name + description + file path). These are the sources of truth; skill bodies live on disk at the listed paths.\n- Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.\n- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.\n- How to use a skill (progressive disclosure):\n  1) After deciding to use a skill, open its `SKILL.md`. Read only enough to follow the workflow.\n  2) If `SKILL.md` points to extra folders such as `references/`, load only the specific files needed for the request; don't bulk-load everything.\n  3) If `scripts/` exist, prefer running or patching them instead of retyping large code blocks.\n  4) If `assets/` or templates exist, reuse them instead of recreating from scratch.\n- Description as trigger: The YAML `description` in `SKILL.md` is the primary trigger signal; rely on it to decide applicability. If unsure, ask a brief clarification before proceeding.\n- Coordination and sequencing:\n  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.\n  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.\n- Context hygiene:\n  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.\n  - Avoid deeply nested references; prefer one-hop files explicitly linked from `SKILL.md`.\n  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.\n- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.";
-        let expected = format!(
-            "base doc\n\n## Skills\nThese skills are discovered at startup from ~/.codex/skills; each entry shows name, description, and file path so you can open the source for full instructions. Content is not inlined to keep context lean.\n- pdf-processing: extract from pdfs (file: {expected_path_str})\n{usage_rules}"
-        );
-        assert_eq!(res, expected);
-    }
-
-    #[tokio::test]
-    async fn skills_render_without_project_doc() {
-        let tmp = tempfile::tempdir().expect("tempdir");
-        let cfg = make_config(&tmp, 4096, None);
-        create_skill(cfg.codex_home.clone(), "linting", "run clippy");
-
-        let res = get_user_instructions(&cfg)
-            .await
-            .expect("instructions expected");
-        let expected_path =
-            dunce::canonicalize(cfg.codex_home.join("skills/linting/SKILL.md").as_path())
-                .unwrap_or_else(|_| cfg.codex_home.join("skills/linting/SKILL.md"));
-        let expected_path_str = expected_path.to_string_lossy().replace('\\', "/");
-        let usage_rules = "- Discovery: Available skills are listed in project docs and may also appear in a runtime \"## Skills\" section (name + description + file path). These are the sources of truth; skill bodies live on disk at the listed paths.\n- Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.\n- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.\n- How to use a skill (progressive disclosure):\n  1) After deciding to use a skill, open its `SKILL.md`. Read only enough to follow the workflow.\n  2) If `SKILL.md` points to extra folders such as `references/`, load only the specific files needed for the request; don't bulk-load everything.\n  3) If `scripts/` exist, prefer running or patching them instead of retyping large code blocks.\n  4) If `assets/` or templates exist, reuse them instead of recreating from scratch.\n- Description as trigger: The YAML `description` in `SKILL.md` is the primary trigger signal; rely on it to decide applicability. If unsure, ask a brief clarification before proceeding.\n- Coordination and sequencing:\n  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.\n  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.\n- Context hygiene:\n  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.\n  - Avoid deeply nested references; prefer one-hop files explicitly linked from `SKILL.md`.\n  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.\n- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue.";
-        let expected = format!(
-            "## Skills\nThese skills are discovered at startup from ~/.codex/skills; each entry shows name, description, and file path so you can open the source for full instructions. Content is not inlined to keep context lean.\n- linting: run clippy (file: {expected_path_str})\n{usage_rules}"
-        );
-        assert_eq!(res, expected);
-    }
-
-    fn create_skill(codex_home: PathBuf, name: &str, description: &str) {
-        let skill_dir = codex_home.join(format!("skills/{name}"));
-        fs::create_dir_all(&skill_dir).unwrap();
-        let content = format!("---\nname: {name}\ndescription: {description}\n---\n\n# Body\n");
-        fs::write(skill_dir.join("SKILL.md"), content).unwrap();
-    }
 }
--- a/codex-rs/core/src/response_processing.rs
+++ b/codex-rs/core/src/response_processing.rs
@@ -0,0 +1,70 @@
+use crate::codex::Session;
+use crate::codex::TurnContext;
+use codex_protocol::models::FunctionCallOutputPayload;
+use codex_protocol::models::ResponseInputItem;
+use codex_protocol::models::ResponseItem;
+use tracing::warn;
+
+/// Process streamed `ResponseItem`s from the model into the pair of:
+/// - items we should record in conversation history; and
+/// - `ResponseInputItem`s to send back to the model on the next turn.
+pub(crate) async fn process_items(
+    processed_items: Vec<crate::codex::ProcessedResponseItem>,
+    sess: &Session,
+    turn_context: &TurnContext,
+) -> (Vec<ResponseInputItem>, Vec<ResponseItem>) {
+    let mut outputs_to_record = Vec::<ResponseItem>::new();
+    let mut new_inputs_to_record = Vec::<ResponseItem>::new();
+    let mut responses = Vec::<ResponseInputItem>::new();
+    for processed_response_item in processed_items {
+        let crate::codex::ProcessedResponseItem { item, response } = processed_response_item;
+
+        if let Some(response) = &response {
+            responses.push(response.clone());
+        }
+
+        match response {
+            Some(ResponseInputItem::FunctionCallOutput { call_id, output }) => {
+                new_inputs_to_record.push(ResponseItem::FunctionCallOutput {
+                    call_id: call_id.clone(),
+                    output: output.clone(),
+                });
+            }
+
+            Some(ResponseInputItem::CustomToolCallOutput { call_id, output }) => {
+                new_inputs_to_record.push(ResponseItem::CustomToolCallOutput {
+                    call_id: call_id.clone(),
+                    output: output.clone(),
+                });
+            }
+            Some(ResponseInputItem::McpToolCallOutput { call_id, result }) => {
+                let output = match result {
+                    Ok(call_tool_result) => FunctionCallOutputPayload::from(&call_tool_result),
+                    Err(err) => FunctionCallOutputPayload {
+                        content: err.clone(),
+                        success: Some(false),
+                        ..Default::default()
+                    },
+                };
+                new_inputs_to_record.push(ResponseItem::FunctionCallOutput {
+                    call_id: call_id.clone(),
+                    output,
+                });
+            }
+            None => {}
+            _ => {
+                warn!("Unexpected response item: {item:?} with response: {response:?}");
+            }
+        };
+
+        outputs_to_record.push(item);
+    }
+
+    let all_items_to_record = [outputs_to_record, new_inputs_to_record].concat();
+    // Only attempt to take the lock if there is something to record.
+    if !all_items_to_record.is_empty() {
+        sess.record_conversation_items(turn_context, &all_items_to_record)
+            .await;
+    }
+    (responses, all_items_to_record)
+}
--- a/codex-rs/core/src/review_format.rs
+++ b/codex-rs/core/src/review_format.rs
@@ -1,5 +1,4 @@
 use crate::protocol::ReviewFinding;
-use crate::protocol::ReviewOutputEvent;

 // Note: We keep this module UI-agnostic. It returns plain strings that
 // higher layers (e.g., TUI) may style as needed.
@@ -11,8 +10,6 @@ fn format_location(item: &ReviewFinding) -> String {
    format!("{path}:{start}-{end}")
 }

-const REVIEW_FALLBACK_MESSAGE: &str = "Reviewer failed to output a response.";
-
 /// Format a full review findings block as plain text lines.
 ///
 /// - When `selection` is `Some`, each item line includes a checkbox marker:
@@ -56,27 +53,3 @@ pub fn format_review_findings_block(

    lines.join("\n")
 }
-
-/// Render a human-readable review summary suitable for a user-facing message.
-///
-/// Returns either the explanation, the formatted findings block, or both
-/// separated by a blank line. If neither is present, emits a fallback message.
-pub fn render_review_output_text(output: &ReviewOutputEvent) -> String {
-    let mut sections = Vec::new();
-    let explanation = output.overall_explanation.trim();
-    if !explanation.is_empty() {
-        sections.push(explanation.to_string());
-    }
-    if !output.findings.is_empty() {
-        let findings = format_review_findings_block(&output.findings, None);
-        let trimmed = findings.trim();
-        if !trimmed.is_empty() {
-            sections.push(trimmed.to_string());
-        }
-    }
-    if sections.is_empty() {
-        REVIEW_FALLBACK_MESSAGE.to_string()
-    } else {
-        sections.join("\n\n")
-    }
-}
--- a/codex-rs/core/src/review_prompts.rs
+++ b/codex-rs/core/src/review_prompts.rs
@@ -1,93 +0,0 @@
-use codex_git::merge_base_with_head;
-use codex_protocol::protocol::ReviewRequest;
-use codex_protocol::protocol::ReviewTarget;
-use std::path::Path;
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct ResolvedReviewRequest {
-    pub target: ReviewTarget,
-    pub prompt: String,
-    pub user_facing_hint: String,
-}
-
-const UNCOMMITTED_PROMPT: &str = "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.";
-
-const BASE_BRANCH_PROMPT_BACKUP: &str = "Review the code changes against the base branch '{branch}'. Start by finding the merge diff between the current branch and {branch}'s upstream e.g. (`git merge-base HEAD \"$(git rev-parse --abbrev-ref \"{branch}@{upstream}\")\"`), then run `git diff` against that SHA to see what changes we would merge into the {branch} branch. Provide prioritized, actionable findings.";
-const BASE_BRANCH_PROMPT: &str = "Review the code changes against the base branch '{baseBranch}'. The merge base commit for this comparison is {mergeBaseSha}. Run `git diff {mergeBaseSha}` to inspect the changes relative to {baseBranch}. Provide prioritized, actionable findings.";
-
-const COMMIT_PROMPT_WITH_TITLE: &str = "Review the code changes introduced by commit {sha} (\"{title}\"). Provide prioritized, actionable findings.";
-const COMMIT_PROMPT: &str =
-    "Review the code changes introduced by commit {sha}. Provide prioritized, actionable findings.";
-
-pub fn resolve_review_request(
-    request: ReviewRequest,
-    cwd: &Path,
-) -> anyhow::Result<ResolvedReviewRequest> {
-    let target = request.target;
-    let prompt = review_prompt(&target, cwd)?;
-    let user_facing_hint = request
-        .user_facing_hint
-        .unwrap_or_else(|| user_facing_hint(&target));
-
-    Ok(ResolvedReviewRequest {
-        target,
-        prompt,
-        user_facing_hint,
-    })
-}
-
-pub fn review_prompt(target: &ReviewTarget, cwd: &Path) -> anyhow::Result<String> {
-    match target {
-        ReviewTarget::UncommittedChanges => Ok(UNCOMMITTED_PROMPT.to_string()),
-        ReviewTarget::BaseBranch { branch } => {
-            if let Some(commit) = merge_base_with_head(cwd, branch)? {
-                Ok(BASE_BRANCH_PROMPT
-                    .replace("{baseBranch}", branch)
-                    .replace("{mergeBaseSha}", &commit))
-            } else {
-                Ok(BASE_BRANCH_PROMPT_BACKUP.replace("{branch}", branch))
-            }
-        }
-        ReviewTarget::Commit { sha, title } => {
-            if let Some(title) = title {
-                Ok(COMMIT_PROMPT_WITH_TITLE
-                    .replace("{sha}", sha)
-                    .replace("{title}", title))
-            } else {
-                Ok(COMMIT_PROMPT.replace("{sha}", sha))
-            }
-        }
-        ReviewTarget::Custom { instructions } => {
-            let prompt = instructions.trim();
-            if prompt.is_empty() {
-                anyhow::bail!("Review prompt cannot be empty");
-            }
-            Ok(prompt.to_string())
-        }
-    }
-}
-
-pub fn user_facing_hint(target: &ReviewTarget) -> String {
-    match target {
-        ReviewTarget::UncommittedChanges => "current changes".to_string(),
-        ReviewTarget::BaseBranch { branch } => format!("changes against '{branch}'"),
-        ReviewTarget::Commit { sha, title } => {
-            let short_sha: String = sha.chars().take(7).collect();
-            if let Some(title) = title {
-                format!("commit {short_sha}: {title}")
-            } else {
-                format!("commit {short_sha}")
-            }
-        }
-        ReviewTarget::Custom { instructions } => instructions.trim().to_string(),
-    }
-}
-
-impl From<ResolvedReviewRequest> for ReviewRequest {
-    fn from(resolved: ResolvedReviewRequest) -> Self {
-        ReviewRequest {
-            target: resolved.target,
-            user_facing_hint: Some(resolved.user_facing_hint),
-        }
-    }
-}
--- a/codex-rs/core/src/rollout/error.rs
+++ b/codex-rs/core/src/rollout/error.rs
@@ -1,49 +0,0 @@
-use std::io::ErrorKind;
-use std::path::Path;
-
-use crate::error::CodexErr;
-use crate::rollout::SESSIONS_SUBDIR;
-
-pub(crate) fn map_session_init_error(err: &anyhow::Error, codex_home: &Path) -> CodexErr {
-    if let Some(mapped) = err
-        .chain()
-        .filter_map(|cause| cause.downcast_ref::<std::io::Error>())
-        .find_map(|io_err| map_rollout_io_error(io_err, codex_home))
-    {
-        return mapped;
-    }
-
-    CodexErr::Fatal(format!("Failed to initialize session: {err:#}"))
-}
-
-fn map_rollout_io_error(io_err: &std::io::Error, codex_home: &Path) -> Option<CodexErr> {
-    let sessions_dir = codex_home.join(SESSIONS_SUBDIR);
-    let hint = match io_err.kind() {
-        ErrorKind::PermissionDenied => format!(
-            "Codex cannot access session files at {} (permission denied). If sessions were created using sudo, fix ownership: sudo chown -R $(whoami) {}",
-            sessions_dir.display(),
-            codex_home.display()
-        ),
-        ErrorKind::NotFound => format!(
-            "Session storage missing at {}. Create the directory or choose a different Codex home.",
-            sessions_dir.display()
-        ),
-        ErrorKind::AlreadyExists => format!(
-            "Session storage path {} is blocked by an existing file. Remove or rename it so Codex can create sessions.",
-            sessions_dir.display()
-        ),
-        ErrorKind::InvalidData | ErrorKind::InvalidInput => format!(
-            "Session data under {} looks corrupt or unreadable. Clearing the sessions directory may help (this will remove saved conversations).",
-            sessions_dir.display()
-        ),
-        ErrorKind::IsADirectory | ErrorKind::NotADirectory => format!(
-            "Session storage path {} has an unexpected type. Ensure it is a directory Codex can use for session files.",
-            sessions_dir.display()
-        ),
-        _ => return None,
-    };
-
-    Some(CodexErr::Fatal(format!(
-        "{hint} (underlying error: {io_err})"
-    )))
-}
--- a/codex-rs/core/src/rollout/list.rs
+++ b/codex-rs/core/src/rollout/list.rs
@@ -9,7 +9,6 @@ use std::sync::atomic::AtomicBool;
 use time::OffsetDateTime;
 use time::PrimitiveDateTime;
 use time::format_description::FormatItem;
-use time::format_description::well_known::Rfc3339;
 use time::macros::format_description;
 use uuid::Uuid;

@@ -40,15 +39,18 @@ pub struct ConversationItem {
    pub path: PathBuf,
    /// First up to `HEAD_RECORD_LIMIT` JSONL records parsed as JSON (includes meta line).
    pub head: Vec<serde_json::Value>,
+    /// Last up to `TAIL_RECORD_LIMIT` JSONL response records parsed as JSON.
+    pub tail: Vec<serde_json::Value>,
    /// RFC3339 timestamp string for when the session was created, if available.
    pub created_at: Option<String>,
-    /// RFC3339 timestamp string for the most recent update (from file mtime).
+    /// RFC3339 timestamp string for the most recent response in the tail, if available.
    pub updated_at: Option<String>,
 }

 #[derive(Default)]
 struct HeadTailSummary {
    head: Vec<serde_json::Value>,
+    tail: Vec<serde_json::Value>,
    saw_session_meta: bool,
    saw_user_event: bool,
    source: Option<SessionSource>,
@@ -60,6 +62,7 @@ struct HeadTailSummary {
 /// Hard cap to bound worst‑case work per request.
 const MAX_SCAN_FILES: usize = 10000;
 const HEAD_RECORD_LIMIT: usize = 10;
+const TAIL_RECORD_LIMIT: usize = 10;

 /// Pagination cursor identifying a file by timestamp and UUID.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -138,6 +141,13 @@ pub(crate) async fn get_conversations(
    Ok(result)
 }

+/// Load the full contents of a single conversation session file at `path`.
+/// Returns the entire file contents as a String.
+#[allow(dead_code)]
+pub(crate) async fn get_conversation(path: &Path) -> io::Result<String> {
+    tokio::fs::read_to_string(path).await
+}
+
 /// Load conversation file paths from disk using directory traversal.
 ///
 /// Directory layout: `~/.codex/sessions/YYYY/MM/DD/rollout-YYYY-MM-DDThh-mm-ss-<uuid>.jsonl`
@@ -202,8 +212,9 @@ async fn traverse_directories_for_paths(
                        more_matches_available = true;
                        break 'outer;
                    }
-                    // Read head and detect message events; stop once meta + user are found.
-                    let summary = read_head_summary(&path, HEAD_RECORD_LIMIT)
+                    // Read head and simultaneously detect message events within the same
+                    // first N JSONL records to avoid a second file read.
+                    let summary = read_head_and_tail(&path, HEAD_RECORD_LIMIT, TAIL_RECORD_LIMIT)
                        .await
                        .unwrap_or_default();
                    if !allowed_sources.is_empty()
@@ -222,19 +233,16 @@ async fn traverse_directories_for_paths(
                    if summary.saw_session_meta && summary.saw_user_event {
                        let HeadTailSummary {
                            head,
+                            tail,
                            created_at,
                            mut updated_at,
                            ..
                        } = summary;
-                        if updated_at.is_none() {
-                            updated_at = file_modified_rfc3339(&path)
-                                .await
-                                .unwrap_or(None)
-                                .or_else(|| created_at.clone());
-                        }
+                        updated_at = updated_at.or_else(|| created_at.clone());
                        items.push(ConversationItem {
                            path,
                            head,
+                            tail,
                            created_at,
                            updated_at,
                        });
@@ -376,7 +384,11 @@ impl<'a> ProviderMatcher<'a> {
    }
 }

-async fn read_head_summary(path: &Path, head_limit: usize) -> io::Result<HeadTailSummary> {
+async fn read_head_and_tail(
+    path: &Path,
+    head_limit: usize,
+    tail_limit: usize,
+) -> io::Result<HeadTailSummary> {
    use tokio::io::AsyncBufReadExt;

    let file = tokio::fs::File::open(path).await?;
@@ -429,30 +441,107 @@ async fn read_head_summary(path: &Path, head_limit: usize) -> io::Result<HeadTai
                }
            }
        }
-
-        if summary.saw_session_meta && summary.saw_user_event {
-            break;
-        }
    }

+    if tail_limit != 0 {
+        let (tail, updated_at) = read_tail_records(path, tail_limit).await?;
+        summary.tail = tail;
+        summary.updated_at = updated_at;
+    }
    Ok(summary)
 }

 /// Read up to `HEAD_RECORD_LIMIT` records from the start of the rollout file at `path`.
 /// This should be enough to produce a summary including the session meta line.
 pub async fn read_head_for_summary(path: &Path) -> io::Result<Vec<serde_json::Value>> {
-    let summary = read_head_summary(path, HEAD_RECORD_LIMIT).await?;
+    let summary = read_head_and_tail(path, HEAD_RECORD_LIMIT, 0).await?;
    Ok(summary.head)
 }

-async fn file_modified_rfc3339(path: &Path) -> io::Result<Option<String>> {
-    let meta = tokio::fs::metadata(path).await?;
-    let modified = meta.modified().ok();
-    let Some(modified) = modified else {
-        return Ok(None);
-    };
-    let dt = OffsetDateTime::from(modified);
-    Ok(dt.format(&Rfc3339).ok())
+async fn read_tail_records(
+    path: &Path,
+    max_records: usize,
+) -> io::Result<(Vec<serde_json::Value>, Option<String>)> {
+    use std::io::SeekFrom;
+    use tokio::io::AsyncReadExt;
+    use tokio::io::AsyncSeekExt;
+
+    if max_records == 0 {
+        return Ok((Vec::new(), None));
+    }
+
+    const CHUNK_SIZE: usize = 8192;
+
+    let mut file = tokio::fs::File::open(path).await?;
+    let mut pos = file.seek(SeekFrom::End(0)).await?;
+    if pos == 0 {
+        return Ok((Vec::new(), None));
+    }
+
+    let mut buffer: Vec<u8> = Vec::new();
+    let mut latest_timestamp: Option<String> = None;
+
+    loop {
+        let slice_start = match (pos > 0, buffer.iter().position(|&b| b == b'\n')) {
+            (true, Some(idx)) => idx + 1,
+            _ => 0,
+        };
+        let (tail, newest_ts) = collect_last_response_values(&buffer[slice_start..], max_records);
+        if latest_timestamp.is_none() {
+            latest_timestamp = newest_ts.clone();
+        }
+        if tail.len() >= max_records || pos == 0 {
+            return Ok((tail, latest_timestamp.or(newest_ts)));
+        }
+
+        let read_size = CHUNK_SIZE.min(pos as usize);
+        if read_size == 0 {
+            return Ok((tail, latest_timestamp.or(newest_ts)));
+        }
+        pos -= read_size as u64;
+        file.seek(SeekFrom::Start(pos)).await?;
+        let mut chunk = vec![0; read_size];
+        file.read_exact(&mut chunk).await?;
+        chunk.extend_from_slice(&buffer);
+        buffer = chunk;
+    }
+}
+
+fn collect_last_response_values(
+    buffer: &[u8],
+    max_records: usize,
+) -> (Vec<serde_json::Value>, Option<String>) {
+    use std::borrow::Cow;
+
+    if buffer.is_empty() || max_records == 0 {
+        return (Vec::new(), None);
+    }
+
+    let text: Cow<'_, str> = String::from_utf8_lossy(buffer);
+    let mut collected_rev: Vec<serde_json::Value> = Vec::new();
+    let mut latest_timestamp: Option<String> = None;
+    for line in text.lines().rev() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let parsed: serde_json::Result<RolloutLine> = serde_json::from_str(trimmed);
+        let Ok(rollout_line) = parsed else { continue };
+        let RolloutLine { timestamp, item } = rollout_line;
+        if let RolloutItem::ResponseItem(item) = item
+            && let Ok(val) = serde_json::to_value(&item)
+        {
+            if latest_timestamp.is_none() {
+                latest_timestamp = Some(timestamp.clone());
+            }
+            collected_rev.push(val);
+            if collected_rev.len() == max_records {
+                break;
+            }
+        }
+    }
+    collected_rev.reverse();
+    (collected_rev, latest_timestamp)
 }

 /// Locate a recorded conversation rollout file by its UUID string using the existing
--- a/codex-rs/core/src/rollout/mod.rs
+++ b/codex-rs/core/src/rollout/mod.rs
@@ -7,13 +7,11 @@ pub const ARCHIVED_SESSIONS_SUBDIR: &str = "archived_sessions";
 pub const INTERACTIVE_SESSION_SOURCES: &[SessionSource] =
    &[SessionSource::Cli, SessionSource::VSCode];

-pub(crate) mod error;
 pub mod list;
 pub(crate) mod policy;
 pub mod recorder;

 pub use codex_protocol::protocol::SessionMeta;
-pub(crate) use error::map_session_init_error;
 pub use list::find_conversation_path_by_id_str;
 pub use recorder::RolloutRecorder;
 pub use recorder::RolloutRecorderParams;
--- a/codex-rs/core/src/rollout/tests.rs
+++ b/codex-rs/core/src/rollout/tests.rs
@@ -16,11 +16,13 @@ use crate::rollout::INTERACTIVE_SESSION_SOURCES;
 use crate::rollout::list::ConversationItem;
 use crate::rollout::list::ConversationsPage;
 use crate::rollout::list::Cursor;
+use crate::rollout::list::get_conversation;
 use crate::rollout::list::get_conversations;
 use anyhow::Result;
 use codex_protocol::ConversationId;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
+use codex_protocol::protocol::CompactedItem;
 use codex_protocol::protocol::EventMsg;
 use codex_protocol::protocol::RolloutItem;
 use codex_protocol::protocol::RolloutLine;
@@ -224,28 +226,28 @@ async fn test_list_conversations_latest_first() {
        "model_provider": "test-provider",
    })];

-    let updated_times: Vec<Option<String>> =
-        page.items.iter().map(|i| i.updated_at.clone()).collect();
-
    let expected = ConversationsPage {
        items: vec![
            ConversationItem {
                path: p1,
                head: head_3,
+                tail: Vec::new(),
                created_at: Some("2025-01-03T12-00-00".into()),
-                updated_at: updated_times.first().cloned().flatten(),
+                updated_at: Some("2025-01-03T12-00-00".into()),
            },
            ConversationItem {
                path: p2,
                head: head_2,
+                tail: Vec::new(),
                created_at: Some("2025-01-02T12-00-00".into()),
-                updated_at: updated_times.get(1).cloned().flatten(),
+                updated_at: Some("2025-01-02T12-00-00".into()),
            },
            ConversationItem {
                path: p3,
                head: head_1,
+                tail: Vec::new(),
                created_at: Some("2025-01-01T12-00-00".into()),
-                updated_at: updated_times.get(2).cloned().flatten(),
+                updated_at: Some("2025-01-01T12-00-00".into()),
            },
        ],
        next_cursor: None,
@@ -353,8 +355,6 @@ async fn test_pagination_cursor() {
        "source": "vscode",
        "model_provider": "test-provider",
    })];
-    let updated_page1: Vec<Option<String>> =
-        page1.items.iter().map(|i| i.updated_at.clone()).collect();
    let expected_cursor1: Cursor =
        serde_json::from_str(&format!("\"2025-03-04T09-00-00|{u4}\"")).unwrap();
    let expected_page1 = ConversationsPage {
@@ -362,14 +362,16 @@ async fn test_pagination_cursor() {
            ConversationItem {
                path: p5,
                head: head_5,
+                tail: Vec::new(),
                created_at: Some("2025-03-05T09-00-00".into()),
-                updated_at: updated_page1.first().cloned().flatten(),
+                updated_at: Some("2025-03-05T09-00-00".into()),
            },
            ConversationItem {
                path: p4,
                head: head_4,
+                tail: Vec::new(),
                created_at: Some("2025-03-04T09-00-00".into()),
-                updated_at: updated_page1.get(1).cloned().flatten(),
+                updated_at: Some("2025-03-04T09-00-00".into()),
            },
        ],
        next_cursor: Some(expected_cursor1.clone()),
@@ -420,8 +422,6 @@ async fn test_pagination_cursor() {
        "source": "vscode",
        "model_provider": "test-provider",
    })];
-    let updated_page2: Vec<Option<String>> =
-        page2.items.iter().map(|i| i.updated_at.clone()).collect();
    let expected_cursor2: Cursor =
        serde_json::from_str(&format!("\"2025-03-02T09-00-00|{u2}\"")).unwrap();
    let expected_page2 = ConversationsPage {
@@ -429,14 +429,16 @@ async fn test_pagination_cursor() {
            ConversationItem {
                path: p3,
                head: head_3,
+                tail: Vec::new(),
                created_at: Some("2025-03-03T09-00-00".into()),
-                updated_at: updated_page2.first().cloned().flatten(),
+                updated_at: Some("2025-03-03T09-00-00".into()),
            },
            ConversationItem {
                path: p2,
                head: head_2,
+                tail: Vec::new(),
                created_at: Some("2025-03-02T09-00-00".into()),
-                updated_at: updated_page2.get(1).cloned().flatten(),
+                updated_at: Some("2025-03-02T09-00-00".into()),
            },
        ],
        next_cursor: Some(expected_cursor2.clone()),
@@ -471,14 +473,13 @@ async fn test_pagination_cursor() {
        "source": "vscode",
        "model_provider": "test-provider",
    })];
-    let updated_page3: Vec<Option<String>> =
-        page3.items.iter().map(|i| i.updated_at.clone()).collect();
    let expected_page3 = ConversationsPage {
        items: vec![ConversationItem {
            path: p1,
            head: head_1,
+            tail: Vec::new(),
            created_at: Some("2025-03-01T09-00-00".into()),
-            updated_at: updated_page3.first().cloned().flatten(),
+            updated_at: Some("2025-03-01T09-00-00".into()),
        }],
        next_cursor: None,
        num_scanned_files: 5, // scanned 05, 04 (anchor), 03, 02 (anchor), 01
@@ -509,7 +510,7 @@ async fn test_get_conversation_contents() {
    .unwrap();
    let path = &page.items[0].path;

-    let content = tokio::fs::read_to_string(path).await.unwrap();
+    let content = get_conversation(path).await.unwrap();

    // Page equality (single item)
    let expected_path = home
@@ -532,8 +533,9 @@ async fn test_get_conversation_contents() {
        items: vec![ConversationItem {
            path: expected_path,
            head: expected_head,
+            tail: Vec::new(),
            created_at: Some(ts.into()),
-            updated_at: page.items[0].updated_at.clone(),
+            updated_at: Some(ts.into()),
        }],
        next_cursor: None,
        num_scanned_files: 1,
@@ -568,7 +570,7 @@ async fn test_get_conversation_contents() {
 }

 #[tokio::test]
-async fn test_updated_at_uses_file_mtime() -> Result<()> {
+async fn test_tail_includes_last_response_items() -> Result<()> {
    let temp = TempDir::new().unwrap();
    let home = temp.path();

@@ -634,16 +636,229 @@ async fn test_updated_at_uses_file_mtime() -> Result<()> {
    )
    .await?;
    let item = page.items.first().expect("conversation item");
+    let tail_len = item.tail.len();
+    assert_eq!(tail_len, 10usize.min(total_messages));
+
+    let expected: Vec<serde_json::Value> = (total_messages - tail_len..total_messages)
+        .map(|idx| {
+            serde_json::json!({
+                "type": "message",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": format!("reply-{idx}"),
+                    }
+                ],
+            })
+        })
+        .collect();
+
+    assert_eq!(item.tail, expected);
    assert_eq!(item.created_at.as_deref(), Some(ts));
-    let updated = item
-        .updated_at
-        .as_deref()
-        .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok())
-        .map(|dt| dt.with_timezone(&chrono::Utc))
-        .expect("updated_at set from file mtime");
-    let now = chrono::Utc::now();
-    let age = now - updated;
-    assert!(age.num_seconds().abs() < 30);
+    let expected_updated = format!("{ts}-{last:02}", last = total_messages - 1);
+    assert_eq!(item.updated_at.as_deref(), Some(expected_updated.as_str()));
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_tail_handles_short_sessions() -> Result<()> {
+    let temp = TempDir::new().unwrap();
+    let home = temp.path();
+
+    let ts = "2025-06-02T08-30-00";
+    let uuid = Uuid::from_u128(7);
+    let day_dir = home.join("sessions").join("2025").join("06").join("02");
+    fs::create_dir_all(&day_dir)?;
+    let file_path = day_dir.join(format!("rollout-{ts}-{uuid}.jsonl"));
+    let mut file = File::create(&file_path)?;
+
+    let conversation_id = ConversationId::from_string(&uuid.to_string())?;
+    let meta_line = RolloutLine {
+        timestamp: ts.to_string(),
+        item: RolloutItem::SessionMeta(SessionMetaLine {
+            meta: SessionMeta {
+                id: conversation_id,
+                timestamp: ts.to_string(),
+                instructions: None,
+                cwd: ".".into(),
+                originator: "test_originator".into(),
+                cli_version: "test_version".into(),
+                source: SessionSource::VSCode,
+                model_provider: Some("test-provider".into()),
+            },
+            git: None,
+        }),
+    };
+    writeln!(file, "{}", serde_json::to_string(&meta_line)?)?;
+
+    let user_event_line = RolloutLine {
+        timestamp: ts.to_string(),
+        item: RolloutItem::EventMsg(EventMsg::UserMessage(UserMessageEvent {
+            message: "hi".into(),
+            images: None,
+        })),
+    };
+    writeln!(file, "{}", serde_json::to_string(&user_event_line)?)?;
+
+    for idx in 0..3 {
+        let response_line = RolloutLine {
+            timestamp: format!("{ts}-{idx:02}"),
+            item: RolloutItem::ResponseItem(ResponseItem::Message {
+                id: None,
+                role: "assistant".into(),
+                content: vec![ContentItem::OutputText {
+                    text: format!("short-{idx}"),
+                }],
+            }),
+        };
+        writeln!(file, "{}", serde_json::to_string(&response_line)?)?;
+    }
+    drop(file);
+
+    let provider_filter = provider_vec(&[TEST_PROVIDER]);
+    let page = get_conversations(
+        home,
+        1,
+        None,
+        INTERACTIVE_SESSION_SOURCES,
+        Some(provider_filter.as_slice()),
+        TEST_PROVIDER,
+    )
+    .await?;
+    let tail = &page.items.first().expect("conversation item").tail;
+
+    assert_eq!(tail.len(), 3);
+
+    let expected: Vec<serde_json::Value> = (0..3)
+        .map(|idx| {
+            serde_json::json!({
+                "type": "message",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": format!("short-{idx}"),
+                    }
+                ],
+            })
+        })
+        .collect();
+
+    assert_eq!(tail, &expected);
+    let expected_updated = format!("{ts}-{last:02}", last = 2);
+    assert_eq!(
+        page.items[0].updated_at.as_deref(),
+        Some(expected_updated.as_str())
+    );
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_tail_skips_trailing_non_responses() -> Result<()> {
+    let temp = TempDir::new().unwrap();
+    let home = temp.path();
+
+    let ts = "2025-06-03T10-00-00";
+    let uuid = Uuid::from_u128(11);
+    let day_dir = home.join("sessions").join("2025").join("06").join("03");
+    fs::create_dir_all(&day_dir)?;
+    let file_path = day_dir.join(format!("rollout-{ts}-{uuid}.jsonl"));
+    let mut file = File::create(&file_path)?;
+
+    let conversation_id = ConversationId::from_string(&uuid.to_string())?;
+    let meta_line = RolloutLine {
+        timestamp: ts.to_string(),
+        item: RolloutItem::SessionMeta(SessionMetaLine {
+            meta: SessionMeta {
+                id: conversation_id,
+                timestamp: ts.to_string(),
+                instructions: None,
+                cwd: ".".into(),
+                originator: "test_originator".into(),
+                cli_version: "test_version".into(),
+                source: SessionSource::VSCode,
+                model_provider: Some("test-provider".into()),
+            },
+            git: None,
+        }),
+    };
+    writeln!(file, "{}", serde_json::to_string(&meta_line)?)?;
+
+    let user_event_line = RolloutLine {
+        timestamp: ts.to_string(),
+        item: RolloutItem::EventMsg(EventMsg::UserMessage(UserMessageEvent {
+            message: "hello".into(),
+            images: None,
+        })),
+    };
+    writeln!(file, "{}", serde_json::to_string(&user_event_line)?)?;
+
+    for idx in 0..4 {
+        let response_line = RolloutLine {
+            timestamp: format!("{ts}-{idx:02}"),
+            item: RolloutItem::ResponseItem(ResponseItem::Message {
+                id: None,
+                role: "assistant".into(),
+                content: vec![ContentItem::OutputText {
+                    text: format!("response-{idx}"),
+                }],
+            }),
+        };
+        writeln!(file, "{}", serde_json::to_string(&response_line)?)?;
+    }
+
+    let compacted_line = RolloutLine {
+        timestamp: format!("{ts}-compacted"),
+        item: RolloutItem::Compacted(CompactedItem {
+            message: "compacted".into(),
+            replacement_history: None,
+        }),
+    };
+    writeln!(file, "{}", serde_json::to_string(&compacted_line)?)?;
+
+    let shutdown_event = RolloutLine {
+        timestamp: format!("{ts}-shutdown"),
+        item: RolloutItem::EventMsg(EventMsg::ShutdownComplete),
+    };
+    writeln!(file, "{}", serde_json::to_string(&shutdown_event)?)?;
+    drop(file);
+
+    let provider_filter = provider_vec(&[TEST_PROVIDER]);
+    let page = get_conversations(
+        home,
+        1,
+        None,
+        INTERACTIVE_SESSION_SOURCES,
+        Some(provider_filter.as_slice()),
+        TEST_PROVIDER,
+    )
+    .await?;
+    let tail = &page.items.first().expect("conversation item").tail;
+
+    let expected: Vec<serde_json::Value> = (0..4)
+        .map(|idx| {
+            serde_json::json!({
+                "type": "message",
+                "role": "assistant",
+                "content": [
+                    {
+                        "type": "output_text",
+                        "text": format!("response-{idx}"),
+                    }
+                ],
+            })
+        })
+        .collect();
+
+    assert_eq!(tail, &expected);
+    let expected_updated = format!("{ts}-{last:02}", last = 3);
+    assert_eq!(
+        page.items[0].updated_at.as_deref(),
+        Some(expected_updated.as_str())
+    );

    Ok(())
 }
@@ -698,22 +913,22 @@ async fn test_stable_ordering_same_second_pagination() {
            "model_provider": "test-provider",
        })]
    };
-    let updated_page1: Vec<Option<String>> =
-        page1.items.iter().map(|i| i.updated_at.clone()).collect();
    let expected_cursor1: Cursor = serde_json::from_str(&format!("\"{ts}|{u2}\"")).unwrap();
    let expected_page1 = ConversationsPage {
        items: vec![
            ConversationItem {
                path: p3,
                head: head(u3),
+                tail: Vec::new(),
                created_at: Some(ts.to_string()),
-                updated_at: updated_page1.first().cloned().flatten(),
+                updated_at: Some(ts.to_string()),
            },
            ConversationItem {
                path: p2,
                head: head(u2),
+                tail: Vec::new(),
                created_at: Some(ts.to_string()),
-                updated_at: updated_page1.get(1).cloned().flatten(),
+                updated_at: Some(ts.to_string()),
            },
        ],
        next_cursor: Some(expected_cursor1.clone()),
@@ -738,14 +953,13 @@ async fn test_stable_ordering_same_second_pagination() {
        .join("07")
        .join("01")
        .join(format!("rollout-2025-07-01T00-00-00-{u1}.jsonl"));
-    let updated_page2: Vec<Option<String>> =
-        page2.items.iter().map(|i| i.updated_at.clone()).collect();
    let expected_page2 = ConversationsPage {
        items: vec![ConversationItem {
            path: p1,
            head: head(u1),
+            tail: Vec::new(),
            created_at: Some(ts.to_string()),
-            updated_at: updated_page2.first().cloned().flatten(),
+            updated_at: Some(ts.to_string()),
        }],
        next_cursor: None,
        num_scanned_files: 3, // scanned u3, u2 (anchor), u1
--- a/codex-rs/core/src/safety.rs
+++ b/codex-rs/core/src/safety.rs
@@ -6,7 +6,6 @@ use codex_apply_patch::ApplyPatchAction;
 use codex_apply_patch::ApplyPatchFileChange;

 use crate::exec::SandboxType;
-use crate::util::resolve_path;

 use crate::protocol::AskForApproval;
 use crate::protocol::SandboxPolicy;
@@ -151,7 +150,11 @@ fn is_write_patch_constrained_to_writable_paths(
    // and roots are converted to absolute, normalized forms before the
    // prefix check.
    let is_path_writable = |p: &PathBuf| {
-        let abs = resolve_path(cwd, p);
+        let abs = if p.is_absolute() {
+            p.clone()
+        } else {
+            cwd.join(p)
+        };
        let abs = match normalize(&abs) {
            Some(v) => v,
            None => return false,
--- a/codex-rs/core/src/sandboxing/assessment.rs
+++ b/codex-rs/core/src/sandboxing/assessment.rs
@@ -10,14 +10,12 @@ use crate::client::ModelClient;
 use crate::client_common::Prompt;
 use crate::client_common::ResponseEvent;
 use crate::config::Config;
-use crate::openai_models::models_manager::ModelsManager;
 use crate::protocol::SandboxPolicy;
 use askama::Template;
 use codex_otel::otel_event_manager::OtelEventManager;
 use codex_protocol::ConversationId;
 use codex_protocol::models::ContentItem;
 use codex_protocol::models::ResponseItem;
-use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::protocol::SandboxCommandAssessment;
 use codex_protocol::protocol::SessionSource;
 use futures::StreamExt;
@@ -25,8 +23,7 @@ use serde_json::json;
 use tokio::time::timeout;
 use tracing::warn;

-const SANDBOX_ASSESSMENT_TIMEOUT: Duration = Duration::from_secs(15);
-const SANDBOX_ASSESSMENT_REASONING_EFFORT: ReasoningEffortConfig = ReasoningEffortConfig::Medium;
+const SANDBOX_ASSESSMENT_TIMEOUT: Duration = Duration::from_secs(5);

 #[derive(Template)]
 #[template(path = "sandboxing/assessment_prompt.md", escape = "none")]
@@ -47,7 +44,6 @@ pub(crate) async fn assess_command(
    auth_manager: Arc<AuthManager>,
    parent_otel: &OtelEventManager,
    conversation_id: ConversationId,
-    models_manager: Arc<ModelsManager>,
    session_source: SessionSource,
    call_id: &str,
    command: &[String],
@@ -126,17 +122,15 @@ pub(crate) async fn assess_command(
        output_schema: Some(sandbox_assessment_schema()),
    };

-    let model_family = models_manager.construct_model_family(&config.model, &config);
-
-    let child_otel = parent_otel.with_model(config.model.as_str(), model_family.slug.as_str());
+    let child_otel =
+        parent_otel.with_model(config.model.as_str(), config.model_family.slug.as_str());

    let client = ModelClient::new(
        Arc::clone(&config),
        Some(auth_manager),
-        model_family,
        child_otel,
        provider,
-        Some(SANDBOX_ASSESSMENT_REASONING_EFFORT),
+        config.model_reasoning_effort,
        config.model_reasoning_summary,
        conversation_id,
        session_source,
--- a/codex-rs/core/src/seatbelt_base_policy.sbpl
+++ b/codex-rs/core/src/seatbelt_base_policy.sbpl
@@ -53,7 +53,6 @@
  (sysctl-name "hw.physicalcpu_max")
  (sysctl-name "hw.tbfrequency_compat")
  (sysctl-name "hw.vectorunit")
-  (sysctl-name "kern.argmax")
  (sysctl-name "kern.hostname")
  (sysctl-name "kern.maxfilesperproc")
  (sysctl-name "kern.maxproc")
@@ -73,8 +72,7 @@
  (sysctl-name-prefix "net.routetable.")
 )

-; Allow Java to read some CPU info. This is misclassified as a "write" because
-; userspace passes a memory buffer to the sysctl, but conceptually it is a read.
+; Allow Java to set CPU type grade when required
 (allow sysctl-write
  (sysctl-name "kern.grade_cputype"))

@@ -88,20 +86,10 @@
  (global-name "com.apple.system.opendirectoryd.libinfo")
 )

+; Added on top of Chrome profile
 ; Needed for python multiprocessing on MacOS for the SemLock
 (allow ipc-posix-sem)

 (allow mach-lookup
  (global-name "com.apple.PowerManagement.control")
 )
-
-; allow openpty()
-(allow pseudo-tty)
-(allow file-read* file-write* file-ioctl (literal "/dev/ptmx"))
-(allow file-read* file-write*
-  (require-all
-    (regex #"^/dev/ttys[0-9]+")
-    (extension "com.apple.sandbox.pty")))
-; PTYs created before entering seatbelt may lack the extension; allow ioctl
-; on those slave ttys so interactive shells detect a TTY and remain functional.
-(allow file-ioctl (regex #"^/dev/ttys[0-9]+"))
--- a/codex-rs/core/src/skills/loader.rs
+++ b/codex-rs/core/src/skills/loader.rs
@@ -1,291 +0,0 @@
-use crate::config::Config;
-use crate::skills::model::SkillError;
-use crate::skills::model::SkillLoadOutcome;
-use crate::skills::model::SkillMetadata;
-use dunce::canonicalize as normalize_path;
-use serde::Deserialize;
-use std::collections::VecDeque;
-use std::error::Error;
-use std::fmt;
-use std::fs;
-use std::path::Path;
-use std::path::PathBuf;
-use tracing::error;
-
-#[derive(Debug, Deserialize)]
-struct SkillFrontmatter {
-    name: String,
-    description: String,
-}
-
-const SKILLS_FILENAME: &str = "SKILL.md";
-const SKILLS_DIR_NAME: &str = "skills";
-const MAX_NAME_LEN: usize = 100;
-const MAX_DESCRIPTION_LEN: usize = 500;
-
-#[derive(Debug)]
-enum SkillParseError {
-    Read(std::io::Error),
-    MissingFrontmatter,
-    InvalidYaml(serde_yaml::Error),
-    MissingField(&'static str),
-    InvalidField { field: &'static str, reason: String },
-}
-
-impl fmt::Display for SkillParseError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            SkillParseError::Read(e) => write!(f, "failed to read file: {e}"),
-            SkillParseError::MissingFrontmatter => {
-                write!(f, "missing YAML frontmatter delimited by ---")
-            }
-            SkillParseError::InvalidYaml(e) => write!(f, "invalid YAML: {e}"),
-            SkillParseError::MissingField(field) => write!(f, "missing field `{field}`"),
-            SkillParseError::InvalidField { field, reason } => {
-                write!(f, "invalid {field}: {reason}")
-            }
-        }
-    }
-}
-
-impl Error for SkillParseError {}
-
-pub fn load_skills(config: &Config) -> SkillLoadOutcome {
-    let mut outcome = SkillLoadOutcome::default();
-    let roots = skill_roots(config);
-    for root in roots {
-        discover_skills_under_root(&root, &mut outcome);
-    }
-
-    outcome
-        .skills
-        .sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.path.cmp(&b.path)));
-
-    outcome
-}
-
-fn skill_roots(config: &Config) -> Vec<PathBuf> {
-    vec![config.codex_home.join(SKILLS_DIR_NAME)]
-}
-
-fn discover_skills_under_root(root: &Path, outcome: &mut SkillLoadOutcome) {
-    let Ok(root) = normalize_path(root) else {
-        return;
-    };
-
-    if !root.is_dir() {
-        return;
-    }
-
-    let mut queue: VecDeque<PathBuf> = VecDeque::from([root]);
-    while let Some(dir) = queue.pop_front() {
-        let entries = match fs::read_dir(&dir) {
-            Ok(entries) => entries,
-            Err(e) => {
-                error!("failed to read skills dir {}: {e:#}", dir.display());
-                continue;
-            }
-        };
-
-        for entry in entries.flatten() {
-            let path = entry.path();
-            let file_name = match path.file_name().and_then(|f| f.to_str()) {
-                Some(name) => name,
-                None => continue,
-            };
-
-            if file_name.starts_with('.') {
-                continue;
-            }
-
-            let Ok(file_type) = entry.file_type() else {
-                continue;
-            };
-
-            if file_type.is_symlink() {
-                continue;
-            }
-
-            if file_type.is_dir() {
-                queue.push_back(path);
-                continue;
-            }
-
-            if file_type.is_file() && file_name == SKILLS_FILENAME {
-                match parse_skill_file(&path) {
-                    Ok(skill) => outcome.skills.push(skill),
-                    Err(err) => outcome.errors.push(SkillError {
-                        path,
-                        message: err.to_string(),
-                    }),
-                }
-            }
-        }
-    }
-}
-
-fn parse_skill_file(path: &Path) -> Result<SkillMetadata, SkillParseError> {
-    let contents = fs::read_to_string(path).map_err(SkillParseError::Read)?;
-
-    let frontmatter = extract_frontmatter(&contents).ok_or(SkillParseError::MissingFrontmatter)?;
-
-    let parsed: SkillFrontmatter =
-        serde_yaml::from_str(&frontmatter).map_err(SkillParseError::InvalidYaml)?;
-
-    let name = sanitize_single_line(&parsed.name);
-    let description = sanitize_single_line(&parsed.description);
-
-    validate_field(&name, MAX_NAME_LEN, "name")?;
-    validate_field(&description, MAX_DESCRIPTION_LEN, "description")?;
-
-    let resolved_path = normalize_path(path).unwrap_or_else(|_| path.to_path_buf());
-
-    Ok(SkillMetadata {
-        name,
-        description,
-        path: resolved_path,
-    })
-}
-
-fn sanitize_single_line(raw: &str) -> String {
-    raw.split_whitespace().collect::<Vec<_>>().join(" ")
-}
-
-fn validate_field(
-    value: &str,
-    max_len: usize,
-    field_name: &'static str,
-) -> Result<(), SkillParseError> {
-    if value.is_empty() {
-        return Err(SkillParseError::MissingField(field_name));
-    }
-    if value.len() > max_len {
-        return Err(SkillParseError::InvalidField {
-            field: field_name,
-            reason: format!("exceeds maximum length of {max_len} characters"),
-        });
-    }
-    Ok(())
-}
-
-fn extract_frontmatter(contents: &str) -> Option<String> {
-    let mut lines = contents.lines();
-    if !matches!(lines.next(), Some(line) if line.trim() == "---") {
-        return None;
-    }
-
-    let mut frontmatter_lines: Vec<&str> = Vec::new();
-    let mut found_closing = false;
-    for line in lines.by_ref() {
-        if line.trim() == "---" {
-            found_closing = true;
-            break;
-        }
-        frontmatter_lines.push(line);
-    }
-
-    if frontmatter_lines.is_empty() || !found_closing {
-        return None;
-    }
-
-    Some(frontmatter_lines.join("\n"))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::config::ConfigOverrides;
-    use crate::config::ConfigToml;
-    use tempfile::TempDir;
-
-    fn make_config(codex_home: &TempDir) -> Config {
-        let mut config = Config::load_from_base_config_with_overrides(
-            ConfigToml::default(),
-            ConfigOverrides::default(),
-            codex_home.path().to_path_buf(),
-        )
-        .expect("defaults for test should always succeed");
-
-        config.cwd = codex_home.path().to_path_buf();
-        config
-    }
-
-    fn write_skill(codex_home: &TempDir, dir: &str, name: &str, description: &str) -> PathBuf {
-        let skill_dir = codex_home.path().join(format!("skills/{dir}"));
-        fs::create_dir_all(&skill_dir).unwrap();
-        let indented_description = description.replace('\n', "\n  ");
-        let content = format!(
-            "---\nname: {name}\ndescription: |-\n  {indented_description}\n---\n\n# Body\n"
-        );
-        let path = skill_dir.join(SKILLS_FILENAME);
-        fs::write(&path, content).unwrap();
-        path
-    }
-
-    #[test]
-    fn loads_valid_skill() {
-        let codex_home = tempfile::tempdir().expect("tempdir");
-        write_skill(&codex_home, "demo", "demo-skill", "does things\ncarefully");
-        let cfg = make_config(&codex_home);
-
-        let outcome = load_skills(&cfg);
-        assert!(
-            outcome.errors.is_empty(),
-            "unexpected errors: {:?}",
-            outcome.errors
-        );
-        assert_eq!(outcome.skills.len(), 1);
-        let skill = &outcome.skills[0];
-        assert_eq!(skill.name, "demo-skill");
-        assert_eq!(skill.description, "does things carefully");
-        let path_str = skill.path.to_string_lossy().replace('\\', "/");
-        assert!(
-            path_str.ends_with("skills/demo/SKILL.md"),
-            "unexpected path {path_str}"
-        );
-    }
-
-    #[test]
-    fn skips_hidden_and_invalid() {
-        let codex_home = tempfile::tempdir().expect("tempdir");
-        let hidden_dir = codex_home.path().join("skills/.hidden");
-        fs::create_dir_all(&hidden_dir).unwrap();
-        fs::write(
-            hidden_dir.join(SKILLS_FILENAME),
-            "---\nname: hidden\ndescription: hidden\n---\n",
-        )
-        .unwrap();
-
-        // Invalid because missing closing frontmatter.
-        let invalid_dir = codex_home.path().join("skills/invalid");
-        fs::create_dir_all(&invalid_dir).unwrap();
-        fs::write(invalid_dir.join(SKILLS_FILENAME), "---\nname: bad").unwrap();
-
-        let cfg = make_config(&codex_home);
-        let outcome = load_skills(&cfg);
-        assert_eq!(outcome.skills.len(), 0);
-        assert_eq!(outcome.errors.len(), 1);
-        assert!(
-            outcome.errors[0]
-                .message
-                .contains("missing YAML frontmatter"),
-            "expected frontmatter error"
-        );
-    }
-
-    #[test]
-    fn enforces_length_limits() {
-        let codex_home = tempfile::tempdir().expect("tempdir");
-        let long_desc = "a".repeat(MAX_DESCRIPTION_LEN + 1);
-        write_skill(&codex_home, "too-long", "toolong", &long_desc);
-        let cfg = make_config(&codex_home);
-
-        let outcome = load_skills(&cfg);
-        assert_eq!(outcome.skills.len(), 0);
-        assert_eq!(outcome.errors.len(), 1);
-        assert!(
-            outcome.errors[0].message.contains("invalid description"),
-            "expected length error"
-        );
-    }
-}
--- a/codex-rs/core/src/skills/mod.rs
+++ b/codex-rs/core/src/skills/mod.rs
@@ -1,9 +0,0 @@
-pub mod loader;
-pub mod model;
-pub mod render;
-
-pub use loader::load_skills;
-pub use model::SkillError;
-pub use model::SkillLoadOutcome;
-pub use model::SkillMetadata;
-pub use render::render_skills_section;
--- a/codex-rs/core/src/skills/model.rs
+++ b/codex-rs/core/src/skills/model.rs
@@ -1,20 +0,0 @@
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SkillMetadata {
-    pub name: String,
-    pub description: String,
-    pub path: PathBuf,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SkillError {
-    pub path: PathBuf,
-    pub message: String,
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct SkillLoadOutcome {
-    pub skills: Vec<SkillMetadata>,
-    pub errors: Vec<SkillError>,
-}
--- a/codex-rs/core/src/skills/render.rs
+++ b/codex-rs/core/src/skills/render.rs
@@ -1,42 +0,0 @@
-use crate::skills::model::SkillMetadata;
-
-pub fn render_skills_section(skills: &[SkillMetadata]) -> Option<String> {
-    if skills.is_empty() {
-        return None;
-    }
-
-    let mut lines: Vec<String> = Vec::new();
-    lines.push("## Skills".to_string());
-    lines.push("These skills are discovered at startup from ~/.codex/skills; each entry shows name, description, and file path so you can open the source for full instructions. Content is not inlined to keep context lean.".to_string());
-
-    for skill in skills {
-        let path_str = skill.path.to_string_lossy().replace('\\', "/");
-        lines.push(format!(
-            "- {}: {} (file: {})",
-            skill.name, skill.description, path_str
-        ));
-    }
-
-    lines.push(
-        r###"- Discovery: Available skills are listed in project docs and may also appear in a runtime "## Skills" section (name + description + file path). These are the sources of truth; skill bodies live on disk at the listed paths.
- Trigger rules: If the user names a skill (with `$SkillName` or plain text) OR the task clearly matches a skill's description, you must use that skill for that turn. Multiple mentions mean use them all. Do not carry skills across turns unless re-mentioned.
- Missing/blocked: If a named skill isn't in the list or the path can't be read, say so briefly and continue with the best fallback.
- How to use a skill (progressive disclosure):
-  1) After deciding to use a skill, open its `SKILL.md`. Read only enough to follow the workflow.
-  2) If `SKILL.md` points to extra folders such as `references/`, load only the specific files needed for the request; don't bulk-load everything.
-  3) If `scripts/` exist, prefer running or patching them instead of retyping large code blocks.
-  4) If `assets/` or templates exist, reuse them instead of recreating from scratch.
- Description as trigger: The YAML `description` in `SKILL.md` is the primary trigger signal; rely on it to decide applicability. If unsure, ask a brief clarification before proceeding.
- Coordination and sequencing:
-  - If multiple skills apply, choose the minimal set that covers the request and state the order you'll use them.
-  - Announce which skill(s) you're using and why (one short line). If you skip an obvious skill, say why.
- Context hygiene:
-  - Keep context small: summarize long sections instead of pasting them; only load extra files when needed.
-  - Avoid deeply nested references; prefer one-hop files explicitly linked from `SKILL.md`.
-  - When variants exist (frameworks, providers, domains), pick only the relevant reference file(s) and note that choice.
- Safety and fallback: If a skill can't be applied cleanly (missing files, unclear instructions), state the issue, pick the next-best approach, and continue."###
-            .to_string(),
-    );
-
-    Some(lines.join("\n"))
-}
--- a/codex-rs/core/src/state/service.rs
+++ b/codex-rs/core/src/state/service.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use crate::AuthManager;
 use crate::RolloutRecorder;
 use crate::mcp_connection_manager::McpConnectionManager;
-use crate::openai_models::models_manager::ModelsManager;
+use crate::status::ComponentHealth;
 use crate::tools::sandboxing::ApprovalStore;
 use crate::unified_exec::UnifiedExecSessionManager;
 use crate::user_notification::UserNotifier;
@@ -21,7 +21,7 @@ pub(crate) struct SessionServices {
    pub(crate) user_shell: crate::shell::Shell,
    pub(crate) show_raw_agent_reasoning: bool,
    pub(crate) auth_manager: Arc<AuthManager>,
-    pub(crate) models_manager: Arc<ModelsManager>,
    pub(crate) otel_event_manager: OtelEventManager,
    pub(crate) tool_approvals: Mutex<ApprovalStore>,
+    pub(crate) codex_backend_status: Mutex<Option<ComponentHealth>>,
 }
--- a/codex-rs/core/src/state/session.rs
+++ b/codex-rs/core/src/state/session.rs
@@ -62,10 +62,7 @@ impl SessionState {
    }

    pub(crate) fn set_rate_limits(&mut self, snapshot: RateLimitSnapshot) {
-        self.latest_rate_limits = Some(merge_rate_limit_credits(
-            self.latest_rate_limits.as_ref(),
-            snapshot,
-        ));
+        self.latest_rate_limits = Some(snapshot);
    }

    pub(crate) fn token_info_and_rate_limits(
@@ -82,14 +79,3 @@ impl SessionState {
        self.history.get_total_token_usage()
    }
 }
-
-// Sometimes new snapshots don't include credits
-fn merge_rate_limit_credits(
-    previous: Option<&RateLimitSnapshot>,
-    mut snapshot: RateLimitSnapshot,
-) -> RateLimitSnapshot {
-    if snapshot.credits.is_none() {
-        snapshot.credits = previous.and_then(|prior| prior.credits.clone());
-    }
-    snapshot
-}
--- a/codex-rs/core/src/status.rs
+++ b/codex-rs/core/src/status.rs
@@ -0,0 +1,257 @@
+use std::sync::OnceLock;
+use std::time::Duration;
+
+use crate::codex::Session;
+use anyhow::Context;
+use anyhow::Result;
+use anyhow::anyhow;
+use anyhow::bail;
+use codex_client::HttpTransport;
+use codex_client::Request;
+use codex_client::ReqwestTransport;
+use codex_client::RetryOn;
+use codex_client::RetryPolicy;
+use codex_client::run_with_retry;
+use http::header::CONTENT_TYPE;
+use reqwest::Method;
+use serde::Deserialize;
+use serde::Serialize;
+use strum_macros::Display;
+
+const STATUS_WIDGET_URL: &str = "https://status.openai.com/proxy/status.openai.com";
+const CODEX_COMPONENT_NAME: &str = "Codex";
+
+static TEST_STATUS_WIDGET_URL: OnceLock<String> = OnceLock::new();
+
+#[derive(Debug, Clone, Display, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub(crate) enum ComponentHealth {
+    #[strum(to_string = "operational")]
+    Operational,
+    #[strum(to_string = "degraded performance")]
+    DegradedPerformance,
+    #[strum(to_string = "partial outage")]
+    PartialOutage,
+    #[strum(to_string = "major outage")]
+    MajorOutage,
+    #[strum(to_string = "under maintenance")]
+    UnderMaintenance,
+    #[serde(other)]
+    #[strum(to_string = "unknown")]
+    Unknown,
+}
+
+impl ComponentHealth {
+    fn operational() -> Self {
+        Self::Operational
+    }
+
+    pub(crate) fn is_operational(self) -> bool {
+        self == Self::Operational
+    }
+}
+
+pub(crate) async fn maybe_codex_status_warning(session: &Session) -> Option<String> {
+    let Ok(status) = fetch_codex_health().await else {
+        return None;
+    };
+
+    let previous = session.replace_codex_backend_status(status).await;
+    if status.is_operational() || previous == Some(status) {
+        return None;
+    }
+
+    Some(format!(
+        "Codex is experiencing a {status}. If a response stalls, try again later. You can follow incident updates at status.openai.com."
+    ))
+}
+
+async fn fetch_codex_health() -> Result<ComponentHealth> {
+    let status_widget_url = status_widget_url();
+
+    let client = reqwest::Client::builder()
+        .connect_timeout(Duration::from_millis(200))
+        .timeout(Duration::from_millis(300))
+        .build()
+        .context("building HTTP client")?;
+
+    let transport = ReqwestTransport::new(client);
+    let policy = RetryPolicy {
+        max_attempts: 0,
+        base_delay: Duration::from_millis(100),
+        retry_on: RetryOn {
+            retry_429: true,
+            retry_5xx: true,
+            retry_transport: true,
+        },
+    };
+
+    let response = run_with_retry(
+        policy,
+        || Request::new(Method::GET, status_widget_url.clone()),
+        |req, _attempt| {
+            let transport = transport.clone();
+            async move { transport.execute(req).await }
+        },
+    )
+    .await
+    .context("requesting status widget")?;
+
+    let content_type = response
+        .headers
+        .get(CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+
+    if !content_type.contains("json") {
+        let snippet = String::from_utf8_lossy(&response.body)
+            .chars()
+            .take(200)
+            .collect::<String>();
+
+        bail!(
+            "Expected JSON from {status_widget_url}: Content-Type={content_type}. Body starts with: {snippet:?}"
+        );
+    }
+
+    let payload: StatusPayload =
+        serde_json::from_slice(&response.body).context("parsing status widget JSON")?;
+
+    derive_component_health(&payload, CODEX_COMPONENT_NAME)
+}
+
+#[derive(Debug, Clone, Deserialize, Default)]
+struct StatusPayload {
+    #[serde(default)]
+    summary: Summary,
+}
+
+#[derive(Debug, Clone, Deserialize, Default)]
+struct Summary {
+    #[serde(default)]
+    components: Vec<Component>,
+    #[serde(default)]
+    affected_components: Vec<AffectedComponent>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct Component {
+    id: String,
+    name: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct AffectedComponent {
+    component_id: String,
+    #[serde(default = "ComponentHealth::operational")]
+    status: ComponentHealth,
+}
+
+fn derive_component_health(
+    payload: &StatusPayload,
+    component_name: &str,
+) -> Result<ComponentHealth> {
+    let component = payload
+        .summary
+        .components
+        .iter()
+        .find(|component| component.name == component_name)
+        .ok_or_else(|| anyhow!("Component {component_name:?} not found in status summary"))?;
+
+    let status = payload
+        .summary
+        .affected_components
+        .iter()
+        .find(|affected| affected.component_id == component.id)
+        .map(|affected| affected.status)
+        .unwrap_or(ComponentHealth::Operational);
+
+    Ok(status)
+}
+
+fn status_widget_url() -> String {
+    TEST_STATUS_WIDGET_URL
+        .get()
+        .cloned()
+        .unwrap_or_else(|| STATUS_WIDGET_URL.to_string())
+}
+
+#[doc(hidden)]
+#[cfg_attr(not(test), allow(dead_code))]
+pub fn set_test_status_widget_url(url: impl Into<String>) {
+    let _ = TEST_STATUS_WIDGET_URL.set(url.into());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+    use serde_json::json;
+
+    #[test]
+    fn uses_affected_component_status() {
+        let payload = serde_json::from_value::<StatusPayload>(json!({
+            "summary": {
+                "id": "sum-1",
+                "name": "OpenAI",
+                "components": [
+                    {"id": "cmp-1", "name": "Codex", "status_page_id": "page-1"}
+                ],
+                "affected_components": [
+                    {"component_id": "cmp-1", "status": "major_outage"}
+                ]
+            }
+        }))
+        .expect("valid payload");
+
+        let status = derive_component_health(&payload, "Codex").expect("codex component exists");
+
+        assert_eq!(status, ComponentHealth::MajorOutage);
+        assert!(!status.is_operational());
+    }
+
+    #[test]
+    fn unknown_status_is_preserved_as_unknown() {
+        let payload = serde_json::from_value::<StatusPayload>(json!({
+            "summary": {
+                "id": "sum-1",
+                "name": "OpenAI",
+                "components": [
+                    {"id": "cmp-1", "name": "Codex", "status_page_id": "page-1"}
+                ],
+                "affected_components": [
+                    {"component_id": "cmp-1", "status": "custom_status"}
+                ]
+            }
+        }))
+        .expect("valid payload");
+
+        let status = derive_component_health(&payload, "Codex").expect("codex component exists");
+
+        assert_eq!(status, ComponentHealth::Unknown);
+        assert!(!status.is_operational());
+    }
+
+    #[test]
+    fn missing_component_returns_error() {
+        let payload = serde_json::from_value::<StatusPayload>(json!({
+            "summary": {
+                "id": "sum-1",
+                "name": "OpenAI",
+                "components": [],
+                "affected_components": []
+            }
+        }))
+        .expect("valid payload");
+
+        let error =
+            derive_component_health(&payload, "Codex").expect_err("missing component should error");
+
+        assert!(
+            error
+                .to_string()
+                .contains("Component \"Codex\" not found in status summary")
+        );
+    }
+}
--- a/codex-rs/core/src/stream_events_utils.rs
+++ b/codex-rs/core/src/stream_events_utils.rs
@@ -1,212 +0,0 @@
-use std::pin::Pin;
-use std::sync::Arc;
-
-use codex_protocol::items::TurnItem;
-use tokio_util::sync::CancellationToken;
-
-use crate::codex::Session;
-use crate::codex::TurnContext;
-use crate::error::CodexErr;
-use crate::error::Result;
-use crate::function_tool::FunctionCallError;
-use crate::parse_turn_item;
-use crate::tools::parallel::ToolCallRuntime;
-use crate::tools::router::ToolRouter;
-use codex_protocol::models::FunctionCallOutputPayload;
-use codex_protocol::models::ResponseInputItem;
-use codex_protocol::models::ResponseItem;
-use futures::Future;
-use tracing::debug;
-
-/// Handle a completed output item from the model stream, recording it and
-/// queuing any tool execution futures. This records items immediately so
-/// history and rollout stay in sync even if the turn is later cancelled.
-pub(crate) type InFlightFuture<'f> =
-    Pin<Box<dyn Future<Output = Result<ResponseInputItem>> + Send + 'f>>;
-
-#[derive(Default)]
-pub(crate) struct OutputItemResult {
-    pub last_agent_message: Option<String>,
-    pub needs_follow_up: bool,
-    pub tool_future: Option<InFlightFuture<'static>>,
-}
-
-pub(crate) struct HandleOutputCtx {
-    pub sess: Arc<Session>,
-    pub turn_context: Arc<TurnContext>,
-    pub tool_runtime: ToolCallRuntime,
-    pub cancellation_token: CancellationToken,
-}
-
-pub(crate) async fn handle_output_item_done(
-    ctx: &mut HandleOutputCtx,
-    item: ResponseItem,
-    previously_active_item: Option<TurnItem>,
-) -> Result<OutputItemResult> {
-    let mut output = OutputItemResult::default();
-
-    match ToolRouter::build_tool_call(ctx.sess.as_ref(), item.clone()).await {
-        // The model emitted a tool call; log it, persist the item immediately, and queue the tool execution.
-        Ok(Some(call)) => {
-            let payload_preview = call.payload.log_payload().into_owned();
-            tracing::info!("ToolCall: {} {}", call.tool_name, payload_preview);
-
-            ctx.sess
-                .record_conversation_items(&ctx.turn_context, std::slice::from_ref(&item))
-                .await;
-
-            let cancellation_token = ctx.cancellation_token.child_token();
-            let tool_runtime = ctx.tool_runtime.clone();
-
-            let tool_future: InFlightFuture<'static> = Box::pin(async move {
-                let response_input = tool_runtime
-                    .handle_tool_call(call, cancellation_token)
-                    .await?;
-                Ok(response_input)
-            });
-
-            output.needs_follow_up = true;
-            output.tool_future = Some(tool_future);
-        }
-        // No tool call: convert messages/reasoning into turn items and mark them as complete.
-        Ok(None) => {
-            if let Some(turn_item) = handle_non_tool_response_item(&item).await {
-                if previously_active_item.is_none() {
-                    ctx.sess
-                        .emit_turn_item_started(&ctx.turn_context, &turn_item)
-                        .await;
-                }
-
-                ctx.sess
-                    .emit_turn_item_completed(&ctx.turn_context, turn_item)
-                    .await;
-            }
-
-            ctx.sess
-                .record_conversation_items(&ctx.turn_context, std::slice::from_ref(&item))
-                .await;
-            let last_agent_message = last_assistant_message_from_item(&item);
-
-            output.last_agent_message = last_agent_message;
-        }
-        // Guardrail: the model issued a LocalShellCall without an id; surface the error back into history.
-        Err(FunctionCallError::MissingLocalShellCallId) => {
-            let msg = "LocalShellCall without call_id or id";
-            ctx.turn_context
-                .client
-                .get_otel_event_manager()
-                .log_tool_failed("local_shell", msg);
-            tracing::error!(msg);
-
-            let response = ResponseInputItem::FunctionCallOutput {
-                call_id: String::new(),
-                output: FunctionCallOutputPayload {
-                    content: msg.to_string(),
-                    ..Default::default()
-                },
-            };
-            ctx.sess
-                .record_conversation_items(&ctx.turn_context, std::slice::from_ref(&item))
-                .await;
-            if let Some(response_item) = response_input_to_response_item(&response) {
-                ctx.sess
-                    .record_conversation_items(
-                        &ctx.turn_context,
-                        std::slice::from_ref(&response_item),
-                    )
-                    .await;
-            }
-
-            output.needs_follow_up = true;
-        }
-        // The tool request should be answered directly (or was denied); push that response into the transcript.
-        Err(FunctionCallError::RespondToModel(message))
-        | Err(FunctionCallError::Denied(message)) => {
-            let response = ResponseInputItem::FunctionCallOutput {
-                call_id: String::new(),
-                output: FunctionCallOutputPayload {
-                    content: message,
-                    ..Default::default()
-                },
-            };
-            ctx.sess
-                .record_conversation_items(&ctx.turn_context, std::slice::from_ref(&item))
-                .await;
-            if let Some(response_item) = response_input_to_response_item(&response) {
-                ctx.sess
-                    .record_conversation_items(
-                        &ctx.turn_context,
-                        std::slice::from_ref(&response_item),
-                    )
-                    .await;
-            }
-
-            output.needs_follow_up = true;
-        }
-        // A fatal error occurred; surface it back into history.
-        Err(FunctionCallError::Fatal(message)) => {
-            return Err(CodexErr::Fatal(message));
-        }
-    }
-
-    Ok(output)
-}
-
-pub(crate) async fn handle_non_tool_response_item(item: &ResponseItem) -> Option<TurnItem> {
-    debug!(?item, "Output item");
-
-    match item {
-        ResponseItem::Message { .. }
-        | ResponseItem::Reasoning { .. }
-        | ResponseItem::WebSearchCall { .. } => parse_turn_item(item),
-        ResponseItem::FunctionCallOutput { .. } | ResponseItem::CustomToolCallOutput { .. } => {
-            debug!("unexpected tool output from stream");
-            None
-        }
-        _ => None,
-    }
-}
-
-pub(crate) fn last_assistant_message_from_item(item: &ResponseItem) -> Option<String> {
-    if let ResponseItem::Message { role, content, .. } = item
-        && role == "assistant"
-    {
-        return content.iter().rev().find_map(|ci| match ci {
-            codex_protocol::models::ContentItem::OutputText { text } => Some(text.clone()),
-            _ => None,
-        });
-    }
-    None
-}
-
-pub(crate) fn response_input_to_response_item(input: &ResponseInputItem) -> Option<ResponseItem> {
-    match input {
-        ResponseInputItem::FunctionCallOutput { call_id, output } => {
-            Some(ResponseItem::FunctionCallOutput {
-                call_id: call_id.clone(),
-                output: output.clone(),
-            })
-        }
-        ResponseInputItem::CustomToolCallOutput { call_id, output } => {
-            Some(ResponseItem::CustomToolCallOutput {
-                call_id: call_id.clone(),
-                output: output.clone(),
-            })
-        }
-        ResponseInputItem::McpToolCallOutput { call_id, result } => {
-            let output = match result {
-                Ok(call_tool_result) => FunctionCallOutputPayload::from(call_tool_result),
-                Err(err) => FunctionCallOutputPayload {
-                    content: err.clone(),
-                    success: Some(false),
-                    ..Default::default()
-                },
-            };
-            Some(ResponseItem::FunctionCallOutput {
-                call_id: call_id.clone(),
-                output,
-            })
-        }
-        _ => None,
-    }
-}
--- a/codex-rs/core/src/tasks/compact.rs
+++ b/codex-rs/core/src/tasks/compact.rs
@@ -25,7 +25,7 @@ impl SessionTask for CompactTask {
        _cancellation_token: CancellationToken,
    ) -> Option<String> {
        let session = session.clone_session();
-        if crate::compact::should_use_remote_compact_task(&session) {
+        if crate::compact::should_use_remote_compact_task(&session).await {
            crate::compact_remote::run_remote_compact_task(session, ctx).await
        } else {
            crate::compact::run_compact_task(session, ctx, input).await
--- a/codex-rs/core/src/tasks/mod.rs
+++ b/codex-rs/core/src/tasks/mod.rs
@@ -19,7 +19,6 @@ use tracing::warn;
 use crate::AuthManager;
 use crate::codex::Session;
 use crate::codex::TurnContext;
-use crate::openai_models::models_manager::ModelsManager;
 use crate::protocol::EventMsg;
 use crate::protocol::TaskCompleteEvent;
 use crate::protocol::TurnAbortReason;
@@ -56,10 +55,6 @@ impl SessionTaskContext {
    pub(crate) fn auth_manager(&self) -> Arc<AuthManager> {
        Arc::clone(&self.session.services.auth_manager)
    }
-
-    pub(crate) fn models_manager(&self) -> Arc<ModelsManager> {
-        Arc::clone(&self.session.services.models_manager)
-    }
 }

 /// Async task that drives a [`Session`] turn.
--- a/codex-rs/core/src/tasks/review.rs
+++ b/codex-rs/core/src/tasks/review.rs
@@ -16,9 +16,7 @@ use tokio_util::sync::CancellationToken;
 use crate::codex::Session;
 use crate::codex::TurnContext;
 use crate::codex_delegate::run_codex_conversation_one_shot;
-use crate::protocol::SandboxPolicy;
 use crate::review_format::format_review_findings_block;
-use crate::review_format::render_review_output_text;
 use crate::state::TaskKind;
 use codex_protocol::user_input::UserInput;

@@ -26,11 +24,15 @@ use super::SessionTask;
 use super::SessionTaskContext;

 #[derive(Clone, Copy)]
-pub(crate) struct ReviewTask;
+pub(crate) struct ReviewTask {
+    append_to_original_thread: bool,
+}

 impl ReviewTask {
-    pub(crate) fn new() -> Self {
-        Self
+    pub(crate) fn new(append_to_original_thread: bool) -> Self {
+        Self {
+            append_to_original_thread,
+        }
    }
 }

@@ -60,13 +62,25 @@ impl SessionTask for ReviewTask {
            None => None,
        };
        if !cancellation_token.is_cancelled() {
-            exit_review_mode(session.clone_session(), output.clone(), ctx.clone()).await;
+            exit_review_mode(
+                session.clone_session(),
+                output.clone(),
+                ctx.clone(),
+                self.append_to_original_thread,
+            )
+            .await;
        }
        None
    }

    async fn abort(&self, session: Arc<SessionTaskContext>, ctx: Arc<TurnContext>) {
-        exit_review_mode(session.clone_session(), None, ctx).await;
+        exit_review_mode(
+            session.clone_session(),
+            None,
+            ctx,
+            self.append_to_original_thread,
+        )
+        .await;
    }
 }

@@ -78,7 +92,6 @@ async fn start_review_conversation(
 ) -> Option<async_channel::Receiver<Event>> {
    let config = ctx.client.config();
    let mut sub_agent_config = config.as_ref().clone();
-    sub_agent_config.sandbox_policy = SandboxPolicy::new_read_only_policy();
    // Run with only reviewer rubric — drop outer user_instructions
    sub_agent_config.user_instructions = None;
    // Avoid loading project docs; reviewer only needs findings
@@ -95,7 +108,6 @@ async fn start_review_conversation(
    (run_codex_conversation_one_shot(
        sub_agent_config,
        session.auth_manager(),
-        session.models_manager(),
        input,
        session.clone_session(),
        ctx.clone(),
@@ -185,57 +197,39 @@ pub(crate) async fn exit_review_mode(
    session: Arc<Session>,
    review_output: Option<ReviewOutputEvent>,
    ctx: Arc<TurnContext>,
+    append_to_original_thread: bool,
 ) {
-    const REVIEW_USER_MESSAGE_ID: &str = "review:rollout:user";
-    const REVIEW_ASSISTANT_MESSAGE_ID: &str = "review:rollout:assistant";
-    let (user_message, assistant_message) = if let Some(out) = review_output.clone() {
-        let mut findings_str = String::new();
-        let text = out.overall_explanation.trim();
-        if !text.is_empty() {
-            findings_str.push_str(text);
-        }
-        if !out.findings.is_empty() {
-            let block = format_review_findings_block(&out.findings, None);
-            findings_str.push_str(&format!("\n{block}"));
-        }
-        let rendered =
-            crate::client_common::REVIEW_EXIT_SUCCESS_TMPL.replace("{results}", &findings_str);
-        let assistant_message = render_review_output_text(&out);
-        (rendered, assistant_message)
-    } else {
-        let rendered = crate::client_common::REVIEW_EXIT_INTERRUPTED_TMPL.to_string();
-        let assistant_message =
-            "Review was interrupted. Please re-run /review and wait for it to complete."
-                .to_string();
-        (rendered, assistant_message)
-    };
+    if append_to_original_thread {
+        let user_message = if let Some(out) = review_output.clone() {
+            let mut findings_str = String::new();
+            let text = out.overall_explanation.trim();
+            if !text.is_empty() {
+                findings_str.push_str(text);
+            }
+            if !out.findings.is_empty() {
+                let block = format_review_findings_block(&out.findings, None);
+                findings_str.push_str(&format!("\n{block}"));
+            }
+            crate::client_common::REVIEW_EXIT_SUCCESS_TMPL.replace("{results}", &findings_str)
+        } else {
+            crate::client_common::REVIEW_EXIT_INTERRUPTED_TMPL.to_string()
+        };

-    session
-        .record_conversation_items(
-            &ctx,
-            &[ResponseItem::Message {
-                id: Some(REVIEW_USER_MESSAGE_ID.to_string()),
-                role: "user".to_string(),
-                content: vec![ContentItem::InputText { text: user_message }],
-            }],
-        )
-        .await;
+        session
+            .record_conversation_items(
+                &ctx,
+                &[ResponseItem::Message {
+                    id: None,
+                    role: "user".to_string(),
+                    content: vec![ContentItem::InputText { text: user_message }],
+                }],
+            )
+            .await;
+    }
    session
        .send_event(
            ctx.as_ref(),
            EventMsg::ExitedReviewMode(ExitedReviewModeEvent { review_output }),
        )
        .await;
-    session
-        .record_response_item_and_emit_turn_item(
-            ctx.as_ref(),
-            ResponseItem::Message {
-                id: Some(REVIEW_ASSISTANT_MESSAGE_ID.to_string()),
-                role: "assistant".to_string(),
-                content: vec![ContentItem::OutputText {
-                    text: assistant_message,
-                }],
-            },
-        )
-        .await;
 }
--- a/codex-rs/core/src/tools/handlers/apply_patch.rs
+++ b/codex-rs/core/src/tools/handlers/apply_patch.rs
@@ -1,5 +1,4 @@
 use std::collections::BTreeMap;
-use std::path::Path;

 use crate::apply_patch;
 use crate::apply_patch::InternalApplyPatchInvocation;
@@ -8,10 +7,7 @@ use crate::client_common::tools::FreeformTool;
 use crate::client_common::tools::FreeformToolFormat;
 use crate::client_common::tools::ResponsesApiTool;
 use crate::client_common::tools::ToolSpec;
-use crate::codex::Session;
-use crate::codex::TurnContext;
 use crate::function_tool::FunctionCallError;
-use crate::tools::context::SharedTurnDiffTracker;
 use crate::tools::context::ToolInvocation;
 use crate::tools::context::ToolOutput;
 use crate::tools::context::ToolPayload;
@@ -168,86 +164,6 @@ pub enum ApplyPatchToolType {
    Function,
 }

-#[allow(clippy::too_many_arguments)]
-pub(crate) async fn intercept_apply_patch(
-    command: &[String],
-    cwd: &Path,
-    timeout_ms: Option<u64>,
-    session: &Session,
-    turn: &TurnContext,
-    tracker: Option<&SharedTurnDiffTracker>,
-    call_id: &str,
-    tool_name: &str,
-) -> Result<Option<ToolOutput>, FunctionCallError> {
-    match codex_apply_patch::maybe_parse_apply_patch_verified(command, cwd) {
-        codex_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
-            session
-                .record_model_warning(
-                    format!("apply_patch was requested via {tool_name}. Use the apply_patch tool instead of exec_command."),
-                    turn,
-                )
-                .await;
-            match apply_patch::apply_patch(session, turn, call_id, changes).await {
-                InternalApplyPatchInvocation::Output(item) => {
-                    let content = item?;
-                    Ok(Some(ToolOutput::Function {
-                        content,
-                        content_items: None,
-                        success: Some(true),
-                    }))
-                }
-                InternalApplyPatchInvocation::DelegateToExec(apply) => {
-                    let emitter = ToolEmitter::apply_patch(
-                        convert_apply_patch_to_protocol(&apply.action),
-                        !apply.user_explicitly_approved_this_action,
-                    );
-                    let event_ctx =
-                        ToolEventCtx::new(session, turn, call_id, tracker.as_ref().copied());
-                    emitter.begin(event_ctx).await;
-
-                    let req = ApplyPatchRequest {
-                        patch: apply.action.patch.clone(),
-                        cwd: apply.action.cwd.clone(),
-                        timeout_ms,
-                        user_explicitly_approved: apply.user_explicitly_approved_this_action,
-                        codex_exe: turn.codex_linux_sandbox_exe.clone(),
-                    };
-
-                    let mut orchestrator = ToolOrchestrator::new();
-                    let mut runtime = ApplyPatchRuntime::new();
-                    let tool_ctx = ToolCtx {
-                        session,
-                        turn,
-                        call_id: call_id.to_string(),
-                        tool_name: tool_name.to_string(),
-                    };
-                    let out = orchestrator
-                        .run(&mut runtime, &req, &tool_ctx, turn, turn.approval_policy)
-                        .await;
-                    let event_ctx =
-                        ToolEventCtx::new(session, turn, call_id, tracker.as_ref().copied());
-                    let content = emitter.finish(event_ctx, out).await?;
-                    Ok(Some(ToolOutput::Function {
-                        content,
-                        content_items: None,
-                        success: Some(true),
-                    }))
-                }
-            }
-        }
-        codex_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
-            Err(FunctionCallError::RespondToModel(format!(
-                "apply_patch verification failed: {parse_error}"
-            )))
-        }
-        codex_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
-            tracing::trace!("Failed to parse apply_patch input, {error:?}");
-            Ok(None)
-        }
-        codex_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => Ok(None),
-    }
-}
-
 /// Returns a custom tool that can be used to edit files. Well-suited for GPT-5 models
 /// https://platform.openai.com/docs/guides/function-calling#custom-tools
 pub(crate) fn create_apply_patch_freeform_tool() -> ToolSpec {
--- a/codex-rs/core/src/tools/handlers/shell.rs
+++ b/codex-rs/core/src/tools/handlers/shell.rs
@@ -3,10 +3,13 @@ use codex_protocol::models::ShellCommandToolCallParams;
 use codex_protocol::models::ShellToolCallParams;
 use std::sync::Arc;

+use crate::apply_patch;
+use crate::apply_patch::InternalApplyPatchInvocation;
+use crate::apply_patch::convert_apply_patch_to_protocol;
 use crate::codex::TurnContext;
 use crate::exec::ExecParams;
 use crate::exec_env::create_env;
-use crate::exec_policy::create_exec_approval_requirement_for_command;
+use crate::exec_policy::create_approval_requirement_for_command;
 use crate::function_tool::FunctionCallError;
 use crate::is_safe_command::is_known_safe_command;
 use crate::protocol::ExecCommandSource;
@@ -16,10 +19,11 @@ use crate::tools::context::ToolOutput;
 use crate::tools::context::ToolPayload;
 use crate::tools::events::ToolEmitter;
 use crate::tools::events::ToolEventCtx;
-use crate::tools::handlers::apply_patch::intercept_apply_patch;
 use crate::tools::orchestrator::ToolOrchestrator;
 use crate::tools::registry::ToolHandler;
 use crate::tools::registry::ToolKind;
+use crate::tools::runtimes::apply_patch::ApplyPatchRequest;
+use crate::tools::runtimes::apply_patch::ApplyPatchRuntime;
 use crate::tools::runtimes::shell::ShellRequest;
 use crate::tools::runtimes::shell::ShellRuntime;
 use crate::tools::sandboxing::ToolCtx;
@@ -206,19 +210,81 @@ impl ShellHandler {
        }

        // Intercept apply_patch if present.
-        if let Some(output) = intercept_apply_patch(
+        match codex_apply_patch::maybe_parse_apply_patch_verified(
            &exec_params.command,
            &exec_params.cwd,
-            exec_params.expiration.timeout_ms(),
-            session.as_ref(),
-            turn.as_ref(),
-            Some(&tracker),
-            &call_id,
-            tool_name,
-        )
-        .await?
-        {
-            return Ok(output);
+        ) {
+            codex_apply_patch::MaybeApplyPatchVerified::Body(changes) => {
+                match apply_patch::apply_patch(session.as_ref(), turn.as_ref(), &call_id, changes)
+                    .await
+                {
+                    InternalApplyPatchInvocation::Output(item) => {
+                        // Programmatic apply_patch path; return its result.
+                        let content = item?;
+                        return Ok(ToolOutput::Function {
+                            content,
+                            content_items: None,
+                            success: Some(true),
+                        });
+                    }
+                    InternalApplyPatchInvocation::DelegateToExec(apply) => {
+                        let emitter = ToolEmitter::apply_patch(
+                            convert_apply_patch_to_protocol(&apply.action),
+                            !apply.user_explicitly_approved_this_action,
+                        );
+                        let event_ctx = ToolEventCtx::new(
+                            session.as_ref(),
+                            turn.as_ref(),
+                            &call_id,
+                            Some(&tracker),
+                        );
+                        emitter.begin(event_ctx).await;
+
+                        let req = ApplyPatchRequest {
+                            patch: apply.action.patch.clone(),
+                            cwd: apply.action.cwd.clone(),
+                            timeout_ms: exec_params.expiration.timeout_ms(),
+                            user_explicitly_approved: apply.user_explicitly_approved_this_action,
+                            codex_exe: turn.codex_linux_sandbox_exe.clone(),
+                        };
+                        let mut orchestrator = ToolOrchestrator::new();
+                        let mut runtime = ApplyPatchRuntime::new();
+                        let tool_ctx = ToolCtx {
+                            session: session.as_ref(),
+                            turn: turn.as_ref(),
+                            call_id: call_id.clone(),
+                            tool_name: tool_name.to_string(),
+                        };
+                        let out = orchestrator
+                            .run(&mut runtime, &req, &tool_ctx, &turn, turn.approval_policy)
+                            .await;
+                        let event_ctx = ToolEventCtx::new(
+                            session.as_ref(),
+                            turn.as_ref(),
+                            &call_id,
+                            Some(&tracker),
+                        );
+                        let content = emitter.finish(event_ctx, out).await?;
+                        return Ok(ToolOutput::Function {
+                            content,
+                            content_items: None,
+                            success: Some(true),
+                        });
+                    }
+                }
+            }
+            codex_apply_patch::MaybeApplyPatchVerified::CorrectnessError(parse_error) => {
+                return Err(FunctionCallError::RespondToModel(format!(
+                    "apply_patch verification failed: {parse_error}"
+                )));
+            }
+            codex_apply_patch::MaybeApplyPatchVerified::ShellParseError(error) => {
+                tracing::trace!("Failed to parse shell command, {error:?}");
+                // Fall through to regular shell execution.
+            }
+            codex_apply_patch::MaybeApplyPatchVerified::NotApplyPatch => {
+                // Fall through to regular shell execution.
+            }
        }

        let source = ExecCommandSource::Agent;
@@ -231,17 +297,6 @@ impl ShellHandler {
        let event_ctx = ToolEventCtx::new(session.as_ref(), turn.as_ref(), &call_id, None);
        emitter.begin(event_ctx).await;

-        let features = session.features();
-        let exec_approval_requirement = create_exec_approval_requirement_for_command(
-            &turn.exec_policy,
-            &features,
-            &exec_params.command,
-            turn.approval_policy,
-            &turn.sandbox_policy,
-            SandboxPermissions::from(exec_params.with_escalated_permissions.unwrap_or(false)),
-        )
-        .await;
-
        let req = ShellRequest {
            command: exec_params.command.clone(),
            cwd: exec_params.cwd.clone(),
@@ -249,7 +304,13 @@ impl ShellHandler {
            env: exec_params.env.clone(),
            with_escalated_permissions: exec_params.with_escalated_permissions,
            justification: exec_params.justification.clone(),
-            exec_approval_requirement,
+            approval_requirement: create_approval_requirement_for_command(
+                &turn.exec_policy,
+                &exec_params.command,
+                turn.approval_policy,
+                &turn.sandbox_policy,
+                SandboxPermissions::from(exec_params.with_escalated_permissions.unwrap_or(false)),
+            ),
        };
        let mut orchestrator = ToolOrchestrator::new();
        let mut runtime = ShellRuntime::new();
--- a/codex-rs/core/src/tools/handlers/unified_exec.rs
+++ b/codex-rs/core/src/tools/handlers/unified_exec.rs
@@ -6,7 +6,6 @@ use crate::protocol::EventMsg;
 use crate::protocol::ExecCommandOutputDeltaEvent;
 use crate::protocol::ExecCommandSource;
 use crate::protocol::ExecOutputStream;
-use crate::shell::default_user_shell;
 use crate::shell::get_shell_by_model_provided_path;
 use crate::tools::context::ToolInvocation;
 use crate::tools::context::ToolOutput;
@@ -14,7 +13,6 @@ use crate::tools::context::ToolPayload;
 use crate::tools::events::ToolEmitter;
 use crate::tools::events::ToolEventCtx;
 use crate::tools::events::ToolEventStage;
-use crate::tools::handlers::apply_patch::intercept_apply_patch;
 use crate::tools::registry::ToolHandler;
 use crate::tools::registry::ToolKind;
 use crate::unified_exec::ExecCommandRequest;
@@ -32,8 +30,8 @@ struct ExecCommandArgs {
    cmd: String,
    #[serde(default)]
    workdir: Option<String>,
-    #[serde(default)]
-    shell: Option<String>,
+    #[serde(default = "default_shell")]
+    shell: String,
    #[serde(default = "default_login")]
    login: bool,
    #[serde(default = "default_exec_yield_time_ms")]
@@ -66,6 +64,10 @@ fn default_write_stdin_yield_time_ms() -> u64 {
    250
 }

+fn default_shell() -> String {
+    "/bin/bash".to_string()
+}
+
 fn default_login() -> bool {
    true
 }
@@ -101,7 +103,6 @@ impl ToolHandler for UnifiedExecHandler {
        let ToolInvocation {
            session,
            turn,
-            tracker,
            call_id,
            tool_name,
            payload,
@@ -146,34 +147,18 @@ impl ToolHandler for UnifiedExecHandler {
                        codex_protocol::protocol::AskForApproval::OnRequest
                    )
                {
-                    manager.release_process_id(&process_id).await;
                    return Err(FunctionCallError::RespondToModel(format!(
                        "approval policy is {policy:?}; reject command — you cannot ask for escalated permissions if the approval policy is {policy:?}",
                        policy = context.turn.approval_policy
                    )));
                }

-                let workdir = workdir.filter(|value| !value.is_empty());
-
-                let workdir = workdir.map(|dir| context.turn.resolve_path(Some(dir)));
+                let workdir = workdir
+                    .as_deref()
+                    .filter(|value| !value.is_empty())
+                    .map(PathBuf::from);
                let cwd = workdir.clone().unwrap_or_else(|| context.turn.cwd.clone());

-                if let Some(output) = intercept_apply_patch(
-                    &command,
-                    &cwd,
-                    Some(yield_time_ms),
-                    context.session.as_ref(),
-                    context.turn.as_ref(),
-                    Some(&tracker),
-                    &context.call_id,
-                    tool_name.as_str(),
-                )
-                .await?
-                {
-                    manager.release_process_id(&process_id).await;
-                    return Ok(output);
-                }
-
                let event_ctx = ToolEventCtx::new(
                    context.session.as_ref(),
                    context.turn.as_ref(),
@@ -256,12 +241,7 @@ impl ToolHandler for UnifiedExecHandler {
 }

 fn get_command(args: &ExecCommandArgs) -> Vec<String> {
-    let shell = if let Some(shell_str) = &args.shell {
-        get_shell_by_model_provided_path(&PathBuf::from(shell_str))
-    } else {
-        default_user_shell()
-    };
-
+    let shell = get_shell_by_model_provided_path(&PathBuf::from(args.shell.clone()));
    shell.derive_exec_args(&args.cmd, args.login)
 }

@@ -293,65 +273,3 @@ fn format_response(response: &UnifiedExecResponse) -> String {

    sections.join("\n")
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_command_uses_default_shell_when_unspecified() {
-        let json = r#"{"cmd": "echo hello"}"#;
-
-        let args: ExecCommandArgs =
-            serde_json::from_str(json).expect("deserialize ExecCommandArgs");
-
-        assert!(args.shell.is_none());
-
-        let command = get_command(&args);
-
-        assert_eq!(command.len(), 3);
-        assert_eq!(command[2], "echo hello");
-    }
-
-    #[test]
-    fn test_get_command_respects_explicit_bash_shell() {
-        let json = r#"{"cmd": "echo hello", "shell": "/bin/bash"}"#;
-
-        let args: ExecCommandArgs =
-            serde_json::from_str(json).expect("deserialize ExecCommandArgs");
-
-        assert_eq!(args.shell.as_deref(), Some("/bin/bash"));
-
-        let command = get_command(&args);
-
-        assert_eq!(command[2], "echo hello");
-    }
-
-    #[test]
-    fn test_get_command_respects_explicit_powershell_shell() {
-        let json = r#"{"cmd": "echo hello", "shell": "powershell"}"#;
-
-        let args: ExecCommandArgs =
-            serde_json::from_str(json).expect("deserialize ExecCommandArgs");
-
-        assert_eq!(args.shell.as_deref(), Some("powershell"));
-
-        let command = get_command(&args);
-
-        assert_eq!(command[2], "echo hello");
-    }
-
-    #[test]
-    fn test_get_command_respects_explicit_cmd_shell() {
-        let json = r#"{"cmd": "echo hello", "shell": "cmd"}"#;
-
-        let args: ExecCommandArgs =
-            serde_json::from_str(json).expect("deserialize ExecCommandArgs");
-
-        assert_eq!(args.shell.as_deref(), Some("cmd"));
-
-        let command = get_command(&args);
-
-        assert_eq!(command[2], "echo hello");
-    }
-}
--- a/codex-rs/core/src/tools/orchestrator.rs
+++ b/codex-rs/core/src/tools/orchestrator.rs
@@ -11,14 +11,14 @@ use crate::error::get_error_message_ui;
 use crate::exec::ExecToolCallOutput;
 use crate::sandboxing::SandboxManager;
 use crate::tools::sandboxing::ApprovalCtx;
-use crate::tools::sandboxing::ExecApprovalRequirement;
+use crate::tools::sandboxing::ApprovalRequirement;
 use crate::tools::sandboxing::ProvidesSandboxRetryData;
 use crate::tools::sandboxing::SandboxAttempt;
 use crate::tools::sandboxing::SandboxOverride;
 use crate::tools::sandboxing::ToolCtx;
 use crate::tools::sandboxing::ToolError;
 use crate::tools::sandboxing::ToolRuntime;
-use crate::tools::sandboxing::default_exec_approval_requirement;
+use crate::tools::sandboxing::default_approval_requirement;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::ReviewDecision;

@@ -54,17 +54,17 @@ impl ToolOrchestrator {
        // 1) Approval
        let mut already_approved = false;

-        let requirement = tool.exec_approval_requirement(req).unwrap_or_else(|| {
-            default_exec_approval_requirement(approval_policy, &turn_ctx.sandbox_policy)
+        let requirement = tool.approval_requirement(req).unwrap_or_else(|| {
+            default_approval_requirement(approval_policy, &turn_ctx.sandbox_policy)
        });
        match requirement {
-            ExecApprovalRequirement::Skip { .. } => {
-                otel.tool_decision(otel_tn, otel_ci, &ReviewDecision::Approved, otel_cfg);
+            ApprovalRequirement::Skip { .. } => {
+                otel.tool_decision(otel_tn, otel_ci, ReviewDecision::Approved, otel_cfg);
            }
-            ExecApprovalRequirement::Forbidden { reason } => {
+            ApprovalRequirement::Forbidden { reason } => {
                return Err(ToolError::Rejected(reason));
            }
-            ExecApprovalRequirement::NeedsApproval { reason, .. } => {
+            ApprovalRequirement::NeedsApproval { reason } => {
                let mut risk = None;

                if let Some(metadata) = req.sandbox_retry_data() {
@@ -88,15 +88,13 @@ impl ToolOrchestrator {
                };
                let decision = tool.start_approval_async(req, approval_ctx).await;

-                otel.tool_decision(otel_tn, otel_ci, &decision, otel_user.clone());
+                otel.tool_decision(otel_tn, otel_ci, decision, otel_user.clone());

                match decision {
                    ReviewDecision::Denied | ReviewDecision::Abort => {
                        return Err(ToolError::Rejected("rejected by user".to_string()));
                    }
-                    ReviewDecision::Approved
-                    | ReviewDecision::ApprovedExecpolicyAmendment { .. }
-                    | ReviewDecision::ApprovedForSession => {}
+                    ReviewDecision::Approved | ReviewDecision::ApprovedForSession => {}
                }
                already_approved = true;
            }
@@ -171,15 +169,13 @@ impl ToolOrchestrator {
                    };

                    let decision = tool.start_approval_async(req, approval_ctx).await;
-                    otel.tool_decision(otel_tn, otel_ci, &decision, otel_user);
+                    otel.tool_decision(otel_tn, otel_ci, decision, otel_user);

                    match decision {
                        ReviewDecision::Denied | ReviewDecision::Abort => {
                            return Err(ToolError::Rejected("rejected by user".to_string()));
                        }
-                        ReviewDecision::Approved
-                        | ReviewDecision::ApprovedExecpolicyAmendment { .. }
-                        | ReviewDecision::ApprovedForSession => {}
+                        ReviewDecision::Approved | ReviewDecision::ApprovedForSession => {}
                    }
                }

--- a/codex-rs/core/src/tools/parallel.rs
+++ b/codex-rs/core/src/tools/parallel.rs
@@ -17,7 +17,6 @@ use crate::tools::router::ToolRouter;
 use codex_protocol::models::FunctionCallOutputPayload;
 use codex_protocol::models::ResponseInputItem;

-#[derive(Clone)]
 pub(crate) struct ToolCallRuntime {
    router: Arc<ToolRouter>,
    session: Arc<Session>,
--- a/codex-rs/core/src/tools/runtimes/apply_patch.rs
+++ b/codex-rs/core/src/tools/runtimes/apply_patch.rs
@@ -127,7 +127,6 @@ impl Approvable<ApplyPatchRequest> for ApplyPatchRuntime {
                            cwd,
                            Some(reason),
                            risk,
-                            None,
                        )
                        .await
                } else if user_explicitly_approved {
--- a/codex-rs/core/src/tools/runtimes/shell.rs
+++ b/codex-rs/core/src/tools/runtimes/shell.rs
@@ -9,7 +9,7 @@ use crate::sandboxing::execute_env;
 use crate::tools::runtimes::build_command_spec;
 use crate::tools::sandboxing::Approvable;
 use crate::tools::sandboxing::ApprovalCtx;
-use crate::tools::sandboxing::ExecApprovalRequirement;
+use crate::tools::sandboxing::ApprovalRequirement;
 use crate::tools::sandboxing::ProvidesSandboxRetryData;
 use crate::tools::sandboxing::SandboxAttempt;
 use crate::tools::sandboxing::SandboxOverride;
@@ -32,7 +32,7 @@ pub struct ShellRequest {
    pub env: std::collections::HashMap<String, String>,
    pub with_escalated_permissions: Option<bool>,
    pub justification: Option<String>,
-    pub exec_approval_requirement: ExecApprovalRequirement,
+    pub approval_requirement: ApprovalRequirement,
 }

 impl ProvidesSandboxRetryData for ShellRequest {
@@ -107,32 +107,22 @@ impl Approvable<ShellRequest> for ShellRuntime {
        Box::pin(async move {
            with_cached_approval(&session.services, key, move || async move {
                session
-                    .request_command_approval(
-                        turn,
-                        call_id,
-                        command,
-                        cwd,
-                        reason,
-                        risk,
-                        req.exec_approval_requirement
-                            .proposed_execpolicy_amendment()
-                            .cloned(),
-                    )
+                    .request_command_approval(turn, call_id, command, cwd, reason, risk)
                    .await
            })
            .await
        })
    }

-    fn exec_approval_requirement(&self, req: &ShellRequest) -> Option<ExecApprovalRequirement> {
-        Some(req.exec_approval_requirement.clone())
+    fn approval_requirement(&self, req: &ShellRequest) -> Option<ApprovalRequirement> {
+        Some(req.approval_requirement.clone())
    }

    fn sandbox_mode_for_first_attempt(&self, req: &ShellRequest) -> SandboxOverride {
        if req.with_escalated_permissions.unwrap_or(false)
            || matches!(
-                req.exec_approval_requirement,
-                ExecApprovalRequirement::Skip {
+                req.approval_requirement,
+                ApprovalRequirement::Skip {
                    bypass_sandbox: true
                }
            )
--- a/codex-rs/core/src/tools/runtimes/unified_exec.rs
+++ b/codex-rs/core/src/tools/runtimes/unified_exec.rs
@@ -10,7 +10,7 @@ use crate::exec::ExecExpiration;
 use crate::tools::runtimes::build_command_spec;
 use crate::tools::sandboxing::Approvable;
 use crate::tools::sandboxing::ApprovalCtx;
-use crate::tools::sandboxing::ExecApprovalRequirement;
+use crate::tools::sandboxing::ApprovalRequirement;
 use crate::tools::sandboxing::ProvidesSandboxRetryData;
 use crate::tools::sandboxing::SandboxAttempt;
 use crate::tools::sandboxing::SandboxOverride;
@@ -36,7 +36,7 @@ pub struct UnifiedExecRequest {
    pub env: HashMap<String, String>,
    pub with_escalated_permissions: Option<bool>,
    pub justification: Option<String>,
-    pub exec_approval_requirement: ExecApprovalRequirement,
+    pub approval_requirement: ApprovalRequirement,
 }

 impl ProvidesSandboxRetryData for UnifiedExecRequest {
@@ -66,7 +66,7 @@ impl UnifiedExecRequest {
        env: HashMap<String, String>,
        with_escalated_permissions: Option<bool>,
        justification: Option<String>,
-        exec_approval_requirement: ExecApprovalRequirement,
+        approval_requirement: ApprovalRequirement,
    ) -> Self {
        Self {
            command,
@@ -74,7 +74,7 @@ impl UnifiedExecRequest {
            env,
            with_escalated_permissions,
            justification,
-            exec_approval_requirement,
+            approval_requirement,
        }
    }
 }
@@ -125,35 +125,22 @@ impl Approvable<UnifiedExecRequest> for UnifiedExecRuntime<'_> {
        Box::pin(async move {
            with_cached_approval(&session.services, key, || async move {
                session
-                    .request_command_approval(
-                        turn,
-                        call_id,
-                        command,
-                        cwd,
-                        reason,
-                        risk,
-                        req.exec_approval_requirement
-                            .proposed_execpolicy_amendment()
-                            .cloned(),
-                    )
+                    .request_command_approval(turn, call_id, command, cwd, reason, risk)
                    .await
            })
            .await
        })
    }

-    fn exec_approval_requirement(
-        &self,
-        req: &UnifiedExecRequest,
-    ) -> Option<ExecApprovalRequirement> {
-        Some(req.exec_approval_requirement.clone())
+    fn approval_requirement(&self, req: &UnifiedExecRequest) -> Option<ApprovalRequirement> {
+        Some(req.approval_requirement.clone())
    }

    fn sandbox_mode_for_first_attempt(&self, req: &UnifiedExecRequest) -> SandboxOverride {
        if req.with_escalated_permissions.unwrap_or(false)
            || matches!(
-                req.exec_approval_requirement,
-                ExecApprovalRequirement::Skip {
+                req.approval_requirement,
+                ApprovalRequirement::Skip {
                    bypass_sandbox: true
                }
            )
--- a/codex-rs/core/src/tools/sandboxing.rs
+++ b/codex-rs/core/src/tools/sandboxing.rs
@@ -13,7 +13,6 @@ use crate::sandboxing::CommandSpec;
 use crate::sandboxing::SandboxManager;
 use crate::sandboxing::SandboxTransformError;
 use crate::state::SessionServices;
-use codex_protocol::approvals::ExecPolicyAmendment;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::ReviewDecision;
 use std::collections::HashMap;
@@ -89,43 +88,26 @@ pub(crate) struct ApprovalCtx<'a> {

 // Specifies what tool orchestrator should do with a given tool call.
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum ExecApprovalRequirement {
+pub(crate) enum ApprovalRequirement {
    /// No approval required for this tool call.
    Skip {
        /// The first attempt should skip sandboxing (e.g., when explicitly
        /// greenlit by policy).
        bypass_sandbox: bool,
    },
-    /// Approval required for this tool call.
-    NeedsApproval {
-        reason: Option<String>,
-        /// Proposed execpolicy amendment to skip future approvals for similar commands
-        /// See core/src/exec_policy.rs for more details on how proposed_execpolicy_amendment is determined.
-        proposed_execpolicy_amendment: Option<ExecPolicyAmendment>,
-    },
-    /// Execution forbidden for this tool call.
+    /// Approval required for this tool call
+    NeedsApproval { reason: Option<String> },
+    /// Execution forbidden for this tool call
    Forbidden { reason: String },
 }

-impl ExecApprovalRequirement {
-    pub fn proposed_execpolicy_amendment(&self) -> Option<&ExecPolicyAmendment> {
-        match self {
-            Self::NeedsApproval {
-                proposed_execpolicy_amendment: Some(prefix),
-                ..
-            } => Some(prefix),
-            _ => None,
-        }
-    }
-}
-
 /// - Never, OnFailure: do not ask
 /// - OnRequest: ask unless sandbox policy is DangerFullAccess
 /// - UnlessTrusted: always ask
-pub(crate) fn default_exec_approval_requirement(
+pub(crate) fn default_approval_requirement(
    policy: AskForApproval,
    sandbox_policy: &SandboxPolicy,
-) -> ExecApprovalRequirement {
+) -> ApprovalRequirement {
    let needs_approval = match policy {
        AskForApproval::Never | AskForApproval::OnFailure => false,
        AskForApproval::OnRequest => !matches!(sandbox_policy, SandboxPolicy::DangerFullAccess),
@@ -133,12 +115,9 @@ pub(crate) fn default_exec_approval_requirement(
    };

    if needs_approval {
-        ExecApprovalRequirement::NeedsApproval {
-            reason: None,
-            proposed_execpolicy_amendment: None,
-        }
+        ApprovalRequirement::NeedsApproval { reason: None }
    } else {
-        ExecApprovalRequirement::Skip {
+        ApprovalRequirement::Skip {
            bypass_sandbox: false,
        }
    }
@@ -170,9 +149,10 @@ pub(crate) trait Approvable<Req> {
        matches!(policy, AskForApproval::Never)
    }

-    /// Return `Some(_)` to specify a custom exec approval requirement, or `None`
-    /// to fall back to policy-based default.
-    fn exec_approval_requirement(&self, _req: &Req) -> Option<ExecApprovalRequirement> {
+    /// Override the default approval requirement. Return `Some(_)` to specify
+    /// a custom requirement, or `None` to fall back to
+    /// policy-based default.
+    fn approval_requirement(&self, _req: &Req) -> Option<ApprovalRequirement> {
        None
    }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ahmed Ibrahim	e6016f5489	client	2025-12-02 16:16:38 -08:00
Ahmed Ibrahim	2721498ec9	client	2025-12-02 14:54:33 -08:00
Ahmed Ibrahim	47ef2cd9ca	client	2025-12-02 14:45:44 -08:00
Ahmed Ibrahim	db70faab42	copy	2025-11-25 16:01:19 -08:00
Ahmed Ibrahim	1e7796570a	copy	2025-11-25 15:56:48 -08:00
Ahmed Ibrahim	11b13914a8	copy	2025-11-25 15:54:53 -08:00
Ahmed Ibrahim	567844fe05	codex-status	2025-11-25 15:47:39 -08:00
Ahmed Ibrahim	6eb0474455	Merge branch 'codex-status' of https://github.com/openai/codex into codex-status	2025-11-25 15:42:32 -08:00
Ahmed Ibrahim	af1254fc4e	codex-status	2025-11-25 15:39:03 -08:00
Ahmed Ibrahim	764aff6753	codex-status	2025-11-25 15:38:54 -08:00
Ahmed Ibrahim	e2a55921ec	Merge branch 'main' into codex-status	2025-11-25 15:36:46 -08:00
Ahmed Ibrahim	08b6d9ef1f	codex-status	2025-11-25 15:35:43 -08:00
Ahmed Ibrahim	bbf536847c	codex-status	2025-11-25 15:34:32 -08:00
Ahmed Ibrahim	0d0779d08a	codex-status	2025-11-25 15:32:46 -08:00
Ahmed Ibrahim	087e571198	tests	2025-11-25 15:17:14 -08:00
Ahmed Ibrahim	70b613be81	warning	2025-11-25 14:18:41 -08:00
Ahmed Ibrahim	53ff941cf3	warning	2025-11-25 14:18:25 -08:00
Ahmed Ibrahim	6b66534356	status	2025-11-25 12:49:59 -08:00
Ahmed Ibrahim	1938116a5d	status	2025-11-25 12:49:04 -08:00
Ahmed Ibrahim	075d50677d	use client	2025-11-25 12:44:43 -08:00
Ahmed Ibrahim	5c40534e98	use client	2025-11-25 12:42:25 -08:00
Ahmed Ibrahim	f05492fc94	crate	2025-11-25 12:35:40 -08:00
Ahmed Ibrahim	44ff9fcb69	review	2025-11-25 12:35:40 -08:00
Ahmed Ibrahim	b4a1a500ec	status	2025-11-25 12:35:40 -08:00